public bool ProcessEnvelope(ReadEnvelope item, SaveStatus status)
{
if (item == null || string.IsNullOrWhiteSpace(item.EnvelopeIdentifier))
{
status.AddError("A valid ReadEnvelope must be provided.");
return(false);
}
string payload = item.DecodedResource.ToString();
string envelopeIdentifier = item.EnvelopeIdentifier;
string ctdlType = RegistryServices.GetResourceType(payload);
string envelopeUrl = RegistryServices.GetEnvelopeUrl(envelopeIdentifier);
if (ImportServiceHelpers.IsAGraphResource(payload))
{
//if ( payload.IndexOf( "\"en\":" ) > 0 )
return(ImportV3(payload, envelopeIdentifier, status));
//else
// return ImportV2( payload, envelopeIdentifier, status );
}
else
{
LoggingHelper.DoTrace(5, " envelopeUrl: "+ envelopeUrl);
LoggingHelper.WriteLogFile(1, "lopp_" + item.EnvelopeIdentifier, payload, "", false);
input = JsonConvert.DeserializeObject <InputEntity>(item.DecodedResource.ToString());
return(Import(input, envelopeIdentifier, status));
}
}
} //
/// <summary>
/// Retrieve an envelop from the registry and do import
/// </summary>
/// <param name="envelopeId"></param>
/// <param name="status"></param>
/// <returns></returns>
public bool ImportByEnvelopeId(string envelopeId, SaveStatus status)
{
//this is currently specific, assumes envelop contains a credential
//can use the hack fo GetResourceType to determine the type, and then call the appropriate import method
if (string.IsNullOrWhiteSpace(envelopeId))
{
status.AddError("ImportByEnvelope - a valid envelope id must be provided");
return(false);
}
string statusMessage = "";
//EntityServices mgr = new EntityServices();
string ctdlType = "";
try
{
ReadEnvelope envelope = RegistryServices.GetEnvelope(envelopeId, ref statusMessage, ref ctdlType);
if (envelope != null && !string.IsNullOrWhiteSpace(envelope.EnvelopeIdentifier))
{
return(ProcessEnvelope(envelope, status));
}
else
{
return(false);
}
} catch (Exception ex)
{
LoggingHelper.LogError(ex, "ImportCredential.ImportByEnvelopeId()");
return(false);
}
}
public bool ProcessEnvelope(ReadEnvelope item, SaveStatus status)
{
if (item == null || string.IsNullOrWhiteSpace(item.EnvelopeIdentifier))
{
status.AddError(thisClassName + " A valid ReadEnvelope must be provided.");
return(false);
}
DateTime createDate = new DateTime();
DateTime envelopeUpdateDate = new DateTime();
if (DateTime.TryParse(item.NodeHeaders.CreatedAt.Replace("UTC", "").Trim(), out createDate))
{
status.SetEnvelopeCreated(createDate);
}
if (DateTime.TryParse(item.NodeHeaders.UpdatedAt.Replace("UTC", "").Trim(), out envelopeUpdateDate))
{
status.SetEnvelopeUpdated(envelopeUpdateDate);
}
string payload = item.DecodedResource.ToString();
string envelopeIdentifier = item.EnvelopeIdentifier;
string ctdlType = RegistryServices.GetResourceType(payload);
string envelopeUrl = RegistryServices.GetEnvelopeUrl(envelopeIdentifier);
LoggingHelper.DoTrace(5, " envelopeUrl: "+ envelopeUrl);
LoggingHelper.WriteLogFile(UtilityManager.GetAppKeyValue("logFileTraceLevel", 5), item.EnvelopeCetermsCtid + "_ConceptScheme", payload, "", false);
//just store input for now
return(Import(payload, envelopeIdentifier, status));
//return true;
} //
public bool ProcessEnvelope(ReadEnvelope item, SaveStatus status)
{
if (item == null || string.IsNullOrWhiteSpace(item.EnvelopeIdentifier))
{
status.AddError("A valid ReadEnvelope must be provided.");
return(false);
}
DateTime createDate = new DateTime();
DateTime envelopeUpdateDate = new DateTime();
if (DateTime.TryParse(item.NodeHeaders.CreatedAt.Replace("UTC", "").Trim(), out createDate))
{
status.SetEnvelopeCreated(createDate);
}
if (DateTime.TryParse(item.NodeHeaders.UpdatedAt.Replace("UTC", "").Trim(), out envelopeUpdateDate))
{
status.SetEnvelopeUpdated(envelopeUpdateDate);
}
status.DocumentOwnedBy = item.documentOwnedBy;
if (item.documentPublishedBy != null)
{
if (item.documentOwnedBy == null || (item.documentPublishedBy != item.documentOwnedBy))
{
status.DocumentPublishedBy = item.documentPublishedBy;
}
}
else
{
//will need to check elsewhere
//OR as part of import check if existing one had 3rd party publisher
}
string payload = item.DecodedResource.ToString();
string envelopeIdentifier = item.EnvelopeIdentifier;
string ctdlType = RegistryServices.GetResourceType(payload);
string envelopeUrl = RegistryServices.GetEnvelopeUrl(envelopeIdentifier);
//Already done in RegistryImport
//LoggingHelper.WriteLogFile( UtilityManager.GetAppKeyValue( "logFileTraceLevel", 5 ), item.EnvelopeCetermsCtid + "_assessment", payload, "", false );
if (ImportServiceHelpers.IsAGraphResource(payload))
{
//if ( payload.IndexOf( "\"en\":" ) > 0 )
return(ImportV3(payload, envelopeIdentifier, status));
//else
// return ImportV2( payload, envelopeIdentifier, status );
}
else
{
status.AddError(thisClassName + ".ImportByResourceUrl - 2019-05-01 ONLY GRAPH BASED IMPORTS ARE HANDLED");
return(false);
//LoggingHelper.DoTrace( 5, " envelopeUrl: " + envelopeUrl );
// LoggingHelper.WriteLogFile( 1, "asmt_" + item.EnvelopeIdentifier, payload, "", false );
// input = JsonConvert.DeserializeObject<InputEntity>( item.DecodedResource.ToString() );
// return Import( input, envelopeIdentifier, status );
}
}
public bool ProcessEnvelope(ReadEnvelope item, SaveStatus status)
{
if (item == null || string.IsNullOrWhiteSpace(item.EnvelopeIdentifier))
{
status.AddError("A valid ReadEnvelope must be provided.");
return(false);
}
//
DateTime createDate = new DateTime();
DateTime envelopeUpdateDate = new DateTime();
if (DateTime.TryParse(item.NodeHeaders.CreatedAt.Replace("UTC", "").Trim(), out createDate))
{
status.SetEnvelopeCreated(createDate);
}
if (DateTime.TryParse(item.NodeHeaders.UpdatedAt.Replace("UTC", "").Trim(), out envelopeUpdateDate))
{
status.SetEnvelopeUpdated(envelopeUpdateDate);
}
status.DocumentOwnedBy = item.documentOwnedBy;
if (item.documentOwnedBy != null && item.documentPublishedBy != null && item.documentPublishedBy != item.documentOwnedBy)
{
status.DocumentPublishedBy = item.documentPublishedBy;
}
//
string payload = item.DecodedResource.ToString();
status.EnvelopeId = item.EnvelopeIdentifier;
string ctdlType = RegistryServices.GetResourceType(payload);
//string envelopeUrl = RegistryServices.GetEnvelopeUrl( status.EnvelopeId );
//Already done in RegistryImport
//LoggingHelper.WriteLogFile( UtilityManager.GetAppKeyValue( "logFileTraceLevel", 5 ), item.EnvelopeCetermsCtid + "_organization", payload, "", false );
if (ImportServiceHelpers.IsAGraphResource(payload))
{
//if ( payload.IndexOf( "\"en\":" ) > 0 )
return(ImportV3(payload, status));
//else
// return ImportV2( payload, envelopeIdentifier, status );
}
else
{
status.AddError("Importing of an organization resource payload is no longer supported. Please provide a /graph/ input.");
//LoggingHelper.DoTrace( 5, " envelopeUrl: " + envelopeUrl );
//LoggingHelper.WriteLogFile( 1, "org_" + item.EnvelopeIdentifier, payload, "", false );
//input = JsonConvert.DeserializeObject<InputEntity>( item.DecodedResource.ToString() );
//return Import( input, envelopeIdentifier, status );
return(false);
}
}
public bool ProcessEnvelope(ReadEnvelope item, SaveStatus status)
{
if (item == null || string.IsNullOrWhiteSpace(item.EnvelopeIdentifier))
{
status.AddError(thisClassName + " A valid ReadEnvelope must be provided.");
return(false);
}
DateTime createDate = new DateTime();
DateTime envelopeUpdateDate = new DateTime();
if (DateTime.TryParse(item.NodeHeaders.CreatedAt.Replace("UTC", "").Trim(), out createDate))
{
status.SetEnvelopeCreated(createDate);
}
if (DateTime.TryParse(item.NodeHeaders.UpdatedAt.Replace("UTC", "").Trim(), out envelopeUpdateDate))
{
status.SetEnvelopeUpdated(envelopeUpdateDate);
}
status.DocumentOwnedBy = item.documentOwnedBy;
if (item.documentPublishedBy != null)
{
if (item.documentOwnedBy == null || (item.documentPublishedBy != item.documentOwnedBy))
{
status.DocumentPublishedBy = item.documentPublishedBy;
}
}
else
{
//will need to check elsewhere
//OR as part of import check if existing one had 3rd party publisher
}
string payload = item.DecodedResource.ToString();
string envelopeIdentifier = item.EnvelopeIdentifier;
string ctdlType = RegistryServices.GetResourceType(payload);
string envelopeUrl = RegistryServices.GetEnvelopeUrl(envelopeIdentifier);
LoggingHelper.DoTrace(5, " envelopeUrl: "+ envelopeUrl);
LoggingHelper.WriteLogFile(UtilityManager.GetAppKeyValue("logFileTraceLevel", 5), item.EnvelopeCetermsCtid + "_competencyFrameswork", payload, "", false);
//input = JsonConvert.DeserializeObject<InputGraph>( item.DecodedResource.ToString() );
//InputEntity framework = GetFramework( input.Graph );
//LoggingHelper.DoTrace( 5, " framework name: " + framework.name.ToString() );
//just store input for now
return(Import(payload, envelopeIdentifier, status));
//return true;
} //
/// <summary>
/// Retrieve an resource from the registry by ctid and do import
/// </summary>
/// <param name="ctid"></param>
/// <param name="status"></param>
/// <returns></returns>
public bool ImportByCtid(string ctid, SaveStatus status)
{
if (string.IsNullOrWhiteSpace(ctid))
{
status.AddError(thisClassName + ".ImportByCtid - a valid ctid must be provided");
return(false);
}
//this is currently specific, assumes envelop contains a credential
//can use the hack for GetResourceType to determine the type, and then call the appropriate import method
string statusMessage = "";
EntityServices mgr = new EntityServices();
string ctdlType = "";
try
{
//probably always want to get by envelope
ReadEnvelope envelope = RegistryServices.GetEnvelopeByCtid(ctid, ref statusMessage, ref ctdlType);
if (envelope != null && !string.IsNullOrWhiteSpace(envelope.EnvelopeIdentifier))
{
return(CustomProcessEnvelope(envelope, status));
}
else
{
return(false);
}
//string payload = RegistryServices.GetResourceByCtid( ctid, ref ctdlType, ref statusMessage );
//if ( !string.IsNullOrWhiteSpace( payload ) )
//{
// input = JsonConvert.DeserializeObject<InputEntity>( payload.ToString() );
// //ctdlType = RegistryServices.GetResourceType( payload );
// return Import( mgr, input, "", status );
//}
//else
// return false;
}
catch (Exception ex)
{
LoggingHelper.LogError(ex, thisClassName + string.Format(".ImportByCtid(). CTID: {0}", ctid));
status.AddError(ex.Message);
if (ex.Message.IndexOf("Path '@context', line 1") > 0)
{
status.AddWarning("The referenced registry document is using an old schema. Please republish it with the latest schema!");
}
return(false);
}
}
public bool CustomProcessEnvelope(ReadEnvelope item, SaveStatus status)
{
//handle
bool importSuccessfull = ProcessEnvelope(item, status);
List <string> messages = new List <string>();
string importError = string.Join("\r\n", status.GetAllMessages().ToArray());
//store envelope
int newImportId = importHelper.Add(item, CodesManager.ENTITY_TYPE_PATHWAY, status.Ctid, importSuccessfull, importError, ref messages);
if (newImportId > 0 && status.Messages != null && status.Messages.Count > 0)
{
//add indicator of current recored
string msg = string.Format("========= Messages for {4}, EnvelopeIdentifier: {0}, ctid: {1}, Id: {2}, rowId: {3} =========", item.EnvelopeIdentifier, status.Ctid, status.DocumentId, status.DocumentRowId, thisClassName);
importHelper.AddMessages(newImportId, status, ref messages);
}
return(importSuccessfull);
}
/// <summary>
/// Custom version, typically called outside a scheduled import
/// </summary>
/// <param name="item"></param>
/// <param name="status"></param>
/// <returns></returns>
public bool CustomProcessEnvelope(ReadEnvelope item, SaveStatus status)
{
EntityServices mgr = new EntityServices();
bool importSuccessfull = ProcessEnvelope(item, status);
List <string> messages = new List <string>();
string importError = string.Join("\r\n", status.GetAllMessages().ToArray());
//store envelope
int newImportId = importHelper.Add(item, 2, status.Ctid, importSuccessfull, importError, ref messages);
if (newImportId > 0 && status.Messages != null && status.Messages.Count > 0)
{
//add indicator of current recored
string msg = string.Format("========= Messages for Organization, EnvelopeIdentifier: {0}, ctid: {1}, Id: {2}, rowId: {3} =========", item.EnvelopeIdentifier, status.Ctid, status.DocumentId, status.DocumentRowId);
importHelper.AddMessages(newImportId, status, ref messages);
}
return(importSuccessfull);
}
public bool ProcessEnvelope(ReadEnvelope item, SaveStatus status)
{
if (item == null || string.IsNullOrWhiteSpace(item.EnvelopeIdentifier))
{
status.AddError("A valid ReadEnvelope must be provided.");
return(false);
}
//
DateTime createDate = new DateTime();
DateTime envelopeUpdateDate = new DateTime();
if (DateTime.TryParse(item.NodeHeaders.CreatedAt.Replace("UTC", "").Trim(), out createDate))
{
status.SetEnvelopeCreated(createDate);
}
if (DateTime.TryParse(item.NodeHeaders.UpdatedAt.Replace("UTC", "").Trim(), out envelopeUpdateDate))
{
status.SetEnvelopeUpdated(envelopeUpdateDate);
}
//
string payload = item.DecodedResource.ToString();
string envelopeIdentifier = item.EnvelopeIdentifier;
string ctdlType = RegistryServices.GetResourceType(payload);
string envelopeUrl = RegistryServices.GetEnvelopeUrl(envelopeIdentifier);
LoggingHelper.WriteLogFile(UtilityManager.GetAppKeyValue("logFileTraceLevel", 5), item.EnvelopeCetermsCtid + "_costManifest", payload, "", false);
if (ImportServiceHelpers.IsAGraphResource(payload))
{
//if ( payload.IndexOf( "\"en\":" ) > 0 )
return(ImportV3(payload, "", status));
//else
// return ImportV2( payload, "", status );
}
else
{
status.AddError("A valid graph object must be provided for a cost manifest.");
return(false);
//LoggingHelper.DoTrace( 5, " envelopeUrl: " + envelopeUrl );
// LoggingHelper.WriteLogFile( 1, "costManifest_" + item.EnvelopeIdentifier, payload, "", false );
// input = JsonConvert.DeserializeObject<InputEntity>( item.DecodedResource.ToString() );
// return Import( input, envelopeIdentifier, status );
}
}
public static string GetCtidFromUnknownEnvelope(ReadEnvelope item)
{
string ctid = "";
//string envelopeId = "";
try
{
RegistryObject ro = new RegistryObject(item.DecodedResource.ToString());
ctid = ro.Ctid;
//TODO - this will have to change for type of @graph
//envelopeId = item.EnvelopeIdentifier;
//ctid = item.EnvelopeCetermsCtid ?? "";
//if ( !string.IsNullOrWhiteSpace( ctid ) )
// return ctid;
//string payload = item.DecodedResource.ToString();
//if ( payload.IndexOf( "@graph" ) > -1 )
//{
// UnknownPayload input = JsonConvert.DeserializeObject<UnknownPayload>( item.DecodedResource.ToString() );
// //extract from the @id
// if ( !string.IsNullOrWhiteSpace( input.Ctid ) )
// {
// ctid = input.Ctid;
// }
// else if ( !string.IsNullOrWhiteSpace( input.CtdlId ) )
// {
// int pos = input.CtdlId.LastIndexOf( "/" );
// ctid = input.CtdlId.Substring( pos );
// }
//}
//else
//{
// UnknownPayload input = JsonConvert.DeserializeObject<UnknownPayload>( item.DecodedResource.ToString() );
// ctid = input.Ctid;
//}
}
catch (Exception ex)
{
LoggingHelper.DoTrace(2, "GetCtidFromUnknownEnvelope - unable to extract ctid from envelope");
}
return(ctid);
}
public bool ProcessEnvelope(ReadEnvelope item, SaveStatus status)
{
if (item == null || string.IsNullOrWhiteSpace(item.EnvelopeIdentifier))
{
status.AddError("A valid ReadEnvelope must be provided.");
return(false);
}
DateTime createDate = new DateTime();
DateTime envelopeUpdateDate = new DateTime();
if (DateTime.TryParse(item.NodeHeaders.CreatedAt.Replace("UTC", "").Trim(), out createDate))
{
//entity.DocumentUpdatedAt = updateDate;
}
if (DateTime.TryParse(item.NodeHeaders.UpdatedAt.Replace("UTC", "").Trim(), out envelopeUpdateDate))
{
//entity.DocumentUpdatedAt = envelopeUpdateDate;
}
string payload = item.DecodedResource.ToString();
string envelopeIdentifier = item.EnvelopeIdentifier;
string ctdlType = RegistryServices.GetResourceType(payload);
string envelopeUrl = RegistryServices.GetEnvelopeUrl(envelopeIdentifier);
//if ( ImportServiceHelpers.IsAGraphResource( payload ) )
//{
//if ( payload.IndexOf( "\"en\":" ) > 0 )
return(ImportV3(payload, envelopeIdentifier, status));
//else
// return ImportV2( payload, envelopeIdentifier, status );
//}
//else
//{
// LoggingHelper.DoTrace( 5, " envelopeUrl: " + envelopeUrl );
// LoggingHelper.WriteLogFile( 1, "credential_" + item.EnvelopeIdentifier, payload, "", false );
// input = JsonConvert.DeserializeObject<InputEntity>( item.DecodedResource.ToString() );
// return Import( input, envelopeIdentifier, status, envelopeUpdateDate );
//}
}
/// <summary>
/// Add envelope and related data to the staging table
/// </summary>
/// <param name="item"></param>
/// <param name="entityTypeId"></param>
/// <param name="ctid"></param>
/// <param name="importSuccessfull"></param>
/// <param name="importErrorMsg"></param>
/// <param name="messages"></param>
/// <returns></returns>
public int Add(ReadEnvelope item, int entityTypeId, string ctid, bool importSuccessfull,
string importErrorMsg, ref List <string> messages)
{
ThisEntity entity = new ThisEntity();
entity.EntityTypedId = entityTypeId;
entity.EnvelopeId = item.EnvelopeIdentifier;
entity.Ctid = ctid;
entity.ResourcePublicKey = item.ResourcePublicKey;
DateTime updateDate = new DateTime();
if (DateTime.TryParse(item.NodeHeaders.UpdatedAt.Replace("UTC", "").Trim(), out updateDate))
{
entity.DocumentUpdatedAt = updateDate;
}
entity.Message = importErrorMsg;
entity.Payload = item.DecodedResource.ToString();
return(new EntityMgr().Add(entity, ref messages));
}
/// <summary>
/// Retrieve an envelop from the registry and do import
/// </summary>
/// <param name="envelopeId"></param>
/// <param name="status"></param>
/// <returns></returns>
public bool ImportByEnvelopeId(string envelopeId, SaveStatus status)
{
//this is currently specific, assumes envelop contains a credential
//can use the hack fo GetResourceType to determine the type, and then call the appropriate import method
if (string.IsNullOrWhiteSpace(envelopeId))
{
status.AddError(thisClassName + ".ImportByEnvelope - a valid envelope id must be provided");
return(false);
}
string statusMessage = "";
//EntityServices mgr = new EntityServices();
string ctdlType = "";
try
{
ReadEnvelope envelope = RegistryServices.GetEnvelope(envelopeId, ref statusMessage, ref ctdlType);
if (envelope != null && !string.IsNullOrWhiteSpace(envelope.EnvelopeIdentifier))
{
return(CustomProcessEnvelope(envelope, status));
}
else
{
return(false);
}
}
catch (Exception ex)
{
LoggingHelper.LogError(ex, thisClassName + ".ImportByEnvelopeId()");
status.AddError(ex.Message);
if (ex.Message.IndexOf("Path '@context', line 1") > 0)
{
status.AddWarning("The referenced registry document is using an old schema. Please republish it with the latest schema!");
}
return(false);
}
}
public bool ProcessEnvelope(EntityServices mgr, ReadEnvelope item, SaveStatus status)
{
if (item == null || string.IsNullOrWhiteSpace(item.EnvelopeIdentifier))
{
status.AddError(thisClassName + " A valid ReadEnvelope must be provided.");
return(false);
}
DateTime createDate = new DateTime();
DateTime envelopeUpdateDate = new DateTime();
if (DateTime.TryParse(item.NodeHeaders.CreatedAt.Replace("UTC", "").Trim(), out createDate))
{
//entity.DocumentUpdatedAt = updateDate;
}
if (DateTime.TryParse(item.NodeHeaders.UpdatedAt.Replace("UTC", "").Trim(), out envelopeUpdateDate))
{
//entity.DocumentUpdatedAt = envelopeUpdateDate;
}
string payload = item.DecodedResource.ToString();
string envelopeIdentifier = item.EnvelopeIdentifier;
string ctdlType = RegistryServices.GetResourceType(payload);
string envelopeUrl = RegistryServices.GetEnvelopeUrl(envelopeIdentifier);
LoggingHelper.DoTrace(5, " envelopeUrl: "+ envelopeUrl);
LoggingHelper.WriteLogFile(1, item.EnvelopeIdentifier + "_competencyFrameswork", payload, "", false);
//input = JsonConvert.DeserializeObject<InputGraph>( item.DecodedResource.ToString() );
//InputEntity framework = GetFramework( input.Graph );
//LoggingHelper.DoTrace( 5, " framework name: " + framework.name.ToString() );
//just store input for now
return(Import(mgr, payload, envelopeIdentifier, status));
//return true;
} //
/// <summary>
/// Retrieve an envelop from the registry and do import
/// </summary>
/// <param name="envelopeId"></param>
/// <param name="status"></param>
/// <returns></returns>
public bool ImportByEnvelopeId(string envelopeId, SaveStatus status)
{
//this is currently specific, assumes envelop contains a credential
//can use the hack for GetResourceType to determine the type, and then call the appropriate import method
if (string.IsNullOrWhiteSpace(envelopeId))
{
status.AddError("ImportByEnvelope - a valid envelope id must be provided");
return(false);
}
string statusMessage = "";
string ctdlType = "";
try
{
ReadEnvelope envelope = RegistryServices.GetEnvelope(envelopeId, ref statusMessage, ref ctdlType);
if (envelope == null || string.IsNullOrWhiteSpace(envelope.EnvelopeType))
{
string defCommunity = UtilityManager.GetAppKeyValue("defaultCommunity");
string community = UtilityManager.GetAppKeyValue("additionalCommunity");
if (defCommunity != community)
{
envelope = RegistryServices.GetEnvelope(envelopeId, ref statusMessage, ref ctdlType, community);
}
}
if (envelope != null && !string.IsNullOrWhiteSpace(envelope.EnvelopeIdentifier))
{
LoggingHelper.DoTrace(4, string.Format("RegistryServices.ImportByEnvelopeId ctdlType: {0}, EnvelopeId: {1} ", ctdlType, envelopeId));
ctdlType = ctdlType.Replace("ceterms:", "");
switch (ctdlType.ToLower())
{
case "credentialorganization":
case "qacredentialorganization": //what distinctions do we need for QA orgs?
case "organization":
return(new ImportOrganization().CustomProcessEnvelope(envelope, status));
//break;CredentialOrganization
case "assessmentprofile":
return(new ImportAssessment().CustomProcessEnvelope(envelope, status));
//break;
case "learningopportunityprofile":
return(new ImportLearningOpportunties().CustomProcessEnvelope(envelope, status));
//break;
case "conditionmanifest":
return(new ImportAssessment().CustomProcessEnvelope(envelope, status));
//break;
case "costmanifest":
return(new ImportLearningOpportunties().CustomProcessEnvelope(envelope, status));
//break;
default:
//default to credential
return(new ImportCredential().CustomProcessRequest(envelope, status));
//break;
}
}
else
{
return(false);
}
}
catch (Exception ex)
{
LoggingHelper.LogError(ex, string.Format("RegistryServices`.ImportByEnvelopeId(). ctdlType: {0}", ctdlType));
status.AddError(ex.Message);
if (ex.Message.IndexOf("Path '@context', line 1") > 0)
{
status.AddWarning("The referenced registry document is using an old schema. Please republish it with the latest schema!");
}
return(false);
}
}
/// <summary>
/// Use search to get the envelope for a ctid
/// </summary>
/// <param name="ctid"></param>
/// <param name="statusMessage"></param>
/// <param name="ctdlType"></param>
/// <returns></returns>
public static ReadEnvelope GetEnvelopeByCtid(string ctid, ref string statusMessage, ref string ctdlType, string community = "")
{
string document = "";
//perhaps this should be done in the caller. It could check the default or previous import source
if (string.IsNullOrWhiteSpace(community))
{
community = UtilityManager.GetAppKeyValue("defaultCommunity");
}
string additionalCommunity = UtilityManager.GetAppKeyValue("additionalCommunity");
string credentialEngineAPIKey = UtilityManager.GetAppKeyValue("CredentialEngineAPIKey");
//
string searchUrl = GetRegistrySearchUrl(community);
searchUrl = searchUrl + "ctid=" + ctid.ToLower();
LoggingHelper.DoTrace(5, string.Format("RegistryServices.ImportByCtid ctid: {0}, searchUrl: {1} ", ctid, searchUrl));
ReadEnvelope envelope = new ReadEnvelope();
List <ReadEnvelope> list = new List <ReadEnvelope>();
try
{
// Create a request for the URL.
WebRequest request = WebRequest.Create(searchUrl);
request.Credentials = CredentialCache.DefaultCredentials;
var hdr = new WebHeaderCollection
{
{ "Authorization", "Token " + credentialEngineAPIKey }
};
request.Headers.Add(hdr);
HttpWebResponse response = ( HttpWebResponse )request.GetResponse();
Stream dataStream = response.GetResponseStream();
// Open the stream using a StreamReader for easy access.
StreamReader reader = new StreamReader(dataStream);
// Read the content.
document = reader.ReadToEnd();
// Cleanup the streams and the response.
reader.Close();
dataStream.Close();
response.Close();
//map to list
list = JsonConvert.DeserializeObject <List <ReadEnvelope> >(document);
//only expecting one
if (list != null && list.Count > 0)
{
envelope = list[0];
if (envelope != null && !string.IsNullOrWhiteSpace(envelope.EnvelopeIdentifier))
{
string payload = envelope.DecodedResource.ToString();
ctdlType = RegistryServices.GetResourceType(payload);
}
}
}
catch (Exception exc)
{
LoggingHelper.LogError(exc, "RegistryServices.GetEnvelopeByCtid");
statusMessage = exc.Message;
}
return(envelope);
}
/// <summary>
/// Retrieve an envelope from the registry
/// </summary>
/// <param name="envelopeId"></param>
/// <param name="statusMessage"></param>
/// <param name="ctdlType"></param>
/// <returns></returns>
public static ReadEnvelope GetEnvelope(string envelopeId, ref string statusMessage, ref string ctdlType, string community = "")
{
string document = "";
//need to pass in an override community - eventually
if (string.IsNullOrWhiteSpace(community))
{
community = UtilityManager.GetAppKeyValue("defaultCommunity");
}
string serviceUri = GetEnvelopeUrl(envelopeId, community);
serviceUri = string.Format(serviceUri, envelopeId);
LoggingHelper.DoTrace(5, string.Format("RegistryServices.GetEnvelope envelopeId: {0}, serviceUri: {1} ", envelopeId, serviceUri));
ReadEnvelope envelope = new ReadEnvelope();
try
{
// Create a request for the URL.
WebRequest request = WebRequest.Create(serviceUri);
// If required by the server, set the credentials.
request.Credentials = CredentialCache.DefaultCredentials;
var hdr = new WebHeaderCollection
{
{ "Authorization", "Token " + credentialEngineAPIKey }
};
request.Headers.Add(hdr);
//Get the response.
HttpWebResponse response = ( HttpWebResponse )request.GetResponse();
// Get the stream containing content returned by the server.
Stream dataStream = response.GetResponseStream();
// Open the stream using a StreamReader for easy access.
StreamReader reader = new StreamReader(dataStream);
// Read the content.
document = reader.ReadToEnd();
// Cleanup the streams and the response.
reader.Close();
dataStream.Close();
response.Close();
//map to the default envelope
envelope = JsonConvert.DeserializeObject <ReadEnvelope>(document);
if (envelope != null && !string.IsNullOrWhiteSpace(envelope.EnvelopeIdentifier))
{
string payload = envelope.DecodedResource.ToString();
ctdlType = RegistryServices.GetResourceType(payload);
//return ProcessProxy( mgr, item, status );
}
}
catch (Exception exc)
{
LoggingHelper.LogError(exc, "RegistryServices.GetEnvelope");
statusMessage = exc.Message;
}
return(envelope);
}
