private void DisplayStatusMessage(string message, StatusMessageType messageType)
{
if (DisplayStatusMessageEvent != null)
{
DisplayStatusMessageEvent(message, messageType);
}
}
internal void DisplayStatusMessage(string message, StatusMessageType messageType)
{
if (message != null)
{
#if DEBUG
Debug.Print(message);
#else
if ((messageType != StatusMessageType.DEV) && (messageType != StatusMessageType.DEV_USER))
#endif
{
try
{
//display status message can be called from multiple threads
lock (mLogFileName)
{
string logFileEntry = DateTime.Now.ToString("dd/MMM/yyyy hh:mm:ss.fff") + ": " + messageType + ": " + message + Environment.NewLine;
//this will create the file if it doesn't exist
File.AppendAllText(mLogFileName, logFileEntry, Encoding.Default);
mLogFileSize += logFileEntry.Length;
}
}
catch
{
}
DisplayApplicationStatusMessage(message, messageType);
}
}
}
private void SendStatusMessage(string message, StatusMessageType statusMessageType)
{
if (StatusChanged != null)
{
StatusChanged(this, new StatusChangedEventArgs(message, statusMessageType));
}
}
/// <summary>
/// Emits a stylized status message.
/// </summary>
/// <param name="messageType">The type of message being displayed, determines the style to be used.</param>
/// <param name="messageFormat">The general style and format of the message text.</param>
/// <param name="messageText">Text or html of the message.</param>
/// <param name="htmlAttributes">Additional html attributes for the outer message container.</param>
public static MvcHtmlString StatusMessage(this HtmlHelper htmlHelper, StatusMessageType messageType = StatusMessageType.Success, StatusMessageFormat messageFormat = StatusMessageFormat.BoldCenter, string messageText = null, object htmlAttributes = null)
{
// required for legacy webform pages
if (htmlHelper == null)
return MvcHtmlString.Empty;
var tempData = htmlHelper.ViewContext.TempData;
if (string.IsNullOrEmpty(messageText))
{
messageText = (string)tempData["StatusMessageText"];
}
if (string.IsNullOrEmpty(messageText))
return MvcHtmlString.Empty;
// if dictionary contains keys for format and type use appropriate StatusMessage overload
if (tempData["StatusMessageFormat"] != null)
{
messageFormat = (StatusMessageFormat)tempData["StatusMessageFormat"];
}
if (tempData["StatusMessageType"] != null)
{
messageType = (StatusMessageType)tempData["StatusMessageType"];
}
var innerDiv = new TagBuilder("div") { InnerHtml = messageText };
innerDiv.AddCssClass("divStatusMessage");
switch (messageFormat)
{
case StatusMessageFormat.BoldCenter:
innerDiv.AddCssClass("divStatusFormatBoldCenter");
break;
case StatusMessageFormat.NormalBlock:
innerDiv.AddCssClass("divStatusFormatNormalBlock");
break;
}
var outerDiv = new TagBuilder("div") { InnerHtml = innerDiv.ToString() };
var attribs = htmlAttributes == null ? new RouteValueDictionary() : new RouteValueDictionary(htmlAttributes);
outerDiv.MergeAttributes(attribs);
outerDiv.AddCssClass("divStatusContainer");
switch (messageType)
{
case StatusMessageType.Success:
outerDiv.AddCssClass("divStatusSuccess");
break;
case StatusMessageType.Warning:
outerDiv.AddCssClass("divStatusWarning");
break;
case StatusMessageType.Error:
outerDiv.AddCssClass("divStatusError");
break;
}
return MvcHtmlString.Create( outerDiv.ToString() );
}
public void DisplayStatusMessage(string message, StatusMessageType messageType)
{
if (mDisplayStatusMessage != null)
{
mDisplayStatusMessage(message, messageType);
}
}
protected void DisplayStatusMessage(string message, StatusMessageType messageType)
{
if (CommInterface != null)
{
CommInterface.DisplayStatusMessage(message, messageType);
}
}
private void DisplayApplicationStatusMessage(string message, StatusMessageType messageType)
{
if (message != null)
{
if (messageType == StatusMessageType.USER)
{
mStatusTextBuilder.AppendLine(message);
OnPropertyChanged(new PropertyChangedEventArgs("StatusText"));
}
}
}
/// <summary>
/// Emits a stylized status message.
/// </summary>
/// <param name="htmlHelper">The <see cref="HtmlHelper"/></param>
/// <param name="messageType">The type of message being displayed, determines the style to be used.</param>
/// <param name="messageText">Text or html of the message.</param>
/// <param name="htmlAttributes">Additional html attributes for the outer message container.</param>
public static MvcHtmlString ShowStatusMessage(this HtmlHelper htmlHelper, StatusMessageType messageType = StatusMessageType.Success, string messageText = null, object htmlAttributes = null)
{
// required for legacy webform pages
if (htmlHelper == null)
return MvcHtmlString.Empty;
var tempData = htmlHelper.ViewContext.TempData;
if (string.IsNullOrEmpty(messageText))
{
messageText = (string)tempData[Constants.GeneralAdminConfigs.StatusMessageText];
}
if (string.IsNullOrEmpty(messageText))
return MvcHtmlString.Empty;
// if dictionary contains keys for type use appropriate StatusMessage overload
if (tempData["StatusMessageType"] != null)
{
messageType = (StatusMessageType)tempData[Constants.GeneralAdminConfigs.StatusMessageType];
}
var innerSpan = new TagBuilder("span") { InnerHtml = messageText };
var outerDiv = new TagBuilder("div")
{
InnerHtml = "<button type='button' class='close' data-dismiss='alert'" +
" aria-hidden='true'>×</button>" +
innerSpan
};
var attribs = htmlAttributes == null ? new RouteValueDictionary() : new RouteValueDictionary(htmlAttributes);
outerDiv.MergeAttributes(attribs);
outerDiv.AddCssClass("alert alert-dismissable");
switch (messageType)
{
case StatusMessageType.Success:
outerDiv.AddCssClass("alert-success");
break;
case StatusMessageType.Info:
outerDiv.AddCssClass("alert-info");
break;
case StatusMessageType.Warning:
outerDiv.AddCssClass("alert-warning");
break;
case StatusMessageType.Danger:
outerDiv.AddCssClass("alert-danger");
break;
}
return MvcHtmlString.Create(outerDiv.ToString());
}
/// <summary>
/// The build error response.
/// </summary>
/// <param name="exception">
/// The exception.
/// </param>
/// <returns>
/// The <see cref="RegistryInterface"/>.
/// </returns>
public RegistryInterface BuildErrorResponse(Exception exception)
{
var responseType = new RegistryInterface();
RegistryInterfaceType regInterface = responseType.Content;
var returnType = new SubmitProvisioningResponseType();
regInterface.SubmitProvisioningResponse = returnType;
V2Helper.Header = regInterface;
var statusType = new ProvisioningStatusType();
returnType.ProvisioningStatus.Add(statusType);
var statusMessage = new StatusMessageType();
statusType.StatusMessage = statusMessage;
this.AddStatus(statusMessage, exception);
return responseType;
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
StatusMessageType messageType = (StatusMessageType)value;
if (messageType == StatusMessageType.Error)
{
return(new SolidColorBrush(Colors.Red));
}
else if (messageType == StatusMessageType.Warning)
{
return(new SolidColorBrush(Colors.Orange));
}
return(new SolidColorBrush(Colors.Black));
}
/// <summary> a new <see cref="TrustLevelMessage"/> with the given <see cref="StatusMessageType"/>
/// representing the trust level message to which it corresponds.
/// </summary>
public TrustLevelMessage(StatusMessageType type) : base(type)
{
switch (type)
{
case StatusMessageType.TrustFully: level = TrustLevel.Full; break;
case StatusMessageType.TrustMarginal: level = TrustLevel.Marginal; break;
case StatusMessageType.TrustNever: level = TrustLevel.Never; break;
case StatusMessageType.TrustUltimate: level = TrustLevel.Ultimate; break;
default: level = TrustLevel.Unknown; break;
}
}
/// <summary>
/// Add status message from <paramref name="ex"/> to <paramref name="statusMessage"/>
/// </summary>
/// <param name="statusMessage">
/// The status message
/// </param>
/// <param name="ex">
/// The exception
/// </param>
public void AddStatus(StatusMessageType statusMessage, Exception ex)
{
if (ex == null)
{
statusMessage.status = StatusTypeConstants.Success;
}
else
{
statusMessage.status = StatusTypeConstants.Failure;
var tt = new TextType();
statusMessage.MessageText.Add(tt);
var exception = ex as SdmxException;
tt.TypedValue = exception != null ? exception.FullMessage : ex.Message;
}
}
public void SetStatusMessage(string text, StatusMessageType type = StatusMessageType.Info)
{
if (m_StatusWarningDialogWindow != null && m_StatusDialogWindow != null)
{
if (type == StatusMessageType.Warning)
{
m_StatusWarningDialog.message = text;
m_StatusWarningDialogWindow.Open();
if (m_StatusWarningDialogCloseCoroutine != null)
{
StopCoroutine(m_StatusWarningDialogCloseCoroutine);
m_StatusWarningDialogCloseCoroutine = null;
}
m_StatusWarningDialogCloseCoroutine = StartCoroutine(WaitCloseStatusWarningDialog());
}
else
{
if (type == StatusMessageType.Info)
{
if (m_InstructionMode)
{
return;
}
}
m_StatusDialog.message = text;
m_StatusDialogWindow.Open();
if (m_StatusDialogCloseCoroutine != null)
{
StopCoroutine(m_StatusDialogCloseCoroutine);
m_StatusDialogCloseCoroutine = null;
}
if (type == StatusMessageType.Info)
{
m_StatusDialogCloseCoroutine = StartCoroutine(WaitCloseStatusDialog());
}
}
}
}
/// <summary>
/// Builds error response.
/// </summary>
/// <param name="ex">
/// The exception.
/// </param>
/// <returns>
/// The <see cref="RegistryInterface"/>.
/// </returns>
public RegistryInterface BuildErrorResponse(Exception ex)
{
var responseType = new RegistryInterface();
RegistryInterfaceType regInterface = responseType.Content;
var returnType = new QueryRegistrationResponseType();
regInterface.QueryRegistrationResponse = returnType;
V2Helper.Header = regInterface;
var queryResult = new QueryResultType();
returnType.QueryResult.Add(queryResult);
queryResult.timeSeriesMatch = false;
var statusMessage = new StatusMessageType();
queryResult.StatusMessage = statusMessage;
this.AddStatus(statusMessage, ex);
return responseType;
}
/// <summary>
/// Builds the error response.
/// </summary>
/// <param name="notification">
/// The notification.
/// </param>
/// <param name="exception">
/// The exception.
/// </param>
/// <returns>
/// The <see cref="RegistryInterface"/>.
/// </returns>
public RegistryInterface BuildErrorResponse(ISubscriptionObject notification, Exception exception)
{
var responseType = new RegistryInterface();
RegistryInterfaceType regInterface = responseType.Content;
V21Helper.Header = regInterface;
var returnType = new SubmitSubscriptionsResponseType();
regInterface.SubmitSubscriptionsResponse = returnType;
var subscriptionStatus = new SubscriptionStatusType();
returnType.SubscriptionStatus.Add(subscriptionStatus);
if (notification != null)
{
subscriptionStatus.SubscriptionURN = notification.Urn;
}
var statusMessageType = new StatusMessageType();
subscriptionStatus.StatusMessage = statusMessageType;
this.AddStatus(statusMessageType, exception);
return responseType;
}
public void NetworkStatusMessage(StatusMessageType status, string messasge)
{
switch (status)
{
case StatusMessageType.Information:
StatusLabel.SetModulate(new Color(0.15f, 0.95f, 0.15f));
break;
case StatusMessageType.Warning:
StatusLabel.SetModulate(new Color(0.95f, 0.95f, 0.15f));
break;
case StatusMessageType.Error:
StatusLabel.SetModulate(new Color(0.95f, 0.15f, 0.15f));
break;
}
StatusLabel.Text = messasge;
}
public void StatusMessage(string v, StatusMessageType type)
{
toolStripStatusLabel1.Text = v;
switch (type)
{
case StatusMessageType.Warning:
toolStripStatusLabel1.BackColor = Color.Yellow;
toolStripStatusLabel1.ForeColor = Color.Blue;
break;
case StatusMessageType.Error:
toolStripStatusLabel1.BackColor = Color.Red;
toolStripStatusLabel1.ForeColor = Color.White;
break;
case StatusMessageType.Info:
toolStripStatusLabel1.BackColor = Color.Blue;
toolStripStatusLabel1.ForeColor = Color.White;
break;
}
}
/// <summary>
/// The build success response.
/// </summary>
/// <param name="notifications">
/// The notifications.
/// </param>
/// <returns>
/// The <see cref="RegistryInterface"/>.
/// </returns>
public RegistryInterface BuildSuccessResponse(ICollection<ISubscriptionObject> notifications)
{
var responseType = new RegistryInterface();
RegistryInterfaceType regInterface = responseType.Content;
V21Helper.Header = regInterface;
/* foreach */
foreach (ISubscriptionObject currentNotification in notifications)
{
var returnType = new SubmitSubscriptionsResponseType();
regInterface.SubmitSubscriptionsResponse = returnType;
var subscriptionStatus = new SubscriptionStatusType();
returnType.SubscriptionStatus.Add(subscriptionStatus);
var statusMessageType = new StatusMessageType();
subscriptionStatus.StatusMessage = statusMessageType;
this.AddStatus(statusMessageType, null);
subscriptionStatus.SubscriptionURN = currentNotification.Urn;
}
return responseType;
}
public static void SetStatusMessage(this TempDataDictionary tempData, string message, StatusMessageType messageType = StatusMessageType.Success, StatusMessageFormat messageFormat = StatusMessageFormat.BoldCenter)
{
tempData["StatusMessageText"] = message;
tempData["StatusMessageFormat"] = messageFormat;
tempData["StatusMessageType"] = messageType;
}
/// <summary>
/// The build success response.
/// </summary>
/// <param name="provisions">
/// The provisions.
/// </param>
/// <returns>
/// The <see cref="RegistryInterface"/>.
/// </returns>
public RegistryInterface BuildSuccessResponse(ICollection<IProvisionAgreementObject> provisions)
{
var responseType = new RegistryInterface();
RegistryInterfaceType regInterface = responseType.Content;
var returnType = new QueryProvisioningResponseType();
regInterface.QueryProvisioningResponse = returnType;
V2Helper.Header = regInterface;
var statusMessage = new StatusMessageType();
returnType.StatusMessage = statusMessage;
this.AddStatus(returnType.StatusMessage, null);
if (!ObjectUtil.ValidCollection(provisions))
{
statusMessage.status = StatusTypeConstants.Warning;
var tt = new TextType();
statusMessage.MessageText.Add(tt);
tt.TypedValue = "No Provisions Match The Query Parameters";
}
else
{
statusMessage.status = StatusTypeConstants.Success;
var provTypes = new ProvisionAgreementType[provisions.Count];
int i = 0;
/* foreach */
foreach (IProvisionAgreementObject currentProv in provisions)
{
provTypes[i] = this._provBuilder.Build(currentProv);
i++;
}
returnType.ProvisionAgreement = provTypes;
}
return responseType;
}
protected StatusMessage(StatusMessageType type)
{
this.type = type;
}
/// <summary>
/// Initializes a new instance of the <see cref="StatusMessageEventArgs"/> class.
/// </summary>
/// <param name="type">The type of the status message.</param>
/// <remarks>Documented by Dev03, 2008-08-21</remarks>
public StatusMessageEventArgs(StatusMessageType type)
{
m_Type = type;
m_Progress = 0;
m_MaximumProgress = 100;
}
/// <summary>
/// The process response.
/// </summary>
/// <param name="returnType">
/// The return type.
/// </param>
/// <param name="provisionAgreement">
/// The provision agreement.
/// </param>
private void ProcessResponse(
SubmitProvisioningResponseType returnType, IProvisionAgreementObject provisionAgreement)
{
var statusType = new ProvisioningStatusType();
returnType.ProvisioningStatus.Add(statusType);
var statusMessage = new StatusMessageType();
statusType.StatusMessage = statusMessage;
this.AddStatus(statusMessage, null);
var provRefType = new ProvisionAgreementRefType();
statusType.ProvisionAgreementRef = provRefType;
if (ObjectUtil.ValidString(provisionAgreement.Urn))
{
provRefType.URN = provisionAgreement.Urn;
}
if (provisionAgreement.DataproviderRef != null)
{
ICrossReference crossRef = provisionAgreement.DataproviderRef;
IMaintainableRefObject maintRef = crossRef.MaintainableReference;
string value = maintRef.AgencyId;
if (!string.IsNullOrWhiteSpace(value))
{
provRefType.OrganisationSchemeAgencyID = maintRef.AgencyId;
}
string value1 = maintRef.MaintainableId;
if (!string.IsNullOrWhiteSpace(value1))
{
provRefType.OrganisationSchemeID = maintRef.MaintainableId;
}
string value2 = crossRef.ChildReference.Id;
if (crossRef.ChildReference != null && !string.IsNullOrWhiteSpace(value2))
{
provRefType.DataProviderID = crossRef.ChildReference.Id;
}
string value3 = maintRef.Version;
if (!string.IsNullOrWhiteSpace(value3))
{
provRefType.DataProviderVersion = maintRef.Version;
}
}
if (provisionAgreement.StructureUseage != null)
{
ICrossReference structUseageCrossRef = provisionAgreement.StructureUseage;
IMaintainableRefObject maintRef0 = structUseageCrossRef.MaintainableReference;
if (structUseageCrossRef.TargetReference.EnumType == SdmxStructureEnumType.Dataflow)
{
string value = maintRef0.AgencyId;
if (!string.IsNullOrWhiteSpace(value))
{
provRefType.DataflowAgencyID = maintRef0.AgencyId;
}
string value1 = maintRef0.MaintainableId;
if (!string.IsNullOrWhiteSpace(value1))
{
provRefType.DataflowID = maintRef0.MaintainableId;
}
string value2 = maintRef0.Version;
if (!string.IsNullOrWhiteSpace(value2))
{
provRefType.DataflowVersion = maintRef0.Version;
}
}
}
}
public GetInputMessage(StatusMessageType type, string[] arguments) : base(type)
{
promptId = arguments[0];
}
protected void DisplayStatusMessage(string message, StatusMessageType messageType)
{
//TODO: hook this up
}
public SubscriptionStatusType()
{
this.statusMessageField = new StatusMessageType();
}
public SubmissionResultType(StatusMessageType statusMessage, SubmittedStructureType submittedStructure)
{
this.statusMessageField = statusMessage;
this.submittedStructureField = submittedStructure;
}
public RegistrationStatusType()
{
this.statusMessageField = new StatusMessageType();
this.registrationField = new RegistrationType();
}
public QuerySubscriptionResponseType()
{
this.subscriptionField = new List<SubscriptionType>();
this.statusMessageField = new StatusMessageType();
}
public StatusMessage(string _message,StatusMessageType _messageType)
{
Message = _message; MessageType = _messageType;
}
protected void SetStatusbarMessage(string message, StatusMessageType msgType)
{
var statusBarEvent = EventAggregator.GetEvent<StatusbarEvent>();
statusBarEvent.Publish(new StatusbarEventArgs(message, msgType));
}
/// <summary>
/// Sets the status text message
/// </summary>
/// <param name="message">The status text message</param>
/// <param name="type">The status type</param>
private void SetStatusText(string message, StatusMessageType type = StatusMessageType.None)
{
BusyLabel.Visible = false;
ErrorLabel.Visible = false;
InfoLabel.Visible = false;
WarningLabel.Visible = false;
switch (type)
{
case StatusMessageType.None:
break;
case StatusMessageType.Info:
InfoLabel.Visible = true;
break;
case StatusMessageType.Error:
WarningLabel.Visible = true;
break;
case StatusMessageType.Warning:
ErrorLabel.Visible = true;
break;
case StatusMessageType.Busy:
BusyLabel.Visible = true;
break;
}
StatusLabel.Text = message;
statusStrip.Refresh();
}
public StandardizedStatusMessageException(string message, string code, StatusMessageType type) : base(message)
{
Code = code;
Type = type;
}
public StatusMessage(string _message, StatusMessageType _messageType)
{
Message = _message; MessageType = _messageType;
}
public QueryRegistrationResponseType()
{
this.queryResultField = new List<QueryResultType>();
this.statusMessageField = new StatusMessageType();
}
private void UpdateStatusbar(StatusbarEventArgs obj)
{
this.StatusMessage = obj.StatusMessage;
this.StatusMessageType = obj.StatusType;
}
/// <summary>
/// Initializes a new instance of the <see cref="StatusMessageEventArgs"/> class.
/// </summary>
/// <param name="type">The type of the status message.</param>
/// <remarks>Documented by Dev03, 2008-08-21</remarks>
public StatusMessageEventArgs(StatusMessageType type)
{
m_Type = type;
m_Progress = 0;
m_MaximumProgress = 100;
}
public GenericKeyIdMessage(StatusMessageType type, string[] arguments) : base(type)
{
keyId = arguments[0].ToUpperInvariant();
}
/// <summary>
/// Initializes a new <see cref="StatusMessage"/>.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="type">The type of the message.</param>
/// <param name="multipart">
/// <c>false</c> if this message should be treated as a single message,
/// <c>true</c> if it's one of a number of messages treated as one unit. Default is <c>true</c>.
/// </param>
public StatusMessage(string message, StatusMessageType type, bool multipart)
: this(message, type)
{
this.Multipart = multipart;
}
public GenericMessage(StatusMessageType type) : base(type)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="StatusMessageEventArgs"/> class.
/// </summary>
/// <param name="type">The type of the status message.</param>
/// <param name="progress">The progress.</param>
/// <param name="maximumProgress">The maximum progress.</param>
/// <remarks>Documented by Dev03, 2008-08-21</remarks>
public StatusMessageEventArgs(StatusMessageType type, int progress, int maximumProgress)
{
m_Type = type;
m_Progress = progress;
m_MaximumProgress = maximumProgress;
}
/// <summary>
/// Initializes a new instance of the <see cref="StatusMessageEventArgs"/> class.
/// </summary>
/// <param name="type">The type of the status message.</param>
/// <param name="progress">The progress.</param>
/// <param name="maximumProgress">The maximum progress.</param>
/// <remarks>Documented by Dev03, 2008-08-21</remarks>
public StatusMessageEventArgs(StatusMessageType type, int progress, int maximumProgress)
{
m_Type = type;
m_Progress = progress;
m_MaximumProgress = maximumProgress;
}
/// <summary>
/// The build error response.
/// </summary>
/// <param name="exception">
/// The exception.
/// </param>
/// <returns>
/// The <see cref="RegistryInterface"/>.
/// </returns>
public RegistryInterface BuildErrorResponse(Exception exception)
{
var responseType = new RegistryInterface();
RegistryInterfaceType regInterface = responseType.Content;
var returnType = new QueryStructureResponseType();
regInterface.QueryStructureResponse = returnType;
V2Helper.Header = regInterface;
var statusMessage = new StatusMessageType();
returnType.StatusMessage = statusMessage;
statusMessage.status = StatusTypeConstants.Failure;
var tt = new TextType();
statusMessage.MessageText.Add(tt);
var uncheckedException = exception as SdmxException;
tt.TypedValue = uncheckedException != null ? uncheckedException.FullMessage : exception.Message;
return responseType;
}
public StatusMessage(string message, StatusMessageType messageType = StatusMessageType.Info)
{
Message = message;
MessageType = messageType;
}
/// <summary>
/// Build success response.
/// </summary>
/// <param name="buildFrom">
/// The source sdmx objects.
/// </param>
/// <param name="warningMessage">
/// The warning message.
/// </param>
/// <returns>
/// The <see cref="RegistryInterface"/>.
/// </returns>
public RegistryInterface BuildSuccessResponse(ISdmxObjects buildFrom, string warningMessage)
{
// PLEASE NOTE. The code here is slightly different than in Java.
// That is because of the differences between Java XmlBeans and .NET Linq2Xsd generated classes.
// Please consult GIT log before making any changes.
var responseType = new RegistryInterface();
RegistryInterfaceType regInterface = responseType.Content;
HeaderType headerType;
if (buildFrom.Header != null)
{
headerType = this._headerXmlsBuilder.Build(buildFrom.Header);
regInterface.Header = headerType;
}
else
{
headerType = new HeaderType();
regInterface.Header = headerType;
V2Helper.SetHeader(headerType, buildFrom);
}
var returnType = new QueryStructureResponseType();
regInterface.QueryStructureResponse = returnType;
var statusMessage = new StatusMessageType();
returnType.StatusMessage = statusMessage;
if (!string.IsNullOrWhiteSpace(warningMessage) || !ObjectUtil.ValidCollection(buildFrom.GetAllMaintainables()))
{
statusMessage.status = StatusTypeConstants.Warning;
var tt = new TextType();
statusMessage.MessageText.Add(tt);
tt.TypedValue = !string.IsNullOrWhiteSpace(warningMessage)
? warningMessage
: "No Structures Match The Query Parameters";
}
else
{
statusMessage.status = StatusTypeConstants.Success;
}
ISet<ICategorisationObject> categorisations = buildFrom.Categorisations;
// GET CATEGORY SCHEMES
if (buildFrom.CategorySchemes.Count > 0)
{
var catSchemesType = new CategorySchemesType();
returnType.CategorySchemes = catSchemesType;
/* foreach */
foreach (ICategorySchemeObject cateogrySchemeBean in buildFrom.CategorySchemes)
{
ISet<ICategorisationObject> matchingCategorisations = new HashSet<ICategorisationObject>();
/* foreach */
foreach (ICategorisationObject cat in categorisations)
{
if (MaintainableUtil<ICategorySchemeObject>.Match(cateogrySchemeBean, cat.CategoryReference))
{
matchingCategorisations.Add(cat);
}
}
catSchemesType.CategoryScheme.Add(
this._categorySchemeXmlBuilder.Build(cateogrySchemeBean, categorisations));
}
}
// GET CODELISTS
if (buildFrom.Codelists.Count > 0)
{
CodeListsType codeListsType = new CodeListsType();
returnType.CodeLists = codeListsType;
//CodeListsType codeListsType = returnType.CodeLists;
/* foreach */
foreach (ICodelistObject codelistBean in buildFrom.Codelists)
{
codeListsType.CodeList.Add(this._codelistXmlBuilder.Build(codelistBean));
}
}
// CONCEPT SCHEMES
if (buildFrom.ConceptSchemes.Count > 0)
{
ConceptsType conceptsType = new ConceptsType();
returnType.Concepts = conceptsType;
/* foreach */
foreach (IConceptSchemeObject conceptSchemeBean in buildFrom.ConceptSchemes)
{
conceptsType.ConceptScheme.Add(this._conceptSchemeXmlBuilder.Build(conceptSchemeBean));
}
}
// DATAFLOWS
if (buildFrom.Dataflows.Count > 0)
{
var dataflowsType = new DataflowsType();
returnType.Dataflows = dataflowsType;
/* foreach */
foreach (IDataflowObject currentBean in buildFrom.Dataflows)
{
dataflowsType.Dataflow.Add(
this._dataflowXmlBuilder.Build(currentBean, GetCategorisations(currentBean, categorisations)));
}
}
// HIERARCIC CODELIST
if (buildFrom.HierarchicalCodelists.Count > 0)
{
HierarchicalCodelistsType hierarchicalCodelistsType = new HierarchicalCodelistsType();
returnType.HierarchicalCodelists = hierarchicalCodelistsType;
/* foreach */
foreach (IHierarchicalCodelistObject currentBean0 in buildFrom.HierarchicalCodelists)
{
hierarchicalCodelistsType.HierarchicalCodelist.Add(
this._hierarchicalCodelistXmlBuilder.Build(currentBean0));
}
}
// KEY FAMILY
if (buildFrom.DataStructures.Count > 0)
{
var keyFamiliesType = new KeyFamiliesType();
returnType.KeyFamilies = keyFamiliesType;
/* foreach */
foreach (IDataStructureObject currentBean1 in buildFrom.DataStructures)
{
keyFamiliesType.KeyFamily.Add(this._dataStructureXmlBuilder.Build(currentBean1));
}
}
// METADATA FLOW
if (buildFrom.Metadataflows.Count > 0)
{
var metadataflowsType = new MetadataflowsType();
returnType.Metadataflows = metadataflowsType;
/* foreach */
foreach (IMetadataFlow currentBean2 in buildFrom.Metadataflows)
{
metadataflowsType.Metadataflow.Add(
this._metadataflowXmlBuilder.Build(
currentBean2, GetCategorisations(currentBean2, categorisations)));
}
}
// METADATA STRUCTURE
if (buildFrom.MetadataStructures.Count > 0)
{
var msdsType = new MetadataStructureDefinitionsType();
returnType.MetadataStructureDefinitions = msdsType;
/* foreach */
foreach (IMetadataStructureDefinitionObject currentBean3 in buildFrom.MetadataStructures)
{
msdsType.MetadataStructureDefinition.Add(
this._metadataStructureDefinitionXmlsBuilder.Build(currentBean3));
}
}
OrganisationSchemesType orgSchemesType = null;
// AGENCY SCHEMES
if (buildFrom.AgenciesSchemes.Count > 0)
{
orgSchemesType = new OrganisationSchemesType();
returnType.OrganisationSchemes = orgSchemesType;
/* foreach */
foreach (IAgencyScheme currentBean4 in buildFrom.AgenciesSchemes)
{
orgSchemesType.OrganisationScheme.Add(this._organisationSchemeXmlBuilder.Build(currentBean4));
}
}
// DATA CONSUMER SCHEMES
if (buildFrom.DataConsumerSchemes.Count > 0)
{
if (orgSchemesType == null)
{
orgSchemesType = new OrganisationSchemesType();
returnType.OrganisationSchemes = orgSchemesType;
}
/* foreach */
foreach (IDataConsumerScheme currentBean5 in buildFrom.DataConsumerSchemes)
{
orgSchemesType.OrganisationScheme.Add(this._organisationSchemeXmlBuilder.Build(currentBean5));
}
}
// DATA PROVIDER SCHEMES
if (buildFrom.DataProviderSchemes.Count > 0)
{
if (orgSchemesType == null)
{
orgSchemesType = new OrganisationSchemesType();
returnType.OrganisationSchemes = orgSchemesType;
}
/* foreach */
foreach (IDataProviderScheme currentBean6 in buildFrom.DataProviderSchemes)
{
orgSchemesType.OrganisationScheme.Add(this._organisationSchemeXmlBuilder.Build(currentBean6));
}
}
// PROCESSES
if (buildFrom.Processes.Count > 0)
{
var processesType = new ProcessesType();
returnType.Processes = processesType;
/* foreach */
foreach (IProcessObject currentBean7 in buildFrom.Processes)
{
processesType.Process.Add(this._processXmlBuilder.Build(currentBean7));
}
}
// STRUCTURE SETS
if (buildFrom.StructureSets.Count > 0)
{
var structureSetsType = new StructureSetsType();
returnType.StructureSets = structureSetsType;
/* foreach */
foreach (IStructureSetObject currentBean8 in buildFrom.StructureSets)
{
structureSetsType.StructureSet.Add(this._structureSetXmlBuilder.Build(currentBean8));
}
}
// REPORTING TAXONOMIES
if (buildFrom.ReportingTaxonomys.Count > 0)
{
var reportingTaxonomiesType = new ReportingTaxonomiesType();
returnType.ReportingTaxonomies = reportingTaxonomiesType;
/* foreach */
foreach (IReportingTaxonomyObject currentBean9 in buildFrom.ReportingTaxonomys)
{
reportingTaxonomiesType.ReportingTaxonomy.Add(this._reportingTaxonomyXmlBuilder.Build(currentBean9));
}
}
if (buildFrom.AttachmentConstraints.Count > 0)
{
throw new SdmxNotImplementedException(
ExceptionCode.Unsupported, "Attachment Constraint at SMDX v2.0 - please use SDMX v2.1");
}
if (buildFrom.ContentConstraintObjects.Count > 0)
{
throw new SdmxNotImplementedException(
ExceptionCode.Unsupported, "Content Constraint at SMDX v2.0 - please use SDMX v2.1");
}
return responseType;
}
public static void SetStatusMessage(this TempDataDictionary tempData, string message, StatusMessageType messageType = StatusMessageType.Success)
{
tempData[Constants.GeneralAdminConfigs.StatusMessageText] = message;
tempData[Constants.GeneralAdminConfigs.StatusMessageType] = messageType;
}
/// <summary>
/// Gets new submission result type.
/// </summary>
/// <param name="returnType">
/// The return type.
/// </param>
/// <param name="exception">
/// The exception.
/// </param>
/// <returns>
/// The <see cref="SubmissionResultType"/>.
/// </returns>
private static SubmissionResultType GetNewSubmissionResultType(
SubmitStructureResponseType returnType, Exception exception)
{
var submissionResult = new SubmissionResultType();
returnType.SubmissionResult.Add(submissionResult);
var statusMessage = new StatusMessageType();
submissionResult.StatusMessage = statusMessage;
if (exception == null)
{
statusMessage.status = StatusTypeConstants.Success;
}
else
{
statusMessage.status = StatusTypeConstants.Failure;
var tt = new TextType();
statusMessage.MessageText.Add(tt);
var uncheckedException = exception as SdmxException;
tt.TypedValue = uncheckedException != null ? uncheckedException.FullMessage : exception.Message;
}
return submissionResult;
}
protected KeyIdAndNameSigVerifyMessage(StatusMessageType type, string[] arguments) : base(type)
{
keyId = arguments[0].ToUpperInvariant();
userName = string.Join(" ", arguments, 1, arguments.Length - 1);
}
public StatusMessage(string message, StatusMessageType type)
{
Message = message;
Type = type;
}
/// <summary>
/// 返回提示信息（会自动判断是同步请求还是异步请求）
/// </summary>
/// <param name="messageType">提示信息类型</param>
/// <param name="messageContent">提示信息内容</param>
/// <returns>若是异步请求，则返回json数据；若是同步请求，则跳转到信息提示页面</returns>
private ActionResult StatusMessage(StatusMessageType messageType, string messageContent)
{
if (Request.IsAjaxRequest())
{
if (messageType == StatusMessageType.Error)
WebUtility.SetStatusCodeForError(Response);
return Json(new StatusMessageData(messageType, messageContent));
}
else
{
return Redirect(SiteUrls.Instance().SystemMessage(TempData, new SystemMessageViewModel
{
Title = messageContent,
StatusMessageType = messageType
}));
}
}
/// <summary>
/// 构造器
/// </summary>
/// <param name="messageType">消息类型</param>
/// <param name="messageContent">消息内容</param>
public StatusMessageData(StatusMessageType messageType, string messageContent)
{
this.messageType = messageType;
this.messageContent = messageContent;
}
public StatusChangedEventArgs(string message, StatusMessageType type)
{
Message = message;
Type = type;
}
/// <summary>
/// The build success response.
/// </summary>
/// <param name="registrations">
/// The registrations.
/// </param>
/// <returns>
/// The <see cref="RegistryInterface"/>.
/// </returns>
public RegistryInterface BuildSuccessResponse(ICollection<IRegistrationObject> registrations)
{
var responseType = new RegistryInterface();
RegistryInterfaceType regInterface = responseType.Content;
var returnType = new QueryRegistrationResponseType();
regInterface.QueryRegistrationResponse = returnType;
V2Helper.Header = regInterface;
if (!ObjectUtil.ValidCollection(registrations))
{
var queryResult = new QueryResultType();
returnType.QueryResult.Add(queryResult);
queryResult.timeSeriesMatch = false;
var statusMessage = new StatusMessageType();
queryResult.StatusMessage = statusMessage;
statusMessage.status = StatusTypeConstants.Warning;
var tt = new TextType();
statusMessage.MessageText.Add(tt);
tt.TypedValue = "No Registrations Match The Query Parameters";
}
else
{
/* foreach */
foreach (IRegistrationObject currentRegistration in registrations)
{
var queryResult0 = new QueryResultType();
returnType.QueryResult.Add(queryResult0);
var statusMessage1 = new StatusMessageType();
queryResult0.StatusMessage = statusMessage1;
this.AddStatus(statusMessage1, null);
queryResult0.timeSeriesMatch = false; // FUNC 1 - when is this true? Also We need MetadataResult
var resultType = new ResultType();
queryResult0.DataResult = resultType;
if (currentRegistration.DataSource != null)
{
IDataSource datasourceBean = currentRegistration.DataSource;
var datasourceType = new DatasourceType();
resultType.Datasource = datasourceType;
if (datasourceBean.SimpleDatasource)
{
datasourceType.SimpleDatasource = datasourceBean.DataUrl;
}
else
{
var queryableDatasource = new QueryableDatasourceType();
datasourceType.QueryableDatasource = queryableDatasource;
queryableDatasource.isRESTDatasource = datasourceBean.RESTDatasource;
queryableDatasource.isWebServiceDatasource = datasourceBean.WebServiceDatasource;
queryableDatasource.DataUrl = datasourceBean.DataUrl;
if (datasourceBean.WsdlUrl != null)
{
queryableDatasource.WSDLUrl = datasourceBean.WsdlUrl;
}
}
}
if (currentRegistration.ProvisionAgreementRef != null)
{
WriteProvisionAgreementRef(currentRegistration.ProvisionAgreementRef, resultType);
}
}
}
return responseType;
}
/// <summary>
/// Initializes a new <see cref="StatusMessage"/>.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="type">The type of the message.</param>
public StatusMessage(string message, StatusMessageType type)
{
this.Message = message;
this.MessageType = type;
Multipart = false;
}
/// <summary>
/// Add a status message of the given type to the status message collection. Message is not HTML-encoded. It is possible to have
/// tags as part of the text.
/// </summary>
public static void AddStatusMessage( StatusMessageType type, string messageHtml )
{
Instance.statusMessages.Add( new Tuple<StatusMessageType, string>( type, messageHtml ) );
}
