class IotFunctions_2

Attributes

add_functions_connector[RW]
cert_path[RW]
hua_aceanconnect_connector[RW]
internal_func[RW]
key_path[RW]
mongo_client[RW]
mongoip[RW]
mongoport[RW]

Public Class Methods

new(mongoip, mongoport, iotip, mongo_database, iotplatform_ip, iotplatform_port, cert_path, key_path, telegram_api_url, telegram_chat_id ) click to toggle source
# File lib/imperituroard/projects/iot.rb, line 33
def initialize(mongoip,
               mongoport,
               iotip,
               mongo_database,
               iotplatform_ip,
               iotplatform_port,
               cert_path,
               key_path,
               telegram_api_url,
               telegram_chat_id
  #real_ip, remote_ip
)
  @mongoip = mongoip
  @mongoport = mongoport
  #@iotip = iotip
  #@mongo_database = mongo_database
  #@iotplatform_ip = iotplatform_ip
  #@iotplatform_port = iotplatform_port
  @cert_path = cert_path
  @key_path = key_path
  @mongo_client = MongoIot.new(mongoip, mongoport, mongo_database)
  @add_functions_connector = AdditionalFunc.new(telegram_api_url, telegram_chat_id)
  #@real_ip = real_ip
  #@remote_ip = remote_ip
  @hua_aceanconnect_connector = HuaIot.new(iotplatform_ip, iotplatform_port, cert_path, key_path, mongoip, mongoport, mongo_database)
  @internal_func = InternalFunc.new
end

Public Instance Methods

add_device_to_prof2_2(request_full, real_ip, remote_ip) click to toggle source
# File lib/imperituroard/projects/iot.rb, line 217
def add_device_to_prof2_2(request_full, real_ip, remote_ip)

  #{"autorization"=>{"login"=>"test", "token"=>"tE3aFvs27"}, "devlist"=>[{"devices"=>{"imei"=>123419520034999, "type"=>"1000002", "profile"=>0}}]}

  login = request_full["autorization"]["login"]

  im_li =[]

  for sd in request_full["devlist"]
    im_li.append(sd["devices"])
  end
  imei_list = im_li

  input_json = {:request_full => request_full}
  input_json22 = {:login => login, :imei_list => imei_list}
  resp_out = {}
  begin

    thr1 = Thread.new do
      if add_functions_connector.check_input_1(login, imei_list)[:code]==200

        imei = []
        list1 = {}
        for_insert = []
        not_processed_list = []
        processed_list = []

        for ii in imei_list
          valid_resp = internal_func.imei_validate(ii["imei"])
          if valid_resp[:checked]
            list1[ii["imei"]] = ii
            imei.append(ii["imei"])
          else
            not_processed_list.append({:imei => ii["imei"], :error => valid_resp[:result]})
          end
        end

        if imei != []
          list_checked = mongo_client.check_imei_exists(imei)

          for ss in list_checked[:body][:exists]
            not_processed_list.append({:imei => ss, :error => "Device exists in database"})
            p ss
            p "ss"
            p list_checked
          end

          for jj in list_checked[:body][:not_exists]
            begin
              get_login_info = mongo_client.check_login_prof_perm_id_one(login, list1[jj]["profile"])[:code]
              if get_login_info==200
                for_insert.append(list1[jj])
              else
                not_processed_list.append({:imei => list1[jj], :error => "Permission denied for this profile"})
              end
            rescue
              not_processed_list.append({:imei => list1[jj], :error => "Unknown error"})
            end
          end
        end

        begin
          added_on_iot_platf = []
          if for_insert != []
            ##Logic for IOT Platform connection###


            for aaa in for_insert

              #########change 2020.05.11. imperituroard
              #########replace process for get iot app_id and password from users to profile

              #credentials = mongo_client.get_iot_oceanconnect_credent(login)
              credentials = mongo_client.get_iot_oceanconn_credent_2(aaa["profile"])

              #########

              if aaa.key?("type") && !aaa.key?("device_type")
                aaa["device_type"] = aaa["type"]
                aaa = internal_func.delete_key_hash(aaa, "type")
              end

              aaa = internal_func.hash_val_to_string(aaa)

              if credentials[:code] == 200

                begin
                  dev_name = aaa["imei"].to_s

                  #get {"model"=>"BGT_PPMC", "ManufacturerID"=>"unknown", "ManufacturerNAME"=>"unknown", "device_type"=>"unknown"}
                  #from database
                  model_data = mongo_client.get_device_type_info_universal(aaa["device_type"])
                  profile_data = mongo_client.get_profile_universal(aaa["profile"])
                  p profile_data
                  p model_data
                  p "model_data"
                  resss = hua_aceanconnect_connector.add_new_device_on_huawei(credentials[:body][:app_id],
                                                                              credentials[:body][:secret],
                                                                              aaa["imei"],
                                                                              dev_name,
                                                                              aaa["description"],
                                                                              model_data[:body]["device_type"],
                                                                              aaa["profile"],
                                                                              model_data[:body]["ManufacturerID"],
                                                                              model_data[:body]["ManufacturerNAME"],
                                                                              model_data[:body]["model"]
                  )
                  if resss[:code]=="200"
                    if resss[:body].key?("error_code") && resss[:body]["error_code"] != 200
                      not_processed_list.append({:imei => aaa["imei"], :error => resss})
                    else
                      s1 = aaa
                      s1[:huadata] = resss
                      s1[:created] = DateTime.now
                      s1["device_type"] = model_data[:body]["model"]
                      s1["profile"] = profile_data["profile_id"]
                      added_on_iot_platf.append(s1)
                    end
                  else
                    not_processed_list.append({:imei => aaa["imei"], :error => resss})
                  end
                rescue
                  not_processed_list.append({:imei => aaa["imei"], :error => "Unknown error with insertion imei on IOT platform"})
                end
                #########end iot platform logic#######

              else
                resss_err = {:code => 400, :result => "IOT platform credentials not found"}
                not_processed_list.append({:imei => aaa["imei"], :error => resss_err})
              end

            end

            if added_on_iot_platf.length != 0
              mongo_client.imei_insert_list(added_on_iot_platf)
              resp_out = {:code => 200, :result => "Data processed", :body => {:imei_processed => added_on_iot_platf, :error_list => not_processed_list}}
            else
              resp_out = {:code => 202, :result => "Empty list. Nothing for insertion", :body => {:imei_processed => added_on_iot_platf, :error_list => not_processed_list}}
            end
          else
            resp_out = {:code => 202, :result => "Nothing for insertion", :body => {:imei_processed => added_on_iot_platf, :error_list => not_processed_list}}
          end
        rescue
          resp_out = {:code => 505, :result => "Error with database communication"}
        end
      else
        resp_out = {:code => 509, :result => "Input data invalid"}
      end
    end
  rescue
    resp_out = {:code => 507, :result => "Unknown SDK error"}
  end
  thr1.join

  resp_out[:body][:tosoapgw] = internal_func.iot_create_dev_soapgw_answer(input_json22, resp_out)
  mongo_client.audit_logger("add_device_to_profile", remote_ip, input_json, resp_out, real_ip, {})
  resp_out
end
add_device_to_prof_2(login, imei_list, real_ip, remote_ip) click to toggle source

!!1. Add device to profile (only for new device) login - login for client identification profile - profile for device imei_list - device identificator imei_list = [{“imei” => 131234123412341233, “description” => “dfdsf”, “note”=>“second description”, “profile”=>0, “device_type”=>“phone”}, {“imei” => 56213126347645784, “description” => “dfdsf”, “note”=>“second description”, “profile”=>0}] massive commands +++ iot logic added

# File lib/imperituroard/projects/iot.rb, line 70
def add_device_to_prof_2(login, imei_list, real_ip, remote_ip)
  input_json = {:login => login, :imei_list => imei_list}
  resp_out = {}
  begin

    thr1 = Thread.new do
      if add_functions_connector.check_input_1(login, imei_list)[:code]==200

        imei = []
        list1 = {}
        for_insert = []
        not_processed_list = []
        processed_list = []

        for ii in imei_list
          valid_resp = internal_func.imei_validate(ii["imei"])
          if valid_resp[:checked]
            list1[ii["imei"]] = ii
            imei.append(ii["imei"])
          else
            not_processed_list.append({:imei => ii["imei"], :error => valid_resp[:result]})
          end
        end

        if imei != []
          list_checked = mongo_client.check_imei_exists(imei)

          for ss in list_checked[:body][:exists]
            not_processed_list.append({:imei => ss, :error => "Device exists in database"})
            p ss
            p "ss"
            p list_checked
          end

          for jj in list_checked[:body][:not_exists]
            begin
              get_login_info = mongo_client.check_login_prof_perm_id_one(login, list1[jj]["profile"])[:code]
              if get_login_info==200
                for_insert.append(list1[jj])
              else
                not_processed_list.append({:imei => list1[jj], :error => "Permission denied for this profile"})
              end
            rescue
              not_processed_list.append({:imei => list1[jj], :error => "Unknown error"})
            end
          end
        end

        begin
          added_on_iot_platf = []
          if for_insert != []
            ##Logic for IOT Platform connection###


            for aaa in for_insert

              #########change 2020.05.11. imperituroard
              #########replace process for get iot app_id and password from users to profile

              #credentials = mongo_client.get_iot_oceanconnect_credent(login)
              credentials = mongo_client.get_iot_oceanconn_credent_2(aaa["profile"])

              #########

              if aaa.key?("type") && !aaa.key?("device_type")
                aaa["device_type"] = aaa["type"]
                aaa = internal_func.delete_key_hash(aaa, "type")
              end

              aaa = internal_func.hash_val_to_string(aaa)

              if credentials[:code] == 200

                begin
                  dev_name = aaa["imei"].to_s

                  #get {"model"=>"BGT_PPMC", "ManufacturerID"=>"unknown", "ManufacturerNAME"=>"unknown", "device_type"=>"unknown"}
                  #from database
                  model_data = mongo_client.get_device_type_info_universal(aaa["device_type"])
                  profile_data = mongo_client.get_profile_universal(aaa["profile"])
                  p profile_data
                  p model_data
                  p "model_data"
                  resss = hua_aceanconnect_connector.add_new_device_on_huawei(credentials[:body][:app_id],
                                                                              credentials[:body][:secret],
                                                                              aaa["imei"],
                                                                              dev_name,
                                                                              aaa["description"],
                                                                              model_data[:body]["device_type"],
                                                                              aaa["profile"],
                                                                              model_data[:body]["ManufacturerID"],
                                                                              model_data[:body]["ManufacturerNAME"],
                                                                              model_data[:body]["model"]
                  )
                  if resss[:code]=="200"
                    if resss[:body].key?("error_code") && resss[:body]["error_code"] != 200
                      not_processed_list.append({:imei => aaa["imei"], :error => resss})
                    else
                      s1 = aaa
                      s1[:huadata] = resss
                      s1[:created] = DateTime.now
                      s1["device_type"] = model_data[:body]["model"]
                      s1["profile"] = profile_data["profile_id"]
                      added_on_iot_platf.append(s1)
                    end
                  else
                    not_processed_list.append({:imei => aaa["imei"], :error => resss})
                  end
                rescue
                  not_processed_list.append({:imei => aaa["imei"], :error => "Unknown error with insertion imei on IOT platform"})
                end
                #########end iot platform logic#######

              else
                resss_err = {:code => 400, :result => "IOT platform credentials not found"}
                not_processed_list.append({:imei => aaa["imei"], :error => resss_err})
              end

            end

            if added_on_iot_platf.length != 0
              mongo_client.imei_insert_list(added_on_iot_platf)
              resp_out = {:code => 200, :result => "Data processed", :body => {:imei_processed => added_on_iot_platf, :error_list => not_processed_list}}
            else
              resp_out = {:code => 202, :result => "Empty list. Nothing for insertion", :body => {:imei_processed => added_on_iot_platf, :error_list => not_processed_list}}
            end
          else
            resp_out = {:code => 202, :result => "Nothing for insertion", :body => {:imei_processed => added_on_iot_platf, :error_list => not_processed_list}}
          end
        rescue
          resp_out = {:code => 505, :result => "Error with database communication"}
        end
      else
        resp_out = {:code => 509, :result => "Input data invalid"}
      end
    end
  rescue
    resp_out = {:code => 507, :result => "Unknown SDK error"}
  end
  thr1.join

  resp_out[:body][:tosoapgw] = internal_func.iot_create_dev_soapgw_answer(input_json, resp_out)
  mongo_client.audit_logger("add_device_to_profile", remote_ip, input_json, resp_out, real_ip, {})
  resp_out
end
add_model_to_mongo(model, manufacture_id, manufacture_name, device_type, description, note) click to toggle source

for internal use. Add new device model

# File lib/imperituroard/projects/iot.rb, line 1434
def add_model_to_mongo(model, manufacture_id, manufacture_name, device_type, description, note)
  model = {
      model: model,
      ManufacturerID: manufacture_id,
      ManufacturerNAME: manufacture_name,
      device_type: device_type,
      description: description,
      note: note,
      created: DateTime.now
  }
  mongo_client.imei_insert_model(model)
end
add_service_2(login, device_list, real_ip, remote_ip) click to toggle source

6 add service by SPA imei profile imsi msisdn newdevice_list=[{:imei=>7967843245665, :attributes=>{:address=>“Golubeva51”, :profile=>“wqeqcqeqwev”, :msisdn=>375298766719, :imsi=>25702858586756875}}] +

# File lib/imperituroard/projects/iot.rb, line 786
def add_service_2(login, device_list, real_ip, remote_ip)
  resp_out = {}
  not_processed = []
  processed = []

  input_json = {:login => login, :devices => device_list}

  begin

    thr6 = Thread.new do

      if add_functions_connector.check_input_5(login, device_list)[:code]==200

        for g in device_list

          prof_name1 = mongo_client.get_profile_name_from_imei(g["imei"])

          if prof_name1[:code]==200
            permiss1 = mongo_client.check_login_profile_permiss(login, prof_name1[:body]["profile"])
            if permiss1[:code]==200

              if g["attributes"].key?("profile")
                permiss2 = mongo_client.check_login_profile_permiss(login, g["attributes"]["profile"])[:code]

                if permiss2==200

                  attr = g["attributes"]
                  #mod_attr = {}

                  if attr.key?("profile")
                    if attr["profile"].is_a? Integer
                      p "Ok"
                    else
                      p new = mongo_client.get_profile_universal(attr["profile"])
                      attr["profile"] = new["profile_id"]
                    end
                  end
                  mongo_client.device_modify_any_attr_mongo(g["imei"], attr)
                  processed.append(g["imei"])
                else
                  not_processed.append({:imei => g["imei"], :description => "New profile permission error", :error => permiss2})
                end

              else
                attr = g["attributes"]
                mongo_client.device_modify_any_attr_mongo(g["imei"], attr)
                processed.append(g["imei"])
              end
            else
              not_processed.append({:imei => g["imei"], :description => "Old profile permission error", :error => permiss1})
            end

          else
            not_processed.append({:imei => g["imei"], :error => prof_name1})
          end

        end
        resp_out = {:code => 200, :result => "Request completed successfully", :body => {:imei_processed => processed, :error_list => not_processed}}
      else
        resp_out = {:code => 509, :result => "Input data invalid"}
      end
    end
  rescue
    resp_out = {:code => 507, :result => "Unknown SDK error"}
  end
  thr6.join
  mongo_client.audit_logger("device_remove", remote_ip, input_json, resp_out, real_ip, {})
  resp_out
end
answ_dev_query_format_process(dev_list) click to toggle source
# File lib/imperituroard/projects/iot.rb, line 885
def answ_dev_query_format_process(dev_list)
  add_functions_connector.answ_dev_query_format_process(dev_list)
end
autorize_subscriber_2(login, password, real_ip, remote_ip) click to toggle source

7 procedure for subscriber autorization

save data to mongodb
# File lib/imperituroard/projects/iot.rb, line 859
def autorize_subscriber_2(login, password, real_ip, remote_ip)
  input_json = {:login => login, :password => password}
  resp_out = {}
  thr7 = Thread.new do
    begin
      login_inform = mongo_client.get_login_info(login)
      if login_inform[:code]==200
        pass_mongo = login_inform[:body]["password"]
        if pass_mongo == password
          resp_out = {:code => 200, :result => "Access granted"}
        else
          resp_out = {:code => 400, :result => "Access denied"}
        end
      else
        resp_out = {:code => 401, :result => "Access denied. Incorrect login"}
      end
    rescue
      resp_out = {:code => 507, :result => "Unknown SDK error"}
    end
  end
  thr7.join
  mongo_client.audit_logger("autorize_subscriber", remote_ip, input_json, resp_out, real_ip, {})
  resp_out
end
delete_all_devices_in_database() click to toggle source

technology procedures###############

# File lib/imperituroard/projects/iot.rb, line 1418
def delete_all_devices_in_database

  imei_list = []
  all_imei = mongo_client.get_all_imei_from_db
  all_imei[:body].each do |immm|
    imei_list.append(immm["imei"])
  end

  imei_list.each do |del_imei|
    p del_imei
    self.device_remove_2("test", del_imei, "localhost", "localhost")
  end
end
device_add_address_2(login, newdevice_list, real_ip, remote_ip) click to toggle source

!5 add address to device login imei = newdevice_list address = newdevice_list newdevice_list=[{:imei=>7967843245665, :address=>“Golubeva51”}] +++ iot platform integration completed

# File lib/imperituroard/projects/iot.rb, line 706
def device_add_address_2(login, newdevice_list, real_ip, remote_ip)
  #add_functions_connector.telegram_message(newdevice_list.to_s)
  p newdevice_list
  p "gas"
  p MyJSON.valid?(newdevice_list[0].to_s)
  p "sdfsdfgs"
  input_json = {:login => login, :devices => newdevice_list}
  resp_out = {}
  not_processed = []
  processed = []
  begin
    thr5 = Thread.new do
      if add_functions_connector.check_input_5(login, newdevice_list)[:code]==200

        for p in newdevice_list
          prof_name = mongo_client.get_profile_name_from_imei(p[:imei])

          if prof_name[:code]==200
            permiss = mongo_client.check_login_profile_permiss(login, prof_name[:body]["profile"])
            if permiss[:code]==200

              ##Logic for IOT Platform connection###

              #########change 2020.05.11. imperituroard
              #########replace process for get iot app_id and password from users to profile

              #credentials = mongo_client.get_iot_oceanconnect_credent(login)
              credentials = mongo_client.get_iot_oceanconn_credent_2(prof_name[:body]["profile"])

              #########

              resp = {}

              if credentials[:code]==200
                imei_data = mongo_client.get_imei_info_from_db([p[:imei]])
                if imei_data[:body]!=[]
                  ans = hua_aceanconnect_connector.modify_location_iot(credentials[:body][:app_id], credentials[:body][:secret], imei_data[:body][0]["huadata"]["body"]["deviceId"], p[:address])
                  internal_func.printer_texter({:function => "device_add_address Step2", :ans => ans, :descrition => "answer from hua IOT", :input => {:did => imei_data[:body][0]["huadata"]["body"]["deviceId"], :appid => credentials[:body][:app_id], :secret => credentials[:body][:secret], :address => p[:address]}}, "debug")
                end
              end

              #########end iot platform logic#######

              resp = mongo_client.device_modify_attr_mongo(p[:imei], p[:address])
              if resp[:code]==200
                processed.append({:imei => p[:imei]})
              end
            else
              not_processed.append({:imei => p[:imei], :address => p[:address], :error => permiss})
            end
          else
            not_processed.append({:imei => p[:imei], :address => p[:address], :error => prof_name})
          end
        end

        if processed!=[]
          resp_out = {:code => 200, :result => "Request completed successfully", :body => {:imei_processed => processed, :error_list => not_processed}}
        else
          resp_out = {:code => 202, :result => "Nothing processed", :body => {:imei_processed => processed, :error_list => not_processed}}
        end
      else
        resp_out = {:code => 509, :result => "Input data invalid"}
      end
    end
  rescue
    resp_out = {:code => 507, :result => "Unknown SDK error"}
  end
  thr5.join
  mongo_client.audit_logger("device_add_address", remote_ip, input_json, resp_out, real_ip, {})
  resp_out
end
device_find_2(login, imei_list, real_ip, remote_ip) click to toggle source

!!2 Find device (only mongo datebase. IOT platform not need)

procedure for data selection from mongo database.
for this function IOT platform not need
login
imei
imei_list =[41234,23452345,132412]

++

# File lib/imperituroard/projects/iot.rb, line 384
def device_find_2(login, imei_list, real_ip, remote_ip)
  input_json = {:login => login, :imei_list => imei_list}
  ime_list_approved = []
  ime_list_notapproved = []
  resp_out = {}
  begin
    thr2 = Thread.new do
      if add_functions_connector.check_input_2(login, imei_list)[:code] == 200

        for t in imei_list
          prof_name1 = mongo_client.get_profile_name_from_imei(t)
          if prof_name1[:code] == 200
            begin
              permiss1 = mongo_client.check_login_profile_permiss(login, prof_name1[:body]["profile"])
              p "permiss1"
              p permiss1
              if permiss1[:code] == 200
                ime_list_approved.append(t)
              else
                ime_list_notapproved.append({:imei => t, :error => permiss1})
              end
            rescue
              ime_list_notapproved.append({:imei => t, :error => {:code => 405, :result => "Unknown error when check_login_profile_permiss imei #{t.to_s}"}})
            end
          else
            ime_list_notapproved.append({:imei => t, :error => prof_name1})
          end
        end
        begin
          if ime_list_approved != []
            data = mongo_client.get_imei_info_from_db(ime_list_approved)

            resp_out = {:code => 200, :result => "Request completed successfully", :data => {:approved_list => data, :unapproved_list => ime_list_notapproved}}

          else
            resp_out = {:code => 404, :result => "Invalidate data", :data => {:approved_list => [], :unapproved_list => ime_list_notapproved}}
          end
        rescue
          resp_out = {:code => 504, :result => "Unsuccessfully data transfer"}
        end
      else
        resp_out = {:code => 509, :result => "Input data invalid"}
      end
    end
  rescue
    resp_out = {:code => 507, :result => "Unknown SDK error"}
  end
  thr2.join

  resp_out[:data][:tosoapgw] = add_functions_connector.iot_query_dev_soapgw_answer(input_json, resp_out)

  mongo_client.audit_logger("device_find", remote_ip, input_json, resp_out, real_ip, {})
  resp_out

end
device_remove_2(login, imei, real_ip, remote_ip) click to toggle source

!!4 remove device login imei

not massive commands

imei=11341341234 login=“test” +++ IOT logic added

# File lib/imperituroard/projects/iot.rb, line 622
def device_remove_2(login, imei, real_ip, remote_ip)

  input_json = {:login => login, :imei_list => imei}
  resp_out = {}

  begin
    thr4 = Thread.new do

      if add_functions_connector.check_input_4(login, imei)[:code] == 200

        prof_name = mongo_client.get_profile_name_from_imei(imei)
        if prof_name[:code] == 200
          permiss = mongo_client.check_login_profile_permiss(login, prof_name[:body]["profile"])
          if permiss[:code] == 200

            ##Logic for IOT Platform connection###

            #########change 2020.05.11. imperituroard
            #########replace process for get iot app_id and password from users to profile

            #credentials = mongo_client.get_iot_oceanconnect_credent(login)
            credentials = mongo_client.get_iot_oceanconn_credent_2(prof_name[:body]["profile"])

            #########

            resp = {}

            if credentials[:code] == 200

              imei_data = mongo_client.get_imei_info_from_db([imei])
              if imei_data[:body] != []
                ans = {}
                if imei_data[:body][0]["huadata"]["body"]["deviceId"] != nil
                  ans = hua_aceanconnect_connector.remove_one_device_from_iot(credentials[:body][:app_id], credentials[:body][:secret], imei_data[:body][0]["huadata"]["body"]["deviceId"])
                else
                  ans = {:code => "204", :result => "Not processed by iot platform. deviceId not found in mongoDB"}
                end
                if ans[:code] == "204" or ans[:code] == "200"
                  resp = mongo_client.device_remove_single_mongo(imei)
                else
                  resp = {:code => 500, :result => "Unknown IOT platform error", :body => ans}
                end
              else
                resp_out = {:code => 404, :result => "Data not found"}
              end

              #########end iot platform logic#######

              if resp[:code]==200
                resp_out = {:code => 200, :result => "Request completed successfully"}
              else
                resp_out=resp
              end
            else
              resp_out = {:code => 400, :result => "IOT platform credentials not found"}
            end
          else
            resp_out=permiss
          end
        else
          resp_out=prof_name
        end
      else
        resp_out = {:code => 509, :result => "Input data invalid"}
      end

    end

  rescue
    resp_out = {:code => 507, :result => "Unknown SDK error"}
  end
  thr4.join
  mongo_client.audit_logger("device_remove", remote_ip, input_json, resp_out, real_ip, {})
  resp_out
end
get_available_prof_2(login, real_ip, remote_ip) click to toggle source

8 get available profiles by login

# File lib/imperituroard/projects/iot.rb, line 891
def get_available_prof_2(login, real_ip, remote_ip)

  input_params = {:login => login}
  resp_out = {}

  begin
    data_processed = []
    data_soapgw = []
    login_info = mongo_client.get_login_inf2_select(login)
    if login_info[:code]==200
      permit_profiles = login_info[:body]["permit_profiles"]
      permit_types = login_info[:body]["permit_types"]
      data_from_mongo = mongo_client.get_profile_list_by_id(permit_profiles)
      p data_from_mongo

      for ff in data_from_mongo
        data_processed.append({:profile_id => ff["profile_id"],
                               :description => ff["description"],
                               :note => ff["note"],
                               :form => ff["form"],
                               :profile => ff["profile"],
                               :info => ff["info"]
                              })
        data_soapgw.append({:id => ff["profile_id"], :form => ff["form"], :description => ff["description"], :profile => ff["profile"]})

      end
      tosoapgw = {:code => 200,
                  :result => "Request completed successfully",
                  :profiles => data_soapgw
      }

      resp_out = {:code => 200, :result => "Request completed successfully", :body => {:data => data_processed, :tosoapgw => tosoapgw}}
    else
      tosoapgw = {:code => login_info[:code],
                  :result => login_info[:result],
                  :profiles => data_soapgw
      }
      resp_out = {:code => login_info[:code], :result => login_info[:result], :body => {:tosoapgw => tosoapgw}}
    end

  rescue
    tosoapgw = {:code => 507,
                :result => "Unknown SDK error",
                :profiles => data_soapgw
    }
    resp_out = {:code => 507, :result => "Unknown SDK error", :body => {:tosoapgw => tosoapgw}}
  end
  mongo_client.audit_logger("get_available_prof_2", remote_ip, input_params, resp_out, real_ip, {})
  resp_out
end
get_available_types2_2(login, profile, real_ip, remote_ip) click to toggle source

10 get available device types by login and profile. procedure update

# File lib/imperituroard/projects/iot.rb, line 1000
def get_available_types2_2(login, profile, real_ip, remote_ip)

  input_params = {:login => login}
  resp_out = {}

  begin
    data_processed = []
    data_soapgw = []
    login_info = mongo_client.get_login_inf2_select(login)
    prof_data = mongo_client.get_profile_universal(profile)
    if login_info[:code]==200

      permit_profiles = login_info[:body]["permit_profiles"]
      permit_types = login_info[:body]["permit_types"]
      perm_tp_prof = prof_data["permit_types"]

      if permit_profiles.include?(prof_data["profile_id"])
        res_types_permitted = internal_func.compare_dict(permit_types, perm_tp_prof)
        data_from_mongo = mongo_client.get_type_list_by_id(res_types_permitted)

        for ff in data_from_mongo
          data_processed.append({:type_id => ff["type_id"],
                                 :description => ff["description"],
                                 :note => ff["note"],
                                 :form => ff["form"],
                                 :ManufacturerID => ff["ManufacturerID"],
                                 :ManufacturerNAME => ff["ManufacturerNAME"],
                                 :device_type => ff["device_type"],
                                 :model => ff["model"],
                                 :info => ff["info"]
                                })
          data_soapgw.append({:name => ff["model"], :form => ff["form"], :description => ff["description"], :type_id => ff["type_id"]})
        end

        tosoapgw = {:code => 200,
                    :result => "Request completed successfully",
                    :types => data_soapgw
        }

        resp_out = {:code => 200, :result => "Request completed successfully", :body => {:data => data_processed, :tosoapgw => tosoapgw}}

      else
        tosoapgw = {:code => 700,
                    :result => "Profile not permitted",
                    :types => data_soapgw
        }
        resp_out = {:code => 700, :result => "Profile not permitted", :body => {:tosoapgw => tosoapgw}}
      end


    else
      tosoapgw = {:code => login_info[:code],
                  :result => login_info[:result],
                  :types => data_soapgw
      }
      resp_out = {:code => login_info[:code], :result => login_info[:result], :body => {:tosoapgw => tosoapgw}}
    end

  rescue
    tosoapgw = {:code => 507,
                :result => "Unknown SDK error",
                :types => data_soapgw
    }
    resp_out = {:code => 507, :result => "Unknown SDK error", :body => {:tosoapgw => tosoapgw}}
  end
  mongo_client.audit_logger("get_available_types_2", remote_ip, input_params, resp_out, real_ip, {})
  resp_out
end
get_available_types_2(login, real_ip, remote_ip) click to toggle source

9 get available device types by login

# File lib/imperituroard/projects/iot.rb, line 943
def get_available_types_2(login, real_ip, remote_ip)

  input_params = {:login => login}
  resp_out = {}

  begin
    data_processed = []
    data_soapgw = []
    login_info = mongo_client.get_login_inf2_select(login)
    if login_info[:code]==200

      permit_profiles = login_info[:body]["permit_profiles"]
      permit_types = login_info[:body]["permit_types"]

      data_from_mongo = mongo_client.get_type_list_by_id(permit_types)

      for ff in data_from_mongo
        data_processed.append({:type_id => ff["type_id"],
                               :description => ff["description"],
                               :note => ff["note"],
                               :form => ff["form"],
                               :ManufacturerID => ff["ManufacturerID"],
                               :ManufacturerNAME => ff["ManufacturerNAME"],
                               :device_type => ff["device_type"],
                               :model => ff["model"],
                               :info => ff["info"]
                              })
        data_soapgw.append({:name => ff["model"], :form => ff["form"], :description => ff["description"], :type_id => ff["type_id"]})
      end

      tosoapgw = {:code => 200,
                  :result => "Request completed successfully",
                  :types => data_soapgw
      }

      resp_out = {:code => 200, :result => "Request completed successfully", :body => {:data => data_processed, :tosoapgw => tosoapgw}}
    else
      tosoapgw = {:code => login_info[:code],
                  :result => login_info[:result],
                  :types => data_soapgw
      }
      resp_out = {:code => login_info[:code], :result => login_info[:result], :body => {:tosoapgw => tosoapgw}}
    end

  rescue
    tosoapgw = {:code => 507,
                :result => "Unknown SDK error",
                :types => data_soapgw
    }
    resp_out = {:code => 507, :result => "Unknown SDK error", :body => {:tosoapgw => tosoapgw}}
  end
  mongo_client.audit_logger("get_available_types_2", remote_ip, input_params, resp_out, real_ip, {})
  resp_out
end
get_info_by_imeilist_from_iot(login, imei_list) click to toggle source

14 additional procedure for checking status on iot platform

# File lib/imperituroard/projects/iot.rb, line 1309
def get_info_by_imeilist_from_iot(login, imei_list)
  resp_out={}
  begin
    dev_id_list = []
    for_process_list = {}
    resss = {}
    data_from_db = mongo_client.get_imei_info_from_db(imei_list)
    p data_from_db
    profile = 0
    for g in data_from_db[:body]
      p g
      p "ggggg"
      dev_id_list.append(g["huadata"]["body"]["deviceId"])

      if for_process_list[g["profile"]] == nil
        for_process_list[g["profile"]] = [g["huadata"]["body"]["deviceId"]]
      else
        for_process_list[g["profile"]].append(g["huadata"]["body"]["deviceId"])
      end

      if g["profile"] != nil && g["profile"] != ""
        profile = g["profile"]
      end
    end

    p dev_id_list
    p "dev_id_list"
    p for_process_list

    for ard in for_process_list
      ##Logic for IOT Platform connection###

      #########change 2020.05.11. imperituroard
      #########replace process for get iot app_id and password from users to profile

      #credentials = mongo_client.get_iot_oceanconnect_credent(login)
      credentials = mongo_client.get_iot_oceanconn_credent_2(ard[0])

      #########

      if credentials[:code] == 200
        resp_out[:code] = "200"
        resp_out[:result] = "Processed"
        p apid = credentials[:body][:app_id]
        p secre = credentials[:body][:secret]
        resp_out_1 = hua_aceanconnect_connector.quer_dev_query_list(apid, secre, ard[1])
        p resp_out_1
        p "resp_out_1"
        p resp_out[:body]
        p "resp_out[:body][\"devices\"]"

        if resp_out[:body] == nil || resp_out[:body] == {} || resp_out[:body] == {"devices" => nil}
          p "step1111"
          p resp_out_1[:body]["devices"]
          resp_out[:body] = {'devices' => resp_out_1[:body]["devices"]}
          p "step22222"
        else
          if resp_out_1[:body]["devices"] != nil
            resp_out[:body]["devices"] = resp_out[:body]["devices"] + resp_out_1[:body]["devices"]
          end
        end
      end
    end

    p resp_out
    p "resp_out"

  rescue
    resp_out = {:code => "500", :message => "get_info_by_imeilist_from_iot: Something wrong", :body => {"devices" => []}}
  end
  internal_func.printer_texter(resp_out, "debug")
  resp_out
end
get_info_data_profile_2(profile, real_ip, remote_ip) click to toggle source

12 get info for profile

# File lib/imperituroard/projects/iot.rb, line 1101
def get_info_data_profile_2(profile, real_ip, remote_ip)

  input_params = {:profile => profile}
  output_answ = {}
  mon_answer = {}
  begin
    if internal_func.if_digit_or_string(profile)[:body][:string]
      mon_answer = mongo_client.get_profile_id_by_name(profile)
    else
      mon_answer = mongo_client.get_profile_name_by_id(profile)
    end

    p mon_answer

    if mon_answer != {} && mon_answer != []
      output_answ = {:code => 200, :result => "Request completed successfully", :body => {:data => {:info => mon_answer["info"],
                                                                                                    :profile => mon_answer["profile"],
                                                                                                    :profile_id => mon_answer["profile_id"]
      }}}
    else
      output_answ = {:code => 505, :result => "Unknown SDK error"}
    end
  rescue
    output_answ = {:code => 507, :result => "Unknown SDK error"}
  end
  mongo_client.audit_logger("get_info_data_profile_2", remote_ip, input_params, output_answ, real_ip, {})
  output_answ
end
get_info_data_type_2(type, real_ip, remote_ip) click to toggle source

11 get info for device type

# File lib/imperituroard/projects/iot.rb, line 1071
def get_info_data_type_2(type, real_ip, remote_ip)

  input_params = {:type => type}
  output_answ = {}
  mon_answer = {}
  begin
    #if type.is_a? String
    if internal_func.if_digit_or_string(type)[:body][:string]
      mon_answer = mongo_client.get_type_by_name(type)
    else
      mon_answer = mongo_client.get_type_by_id(type)
    end

    if mon_answer != {} && mon_answer != []
      output_answ = {:code => 200, :result => "Request completed successfully", :body => {:data => {:info => mon_answer["info"],
                                                                                                    :model => mon_answer["model"],
                                                                                                    :type_id => mon_answer["type_id"]
      }}}
    else
      output_answ = {:code => 505, :result => "Unknown SDK error"}
    end
  rescue
    output_answ = {:code => 507, :result => "Unknown SDK error"}
  end
  mongo_client.audit_logger("get_info_data_type_2", remote_ip, input_params, output_answ, real_ip, {})
  output_answ
end
imei_replace_2(login, im_list, real_ip, remote_ip) click to toggle source

!3 device modify, change imei login imei_old imei_new massive commands im_list = [{“imei_old”=>7967843245667, “imei_new”=>7967843245665}] ++

# File lib/imperituroard/projects/iot.rb, line 447
def imei_replace_2(login, im_list, real_ip, remote_ip)
  input_json = {:login => login, :imei_list => im_list}
  resp_out = {}

  begin

    thr3 = Thread.new do

      if add_functions_connector.check_input_3(login, im_list)[:code]==200

        li_new_imei = []
        list1 = {}

        #dictionary for imeis which not processed. Final dictionary
        not_processed_list = []

        #dictionary for devices which was processed correctly
        processed_list = []

        #array for translations from old imei to new
        old_new_translation = {}

        approved_list = []


        #old_imei_list for query to iot platform for data request
        step1_approved_dict_old=[]

        #form dictionary for processing
        for pr1 in im_list
          li_new_imei.append(pr1["imei_new"])
          list1[pr1["imei_new"]]=pr1["imei_old"]
          old_new_translation[pr1["imei_old"]]=pr1["imei_new"]
        end

        #check if imei_new exists in database. If exists - not process this imei
        list_checked = mongo_client.check_imei_exists(li_new_imei)

        internal_func.printer_texter({:function => "imei_replace Step1", :list_checked => list_checked}, "debug")

        #add already exists new IMEI in error dictionary
        for ss in list_checked[:body][:exists]
          not_processed_list.append({:record => {:imei_old => list1[ss], :imei_new => ss}, :error => "New IMEI exists in database"})
        end

        #new_imei list which processed step1
        step2_list = list_checked[:body][:not_exists]

        internal_func.printer_texter({:function => "imei_replace Step2", :step2_list => step2_list}, "debug")


        for a in step2_list
          begin

            #step3 checking permission for writing for imei list
            prof_name1 = mongo_client.get_profile_name_from_imei(list1[a])

            internal_func.printer_texter({:function => "imei_replace Step3", :prof_name1 => prof_name1}, "debug")

            if prof_name1[:code]==200
              permiss1 = mongo_client.check_login_profile_permiss(login, prof_name1[:body]["profile"])[:code]
              internal_func.printer_texter({:function => "imei_replace Step4", :permiss1 => permiss1, :input => prof_name1[:body]["profile"]}, "debug")
              if permiss1==200

                approved_list.append({:imei_old => list1[a], :imei_new => a})
                step1_approved_dict_old.append(list1[a])

              else
                not_processed_list.append({:record => {:imei_old => list1[a], :imei_new => a}, :error => "Old IMEI modification denied"})
              end
            else
              not_processed_list.append({:record => {:imei_old => list1[a], :imei_new => a}, :error => "Old IMEI not exists in database"})
            end
          rescue
            not_processed_list.append({:record => {:imei_old => list1[a], :imei_new => a}, :error => "Unknown error"})
          end
        end

        internal_func.printer_texter({:function => "imei_replace Step5", :not_processed_list => not_processed_list, :input => list1, :approved_list => approved_list, :step1_approved_dict_old => step1_approved_dict_old}, "debug")


        ##Logic for IOT Platform connection###

        list_from_iot = self.get_info_by_imeilist_from_iot(login, step1_approved_dict_old)

        internal_func.printer_texter({:function => "imei_replace Step6", :list_from_iot => list_from_iot, :description => "data from iot platform by old imei"}, "debug")

        #processing data. modifying data on iot platform and mongoDB
        if list_from_iot[:code]=="200" && list_from_iot[:body]["devices"] != nil

          for ard in list_from_iot[:body]["devices"]
            p ard
            new_data_cur_dev = {}
            mongo_answer = {}
            current_old_dev = ard["deviceInfo"]["nodeId"]
            current_device_id = ard["deviceId"]
            new_data_cur_dev = ard["deviceInfo"]
            new_data_cur_dev["nodeId"] = old_new_translation[current_old_dev.to_i].to_s

            p list_from_iot
            p "list_from_iot"


            #########change 2020.05.11. imperituroard
            #########replace process for get iot app_id and password from users to profile

            #credentials = mongo_client.get_iot_oceanconnect_credent(login)
            info_from_mongo = mongo_client.get_imei_info_from_db([current_old_dev.to_i])
            credentials = mongo_client.get_iot_oceanconn_credent_2(info_from_mongo[:body][0]["profile"])

            #########


            if credentials[:code]==200
              flag_remove=0
              flag_create=0
              remove_answer = hua_aceanconnect_connector.remove_one_device_from_iot(credentials[:body][:app_id], credentials[:body][:secret], current_device_id)
              create_answer = hua_aceanconnect_connector.add_new_device_on_huawei2(credentials[:body][:app_id], credentials[:body][:secret], new_data_cur_dev)

              if remove_answer[:code]=="204" || remove_answer[:code]=="200"
                flag_remove=1
              end
              if create_answer[:code]=="200"
                flag_create=1
              end
              if flag_remove==1 && flag_create==1
                mongo_answer = mongo_client.device_modify_any_attr_mongo(current_old_dev.to_i, {:imei => old_new_translation[current_old_dev.to_i], :huadata => {:body => create_answer[:body]}, :updated => DateTime.now})
                processed_list.append({:imei_old => current_old_dev.to_i, :imei_new => old_new_translation[current_old_dev.to_i]})
              else
                not_processed_list.append({:record => {:imei_old => current_old_dev.to_i, :imei_new => old_new_translation[current_old_dev.to_i]}, :error => "Failed for provisioning to IOT platform"})
              end

              internal_func.printer_texter({:function => "imei_replace Step7", :remove_answer => remove_answer, :create_answer => create_answer, :mongo_answer => mongo_answer, :description => "processing imei #{current_old_dev.to_s}"}, "debug")

            else
              approved_list=[]
            end
          end

        else
          approved_list=[]
        end

        if approved_list!=[]
          resp_out = {:code => 200, :result => "Request completed successfully", :data => {:approved_list => processed_list, :unapproved_list => not_processed_list}}
        else
          resp_out = {:code => 202, :result => "Nothing to do", :data => {:approved_list => processed_list, :unapproved_list => not_processed_list}}
        end

      else
        resp_out = {:code => 509, :result => "Input data invalid"}
      end

    end

  rescue
    resp_out = {:code => 507, :result => "Unknown SDK error"}
  end

  thr3.join
  mongo_client.audit_logger("imei_replace", remote_ip, input_json, resp_out, real_ip, {})

  resp_out

end
set_data_replace_2(soapgw_params, real_ip, remote_ip) click to toggle source

set_data_replace 13

{"autorization"=>{"login"=>"test", "token"=>"token"}, "datalist"=>[{"imei"=>"524523654366", "new_profile"=>"3", "new_type"=>"1000001"}, {"imei"=>"53623413423", "new_profile"=>"1", "new_type"=>"1000003"}]}
answer = {:code=>200, :result=>"Success", :body=>{:processednum=>1, :failednum=>1, :deviceserr=>[{:failedimei=>524523654366}]}}
# File lib/imperituroard/projects/iot.rb, line 1135
def set_data_replace_2(soapgw_params, real_ip, remote_ip)
  input_params = {:soapgw_params => soapgw_params, :real_ip => real_ip, :remote_ip => remote_ip}
  output_answ = {}
  failes_list = []
  answ_to_soapgw = {}
  not_processed_list = []
  processed_list = []

  inp_login = soapgw_params["autorization"]["login"]
  inp_dev_list = soapgw_params["datalist"]

  thr13set = Thread.new do
    inp_dev_list.each do |curr_dev|
      begin
        if curr_dev["imei"] != [] && curr_dev["imei"] != nil && curr_dev["imei"] != ""
          list_checked = mongo_client.check_imei_exists([curr_dev["imei"].to_i])
          if list_checked[:code] == 200 && list_checked[:body][:exists] != [] && list_checked[:body][:not_exists] == []

            #step1 checking permission for writing for imei list
            prof_name1 = mongo_client.get_profile_name_from_imei(curr_dev["imei"].to_i)
            p prof_name1
            p "prof_name1"
            if prof_name1[:code] == 200

              if curr_dev["new_profile"] != "nil" && curr_dev["new_profile"] != "null" && curr_dev["new_profile"] != "empty" && curr_dev["new_profile"] != "nill"
                prof_new_id = mongo_client.get_profile_universal(curr_dev["new_profile"])["profile_id"]
              else
                prof_new_id = prof_name1[:body]["profile_id"]
              end

              if curr_dev["new_type"] != "nil" && curr_dev["new_type"] != "null" && curr_dev["new_type"] != "empty" && curr_dev["new_type"] != "nill"
                type_new_pr = curr_dev["new_type"]
              else
                type_new_pr = prof_name1[:imei_info][:body][0]["device_type"]
              end

              p type_new_pr
              p prof_new_id
              p "st111111"

              get_login_info = mongo_client.check_login_prof_perm_id_one(inp_login, prof_name1[:body]["profile_id"])
              p get_login_info
              p "get_login_info"
              if get_login_info[:code] == 200
                get_login_info_new = mongo_client.check_login_prof_perm_id_one(inp_login, prof_new_id)
                p get_login_info_new
                p "get_login_info_new"
                if get_login_info_new[:code] == 200
                  cur_comp1 = mongo_client.compare_profiles(prof_name1[:body]["profile_id"], prof_new_id)
                  p cur_comp1
                  p "cur_comp1"
                  cur_comp2 = mongo_client.compare_device_types(prof_name1[:imei_info][:body][0]["device_type"], type_new_pr)


                  p cur_comp2
                  p "cur_comp2"

                  if cur_comp1[:is_the_same] && cur_comp2[:is_the_same]
                    #the same. Nothing to do
                    processed_list.append(curr_dev)
                    ########
                  else
                    credentials_old = mongo_client.get_iot_oceanconn_credent_2(prof_name1[:body]["profile"])
                    credentials_new = mongo_client.get_iot_oceanconn_credent_2(prof_new_id)
                    p credentials_new
                    p "credentials_new"
                    #########
                    if credentials_old[:code] == 200 && credentials_new[:code] == 200
                      imei_data = mongo_client.get_imei_info_from_db([curr_dev["imei"].to_i])
                      p imei_data
                      p "imei_data"
                      if imei_data[:body] != []
                        ans = {}
                        if imei_data[:body][0]["huadata"]["body"]["deviceId"] != nil
                          model_data = mongo_client.get_device_type_info_universal(type_new_pr)
                          p model_data
                          p "model_data"
                          #####all checks completed. then process data#####
                          ans_old = hua_aceanconnect_connector.remove_one_device_from_iot(credentials_old[:body][:app_id], credentials_old[:body][:secret], imei_data[:body][0]["huadata"]["body"]["deviceId"])


                          if ans_old[:code].to_i == 200 || ans_old[:code].to_i == 202 || ans_old[:code].to_i == 204
                            begin
                              resss = hua_aceanconnect_connector.add_new_device_on_huawei(credentials_new[:body][:app_id],
                                                                                          credentials_new[:body][:secret],
                                                                                          curr_dev["imei"].to_i,
                                                                                          curr_dev["imei"].to_s,
                                                                                          prof_name1[:body]["description"],
                                                                                          model_data[:body]["device_type"],
                                                                                          curr_dev["new_profile"],
                                                                                          model_data[:body]["ManufacturerID"],
                                                                                          model_data[:body]["ManufacturerNAME"],
                                                                                          model_data[:body]["model"]
                              )
                              if resss[:code] == "200"
                                if resss[:body].key?("error_code") && resss[:body]["error_code"] != 200
                                  not_processed_list.append({:imei => curr_dev["imei"], :error => resss})
                                else
                                  p resss
                                  new_id_iot = resss[:body]
                                  new_profile_id = prof_new_id
                                  now_date = DateTime.now
                                  #finished success. update database
                                  attribute = {profile: new_profile_id, device_type: model_data[:body]["model"], huadata: resss, updated: now_date}
                                  answ_mongo = mongo_client.modify_attr_mongo_universal(curr_dev["imei"].to_i, attribute)
                                  if answ_mongo[:code] != 200
                                    not_processed_list.append({:imei => curr_dev["imei"], :error => "Critical error. Mongo not updated", :mongo_err => answ_mongo})
                                  else
                                    processed_list.append(curr_dev)
                                  end
                                end
                              else
                                not_processed_list.append({:imei => curr_dev["imei"], :error => resss})
                              end
                            rescue
                              not_processed_list.append({:imei => curr_dev["imei"], :error => "Unknown error with insertion imei on IOT platform"})
                            end
                          else
                            not_processed_list.append({:imei => curr_dev["imei"], :error => "Something wrong with IOT platform"})
                          end
                        else
                          not_processed_list.append({:imei => curr_dev["imei"], :error => "Not processed by iot platform. deviceId not found in mongoDB"})
                        end
                      else
                        not_processed_list.append({:imei => curr_dev["imei"], :error => "Failed to get info from database"})
                      end
                    else
                      not_processed_list.append({:imei => curr_dev["imei"], :error => "Failed to get credentials from database"})
                    end
                  end
                else
                  not_processed_list.append({:imei => curr_dev["imei"], :error => "New profile modification not permitted"})
                end
              else
                not_processed_list.append({:imei => curr_dev["imei"], :error => "Old profile modification not permitted"})
              end
            else
              not_processed_list.append({:imei => curr_dev["imei"], :error => "Unknown current profile"})
            end
          else
            not_processed_list.append({:imei => curr_dev["imei"], :error => "Device not exists"})
          end
        else
          not_processed_list.append({:imei => curr_dev["imei"], :error => "IMEI can't be nil"})
        end
      rescue
        not_processed_list.append({:imei => curr_dev["imei"], :error => "Unknown SDK error"})
      end

    end

    err_li = []
    if not_processed_list.length > 0
      not_processed_list.each do |err_l|
        err_li.append({:failedimei => err_l[:imei]})
      end
    end

    if processed_list.length > 0
      answ_to_soapgw = {:code => 200, :result => "Success", :body => {:processednum => processed_list.length, :failednum => not_processed_list.length, :deviceserr => err_li}}
    else
      answ_to_soapgw = {:code => 202, :result => "Nothing done", :body => {:processednum => 0, :failednum => not_processed_list.length, :deviceserr => err_li}}
    end
  end
  thr13set.join

  output_answ = {:code => 200, :result => "Success", :body => {:to_soap_gw => answ_to_soapgw, :not_processed_list => not_processed_list, :processed_list => processed_list}}
  mongo_client.audit_logger("set_data_replace_2", remote_ip, input_params, output_answ, real_ip, {})
  output_answ
end
spa_service_set_2(soapgw_params, real_ip, remote_ip) click to toggle source

15 add service iot

soapgw_params = {:imei => "43563456", :imsi => "2452345", :unp => "6454127", :description => "test", :note => "test2"}

{“autorization”=>{“login”=>“login”, “token”=>“token”}, “service”=>{“imei”=>“13412341234”, “imsi”=>“5645645”, “msisdn”=>“3423423”, “unp”=>“4564564”, “note”=>“test”, “descriptiot”=>“test 2”}}

# File lib/imperituroard/projects/iot.rb, line 1389
def spa_service_set_2(soapgw_params, real_ip, remote_ip)
  input_params = {:soapgw_params => soapgw_params, :real_ip => real_ip, :remote_ip => remote_ip}
  output_answ = {}
  begin
    output_answ = {:code => 200,
                   :message => 'Request completed successfully',
                   :body => {
                       :to_soap_gw => {
                           :code => 200,
                           :result => 'Request completed successfully'
                       }}}
    mongo_client.audit_spa_logger('spa_service_set_2', {:remote_ip => remote_ip, :real_ip => real_ip}, input_params, output_answ)
  rescue
    output_answ = {:code => 500,
                   :message => 'Server error',
                   :body => {
                       :to_soap_gw => {
                           :code => 500,
                           :result => 'Server error'
                       }}}
  end
  output_answ
end
test1278493() click to toggle source
# File lib/imperituroard/projects/iot.rb, line 1448
def test1278493
  #ddd = MongoIot.new(mongoip, mongoport, mongo_database)
  #ddd.get_profiles_by_login("test")

  ff = [131234123412341233, 131234123127341233]
  #ddd.get_imsi_info_from_db(ff)

  #p ddd.get_profile_id_by_name("1341241")
  #p ddd.get_device_type_info_by_model("BGT_PPMC11")
  p "yyyyy"

  #fff = HuaIot.new("134.17.93.4", "443", "/Users/imperituroard/Desktop/cert.crt", "/Users/imperituroard/Desktop/key.pem")
  p hua_aceanconnect_connector.querying_device_id("Jy5KpoBUOScZEcrO2bRZhzfaIOUa", "VFFWTOb9k3_cQhzrGsRWT4HE8Z0a", "123412341284999")
end