class Authentication(object):
log = Log()
log.setLogConfig()
def getAuthToken(self, clientInfo):
authUrl = RestConstant.BASE_URL + clientInfo[
'platformIp'] + ":" + clientInfo[
'platformPort'] + RestConstant.APP_AUTH
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
payload = {
'appId': clientInfo['appId'],
'secret': clientInfo['secret']
}
logging.info(clientInfo), logging.info(authUrl), logging.info(
headers), logging.info(payload)
return NorthApiClient.invokeAPI2(RestConstant.HTTPPOST, authUrl,
headers, payload)
def refreshAuthToken(self, arInDTO):
arInDTO = DictUtil.dto2dict(arInDTO)
authUrl = RestConstant.REFRESH_TOKEN
payload = json.dumps(arInDTO)
logging.info(arInDTO), logging.info(payload)
return NorthApiClient.invokeAPI(RestConstant.HTTPPOST, authUrl,
payload, None)
class BatchProcess(object):
log = Log()
log.setLogConfig()
def createBatchTask(self, btcInDTO, accessToken):
btcInDTO = DictUtil.dto2dict(btcInDTO)
authUrl = RestConstant.CREATE_BATCH_TASK
payload = json.dumps(btcInDTO)
logging.info(btcInDTO), logging.info(accessToken), logging.info(
payload)
return NorthApiClient.invokeAPI(RestConstant.HTTPPOST, authUrl,
payload, accessToken)
def queryOneTask(self, taskId, select, appId, accessToken):
authUrl = RestConstant.CREATE_BATCH_TASK + taskId + "?"
if appId != None:
authUrl += "appId=" + appId
if select != None:
authUrl += "&select=" + select
logging.info(taskId), logging.info(select), logging.info(
appId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPGET, authUrl, None,
accessToken)
def queryTaskDetails(self, qtdInDTO, accessToken):
qtdInDTO = DictUtil.dto2dict(qtdInDTO)
authUrl = RestConstant.QUERYTASKDETAILS + str(qtdInDTO['taskId'])
for key in qtdInDTO.keys():
if key == 'taskId':
authUrl = authUrl
elif qtdInDTO[key] != None:
authUrl += "&" + key + "=" + qtdInDTO[key]
logging.info(qtdInDTO), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPGET, authUrl, None,
accessToken)
class SubscriptionManagement(object):
log = Log()
log.setLogConfig()
def subDeviceBusinessData(self, sdbdInDTO, accessToken):
sdbdInDTO = DictUtil.dto2dict(sdbdInDTO)
authUrl = RestConstant.SUB_DEVICE_BUSINESS_DATA
if sdbdInDTO['ownerFlag'] != None:
authUrl += "?ownerFlag=" + sdbdInDTO['ownerFlag']
payload = json.dumps(sdbdInDTO)
logging.info(sdbdInDTO), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPPOST, authUrl,
payload, accessToken)
def subDeviceManagementData(self, sdmdInDTO, accessToken):
sdmdInDTO = DictUtil.dto2dict(sdmdInDTO)
authUrl = RestConstant.SUB_DEVICE_MANAGEMENT_DATA
payload = json.dumps(sdmdInDTO)
logging.info(sdmdInDTO), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPPOST, authUrl,
payload, accessToken)
def querySingleSubscription(self, subscriptionId, appId, accessToken):
authUrl = RestConstant.QUERY_SINGLE_SUB_SCRIPTION + subscriptionId
if appId != None:
authUrl += "?appId=" + appId
logging.info(subscriptionId), logging.info(appId), logging.info(
accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPGET, authUrl, None,
accessToken)
def queryBatchSubscriptions(self, qbsInDTO, accessToken):
qbsInDTO = DictUtil.dto2dict(qbsInDTO)
authUrl = RestConstant.QUERY_BATCH_SUB_SCRIPTIONS
for key in qbsInDTO.keys():
if qbsInDTO[key] != None:
authUrl += "&" + key + "=" + qbsInDTO[key]
logging.info(qbsInDTO), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPGET, authUrl, None,
accessToken)
def deleteSingleSubscription(self, subscriptionId, appId, accessToken):
authUrl = RestConstant.DELETE_SINGLE_SUB_SCRIPTION + subscriptionId
if appId != None:
authUrl += "?appId=" + appId
logging.info(subscriptionId), logging.info(appId), logging.info(
accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPDELETE, authUrl, None,
accessToken)
def deleteBatchSubscriptions(self, dbsInDTO, accessToken):
dbsInDTO = DictUtil.dto2dict(dbsInDTO)
authUrl = RestConstant.DELETE_BATCH_SUB_SCRIPTIONS
for key in dbsInDTO.keys():
if dbsInDTO[key] != None:
authUrl += "&" + key + "=" + dbsInDTO[key]
logging.info(dbsInDTO), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPDELETE, authUrl, None,
accessToken)
class SignalDelivery(object):
log = Log()
log.setLogConfig()
def postDeviceCommand(self, pdcInDTO, appId, accessToken):
pdcInDTO = DictUtil.dto2dict(pdcInDTO)
authUrl = RestConstant.POST_DEVICE_COMMAND
if appId != None:
authUrl += "?appId=" + appId
payload = json.dumps(pdcInDTO)
logging.info(pdcInDTO), logging.info(appId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPPOST, authUrl,
payload, accessToken)
def queryDeviceCommand(self, qdcInDTO, accessToken):
qdcInDTO = DictUtil.dto2dict(qdcInDTO)
authUrl = RestConstant.QUERY_DEVICE_COMMAND
for key in qdcInDTO.keys():
if qdcInDTO[key] != None:
authUrl += "&" + key + "=" + qdcInDTO[key]
logging.info(qdcInDTO), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPGET, authUrl, None,
accessToken)
def updateDeviceCommand(self, udcInDTO, deviceCommandId, appId,
accessToken):
udcInDTO = DictUtil.dto2dict(udcInDTO)
authUrl = RestConstant.UPDATE_DEVICE_COMMAND + deviceCommandId
if appId != None:
authUrl += "?appId=" + appId
payload = json.dumps(udcInDTO)
logging.info(udcInDTO), logging.info(deviceCommandId), logging.info(
appId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPPUT, authUrl, payload,
accessToken)
def createDeviceCmdCancelTask(self, cdcctInDTO, appId, accessToken):
cdcctInDTO = DictUtil.dto2dict(cdcctInDTO)
authUrl = RestConstant.CREATE_DEVICE_CMD_CANCEL_TASK
if appId != None:
authUrl += "?appId=" + appId
payload = json.dumps(cdcctInDTO)
logging.info(cdcctInDTO), logging.info(appId), logging.info(
accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPPOST, authUrl,
payload, accessToken)
def queryDeviceCmdCancelTask(self, qdcctInDTO, accessToken):
qdcctInDTO = DictUtil.dto2dict(qdcctInDTO)
authUrl = RestConstant.QUERY_DEVICE_CMD_CANCEL_TASK
for key in qdcctInDTO.keys():
if qdcctInDTO[key] != None:
authUrl += "&" + key + "=" + qdcctInDTO[key]
logging.info(qdcctInDTO), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPGET, authUrl, None,
accessToken)
class DeviceServiceInvocation(object):
log = Log()
log.setLogConfig()
def invokeDeviceService(self, commandDTO, deviceId, serviceId, appId, accessToken):
commandDTO = DictUtil.dto2dict(commandDTO)
authUrl = RestConstant.INVOKE_DEVICE_SERVICE + deviceId + "/services/" + serviceId + "/sendCommand"
if appId != None:
authUrl += "?appId=" + appId
payload = json.dumps(commandDTO)
logging.info(commandDTO), logging.info(deviceId), logging.info(appId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPPOST, authUrl, payload, accessToken)
class DataCollection(object):
log = Log()
log.setLogConfig()
def querySingleDeviceInfo(self, deviceId, select, appId, accessToken):
authUrl = RestConstant.QUERY_SINGLE_DEVICE_INFO + deviceId + "?"
if appId != None:
authUrl += "appId=" + appId
if select != None:
authUrl += "&select=" + select
logging.info(deviceId), logging.info(select), logging.info(appId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPGET, authUrl, None, accessToken)
def queryBatchDevicesInfo(self, qbdiInDTO, accessToken):
qbdiInDTO = DictUtil.dto2dict(qbdiInDTO)
authUrl = RestConstant.QUERY_BATCH_DEVICES_INFO
for key in qbdiInDTO.keys():
if qbdiInDTO[key] != None:
authUrl += "&" + key + "=" + qbdiInDTO[key]
logging.info(qbdiInDTO), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPGET, authUrl, None, accessToken)
def queryDeviceDataHistory(self, qddhInDTO, accessToken):
authUrl = "/iocm/app/data/v1.2.0/deviceDataHistory"
payload = DictUtil.dto2dict(qddhInDTO)
logging.info(qddhInDTO), logging.info(accessToken), logging.info(payload)
return NorthApiClient.invokeAPI(RestConstant.HTTPGET, authUrl, payload, accessToken)
def queryDeviceDesiredHistory(self, qddhInDTO, accessToken):
qddhInDTO = DictUtil.dto2dict(qddhInDTO)
authUrl = RestConstant.QUERY_DEVICE_DESIRED_HISTORY + qddhInDTO['deviceId'] + "&gatewayId=" + qddhInDTO[
'gatewayId']
for key in qddhInDTO.keys():
if qddhInDTO[key] != None:
authUrl += "&" + key + "=" + qddhInDTO[key]
logging.info(qddhInDTO), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPGET, authUrl, None, accessToken)
def queryDeviceCapabilities(self, qdcInDTO, accessToken):
qdcInDTO = DictUtil.dto2dict(qdcInDTO)
authUrl = RestConstant.QUERY_DEVICE_CAPABILITIES
for key in qdcInDTO.keys():
if qdcInDTO[key] != None:
authUrl += "&" + key + "=" + qdcInDTO[key]
logging.info(qdcInDTO), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPGET, authUrl, None, accessToken)
def receive():
log = Log()
log.setLogConfig()
pmr = PushMessageReceiver()
try:
if request.json['notifyType'] == "deviceAdded":
logging.info(request.json)
pmr.handleDeviceAdded()
return "ok"
if request.json['notifyType'] == "bindDevice":
logging.info(request.json)
pmr.handleBindDevice()
return "ok"
if request.json['notifyType'] == "deviceInfoChanged":
logging.info(request.json)
pmr.handleDeviceInfoChanged()
return "ok"
if request.json['notifyType'] == "deviceDataChanged":
logging.info(request.json)
pmr.handleDeviceDataChanged()
return "ok"
if request.json['notifyType'] == "deviceDatasChanged":
logging.info(request.json)
pmr.handleDeviceDatasChanged()
return "ok"
if request.json['notifyType'] == "serviceInfoChanged":
logging.info(request.json)
pmr.handleServiceInfoChanged()
return "ok"
if request.json['notifyType'] == "deviceDeleted":
logging.info(request.json)
pmr.handleDeviceDeleted()
return "ok"
if request.json['notifyType'] == "messageConfirm":
logging.info(request.json)
pmr.handleMessageConfirm()
return "ok"
if request.json['notifyType'] == "commandRsp":
logging.info(request.json)
pmr.handleCommandRsp()
return "ok"
if request.json['notifyType'] == "deviceEvent":
logging.info(request.json)
pmr.handleDeviceEvent()
return "ok"
if request.json['notifyType'] == "deviceModelAdded":
logging.info(request.json)
pmr.handleDeviceModelAdded()
return "ok"
if request.json['notifyType'] == "deviceModelDeleted":
logging.info(request.json)
pmr.handleDeviceDeleted()
return "ok"
if request.json['notifyType'] == "ruleEvent":
logging.info(request.json)
pmr.handleRuleEvent()
return "ok"
if request.json[
'notifyType'] == "deviceDesiredPropertiesModifyStatusChanged":
logging.info(request.json)
pmr.handleDeviceDesiredStatusChanged()
return "ok"
if request.json['notifyType'] == "swUpgradeStateChangeNotify":
logging.info(request.json)
pmr.handleSwUpgradeStateChanged()
return "ok"
if request.json['notifyType'] == "swUpgradeResultNotify":
logging.info(request.json)
pmr.handleSwUpgradeResult()
return "ok"
if request.json['notifyType'] == "fwUpgradeStateChangeNotify":
logging.info(request.json)
pmr.handleFwUpgradeStateChanged()
return "ok"
if request.json['notifyType'] == "fwUpgradeResultNotify":
logging.info(request.json)
pmr.handleFwUpgradeResult()
return "ok"
else:
return "notifyType doesn't exist or notifyType is not right."
except RequestException as e:
logging.error(e)
raise RequestException(e)
class DeviceUpgrade(object):
log = Log()
log.setLogConfig()
def queryUpgradePackageList(self, quplInDTO, accessToken):
quplInDTO = DictUtil.dto2dict(quplInDTO)
authUrl = RestConstant.QUERY_UPGRADE_PACKAGE_LIST
for key in quplInDTO.keys():
if quplInDTO[key] != None:
authUrl += "&" + key + "=" + quplInDTO[key]
logging.info(quplInDTO), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPGET, authUrl, None,
accessToken)
def queryUpgradePackage(self, fileId, accessToken):
authUrl = RestConstant.QUERY_UPGRADE_PACKAGE + fileId
logging.info(fileId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPGET, authUrl, None,
accessToken)
def deleteUpgradePackage(self, fileId, accessToken):
authUrl = RestConstant.DELETE_UPGRADE_PACKAGE + fileId
logging.info(fileId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPDELETE, authUrl, None,
accessToken)
def createSoftwareUpgradeTask(self, cutInDTO, accessToken):
cutInDTO = DictUtil.dto2dict(cutInDTO)
authUrl = RestConstant.CREATE_SOFTWARE_UPGRADE_TASK
payload = json.dumps(cutInDTO)
logging.info(cutInDTO), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPPOST, authUrl,
payload, accessToken)
def createFirmwareUpgradeTask(self, cutInDTO, accessToken):
cutInDTO = DictUtil.dto2dict(cutInDTO)
authUrl = RestConstant.CREATE_FIRMWARE_UPGRADE_TASK
payload = json.dumps(cutInDTO)
logging.info(cutInDTO), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPPOST, authUrl,
payload, accessToken)
def queryUpgradeTask(self, operationId, accessToken):
authUrl = RestConstant.QUERY_UPGRADE_TASK + operationId
logging.info(operationId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPGET, authUrl, None,
accessToken)
def queryUpgradeSubTask(self, qustInDTO, operationId, accessToken):
qustInDTO = DictUtil.dto2dict(qustInDTO)
authUrl = RestConstant.QUERY_UPGRADE_SUB_TASK + operationId + "/subOperations?"
for key in qustInDTO.keys():
if qustInDTO[key] != None:
authUrl += "&" + key + "=" + qustInDTO[key]
logging.info(qustInDTO), logging.info(operationId), logging.info(
accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPGET, authUrl, None,
accessToken)
def queryUpgradeTaskList(self, qutlInDTO, accessToken):
qutlInDTO = DictUtil.dto2dict(qutlInDTO)
authUrl = RestConstant.QUERY_UPGRADE_TASK_LIST
for key in qutlInDTO.keys():
if qutlInDTO[key] != None:
authUrl += "&" + key + "=" + qutlInDTO[key]
logging.info(qutlInDTO), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPGET, authUrl, None,
accessToken)
class DeviceManagement(object):
log = Log()
log.setLogConfig()
def regDirectDevice(self, rddInDto, appId, accessToken):
rddInDto = DictUtil.dto2dict(rddInDto)
authUrl = RestConstant.REG_DIRECT_DEVICE
if appId != None:
authUrl += "?appId=" + appId
payload = json.dumps(rddInDto)
logging.info(rddInDto), logging.info(appId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPPOST, authUrl,
payload, accessToken)
def refreshDeviceKey(self, rdkInDTO, appId, accessToken):
rdkInDTO = DictUtil.dto2dict(rdkInDTO)
authUrl = RestConstant.REFRESH_DEVICE_KEY + rdkInDTO['deviceId']
if appId != None:
authUrl += "?appId=" + appId
payload = json.dumps(rdkInDTO)
logging.info(rdkInDTO), logging.info(appId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPPUT, authUrl, payload,
accessToken)
def modifyDeviceInfo(self, mdiInDto, deviceId, appId, accessToken):
mdiInDto = DictUtil.dto2dict(mdiInDto)
authUrl = RestConstant.MODIFY_DEVICE_INFO + deviceId
if appId != None:
authUrl += "?appId=" + appId
payload = json.dumps(mdiInDto)
logging.info(mdiInDto), logging.info(deviceId), logging.info(
appId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPPUT, authUrl, payload,
accessToken)
def deleteDirectDevice(self, deviceId, cascade, appId, accessToken):
authUrl = RestConstant.MODIFY_DEVICE_INFO + deviceId + "?"
if appId != None:
authUrl += "&appId=" + appId
if cascade != None:
authUrl += "&cascade=" + cascade
logging.info(deviceId), logging.info(cascade), logging.info(
appId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPDELETE, authUrl, None,
accessToken)
def queryDeviceStatus(self, deviceId, appId, accessToken):
authUrl = RestConstant.QUERY_DEVICE_STATUS + deviceId
if appId != None:
authUrl += "?appId=" + appId
logging.info(deviceId), logging.info(appId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPGET, authUrl, None,
accessToken)
def queryDeviceRealtimeLocation(self, qdrlInDTO, appId, accessToken):
qdrlInDTO = DictUtil.dto2dict(qdrlInDTO)
authUrl = RestConstant.QUERY_DEVICE_REALTIME_LOCATION
if appId != None:
authUrl += "?appId=" + appId
payload = json.dumps(qdrlInDTO)
logging.info(qdrlInDTO), logging.info(appId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPPOST, authUrl,
payload, accessToken)
def queryDeviceShadow(self, deviceId, appId, accessToken):
authUrl = RestConstant.QUERY_DEVICE_SHADOW + deviceId
if appId != None:
authUrl += "?appId=" + appId
logging.info(deviceId), logging.info(appId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPGET, authUrl, None,
accessToken)
def modifyDeviceShadow(self, mdsInDTO, deviceId, appId, accessToken):
mdsInDTO = DictUtil.dto2dict(mdsInDTO)
authUrl = RestConstant.MODIFY_DEVICE_SHADOW + deviceId
if appId != None:
authUrl += "?appId=" + appId
payload = json.dumps(mdsInDTO)
logging.info(mdsInDTO), logging.info(deviceId), logging.info(
appId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPPUT, authUrl, payload,
accessToken)
class RuleEngine(object):
log = Log()
log.setLogConfig()
def createRule(self, ruleDTO, appId, accessToken):
ruleDTO = DictUtil.dto2dict(ruleDTO)
authUrl = RestConstant.CREATE_RULE
if appId != None:
authUrl += "?appId=" + appId
payload = json.dumps(ruleDTO)
logging.info(ruleDTO), logging.info(appId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPPOST, authUrl,
payload, accessToken)
def updateRule(self, ruleDTO, appId, accessToken):
ruleDTO = DictUtil.dto2dict(ruleDTO)
authUrl = RestConstant.UPDATE_RULE
if appId != None:
authUrl += "?appId=" + appId
payload = json.dumps(ruleDTO)
logging.info(ruleDTO), logging.info(appId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPPUT, authUrl, payload,
accessToken)
def deleteRule(self, ruleId, appId, accessToken):
authUrl = RestConstant.DELETE_RULE + ruleId
if appId != None:
authUrl += "?appId=" + appId
logging.info(ruleId), logging.info(appId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPDELETE, authUrl, None,
accessToken)
def queryRules(self, qrInDTO, accessToken):
qrInDTO = DictUtil.dto2dict(qrInDTO)
authUrl = RestConstant.QUERY_RULES + qrInDTO['author']
for key in qrInDTO.keys():
if key == 'author':
authUrl = authUrl
elif qrInDTO[key] != None:
authUrl += "&" + key + "=" + qrInDTO[key]
logging.info(qrInDTO), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPGET, authUrl, None,
accessToken)
def updateRuleStatus(self, ursInDTO, appId, accessToken):
ursInDTO = DictUtil.dto2dict(ursInDTO)
authUrl = RestConstant.UPDATE_RULE_STATUS + ursInDTO[
'ruleId'] + "/status/" + ursInDTO['status']
if appId != None:
authUrl += "?appId=" + appId
logging.info(ursInDTO), logging.info(appId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPPUT, authUrl, None,
accessToken)
def updateBatchRuleStatus(self, ubrsInDTO, appId, accessToken):
ubrsInDTO = DictUtil.dto2dict(ubrsInDTO)
authUrl = RestConstant.UPDATE_BATCH_RULE_STATUS
if appId != None:
authUrl += "?appId=" + appId
payload = json.dumps(ubrsInDTO)
logging.info(ubrsInDTO), logging.info(appId), logging.info(accessToken)
return NorthApiClient.invokeAPI(RestConstant.HTTPPUT, authUrl, payload,
accessToken)