public static async Task FromObject()

in objectModel/CSharp/Microsoft.CommonDataModel.ObjectModel/Persistence/ModelJson/ManifestPersistence.cs [39:203]
133 lines of code
22 McCabe index (conditional complexity)

        public static async Task<CdmManifestDefinition> FromObject(CdmCorpusContext ctx, Model obj, CdmFolderDefinition folder)
        {
            #region Prepare extensionDoc
            List<CdmTraitDefinition> extensionTraitDefList = new List<CdmTraitDefinition>();
            #endregion

            #region Set manifest fields
            CdmManifestDefinition manifest = ctx.Corpus.MakeObject<CdmManifestDefinition>(CdmObjectType.ManifestDef, obj.Name);

            // We need to set up folder path and namespace of a manifest to be able to retrieve that object.
            folder.Documents.Add(manifest);

            if (obj.Imports != null)
            {
                foreach (var element in obj.Imports)
                {
                    manifest.Imports.Add(CdmFolder.ImportPersistence.FromData(ctx, element));
                }
            }

            if (!manifest.Imports.Any((CdmImport importPresent) => importPresent.CorpusPath == "cdm:/foundations.cdm.json"))
            {
                manifest.Imports.Add("cdm:/foundations.cdm.json");
            }

            manifest.Explanation = obj.Description;
            manifest.LastFileModifiedTime = obj.ModifiedTime;
            manifest.LastChildFileModifiedTime = obj.LastChildFileModifiedTime;
            manifest.LastFileStatusCheckTime = obj.LastFileStatusCheckTime;

            if (!string.IsNullOrEmpty(obj.DocumentVersion))
            {
                manifest.DocumentVersion = obj.DocumentVersion;
            }

            if (obj.Application != null)
            {
                var applicationTrait = ctx.Corpus.MakeRef<CdmTraitReference>(CdmObjectType.TraitRef, "is.managedBy", false);
                applicationTrait.IsFromProperty = true;

                var arg = ctx.Corpus.MakeObject<CdmArgumentDefinition>(CdmObjectType.ArgumentDef, "application");
                arg.Value = obj.Application;
                applicationTrait.Arguments.Add(arg);

                manifest.ExhibitsTraits.Add(applicationTrait);
            }

            if (obj.Version != null)
            {
                var versionTrait = ctx.Corpus.MakeRef<CdmTraitReference>(CdmObjectType.TraitRef, "is.modelConversion.modelVersion", false);

                var arg = ctx.Corpus.MakeObject<CdmArgumentDefinition>(CdmObjectType.ArgumentDef, "version");
                arg.Value = obj.Version;
                versionTrait.Arguments.Add(arg);

                manifest.ExhibitsTraits.Add(versionTrait);
            }

            if (obj.Culture != null)
            {
                var cultureTrait = ctx.Corpus.MakeRef<CdmTraitReference>(CdmObjectType.TraitRef, "is.partition.culture", false);
                cultureTrait.IsFromProperty = true;

                var arg = ctx.Corpus.MakeObject<CdmArgumentDefinition>(CdmObjectType.ArgumentDef, "culture");
                arg.Value = obj.Culture;
                cultureTrait.Arguments.Add(arg);

                manifest.ExhibitsTraits.Add(cultureTrait);
            }

            if (obj.IsHidden == true)
            {
                var isHiddenTrait = ctx.Corpus.MakeRef<CdmTraitReference>(CdmObjectType.TraitRef, "is.hidden", true);
                isHiddenTrait.IsFromProperty = true;
                manifest.ExhibitsTraits.Add(isHiddenTrait);
            }

            var referenceModels = new Dictionary<string, string>();

            if (obj.ReferenceModels != null)
            {
                var referenceModelsTrait = ctx.Corpus.MakeRef<CdmTraitReference>(CdmObjectType.TraitRef, "is.modelConversion.referenceModelMap", false);

                var arg = ctx.Corpus.MakeObject<CdmArgumentDefinition>(CdmObjectType.ArgumentDef, "referenceModelMap");
                arg.Value = JToken.FromObject(obj.ReferenceModels);
                referenceModelsTrait.Arguments.Add(arg);

                manifest.ExhibitsTraits.Add(referenceModelsTrait);

                foreach (var referenceModel in obj.ReferenceModels)
                {
                    referenceModels.Add(referenceModel.Id, referenceModel.Location);
                }
            }

            var entitySchemaByName = new Dictionary<string, string>();
            if (obj.Entities != null && obj.Entities.Count > 0)
            {
                foreach (var element in obj.Entities)
                {
                    CdmEntityDeclarationDefinition entity = null;

                    if ((string)element["$type"] == "LocalEntity")
                    {
                        entity = await LocalEntityDeclarationPersistence.FromData(ctx, folder, element.ToObject<LocalEntity>(), extensionTraitDefList, manifest);
                    }
                    else if ((string)element["$type"] == "ReferenceEntity")
                    {
                        var referenceEntity = element.ToObject<ReferenceEntity>();
                        if (!referenceModels.ContainsKey(referenceEntity.ModelId))
                        {
                            Logger.Error((ResolveContext)ctx, Tag, nameof(FromObject), null, CdmLogCode.ErrPersistModelJsonModelIdNotFound, referenceEntity.ModelId, referenceEntity.Name);
                            return null;
                        }
                        entity = await ReferencedEntityDeclarationPersistence.FromData(ctx, referenceEntity, referenceModels[referenceEntity.ModelId]);
                    }
                    else
                    {
                        Logger.Error((ResolveContext)ctx, Tag, nameof(FromObject), null, CdmLogCode.ErrPersistModelJsonEntityParsingError);
                    }

                    if (entity != null)
                    {
                        manifest.Entities.Add(entity);
                        entitySchemaByName.Add(entity.EntityName, entity.EntityPath);
                    }
                    else
                    {
                        Logger.Error((ResolveContext)ctx, Tag, nameof(FromObject), null, CdmLogCode.ErrPersistModelJsonEntityParsingError);
                    }
                }
            }

            if (obj.Relationships != null && obj.Relationships.Count > 0)
            {
                foreach (var element in obj.Relationships)
                {
                    var relationship = await RelationshipPersistence.FromData(ctx, element, entitySchemaByName);
                    if (relationship != null)
                    {
                        manifest.Relationships.Add(relationship);
                    }
                    else
                    {
                        Logger.Warning(ctx, Tag, nameof(FromObject), null, CdmLogCode.WarnPersistModelJsonRelReadFailed);
                    }
                }
            }

            await Utils.ProcessAnnotationsFromData(ctx, obj, manifest.ExhibitsTraits);

            var localExtensionTraitDefList = new List<CdmTraitDefinition>();
            ExtensionHelper.ProcessExtensionFromJson(ctx, obj, manifest.ExhibitsTraits, extensionTraitDefList, localExtensionTraitDefList);
            #endregion

            #region Use extensionDoc, finalize importDocs

            List<CdmImport> importDocs = await ExtensionHelper.StandardImportDetection(ctx, extensionTraitDefList, localExtensionTraitDefList);
            ExtensionHelper.AddImportDocsToManifest(ctx, importDocs, manifest);

            CreateExtensionDocAndAddToFolderAndImports(ctx, extensionTraitDefList, folder);
            #endregion

            return manifest;
        }