static IOTHUB_REGISTRYMANAGER_RESULT parseDeviceOrModuleJsonObject()

in iothub_service_client/src/iothub_registrymanager.c [548:705]


static IOTHUB_REGISTRYMANAGER_RESULT parseDeviceOrModuleJsonObject(JSON_Object* root_object, IOTHUB_DEVICE_OR_MODULE* deviceOrModuleInfo)
{
    IOTHUB_REGISTRYMANAGER_RESULT result;

    const char* deviceId = json_object_get_string(root_object, DEVICE_JSON_KEY_DEVICE_NAME);
    const char* moduleId = json_object_get_string(root_object, DEVICE_JSON_KEY_MODULE_NAME);
    const char* managedBy = json_object_get_string(root_object, DEVICE_JSON_KEY_MANAGED_BY);
    const char* primaryKey = NULL;
    const char* secondaryKey = NULL;
    const char* authType = json_object_dotget_string(root_object, DEVICE_JSON_KEY_DEVICE_AUTH_TYPE);
    const char* generationId = json_object_get_string(root_object, DEVICE_JSON_KEY_DEVICE_GENERATION_ID);
    const char* eTag = json_object_get_string(root_object, DEVICE_JSON_KEY_DEVICE_ETAG);
    const char* connectionState = json_object_get_string(root_object, DEVICE_JSON_KEY_DEVICE_CONNECTIONSTATE);
    const char* connectionStateUpdatedTime = json_object_get_string(root_object, DEVICE_JSON_KEY_DEVICE_CONNECTIONSTATEUPDATEDTIME);
    const char* status = json_object_get_string(root_object, DEVICE_JSON_KEY_DEVICE_STATUS);
    const char* statusReason = json_object_get_string(root_object, DEVICE_JSON_KEY_DEVICE_STATUSREASON);
    const char* statusUpdatedTime = json_object_get_string(root_object, DEVICE_JSON_KEY_DEVICE_STATUSUPDATEDTIME);
    const char* lastActivityTime = json_object_get_string(root_object, DEVICE_JSON_KEY_DEVICE_LASTACTIVITYTIME);
    const char* cloudToDeviceMessageCount = json_object_get_string(root_object, DEVICE_JSON_KEY_DEVICE_CLOUDTODEVICEMESSAGECOUNT);
    const char* isManaged = json_object_get_string(root_object, DEVICE_JSON_KEY_DEVICE_ISMANAGED);
    const char* configuration = json_object_get_string(root_object, DEVICE_JSON_KEY_DEVICE_CONFIGURATION);
    const char* deviceProperties = json_object_get_string(root_object, DEVICE_JSON_KEY_DEVICE_DEVICEROPERTIES);
    const char* serviceProperties = json_object_get_string(root_object, DEVICE_JSON_KEY_DEVICE_SERVICEPROPERTIES);
    int iotEdge_capable = json_object_dotget_boolean(root_object, DEVICE_JSON_KEY_CAPABILITIES_IOTEDGE);

    if (NULL != authType)
    {
        if (0 == strcmp(authType, DEVICE_JSON_KEY_DEVICE_AUTH_SAS))
        {
            primaryKey = (char*)json_object_dotget_string(root_object, DEVICE_JSON_KEY_DEVICE_PRIMARY_KEY);
            secondaryKey = (char*)json_object_dotget_string(root_object, DEVICE_JSON_KEY_DEVICE_SECONDARY_KEY);
            deviceOrModuleInfo->authMethod = IOTHUB_REGISTRYMANAGER_AUTH_SPK;
        }
        else if (0 == strcmp(authType, DEVICE_JSON_KEY_DEVICE_AUTH_SELF_SIGNED))
        {
            primaryKey = (char*)json_object_dotget_string(root_object, DEVICE_JSON_KEY_DEVICE_PRIMARY_THUMBPRINT);
            secondaryKey = (char*)json_object_dotget_string(root_object, DEVICE_JSON_KEY_DEVICE_SECONDARY_THUMBPRINT);
            deviceOrModuleInfo->authMethod = IOTHUB_REGISTRYMANAGER_AUTH_X509_THUMBPRINT;
        }
        else if (0 == strcmp(authType, DEVICE_JSON_KEY_DEVICE_AUTH_CERTIFICATE_AUTHORITY))
        {
            deviceOrModuleInfo->authMethod = IOTHUB_REGISTRYMANAGER_AUTH_X509_CERTIFICATE_AUTHORITY;
        }
        else if (0 == strcmp(authType, DEVICE_JSON_KEY_DEVICE_AUTH_NONE))
        {
            deviceOrModuleInfo->authMethod = IOTHUB_REGISTRYMANAGER_AUTH_NONE;
        }
        else
        {
            deviceOrModuleInfo->authMethod = IOTHUB_REGISTRYMANAGER_AUTH_UNKNOWN;
        }
    }
    else
    {
        deviceOrModuleInfo->authMethod = IOTHUB_REGISTRYMANAGER_AUTH_UNKNOWN;
    }

    if ((deviceId != NULL) && (mallocAndStrcpy_s((char**)&(deviceOrModuleInfo->deviceId), deviceId) != 0))
    {
        LogError("mallocAndStrcpy_s failed for deviceId");
        result = IOTHUB_REGISTRYMANAGER_JSON_ERROR;
    }
    else if ((moduleId != NULL) && (mallocAndStrcpy_s((char**)&(deviceOrModuleInfo->moduleId), moduleId) != 0))
    {
        LogError("mallocAndStrcpy_s failed for moduleId");
        result = IOTHUB_REGISTRYMANAGER_JSON_ERROR;
    }
    else if ((primaryKey != NULL) && (mallocAndStrcpy_s((char**)&deviceOrModuleInfo->primaryKey, primaryKey) != 0))
    {
        LogError("mallocAndStrcpy_s failed for primaryKey");
        result = IOTHUB_REGISTRYMANAGER_JSON_ERROR;
    }
    else if ((secondaryKey != NULL) && (mallocAndStrcpy_s((char**)&deviceOrModuleInfo->secondaryKey, secondaryKey) != 0))
    {
        LogError("mallocAndStrcpy_s failed for secondaryKey");
        result = IOTHUB_REGISTRYMANAGER_JSON_ERROR;
    }
    else if ((generationId != NULL) && (mallocAndStrcpy_s((char**)&deviceOrModuleInfo->generationId, generationId) != 0))
    {
        LogError("mallocAndStrcpy_s failed for generationId");
        result = IOTHUB_REGISTRYMANAGER_JSON_ERROR;
    }
    else if ((eTag != NULL) && (mallocAndStrcpy_s((char**)&deviceOrModuleInfo->eTag, eTag) != 0))
    {
        LogError("mallocAndStrcpy_s failed for eTag");
        result = IOTHUB_REGISTRYMANAGER_JSON_ERROR;
    }
    else if ((connectionStateUpdatedTime != NULL) && (mallocAndStrcpy_s((char**)&deviceOrModuleInfo->connectionStateUpdatedTime, connectionStateUpdatedTime) != 0))
    {
        LogError("mallocAndStrcpy_s failed for connectionStateUpdatedTime");
        result = IOTHUB_REGISTRYMANAGER_JSON_ERROR;
    }
    else if ((statusReason != NULL) && (mallocAndStrcpy_s((char**)&deviceOrModuleInfo->statusReason, statusReason) != 0))
    {
        LogError("mallocAndStrcpy_s failed for statusReason");
        result = IOTHUB_REGISTRYMANAGER_JSON_ERROR;
    }
    else if ((statusUpdatedTime != NULL) && (mallocAndStrcpy_s((char**)&deviceOrModuleInfo->statusUpdatedTime, statusUpdatedTime) != 0))
    {
        LogError("mallocAndStrcpy_s failed for statusUpdatedTime");
        result = IOTHUB_REGISTRYMANAGER_JSON_ERROR;
    }
    else if ((lastActivityTime != NULL) && (mallocAndStrcpy_s((char**)&deviceOrModuleInfo->lastActivityTime, lastActivityTime) != 0))
    {
        LogError("mallocAndStrcpy_s failed for lastActivityTime");
        result = IOTHUB_REGISTRYMANAGER_JSON_ERROR;
    }
    else if ((configuration != NULL) && (mallocAndStrcpy_s((char**)&deviceOrModuleInfo->configuration, configuration) != 0))
    {
        LogError("mallocAndStrcpy_s failed for configuration");
        result = IOTHUB_REGISTRYMANAGER_JSON_ERROR;
    }
    else if ((deviceProperties != NULL) && (mallocAndStrcpy_s((char**)&deviceOrModuleInfo->deviceProperties, deviceProperties) != 0))
    {
        LogError("mallocAndStrcpy_s failed for deviceProperties");
        result = IOTHUB_REGISTRYMANAGER_JSON_ERROR;
    }
    else if ((serviceProperties != NULL) && (mallocAndStrcpy_s((char**)&deviceOrModuleInfo->serviceProperties, serviceProperties) != 0))
    {
        LogError("mallocAndStrcpy_s failed for serviceProperties");
        result = IOTHUB_REGISTRYMANAGER_JSON_ERROR;
    }
    else if ((managedBy != NULL) && (mallocAndStrcpy_s((char**)&(deviceOrModuleInfo->managedBy), managedBy) != 0))
    {
        LogError("mallocAndStrcpy_s failed for managedBy");
        result = IOTHUB_REGISTRYMANAGER_JSON_ERROR;
    }
    else
    {
        if ((connectionState != NULL) && (strcmp(connectionState, DEVICE_JSON_DEFAULT_VALUE_CONNECTED) == 0))
        {
            deviceOrModuleInfo->connectionState = IOTHUB_DEVICE_CONNECTION_STATE_CONNECTED;
        }
        if ((status != NULL) && (strcmp(status, DEVICE_JSON_DEFAULT_VALUE_ENABLED) == 0))
        {
            deviceOrModuleInfo->status = IOTHUB_DEVICE_STATUS_ENABLED;
        }
        if (cloudToDeviceMessageCount != NULL)
        {
            deviceOrModuleInfo->cloudToDeviceMessageCount = atoi(cloudToDeviceMessageCount);
        }
        if ((isManaged != NULL) && (strcmp(isManaged, DEVICE_JSON_DEFAULT_VALUE_TRUE) == 0))
        {
            deviceOrModuleInfo->isManaged = true;
        }
        if ((iotEdge_capable == -1) || (iotEdge_capable == 0))
        {
            deviceOrModuleInfo->iotEdge_capable = false;
        }
        else
        {
            deviceOrModuleInfo->iotEdge_capable = true;
        }
        result = IOTHUB_REGISTRYMANAGER_OK;
    }

    return result;
}