Exemple #1
0
        public bool ImportV3(string payload, string envelopeIdentifier, SaveStatus status)
        {
            InputEntityV3 input      = new InputEntityV3();
            var           bnodes     = new List <BNode>();
            var           mainEntity = new Dictionary <string, object>();

            //status.AddWarning( "The resource uses @graph and is not handled yet" );

            Dictionary <string, object> dictionary = RegistryServices.JsonToDictionary(payload);
            object graph = dictionary["@graph"];
            //serialize the graph object
            var glist = JsonConvert.SerializeObject(graph);

            //parse graph in to list of objects
            JArray graphList = JArray.Parse(glist);
            int    cntr      = 0;

            foreach (var item in graphList)
            {
                cntr++;
                if (cntr == 1)
                {
                    var main = item.ToString();
                    //may not use this. Could add a trace method
                    mainEntity = RegistryServices.JsonToDictionary(main);
                    input      = JsonConvert.DeserializeObject <InputEntityV3>(main);
                }
                else
                {
                    var bn = item.ToString();
                    bnodes.Add(JsonConvert.DeserializeObject <BNode>(bn));
                }
            }

            List <string>   messages          = new List <string>();
            bool            importSuccessfull = false;
            EntityServices  mgr    = new EntityServices();
            MappingHelperV3 helper = new MappingHelperV3();

            helper.entityBlankNodes = bnodes;

            string ctid           = input.Ctid;
            string referencedAtId = input.CtdlId;

            LoggingHelper.DoTrace(5, "		name: "+ input.Name.ToString());
            LoggingHelper.DoTrace(6, "		url: "+ input.SubjectWebpage);
            LoggingHelper.DoTrace(5, "		ctid: "+ input.Ctid);
            LoggingHelper.DoTrace(5, "		@Id: "+ input.CtdlId);
            status.Ctid = ctid;

            if (status.DoingDownloadOnly)
            {
                return(true);
            }

            if (!DoesEntityExist(input.Ctid, ref output))
            {
                //set the rowid now, so that can be referenced as needed
                output.RowId = Guid.NewGuid();
            }
            helper.currentBaseObject = output;

            //start with language and may use with language maps
            foreach (var l in input.InLanguage)
            {
                if (!string.IsNullOrWhiteSpace(l))
                {
                    var language = CodesManager.GetLanguage(l);
                    output.InLanguageCodeList.Add(new TextValueProfile()
                    {
                        CodeId    = language.CodeId,
                        TextTitle = language.Name,
                        TextValue = language.Value
                    });
                }
            }

            if (input.InLanguage.Count > 0)
            {
                //could use to alter helper.DefaultLanguage
            }
            output.Name        = helper.HandleLanguageMap(input.Name, output, "Name");
            output.Description = helper.HandleLanguageMap(input.Description, output, "Description");
            output.Keyword     = helper.MapToTextValueProfile(input.Keyword, output, "Keyword");

            output.CTID = input.Ctid;
            output.CredentialRegistryId = envelopeIdentifier;

            output.DateEffective = input.DateEffective;

            output.SubjectWebpage = input.SubjectWebpage;

            output.AvailabilityListing     = helper.MapListToString(input.AvailabilityListing);
            output.AvailableOnlineAt       = helper.MapListToString(input.AvailableOnlineAt);
            output.DeliveryType            = helper.MapCAOListToEnumermation(input.DeliveryType);
            output.DeliveryTypeDescription = helper.HandleLanguageMap(input.DeliveryTypeDescription, output, "DeliveryTypeDescription");
            //AudienceType
            output.AudienceType = helper.MapCAOListToEnumermation(input.AudienceType);
            //CAO
            output.AudienceLevelType     = helper.MapCAOListToEnumermation(input.AudienceLevelType);
            output.VersionIdentifier     = helper.MapIdentifierValueListToString(input.VersionIdentifier);
            output.VersionIdentifierList = helper.MapIdentifierValueList(input.VersionIdentifier);
            output.CodedNotation         = input.CodedNotation;
            //handle QuantitativeValue
            output.CreditValue = helper.HandleQuantitiveValue(input.CreditValue, output, "CreditValue");
            //
            if (!output.CreditValue.HasData())
            {
                //if ( UtilityManager.GetAppKeyValue( "usingQuantitiveValue", false ) )
                //{
                //	//will not handle ranges
                //	output.CreditValue = new workIT.Models.Common.QuantitativeValue
                //	{
                //		Value = input.CreditHourValue,
                //		CreditUnitType = helper.MapCAOToEnumermation( input.CreditUnitType ),
                //		Description = helper.HandleLanguageMap( input.CreditUnitTypeDescription, output, "CreditUnitTypeDescription" )
                //	};
                //	//what about hours?
                //	//if there is hour data, can't be unit data, so assign
                //	if ( input.CreditHourValue > 0 )
                //	{
                //		output.CreditValue.Value = input.CreditHourValue;
                //		output.CreditValue.Description = helper.HandleLanguageMap( input.CreditHourType, output, "CreditHourType" );
                //	}
                //}
                //else
                //{
                //	output.CreditHourType = helper.HandleLanguageMap( input.CreditHourType, output, "CreditHourType" );
                //	output.CreditHourValue = input.CreditHourValue;

                //	output.CreditUnitType = helper.MapCAOToEnumermation( input.CreditUnitType );
                //	output.CreditUnitValue = input.CreditUnitValue;
                //	output.CreditUnitTypeDescription = helper.HandleLanguageMap( input.CreditUnitTypeDescription, output, "CreditUnitTypeDescription" );
                //}
            }


            //occupations
            //output.Occupation = helper.MapCAOListToEnumermation( input.OccupationType );
            //actually used by import
            output.Occupations = helper.MapCAOListToCAOProfileList(input.OccupationType);
            //just append alternative items. Ensure empty lists are ignored
            output.Occupations.AddRange(helper.AppendLanguageMapListToCAOProfileList(input.AlternativeOccupationType));

            //skip if no occupations
            if (output.Occupations.Count() == 0 &&
                UtilityManager.GetAppKeyValue("skipCredImportIfNoOccupations", false))
            {
                //LoggingHelper.DoTrace( 2, string.Format( "		***Skipping lopp# {0}, {1} as it has no occupations and this is a special run.", output.Id, output.Name ) );
                //return true;
            }
            //Industries
            output.Industries = helper.MapCAOListToCAOProfileList(input.IndustryType);
            output.Industries.AddRange(helper.AppendLanguageMapListToCAOProfileList(input.AlternativeIndustryType));
            //naics
            //output.Naics = input.Naics;

            output.InstructionalProgramTypes = helper.MapCAOListToCAOProfileList(input.InstructionalProgramType);
            output.InstructionalProgramTypes.AddRange(helper.AppendLanguageMapListToCAOProfileList(input.AlternativeInstructionalProgramType));
            if (output.InstructionalProgramTypes.Count() == 0 && UtilityManager.GetAppKeyValue("skipAsmtImportIfNoCIP", false))
            {
                //skip
                //LoggingHelper.DoTrace( 2, string.Format( "		***Skipping lopp# {0}, {1} as it has no InstructionalProgramTypes and this is a special run.", output.Id, output.Name ) );
                //return true;
            }

            output.LearningMethodType = helper.MapCAOListToEnumermation(input.LearningMethodType);
            output.Subject            = helper.MapCAOListToTextValueProfile(input.Subject, CodesManager.PROPERTY_CATEGORY_SUBJECT);

            //output.VerificationMethodDescription = helper.HandleLanguageMap( input.VerificationMethodDescription, output, "VerificationMethodDescription" );
            //financial assitance
            output.FinancialAssistance = helper.FormatFinancialAssistance(input.FinancialAssistance, ref status);

            output.Jurisdiction = helper.MapToJurisdiction(input.Jurisdiction, ref status);

            //***EstimatedCost
            //will need to format, all populate Entity.RelatedCosts (for bubble up) - actually this would be for asmts, and lopps
            output.EstimatedCost = helper.FormatCosts(input.EstimatedCost, ref status);
            //connections
            output.AdvancedStandingFrom = helper.FormatConditionProfile(input.AdvancedStandingFrom, ref status);
            output.AdvancedStandingFor  = helper.FormatConditionProfile(input.IsAdvancedStandingFor, ref status);

            output.PreparationFrom  = helper.FormatConditionProfile(input.PreparationFrom, ref status);
            output.IsPreparationFor = helper.FormatConditionProfile(input.IsPreparationFor, ref status);

            output.IsRequiredFor    = helper.FormatConditionProfile(input.IsRequiredFor, ref status);
            output.IsRecommendedFor = helper.FormatConditionProfile(input.IsRecommendedFor, ref status);

            //EstimatedDuration
            output.EstimatedDuration = helper.FormatDuration(input.EstimatedDuration, ref status);

            //conditions ======================================
            output.Requires       = helper.FormatConditionProfile(input.Requires, ref status);
            output.Recommends     = helper.FormatConditionProfile(input.Recommends, ref status);
            output.EntryCondition = helper.FormatConditionProfile(input.EntryCondition, ref status);
            output.Corequisite    = helper.FormatConditionProfile(input.Corequisite, ref status);

            //TODO - develope entity for IdentitifierValue
            output.VersionIdentifier     = helper.MapIdentifierValueListToString(input.VersionIdentifier);
            output.VersionIdentifierList = helper.MapIdentifierValueList(input.VersionIdentifier);


            //teaches compentencies
            output.TeachesCompetencies = helper.MapCAOListToCAOProfileList(input.Teaches);
            if (output.TeachesCompetencies.Count() == 0 && UtilityManager.GetAppKeyValue("skipLoppImportIfNoCompetencies", false))
            {
                //skip
                LoggingHelper.DoTrace(2, string.Format("		***Skipping lopp# {0}, {1} as it has no competencies and this is a special run.", output.Id, output.Name));
                return(true);
            }

            //common conditions
            output.ConditionManifestIds = helper.MapEntityReferences(input.CommonConditions, CodesManager.ENTITY_TYPE_CONDITION_MANIFEST, CodesManager.ENTITY_TYPE_LEARNING_OPP_PROFILE, ref status);
            //common costs
            output.CostManifestIds = helper.MapEntityReferences(input.CommonCosts, CodesManager.ENTITY_TYPE_COST_MANIFEST, CodesManager.ENTITY_TYPE_LEARNING_OPP_PROFILE, ref status);

            //ADDRESSES
            output.Addresses = helper.FormatAvailableAtAddresses(input.AvailableAt, ref status);

            //BYs
            output.AccreditedBy = helper.MapOrganizationReferenceGuids(input.AccreditedBy, ref status);
            output.ApprovedBy   = helper.MapOrganizationReferenceGuids(input.ApprovedBy, ref status);
            output.OwnedBy      = helper.MapOrganizationReferenceGuids(input.OwnedBy, ref status);
            output.OfferedBy    = helper.MapOrganizationReferenceGuids(input.OfferedBy, ref status);
            if (output.OwnedBy != null && output.OwnedBy.Count > 0)
            {
                output.OwningAgentUid = output.OwnedBy[0];
            }
            else
            {
                //add warning?
                if (output.OfferedBy == null && output.OfferedBy.Count == 0)
                {
                    status.AddWarning("document doesn't have an owning or offering organization.");
                }
            }
            output.RecognizedBy = helper.MapOrganizationReferenceGuids(input.RecognizedBy, ref status);
            output.RegulatedBy  = helper.MapOrganizationReferenceGuids(input.RegulatedBy, ref status);

            //INs
            output.AccreditedIn = helper.MapToJurisdiction(input.AccreditedIn, ref status);
            output.ApprovedIn   = helper.MapToJurisdiction(input.ApprovedIn, ref status);
            output.ApprovedIn   = helper.MapToJurisdiction(input.ApprovedIn, ref status);
            output.RecognizedIn = helper.MapToJurisdiction(input.RecognizedIn, ref status);
            output.RegulatedIn  = helper.MapToJurisdiction(input.RegulatedIn, ref status);


            //var hasPartIds = input.HasPart.Select( x => x.CtdlId ).ToList();
            output.HasPartIds = helper.MapEntityReferences(input.HasPart, CodesManager.ENTITY_TYPE_LEARNING_OPP_PROFILE, CodesManager.ENTITY_TYPE_LEARNING_OPP_PROFILE, ref status);

            //var isPartIds = input.IsPartOf.Select( x => x.CtdlId ).ToList();
            output.IsPartOfIds = helper.MapEntityReferences(input.IsPartOf, CodesManager.ENTITY_TYPE_LEARNING_OPP_PROFILE, CodesManager.ENTITY_TYPE_LEARNING_OPP_PROFILE, ref status);

            //=== if any messages were encountered treat as warnings for now
            if (messages.Count > 0)
            {
                status.SetMessages(messages, true);
            }
            //just in case check if entity added since start
            if (output.Id == 0)
            {
                ThisEntity entity = EntityServices.GetByCtid(ctid);
                if (entity != null && entity.Id > 0)
                {
                    output.Id    = entity.Id;
                    output.RowId = entity.RowId;
                }
            }
            importSuccessfull = mgr.Import(output, ref status);

            status.DocumentId    = output.Id;
            status.DetailPageUrl = string.Format("~/learningOpportunity/{0}", output.Id);
            status.DocumentRowId = output.RowId;

            //just in case
            if (status.HasErrors)
            {
                importSuccessfull = false;
            }

            //if record was added to db, add to/or set EntityResolution as resolved
            int ierId = new ImportManager().Import_EntityResolutionAdd(referencedAtId,
                                                                       ctid, CodesManager.ENTITY_TYPE_LEARNING_OPP_PROFILE,
                                                                       output.RowId,
                                                                       output.Id,
                                                                       (output.Id > 0),
                                                                       ref messages,
                                                                       output.Id > 0);

            return(importSuccessfull);
        }
        public bool ImportV3(string payload, string envelopeIdentifier, SaveStatus status)
        {
            LoggingHelper.DoTrace(6, "ImportV3 Assessment- entered.");
            List <string> messages = new List <string>();

            bool           importSuccessfull = false;
            EntityServices mgr        = new EntityServices();
            InputEntityV3  input      = new InputEntityV3();
            var            bnodes     = new List <BNode>();
            var            mainEntity = new Dictionary <string, object>();

            //status.AddWarning( "The resource uses @graph and is not handled yet" );

            Dictionary <string, object> dictionary = RegistryServices.JsonToDictionary(payload);
            object graph = dictionary["@graph"];
            //serialize the graph object
            var glist = JsonConvert.SerializeObject(graph);

            //parse graph in to list of objects
            JArray graphList = JArray.Parse(glist);
            int    cntr      = 0;

            foreach (var item in graphList)
            {
                cntr++;
                if (cntr == 1)
                {
                    var main = item.ToString();
                    //may not use this. Could add a trace method
                    mainEntity = RegistryServices.JsonToDictionary(main);
                    input      = JsonConvert.DeserializeObject <InputEntityV3>(main);
                }
                else
                {
                    var bn = item.ToString();
                    bnodes.Add(JsonConvert.DeserializeObject <BNode>(bn));
                }
            }
            ///============= process =============================


            MappingHelperV3 helper = new MappingHelperV3(3);

            helper.entityBlankNodes  = bnodes;
            helper.CurrentEntityCTID = input.CTID;
            helper.CurrentEntityName = input.Name.ToString();

            string ctid = input.CTID;

            status.Ctid = ctid;
            string referencedAtId = input.CtdlId;

            LoggingHelper.DoTrace(5, "		name: "+ input.Name.ToString());
            LoggingHelper.DoTrace(6, "		url: "+ input.SubjectWebpage);
            LoggingHelper.DoTrace(5, "		ctid: "+ input.CTID);
            LoggingHelper.DoTrace(5, "		@Id: "+ input.CtdlId);


            if (status.DoingDownloadOnly)
            {
                return(true);
            }

            if (!DoesEntityExist(input.CTID, ref output))
            {
                //set the rowid now, so that can be referenced as needed
                output.RowId = Guid.NewGuid();
                LoggingHelper.DoTrace(1, string.Format(thisClassName + ".ImportV3(). Record was NOT found using CTID: '{0}'", input.CTID));
            }
            else
            {
                LoggingHelper.DoTrace(1, string.Format(thisClassName + ".ImportV3(). Found record: '{0}' using CTID: '{1}'", input.Name, input.CTID));
            }
            helper.currentBaseObject = output;

            //start with language and may use with language maps
            helper.MapInLanguageToTextValueProfile(input.InLanguage, "Assessment.InLanguage.CTID: " + ctid);
            //foreach ( var l in input.InLanguage )
            //{
            //	if ( !string.IsNullOrWhiteSpace( l ) )
            //	{
            //		var language = CodesManager.GetLanguage( l );
            //		output.InLanguageCodeList.Add( new TextValueProfile()
            //		{
            //			CodeId = language.CodeId,
            //			TextTitle = language.Name,
            //			TextValue = language.Value
            //		} );
            //	}
            //}

            if (input.InLanguage.Count > 0)
            {
                //could use to alter helper.DefaultLanguage
            }
            output.Name        = helper.HandleLanguageMap(input.Name, output, "Name");
            output.Description = helper.HandleLanguageMap(input.Description, output, "Description");
            output.CTID        = input.CTID;
            //TBD handling of referencing third party publisher
            if (!string.IsNullOrWhiteSpace(status.DocumentPublishedBy))
            {
                //output.PublishedByOrganizationCTID = status.DocumentPublishedBy;
                var porg = OrganizationManager.GetSummaryByCtid(status.DocumentPublishedBy);
                if (porg != null && porg.Id > 0)
                {
                    //TODO - store this in a json blob??????????
                    //this will result in being added to Entity.AgentRelationship
                    output.PublishedBy = new List <Guid>()
                    {
                        porg.RowId
                    };
                }
                else
                {
                    //if publisher not imported yet, all publishee stuff will be orphaned
                    var entityUid = Guid.NewGuid();
                    var statusMsg = "";
                    var resPos    = referencedAtId.IndexOf("/resources/");
                    var swp       = referencedAtId.Substring(0, (resPos + "/resources/".Length)) + status.DocumentPublishedBy;
                    int orgId     = new OrganizationManager().AddPendingRecord(entityUid, status.DocumentPublishedBy, swp, ref statusMsg);
                }
            }
            else
            {
                //may need a check for existing published by to ensure not lost
                if (output.Id > 0)
                {
                    if (output.OrganizationRole != null && output.OrganizationRole.Any())
                    {
                        var publishedByList = output.OrganizationRole.Where(s => s.RoleTypeId == 30).ToList();
                        if (publishedByList != null && publishedByList.Any())
                        {
                            var pby = publishedByList[0].ActingAgentUid;
                            output.PublishedBy = new List <Guid>()
                            {
                                publishedByList[0].ActingAgentUid
                            };
                        }
                    }
                }
            }
            output.CredentialRegistryId = envelopeIdentifier;
            output.DateEffective        = input.DateEffective;
            output.ExpirationDate       = input.ExpirationDate;

            output.SubjectWebpage = input.SubjectWebpage;
            //
            //BYs - do owned and offered first

            output.OfferedBy = helper.MapOrganizationReferenceGuids("Assessment.OfferedBy", input.OfferedBy, ref status);
            output.OwnedBy   = helper.MapOrganizationReferenceGuids("Assessment.OwnedBy", input.OwnedBy, ref status);
            if (output.OwnedBy != null && output.OwnedBy.Count > 0)
            {
                output.OwningAgentUid        = output.OwnedBy[0];
                helper.CurrentOwningAgentUid = output.OwnedBy[0];
            }
            else
            {
                //add warning?
                if (output.OfferedBy == null && output.OfferedBy.Count == 0)
                {
                    status.AddWarning("document doesn't have an owning or offering organization.");
                }
            }
            output.AccreditedBy = helper.MapOrganizationReferenceGuids("Assessment.AccreditedBy", input.AccreditedBy, ref status);
            output.ApprovedBy   = helper.MapOrganizationReferenceGuids("Assessment.ApprovedBy", input.ApprovedBy, ref status);
            output.RecognizedBy = helper.MapOrganizationReferenceGuids("Assessment.RecognizedBy", input.RecognizedBy, ref status);
            output.RegulatedBy  = helper.MapOrganizationReferenceGuids("Assessment.RegulatedBy", input.RegulatedBy, ref status);


            //
            output.Subject             = helper.MapCAOListToTextValueProfile(input.Subject, CodesManager.PROPERTY_CATEGORY_SUBJECT);
            output.Keyword             = helper.MapToTextValueProfile(input.Keyword, output, "Keyword");
            output.AvailabilityListing = helper.MapListToString(input.AvailabilityListing);
            output.AvailableOnlineAt   = helper.MapListToString(input.AvailableOnlineAt);
            output.AssessmentExample   = input.AssessmentExample;
            output.ExternalResearch    = helper.MapListToString(input.ExternalResearch);

            output.AssessmentExampleDescription = helper.HandleLanguageMap(input.AssessmentExampleDescription, output, "AssessmentExampleDescription");
            output.AssessmentMethodType         = helper.MapCAOListToEnumermation(input.AssessmentMethodType);
            output.AssessmentMethodDescription  = helper.HandleLanguageMap(input.AssessmentMethodDescription, output, "AssessmentMethodDescription");
            //
            output.LearningMethodDescription = helper.HandleLanguageMap(input.LearningMethodDescription, output, "LearningMethodDescription");


            output.AudienceType = helper.MapCAOListToEnumermation(input.AudienceType);
            //CAO
            output.AudienceLevelType = helper.MapCAOListToEnumermation(input.AudienceLevelType);

            output.VersionIdentifier     = helper.MapIdentifierValueListToString(input.VersionIdentifier);
            output.VersionIdentifierList = helper.MapIdentifierValueList(input.VersionIdentifier);

            //To be looked
            output.CodedNotation = input.CodedNotation;
            output.Identifier    = helper.MapIdentifierValueList(input.Identifier);
            if (output.Identifier != null && output.Identifier.Count() > 0)
            {
                output.IdentifierJson = JsonConvert.SerializeObject(output.Identifier, MappingHelperV3.GetJsonSettings());
            }

            output.AssessmentOutput        = helper.HandleLanguageMap(input.AssessmentOutput, output, "AssessmentOutput");
            output.AssessmentUseType       = helper.MapCAOListToEnumermation(input.AssessmentUseType);
            output.DeliveryType            = helper.MapCAOListToEnumermation(input.DeliveryType);
            output.DeliveryTypeDescription = helper.HandleLanguageMap(input.DeliveryTypeDescription, output, "DeliveryTypeDescription");

            output.IsProctored           = input.IsProctored;
            output.HasGroupEvaluation    = input.HasGroupEvaluation;
            output.HasGroupParticipation = input.HasGroupParticipation;

            output.ProcessStandards            = input.ProcessStandards;
            output.ProcessStandardsDescription = helper.HandleLanguageMap(input.ProcessStandardsDescription, output, "ProcessStandardsDescription");
            output.ScoringMethodDescription    = helper.HandleLanguageMap(input.ScoringMethodDescription, output, "ScoringMethodDescription");

            output.ScoringMethodExample            = input.ScoringMethodExample;
            output.ScoringMethodExampleDescription = helper.HandleLanguageMap(input.ScoringMethodExampleDescription, output, "ScoringMethodExampleDescription");
            output.ScoringMethodType = helper.MapCAOListToEnumermation(input.ScoringMethodType);

            //TBD - a custom version
            //output.InstructionalProgramType = helper.MapCAOListToEnumermation( input.InstructionalProgramType );
            //occupations
            output.Occupations = helper.MapCAOListToCAOProfileList(input.OccupationType);
            //just append alternative items. Ensure empty lists are ignored
            //output.Occupations.AddRange( helper.AppendLanguageMapListToCAOProfileList( input.AlternativeOccupationType ) );

            //skip if no occupations
            if (output.Occupations.Count() == 0 &&
                UtilityManager.GetAppKeyValue("skipCredImportIfNoOccupations", false))
            {
                //LoggingHelper.DoTrace( 2, string.Format( "		***Skipping Credential# {0}, {1} as it has no occupations and this is a special run.", output.Id, output.Name ) );
                //return true;
            }
            //Industries
            output.Industries = helper.MapCAOListToCAOProfileList(input.IndustryType);
            //output.Industries.AddRange( helper.AppendLanguageMapListToCAOProfileList( input.AlternativeIndustryType ) );
            //naics
            //output.Naics = input.Naics;

            output.InstructionalProgramTypes = helper.MapCAOListToCAOProfileList(input.InstructionalProgramType);
            //output.InstructionalProgramTypes.AddRange( helper.AppendLanguageMapListToCAOProfileList( input.AlternativeInstructionalProgramType ) );
            if (output.InstructionalProgramTypes.Count() == 0 && UtilityManager.GetAppKeyValue("skipAsmtImportIfNoCIP", false))
            {
                //skip
                LoggingHelper.DoTrace(2, string.Format("		***Skipping asmt# {0}, {1} as it has no InstructionalProgramTypes and this is a special run.", output.Id, output.Name));
                return(true);
            }
            //============================================================
            //handle QuantitativeValue
            //21-03-23 making the move to ValueProfile
            //output.CreditValue = helper.HandleQuantitiveValue( input.CreditValue, "Assessment.CreditValue" );
            //output.QVCreditValueList = helper.HandleValueProfileListToQVList( input.CreditValue, "Assessment.CreditValue" );
            //don't initially need CreditValueList if using CreditValueJson here
            output.CreditValue = helper.HandleValueProfileList(input.CreditValue, "Assessment.CreditValue");
            //however, CreditValueJson must include resolved concepts
            //TODO - take the opportunity to move away from Enumerations
            output.CreditValueJson = JsonConvert.SerializeObject(output.CreditValue, MappingHelperV3.GetJsonSettings());
            //note can still have CreditUnitTypeDescription by itself. What to do if both?
            output.CreditUnitTypeDescription = helper.HandleLanguageMap(input.CreditUnitTypeDescription, output, "Assessment.CreditUnitTypeDescription");
            //if ( output.CreditValueList != null && output.CreditValueList.Any() )
            //	output.CreditValue = output.CreditValueList[ 0 ];
            //


            output.Jurisdiction = helper.MapToJurisdiction(input.Jurisdiction, ref status);

            //EstimatedCost
            //will need to format, all populate Entity.RelatedCosts (for bubble up) - actually this would be for asmts, and lopps
            output.EstimatedCost = helper.FormatCosts(input.EstimatedCost, ref status);

            //assesses compentencies
            output.AssessesCompetencies = helper.MapCAOListToCAOProfileList(input.Assesses);
            if (output.AssessesCompetencies.Count() == 0 && UtilityManager.GetAppKeyValue("skipAsmtImportIfNoCompetencies", false))
            {
                //skip
                LoggingHelper.DoTrace(2, string.Format("		***Skipping asmt# {0}, {1} as it has no competencies and this is a special run.", output.Id, output.Name));
                return(true);
            }

            //common conditions
            output.ConditionManifestIds = helper.MapEntityReferences(input.CommonConditions, CodesManager.ENTITY_TYPE_CONDITION_MANIFEST, CodesManager.ENTITY_TYPE_ASSESSMENT_PROFILE, ref status);
            //common costs
            output.CostManifestIds = helper.MapEntityReferences(input.CommonCosts, CodesManager.ENTITY_TYPE_COST_MANIFEST, CodesManager.ENTITY_TYPE_ASSESSMENT_PROFILE, ref status);

            //connections
            output.AdvancedStandingFrom  = helper.FormatConditionProfile(input.AdvancedStandingFrom, ref status);
            output.IsAdvancedStandingFor = helper.FormatConditionProfile(input.IsAdvancedStandingFor, ref status);

            output.PreparationFrom  = helper.FormatConditionProfile(input.PreparationFrom, ref status);
            output.IsPreparationFor = helper.FormatConditionProfile(input.IsPreparationFor, ref status);

            output.IsRequiredFor    = helper.FormatConditionProfile(input.IsRequiredFor, ref status);
            output.IsRecommendedFor = helper.FormatConditionProfile(input.IsRecommendedFor, ref status);

            //EstimatedDuration ==============================
            output.EstimatedDuration = helper.FormatDuration(input.EstimatedDuration, ref status);

            //conditions ======================================
            output.Requires       = helper.FormatConditionProfile(input.Requires, ref status);
            output.Recommends     = helper.FormatConditionProfile(input.Recommends, ref status);
            output.EntryCondition = helper.FormatConditionProfile(input.EntryCondition, ref status);
            output.Corequisite    = helper.FormatConditionProfile(input.Corequisite, ref status);

            //Process profiles ==============================
            output.AdministrationProcess = helper.FormatProcessProfile(input.AdministrationProcess, ref status);
            output.DevelopmentProcess    = helper.FormatProcessProfile(input.DevelopmentProcess, ref status);
            output.MaintenanceProcess    = helper.FormatProcessProfile(input.MaintenanceProcess, ref status);

            //

            output.Addresses = helper.FormatAvailableAtAddresses(input.AvailableAt, ref status);
            //targets
            if (input.TargetAssessment != null && input.TargetAssessment.Count > 0)
            {
                output.TargetAssessmentIds = helper.MapEntityReferences("Assessment.TargetAssessment", input.TargetAssessment, CodesManager.ENTITY_TYPE_ASSESSMENT_PROFILE, ref status);
            }
            //21-04-13 mp - TargetLearningResource will be URLs not registry resources
            if (input.TargetLearningResource != null && input.TargetLearningResource.Count > 0)
            {
                output.TargetLearningResource = input.TargetLearningResource;
                //output.TargetLearningOpportunityIds = helper.MapEntityReferences( "Assessment.TargetLearningOpportunity", input.TargetLearningResource, CodesManager.ENTITY_TYPE_LEARNING_OPP_PROFILE, ref status );
            }
            //
            if (input.TargetPathway != null && input.TargetPathway.Count > 0)
            {
                output.TargetPathwayIds = helper.MapEntityReferences("Assessment.TargetPathway", input.TargetPathway, CodesManager.ENTITY_TYPE_PATHWAY, ref status);
            }

            //INs
            output.AccreditedIn = helper.MapToJurisdiction(input.AccreditedIn, ref status);
            output.ApprovedIn   = helper.MapToJurisdiction(input.ApprovedIn, ref status);
            output.OfferedIn    = helper.MapToJurisdiction(input.OfferedIn, ref status);
            output.RecognizedIn = helper.MapToJurisdiction(input.RecognizedIn, ref status);
            output.RegulatedIn  = helper.MapToJurisdiction(input.RegulatedIn, ref status);

            //SameAs URI
            output.SameAs = helper.MapToTextValueProfile(input.SameAs);
            //FinancialAssistance ============================
            //output.FinancialAssistanceOLD = helper.FormatFinancialAssistance( input.FinancialAssistance, ref status );
            output.FinancialAssistance = helper.FormatFinancialAssistance(input.FinancialAssistance, ref status);
            if (output.FinancialAssistance != null && output.FinancialAssistance.Any())
            {
                output.FinancialAssistanceJson = JsonConvert.SerializeObject(output.FinancialAssistance, MappingHelperV3.GetJsonSettings());
            }

            //=== if any messages were encountered treat as warnings for now
            if (messages.Count > 0)
            {
                status.SetMessages(messages, true);
            }
            //just in case check if entity added since start
            if (output.Id == 0)
            {
                ThisEntity entity = EntityServices.GetByCtid(ctid);
                if (entity != null && entity.Id > 0)
                {
                    output.Id    = entity.Id;
                    output.RowId = entity.RowId;
                }
            }
            importSuccessfull = mgr.Import(output, ref status);

            status.DocumentId    = output.Id;
            status.DetailPageUrl = string.Format("~/assessment/{0}", output.Id);
            status.DocumentRowId = output.RowId;

            //just in case
            if (status.HasErrors)
            {
                importSuccessfull = false;
            }

            //if record was added to db, add to/or set EntityResolution as resolved
            int ierId = new ImportManager().Import_EntityResolutionAdd(referencedAtId,
                                                                       ctid,
                                                                       CodesManager.ENTITY_TYPE_ASSESSMENT_PROFILE,
                                                                       output.RowId,
                                                                       output.Id,
                                                                       (output.Id > 0),
                                                                       ref messages,
                                                                       output.Id > 0);

            return(importSuccessfull);
        }
        public bool ImportV3(string payload, string envelopeIdentifier, SaveStatus status)
        {
            //instantiate the input document (credential)
            InputEntityV3 input      = new InputEntityV3();
            var           bnodes     = new List <BNode>();
            var           mainEntity = new Dictionary <string, object>();
            //map payload to a dictionary
            Dictionary <string, object> dictionary = RegistryServices.JsonToDictionary(payload);
            //get the @graph property
            object graph = dictionary["@graph"];
            //serialize the graph object
            var glist = JsonConvert.SerializeObject(graph);

            //parse graph in to list of objects
            JArray graphList = JArray.Parse(glist);
            int    cntr      = 0;

            foreach (var item in graphList)
            {
                cntr++;
                if (cntr == 1)
                {
                    var main = item.ToString();
                    //may not use this. Could add a trace method
                    //mainEntity = RegistryServices.JsonToDictionary( main );
                    input = JsonConvert.DeserializeObject <InputEntityV3>(main);
                }
                else
                {
                    //save blank nodes - typically reference organizations
                    var bn = item.ToString();
                    bnodes.Add(JsonConvert.DeserializeObject <BNode>(bn));
                }
            }

            List <string>   messages          = new List <string>();
            bool            importSuccessfull = false;
            EntityServices  mgr    = new EntityServices();
            MappingHelperV3 helper = new MappingHelperV3();

            helper.entityBlankNodes = bnodes;

            status.EnvelopeId = envelopeIdentifier;
            try
            {
                //input = JsonConvert.DeserializeObject<InputEntity>( item.DecodedResource.ToString() );
                string ctid           = input.Ctid;
                string referencedAtId = input.CtdlId;

                LoggingHelper.DoTrace(5, "		name: "+ input.Name.ToString());
                LoggingHelper.DoTrace(6, "		url: "+ input.SubjectWebpage);
                LoggingHelper.DoTrace(5, "		ctid: "+ input.Ctid);
                LoggingHelper.DoTrace(6, "		@Id: "+ input.CtdlId);
                status.Ctid = ctid;

                if (status.DoingDownloadOnly)
                {
                    return(true);
                }

                if (!DoesEntityExist(input.Ctid, ref output))
                {
                    //set the rowid now, so that can be referenced as needed
                    output.RowId = Guid.NewGuid();
                }
                helper.currentBaseObject = output;

                //start with language and may use with language maps
                foreach (var l in input.InLanguage)
                {
                    if (!string.IsNullOrWhiteSpace(l))
                    {
                        var language = CodesManager.GetLanguage(l);
                        output.InLanguageCodeList.Add(new TextValueProfile()
                        {
                            CodeId    = language.CodeId,
                            TextTitle = language.Name,
                            TextValue = language.Value
                        });
                    }
                }

                if (input.InLanguage.Count > 0)
                {
                    //could use to alter helper.DefaultLanguage
                }
                output.Name           = helper.HandleLanguageMap(input.Name, output, "Name");
                output.Description    = helper.HandleLanguageMap(input.Description, output, "Description");
                output.SubjectWebpage = input.SubjectWebpage;
                output.CTID           = input.Ctid;
                //warning this gets set to blank if doing a manual import by ctid
                output.CredentialRegistryId = envelopeIdentifier;
                output.CredentialStatusType = helper.MapCAOToEnumermation(input.CredentialStatusType);
                output.DateEffective        = input.DateEffective;

                output.AlternateNames       = helper.MapToTextValueProfile(input.AlternateName, output, "AlternateName");
                output.ImageUrl             = input.Image;
                output.CredentialTypeSchema = input.CredentialType;


                output.AvailabilityListing = helper.MapListToString(input.AvailabilityListing);
                output.AvailableOnlineAt   = helper.MapListToString(input.AvailableOnlineAt);

                output.CredentialId = input.CredentialId;
                //TODO - develope entity for IdentitifierValue
                output.VersionIdentifier     = helper.MapIdentifierValueListToString(input.VersionIdentifier);
                output.VersionIdentifierList = helper.MapIdentifierValueList(input.VersionIdentifier);

                output.CodedNotation = input.CodedNotation;
                output.ISICV4        = input.IsicV4;

                output.ProcessStandards            = input.ProcessStandards;
                output.ProcessStandardsDescription = helper.HandleLanguageMap(input.ProcessStandardsDescription, output, "ProcessStandardsDescription");
                output.LatestVersion   = input.LatestVersion;
                output.PreviousVersion = input.PreviousVersion;
                output.NextVersion     = input.NextVersion;
                output.SupersededBy    = input.SupersededBy;
                output.Supersedes      = input.Supersedes;

                output.Subject = helper.MapCAOListToTextValueProfile(input.Subject, CodesManager.PROPERTY_CATEGORY_SUBJECT);

                //occupations
                //output.Occupation = helper.MapCAOListToEnumermation( input.OccupationType );
                //actually used by import
                output.Occupations = helper.MapCAOListToCAOProfileList(input.OccupationType);
                //just append alternative items. Ensure empty lists are ignored
                output.Occupations.AddRange(helper.AppendLanguageMapListToCAOProfileList(input.AlternativeOccupationType));

                //skip if no occupations
                if (output.Occupations.Count() == 0 &&
                    UtilityManager.GetAppKeyValue("skipCredImportIfNoOccupations", false))
                {
                    //LoggingHelper.DoTrace( 2, string.Format( "		***Skipping Credential# {0}, {1} as it has no occupations and this is a special run.", output.Id, output.Name ) );
                    //return true;
                }
                //Industries
                output.Industries = helper.MapCAOListToCAOProfileList(input.IndustryType);
                output.Industries.AddRange(helper.AppendLanguageMapListToCAOProfileList(input.AlternativeIndustryType));
                //naics
                output.Naics = input.Naics;

                output.InstructionalProgramTypes = helper.MapCAOListToCAOProfileList(input.InstructionalProgramType);
                output.InstructionalProgramTypes.AddRange(helper.AppendLanguageMapListToCAOProfileList(input.AlternativeInstructionalProgramType));
                //
                //will want a custom method to lookup the rating
                NavyServices nsrvs = new NavyServices();
                output.NavyRating = NavyServices.MapRatingsListToEnumermation(input.HasRating);
                output.NavyRatingType.AddRange(nsrvs.MapCAOListToCAOProfileList(input.HasRating, ref messages));
                //

                output.Keyword = helper.MapToTextValueProfile(input.Keyword, output, "Keyword");

                output.Jurisdiction = helper.MapToJurisdiction(input.Jurisdiction, ref status);
                //CopyrightHolder - expecting single; will need to expand
                output.CopyrightHolder = helper.MapOrganizationReferencesGuid("Credential.CopyrightHolder", input.CopyrightHolder, ref status);
                //CAO
                output.AudienceLevelType = helper.MapCAOListToEnumermation(input.AudienceLevelType);
                //
                output.AudienceType        = helper.MapCAOListToEnumermation(input.AudienceType);
                output.DegreeConcentration = helper.MapCAOListToTextValueProfile(input.DegreeConcentration, CodesManager.PROPERTY_CATEGORY_DEGREE_CONCENTRATION);
                output.DegreeMajor         = helper.MapCAOListToTextValueProfile(input.DegreeMajor, CodesManager.PROPERTY_CATEGORY_DEGREE_MAJOR);
                output.DegreeMinor         = helper.MapCAOListToTextValueProfile(input.DegreeMinor, CodesManager.PROPERTY_CATEGORY_DEGREE_MINOR);

                output.AssessmentDeliveryType = helper.MapCAOListToEnumermation(input.AssessmentDeliveryType);
                output.LearningDeliveryType   = helper.MapCAOListToEnumermation(input.LearningDeliveryType);

                //EstimatedCost
                //will need to format, all populate Entity.RelatedCosts (for bubble up) - actually this would be for asmts, and lopps
                output.EstimatedCost = helper.FormatCosts(input.EstimatedCost, ref status);

                //EstimatedDuration
                output.EstimatedDuration = helper.FormatDuration(input.EstimatedDuration, ref status);
                output.RenewalFrequency  = helper.FormatDurationItem(input.RenewalFrequency);

                //conditions
                output.Requires    = helper.FormatConditionProfile(input.Requires, ref status);
                output.Recommends  = helper.FormatConditionProfile(input.Recommends, ref status);
                output.Renewal     = helper.FormatConditionProfile(input.Renewal, ref status);
                output.Corequisite = helper.FormatConditionProfile(input.Corequisite, ref status);
                output.Revocation  = helper.FormatRevocationProfile(input.Revocation, ref status);

                //connections
                output.AdvancedStandingFrom = helper.FormatConditionProfile(input.AdvancedStandingFrom, ref status);
                output.AdvancedStandingFor  = helper.FormatConditionProfile(input.IsAdvancedStandingFor, ref status);

                output.PreparationFrom  = helper.FormatConditionProfile(input.PreparationFrom, ref status);
                output.IsPreparationFor = helper.FormatConditionProfile(input.IsPreparationFor, ref status);

                output.IsRequiredFor    = helper.FormatConditionProfile(input.IsRequiredFor, ref status);
                output.IsRecommendedFor = helper.FormatConditionProfile(input.IsRecommendedFor, ref status);

                //common conditions
                output.ConditionManifestIds = helper.MapEntityReferences(input.CommonConditions, CodesManager.ENTITY_TYPE_CONDITION_MANIFEST, CodesManager.ENTITY_TYPE_CREDENTIAL, ref status);
                //common costs
                output.CostManifestIds = helper.MapEntityReferences(input.CommonCosts, CodesManager.ENTITY_TYPE_COST_MANIFEST, CodesManager.ENTITY_TYPE_CREDENTIAL, ref status);

                //HasPart/IsPart
                //WARNING - these methods assume all parts are the same type - the provided thisEntityTypeId. AT THIS TIME, THE PARTS SHOULD ALL BE CREDENTIALS
                output.HasPartIds  = helper.MapEntityReferences(input.HasPart, thisEntityTypeId, ref status);
                output.IsPartOfIds = helper.MapEntityReferences(input.IsPartOf, thisEntityTypeId, ref status);

                //Process profiles
                output.AdministrationProcess = helper.FormatProcessProfile(input.AdministrationProcess, ref status);
                output.DevelopmentProcess    = helper.FormatProcessProfile(input.DevelopmentProcess, ref status);
                output.MaintenanceProcess    = helper.FormatProcessProfile(input.MaintenanceProcess, ref status);

                output.AppealProcess     = helper.FormatProcessProfile(input.AppealProcess, ref status);
                output.ComplaintProcess  = helper.FormatProcessProfile(input.ComplaintProcess, ref status);
                output.ReviewProcess     = helper.FormatProcessProfile(input.ReviewProcess, ref status);
                output.RevocationProcess = helper.FormatProcessProfile(input.RevocationProcess, ref status);

                //FinancialAssistance
                output.FinancialAssistance = helper.FormatFinancialAssistance(input.FinancialAssistance, ref status);


                output.Addresses = helper.FormatAvailableAtAddresses(input.AvailableAt, ref status);

                //BYs
                output.AccreditedBy = helper.MapOrganizationReferenceGuids("Credential.AccreditedBy", input.AccreditedBy, ref status);
                output.ApprovedBy   = helper.MapOrganizationReferenceGuids("Credential.ApprovedBy", input.ApprovedBy, ref status);
                output.OfferedBy    = helper.MapOrganizationReferenceGuids("Credential.OfferedBy", input.OfferedBy, ref status);
                //note need to set output.OwningAgentUid to the first entry
                output.OwnedBy = helper.MapOrganizationReferenceGuids("Credential.OwnedBy", input.OwnedBy, ref status);
                if (output.OwnedBy != null && output.OwnedBy.Count > 0)
                {
                    output.OwningAgentUid = output.OwnedBy[0];
                }
                else
                {
                    //add warning?
                    if (output.OfferedBy == null && output.OfferedBy.Count == 0)
                    {
                        status.AddWarning("document doesn't have an owning or offering organization.");
                    }
                }

                output.RecognizedBy = helper.MapOrganizationReferenceGuids("Credential.RecognizedBy", input.RecognizedBy, ref status);
                output.RegulatedBy  = helper.MapOrganizationReferenceGuids("Credential.RegulatedBy", input.RegulatedBy, ref status);
                output.RevokedBy    = helper.MapOrganizationReferenceGuids("Credential.RevokedBy", input.RevokedBy, ref status);
                output.RenewedBy    = helper.MapOrganizationReferenceGuids("Credential.RenewedBy", input.RenewedBy, ref status);

                //INs
                output.AccreditedIn = helper.MapToJurisdiction(input.AccreditedIn, ref status);
                output.ApprovedIn   = helper.MapToJurisdiction(input.ApprovedIn, ref status);
                output.ApprovedIn   = helper.MapToJurisdiction(input.ApprovedIn, ref status);
                output.RecognizedIn = helper.MapToJurisdiction(input.RecognizedIn, ref status);
                output.RegulatedIn  = helper.MapToJurisdiction(input.RegulatedIn, ref status);
                output.RevokedIn    = helper.MapToJurisdiction(input.RevokedIn, ref status);
                output.RenewedIn    = helper.MapToJurisdiction(input.RenewedIn, ref status);

                //=== if any messages were encountered treat as warnings for now
                if (messages.Count > 0)
                {
                    status.SetMessages(messages, true);
                }
                //just in case check if entity added since start
                if (output.Id == 0)
                {
                    ThisEntity entity = EntityServices.GetByCtid(ctid);
                    if (entity != null && entity.Id > 0)
                    {
                        output.Id    = entity.Id;
                        output.RowId = entity.RowId;
                    }
                }
                //save the data
                importSuccessfull    = mgr.Import(output, ref status);
                status.DocumentId    = output.Id;
                status.DetailPageUrl = string.Format("~/credential/{0}", output.Id);
                status.DocumentRowId = output.RowId;

                //if record was added to db, add to/or set EntityResolution as resolved
                int ierId = new ImportManager().Import_EntityResolutionAdd(referencedAtId,
                                                                           ctid,
                                                                           CodesManager.ENTITY_TYPE_CREDENTIAL,
                                                                           output.RowId,
                                                                           output.Id,
                                                                           (output.Id > 0),
                                                                           ref messages,
                                                                           output.Id > 0);
                //just in case
                if (status.HasErrors)
                {
                    importSuccessfull = false;
                }
            }
            catch (Exception ex)
            {
                LoggingHelper.LogError(ex, string.Format("Exception encountered in envelopeId: {0}", envelopeIdentifier), false, "workIT Import exception");
            }

            return(importSuccessfull);
        }