public static fromObject()

in objectModel/TypeScript/Persistence/CdmFolder/ManifestPersistence.ts [52:190]
116 lines of code
41 McCabe index (conditional complexity)

    public static fromObject(
        ctx: CdmCorpusContext,
        name: string,
        namespace: string,
        path: string,
        dataObj: ManifestContent
    ): CdmManifestDefinition {
        // Determine name of the manifest
        let manifestName: string;
        if (dataObj) {
            manifestName = dataObj.manifestName ? dataObj.manifestName : dataObj.folioName;
        }
        // We haven't found the name in the file, use one provided in the call but without the suffixes
        if (!manifestName && name) {
            manifestName = name.replace(CdmConstants.manifestExtension, '')
                .replace(CdmConstants.folioExtension, '');
        }
        const manifest: CdmManifestDefinition = ctx.corpus.MakeObject<CdmManifestDefinition>(cdmObjectType.manifestDef, manifestName);
        // this is the document name which is assumed by constructor to be related to the the manifestName, but may not be
        manifest.name = name;
        manifest.folderPath = path;
        manifest.namespace = namespace;

        if (dataObj) {
            if (dataObj.explanation) {
                manifest.explanation = dataObj.explanation;
            }
            if (dataObj.$schema) {
                manifest.schema = dataObj.$schema;
            }
            // support old model syntax
            if (dataObj.schemaVersion) {
                manifest.jsonSchemaSemanticVersion = dataObj.schemaVersion;
            }
            if (dataObj.jsonSchemaSemanticVersion) {
                manifest.jsonSchemaSemanticVersion = dataObj.jsonSchemaSemanticVersion;
            }
            if (manifest.jsonSchemaSemanticVersion !== '1.0.0') {
                // tslint:disable-next-line:no-suspicious-comment
                // TODO: validate that this is a version we can understand with the OM
            }

            if (dataObj.documentVersion) {
                manifest.documentVersion = dataObj.documentVersion;
            }

            if (dataObj.manifestName) {
                manifest.manifestName = dataObj.manifestName;
                // Might be populated in the case of folio.cdm.json or manifest.cdm.json file.
            } else if (dataObj.folioName) {
                manifest.manifestName = dataObj.folioName;
            }

            if (dataObj.imports) {
                for (const importObj of dataObj.imports) {
                    manifest.imports.push(ImportPersistence.fromData(ctx, importObj));
                }
            }
            if (dataObj.definitions && Array.isArray(dataObj.definitions)) {
                for (const definition of dataObj.definitions) {
                    if ('dataTypeName' in definition) {
                        manifest.definitions.push(DataTypePersistence.fromData(ctx, definition));
                    } else if ('purposeName' in definition) {
                        manifest.definitions.push(PurposePersistence.fromData(ctx, definition));
                    } else if ('attributeGroupName' in definition) {
                        manifest.definitions.push(AttributeGroupPersistence.fromData(ctx, definition));
                    } else if ('traitName' in definition) {
                        manifest.definitions.push(TraitPersistence.fromData(ctx, definition));
                    } else if ('entityShape' in definition) {
                        manifest.definitions.push(ConstantEntityPersistence.fromData(ctx, definition));
                    } else if ('entityName' in definition) {
                        manifest.definitions.push(EntityPersistence.fromData(ctx, definition));
                    }
                }
            }

            if (dataObj.lastFileStatusCheckTime) {
                manifest.lastFileStatusCheckTime = new Date(dataObj.lastFileStatusCheckTime);
            }

            if (dataObj.lastFileModifiedTime) {
                manifest.lastFileModifiedTime = new Date(dataObj.lastFileModifiedTime);
            }

            if (dataObj.lastChildFileModifiedTime) {
                manifest.lastChildFileModifiedTime = new Date(dataObj.lastChildFileModifiedTime);
            }

            utils.addArrayToCdmCollection<CdmTraitReferenceBase>(
                    manifest.exhibitsTraits,
                    utils.createTraitReferenceArray(ctx, dataObj.exhibitsTraits)
            );

            if (dataObj.entities) {
                const fullPath: string = `${namespace ? `${namespace}:${path}` : path}`;
                for (const entityObj of dataObj.entities) {
                    let entity: CdmEntityDeclarationDefinition;
                    if (entityObj.type) {
                        if (entityObj.type === entityDeclarationDefinitionType.localEntity) {
                            entity = LocalEntityDeclarationPersistence.fromData(ctx, fullPath, entityObj);
                        } else if (entityObj.type === entityDeclarationDefinitionType.referencedEntity) {
                            entity = ReferencedEntityDeclarationPersistence.fromData(ctx, fullPath, entityObj);
                        } else {
                            Logger.error(ctx, this.TAG, this.fromObject.name, null, cdmLogCode.ErrPersistEntityDeclarationMissing, entityObj.entityName);
                        }
                    } else {
                        // We see old structure of entity declaration, check for entity schema/declaration.
                        if (entityObj.entitySchema) {
                            // Local entity declaration used to use entity schema.
                            entity = LocalEntityDeclarationPersistence.fromData(ctx, fullPath, entityObj);
                        } else {
                            // While referenced entity declaration used to use entity declaration.
                            entity = ReferencedEntityDeclarationPersistence.fromData(ctx, fullPath, entityObj);
                        }
                    }
                    manifest.entities.push(entity);
                }
            }

            if (dataObj.relationships) {
                for (const rel of dataObj.relationships) {
                    manifest.relationships.push(E2ERelationshipPersistence.fromData(ctx, rel));
                }
            }

            if (dataObj.subManifests) {
                for (const subManifest of dataObj.subManifests) {
                    manifest.subManifests.push(ManifestDeclarationPersistence.fromData(ctx, subManifest));
                }
                // Might be populated in the case of folio.cdm.json or manifest.cdm.json file.
            } else if (dataObj.subFolios) {
                for (const subFolio of dataObj.subFolios) {
                    manifest.subManifests.push(ManifestDeclarationPersistence.fromData(ctx, subFolio));
                }
            }
        }

        return manifest;
    }