private RegistryInterfaceType Get_SubmitSubscriptions_Reponse(string SubscriberAssignedId, string RegistryURN, StatusType StatusType, string StatusMessage, string StatusLanguage)
{
RegistryInterfaceType RetVal;
RetVal = null;
try
{
RetVal = new RegistryInterfaceType();
RetVal.Header = Global.Get_Appropriate_Header();
RetVal.Footer = null;
RetVal.Item = new SDMXObjectModel.Registry.SubmitSubscriptionsResponseType();
((SDMXObjectModel.Registry.SubmitSubscriptionsResponseType)RetVal.Item).SubscriptionStatus = new System.Collections.Generic.List<SubscriptionStatusType>();
((SDMXObjectModel.Registry.SubmitSubscriptionsResponseType)RetVal.Item).SubscriptionStatus.Add(new SubscriptionStatusType());
((SDMXObjectModel.Registry.SubmitSubscriptionsResponseType)RetVal.Item).SubscriptionStatus[0].SubscriberAssignedID = SubscriberAssignedId;
((SDMXObjectModel.Registry.SubmitSubscriptionsResponseType)RetVal.Item).SubscriptionStatus[0].SubscriptionURN = RegistryURN;
((SDMXObjectModel.Registry.SubmitSubscriptionsResponseType)RetVal.Item).SubscriptionStatus[0].StatusMessage = new SDMXObjectModel.Registry.StatusMessageType(StatusType, StatusMessage, StatusLanguage);
}
catch (Exception ex)
{
Global.CreateExceptionString(ex, null);
throw ex;
}
finally
{
}
return RetVal;
}
private XmlDocument GetQueryXmlDocumentForSubmitRegistration(string UserIdAndType, string AgencyId, string DFDOrMFDId, string WebServiceURL, bool IsREST, string WADLURL, bool IsSOAP, string WSDLURL, string FileURL)
{
XmlDocument RetVal;
string id;
string paId;
SDMXObjectModel.Message.RegistryInterfaceType RegistryInterface;
DIConnection DIConnection;
string MaxNId;
string UserId;
RetVal = null;
id = string.Empty;
paId = string.Empty;
MaxNId = string.Empty;
UserId = string.Empty;
try
{
UserId = UserIdAndType.Split('|')[0];
DIConnection = new DIConnection(DIServerType.MsAccess, string.Empty, string.Empty, Server.MapPath("~//stock//Database.mdb"),
string.Empty, string.Empty);
MaxNId = ((int)(Convert.ToInt32(DIConnection.ExecuteDataTable("SELECT MAX(ArtefactsNId) AS MaxNId FROM Artefacts;").Rows[0]["MaxNId"].ToString()) + 1)).ToString();
id = Guid.NewGuid().ToString();
paId = DevInfo.Lib.DI_LibSDMX.Constants.PA.Prefix + UserId + "_" + DFDOrMFDId;
RegistryInterface = new RegistryInterfaceType();
RegistryInterface.Header = Global.Get_Appropriate_Header();
RegistryInterface.Item = new SDMXObjectModel.Registry.SubmitRegistrationsRequestType();
((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)(RegistryInterface.Item)).RegistrationRequest = new List<RegistrationRequestType>();
((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)(RegistryInterface.Item)).RegistrationRequest.Add(new RegistrationRequestType());
((RegistrationRequestType)(((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)(RegistryInterface.Item)).RegistrationRequest[0])).Registration = new RegistrationType(id);
((RegistrationRequestType)(((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)(RegistryInterface.Item)).RegistrationRequest[0])).Registration.indexTimeSeries = true;
((RegistrationRequestType)(((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)(RegistryInterface.Item)).RegistrationRequest[0])).Registration.ProvisionAgreement = new ProvisionAgreementReferenceType();
((RegistrationRequestType)(((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)(RegistryInterface.Item)).RegistrationRequest[0])).Registration.ProvisionAgreement.Items.Add(new ProvisionAgreementRefType(paId, AgencyId, DevInfo.Lib.DI_LibSDMX.Constants.PA.Version));
((RegistrationRequestType)(((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)(RegistryInterface.Item)).RegistrationRequest[0])).Registration.Datasource = new List<object>();
//((RegistrationRequestType)(((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)(RegistryInterface.Item)).RegistrationRequest[0])).Registration.Datasource.Add(new SDMXObjectModel.Registry.QueryableDataSourceType(WebServiceURL, IsREST, WADLURL, IsSOAP, WSDLURL));
((RegistrationRequestType)(((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)(RegistryInterface.Item)).RegistrationRequest[0])).Registration.Datasource.Add(FileURL);
RetVal = Serializer.SerializeToXmlDocument(typeof(SDMXObjectModel.Message.RegistryInterfaceType), RegistryInterface);
}
catch (Exception ex)
{
Global.CreateExceptionString(ex, null);
}
finally
{
}
return RetVal;
}
private RegistryInterfaceType Get_QuerySubscriptions_Reponse(List<SubscriptionType> Subscriptions, StatusType StatusType, string StatusMessage, string StatusLanguage)
{
RegistryInterfaceType RetVal;
RetVal = null;
try
{
RetVal = new RegistryInterfaceType();
RetVal.Header = Global.Get_Appropriate_Header();
RetVal.Footer = null;
RetVal.Item = new SDMXObjectModel.Registry.QuerySubscriptionResponseType();
((SDMXObjectModel.Registry.QuerySubscriptionResponseType)RetVal.Item).Subscription = Subscriptions;
((SDMXObjectModel.Registry.QuerySubscriptionResponseType)RetVal.Item).StatusMessage = new SDMXObjectModel.Registry.StatusMessageType(StatusType, StatusMessage, StatusLanguage);
}
catch (Exception ex)
{
Global.CreateExceptionString(ex, null);
throw ex;
}
finally
{
}
return RetVal;
}
private RegistryInterfaceType Get_SubmitRegistrations_Reponse(RegistrationType Registration, StatusType StatusType, string StatusMessage, string StatusLanguage)
{
RegistryInterfaceType RetVal;
RetVal = null;
try
{
RetVal = new RegistryInterfaceType();
RetVal.Header = Global.Get_Appropriate_Header();
RetVal.Footer = null;
RetVal.Item = new SDMXObjectModel.Registry.SubmitRegistrationsResponseType();
((SDMXObjectModel.Registry.SubmitRegistrationsResponseType)RetVal.Item).RegistrationStatus = new List<RegistrationStatusType>();
((SDMXObjectModel.Registry.SubmitRegistrationsResponseType)RetVal.Item).RegistrationStatus.Add(new RegistrationStatusType());
((SDMXObjectModel.Registry.SubmitRegistrationsResponseType)RetVal.Item).RegistrationStatus[0].Registration = Registration;
((SDMXObjectModel.Registry.SubmitRegistrationsResponseType)RetVal.Item).RegistrationStatus[0].StatusMessage = new SDMXObjectModel.Registry.StatusMessageType(StatusType, StatusMessage, StatusLanguage);
}
catch (Exception ex)
{
Global.CreateExceptionString(ex, null);
throw ex;
}
finally
{
}
return RetVal;
}
private bool UpdateNonMAForUploadedDSDWithHeader(string DbNId, string UserNId, string DataBaseNId)
{
bool RetVal;
SDMXObjectModel.Message.RegistryInterfaceType Registrations;
SDMXApi_2_0.Message.GenericMetadataType MetadataFiles;
//SDMXObjectModel.Message.GenericDataType DataFiles;
SDMXApi_2_0.Message.CompactDataType DataFiles;
SDMXObjectModel.Message.RegistryInterfaceType Subscriptions;
RetVal = true;
string UploadedHeaderFileWPath = string.Empty;
string UploadedHeaderFolderPath = Server.MapPath("../../stock/data");
string UploadedDSDHeaderFilePath = string.Empty;
string UploadedHeaderName = string.Empty;
string SubscriptionsFolderPath = string.Empty;
string MetadataFolderPath = string.Empty;
string RegistrationsFolderPath = string.Empty;
string SDMXMLFolderPath = string.Empty;
string MappingFolderPath = string.Empty;
XmlDocument UploadedHeaderXml = new XmlDocument();
XmlDocument UploadedHeaderXmlFor2_0 = new XmlDocument();
FileInfo[] Files = null;
DirectoryInfo dirRegs = null;
DirectoryInfo dirMetadata = null;
DirectoryInfo dirSubscriptions = null;
DirectoryInfo dirSDMXML = null;
try
{
UploadedHeaderFileWPath = UploadedHeaderFolderPath + "/" + DataBaseNId + "/" + "sdmx" + "/" + DevInfo.Lib.DI_LibSDMX.Constants.Header.FileName;
UploadedDSDHeaderFilePath = UploadedHeaderFolderPath + "/" + DbNId + "/" + "sdmx" + "/" + DevInfo.Lib.DI_LibSDMX.Constants.Header.FileName;
dirRegs = new DirectoryInfo(UploadedHeaderFolderPath + "\\" + DbNId + "\\" + "sdmx" + "\\" + "Registrations");
dirMetadata = new DirectoryInfo(UploadedHeaderFolderPath + "\\" + DbNId + "\\" + "sdmx" + "\\" + "Metadata");
dirSDMXML = new DirectoryInfo(UploadedHeaderFolderPath + "\\" + DbNId + "\\" + "sdmx" + "\\" + "SDMX-ML");
dirSubscriptions = new DirectoryInfo(UploadedHeaderFolderPath + "\\" + DbNId + "\\" + "sdmx" + "\\" + "Subscriptions");
MappingFolderPath = UploadedHeaderFolderPath + "/" + DbNId + "/" + "sdmx" + "/" + "Mappings";
UploadedHeaderXml.Load(UploadedHeaderFileWPath);
UploadedHeaderXmlFor2_0.Load(UploadedDSDHeaderFilePath);
SDMXObjectModel.Message.StructureType UploadedDSDStructure = new SDMXObjectModel.Message.StructureType();
SDMXObjectModel.Message.StructureHeaderType Header = new SDMXObjectModel.Message.StructureHeaderType();
SDMXApi_2_0.Message.StructureType UploadedDSDStruct20 = new SDMXApi_2_0.Message.StructureType();
SDMXApi_2_0.Message.HeaderType DSDHeader = new SDMXApi_2_0.Message.HeaderType();
UploadedDSDStructure = (SDMXObjectModel.Message.StructureType)SDMXObjectModel.Deserializer.LoadFromXmlDocument(typeof(SDMXObjectModel.Message.StructureType), UploadedHeaderXml);
Header = UploadedDSDStructure.Header;
UploadedDSDStruct20 = (SDMXApi_2_0.Message.StructureType)SDMXApi_2_0.Deserializer.LoadFromXmlDocument(typeof(SDMXApi_2_0.Message.StructureType), UploadedHeaderXmlFor2_0);
DSDHeader = UploadedDSDStruct20.Header;
foreach (DirectoryInfo dirReg in dirRegs.GetDirectories())
{
Files = dirReg.GetFiles();
foreach (FileInfo regfile in Files)
{
Registrations = new SDMXObjectModel.Message.RegistryInterfaceType();
Registrations = (SDMXObjectModel.Message.RegistryInterfaceType)Deserializer.LoadFromFile(typeof(SDMXObjectModel.Message.RegistryInterfaceType), UploadedHeaderFolderPath + "\\" + DbNId + "\\" + "sdmx" + "\\" + "Registrations" + "\\" + dirReg.Name + "\\" + regfile.ToString());
Registrations.Header.ID = Header.ID.ToString();
Registrations.Header.Prepared = Header.Prepared.ToString();
foreach (PartyType receiver in Header.Receiver)
{
Registrations.Header.Receiver.Contact = receiver.Contact;
Registrations.Header.Receiver.id = receiver.id;
Registrations.Header.Receiver.Name = receiver.Name;
}
Registrations.Header.Sender = (SDMXObjectModel.Message.SenderType)Header.Sender;
Registrations.Header.Test = Header.Test;
Registrations.Footer = null;
SDMXObjectModel.Serializer.SerializeToFile(typeof(SDMXObjectModel.Message.RegistryInterfaceType), Registrations, UploadedHeaderFolderPath + "\\" + DbNId + "\\" + "sdmx" + "\\" + "Registrations" + "\\" + dirReg.Name + "\\" + regfile.ToString());
}
}
foreach (DirectoryInfo dirMeta in dirMetadata.GetDirectories())
{
Files = null;
Files = dirMeta.GetFiles();
foreach (FileInfo metafile in Files)
{
MetadataFiles = new SDMXApi_2_0.Message.GenericMetadataType();
MetadataFiles = (SDMXApi_2_0.Message.GenericMetadataType)Deserializer.LoadFromFile(typeof(SDMXApi_2_0.Message.GenericMetadataType), UploadedHeaderFolderPath + "\\" + DbNId + "\\" + "sdmx" + "\\" + "Metadata" + "\\" + dirMeta.Name + "\\" + metafile.ToString());
MetadataFiles.Header.ID = DSDHeader.ID.ToString();
MetadataFiles.Header.Prepared = DSDHeader.Prepared.ToString();
MetadataFiles.Header.Receiver = DSDHeader.Receiver;
MetadataFiles.Header.Sender = DSDHeader.Sender;
MetadataFiles.Header.Test = DSDHeader.Test;
SDMXApi_2_0.Serializer.SerializeToFile(typeof(SDMXApi_2_0.Message.GenericMetadataType), MetadataFiles, UploadedHeaderFolderPath + "\\" + DbNId + "\\" + "sdmx" + "\\" + "Metadata" + "\\" + dirMeta.Name + "\\" + metafile.ToString());
}
}
foreach (DirectoryInfo dirSDMX in dirSDMXML.GetDirectories())
{
Files = null;
Files = dirSDMX.GetFiles();
foreach (FileInfo sdmxMlFile in Files)
{
DataFiles = new SDMXApi_2_0.Message.CompactDataType();
DataFiles = (SDMXApi_2_0.Message.CompactDataType)Deserializer.LoadFromFile(typeof(SDMXApi_2_0.Message.CompactDataType), UploadedHeaderFolderPath + "\\" + DbNId + "\\" + "sdmx" + "\\" + "SDMX-ML" + "\\" + dirSDMX.Name + "\\" + sdmxMlFile.ToString());
DataFiles.Header.ID = DSDHeader.ID.ToString();
DataFiles.Header.Prepared = Header.Prepared.ToString();
DataFiles.Header.Receiver = DSDHeader.Receiver;
DataFiles.Header.Sender = DSDHeader.Sender;
DataFiles.Header.Test = DSDHeader.Test;
SDMXApi_2_0.Serializer.SerializeToFile(typeof(SDMXApi_2_0.Message.CompactDataType), DataFiles, UploadedHeaderFolderPath + "\\" + DbNId + "\\" + "sdmx" + "\\" + "SDMX-ML" + "\\" + dirSDMX.Name + "\\" + sdmxMlFile.ToString());
}
}
foreach (DirectoryInfo dirSubs in dirSubscriptions.GetDirectories())
{
Files = null;
Files = dirSubs.GetFiles();
foreach (FileInfo subsFile in Files)
{
Subscriptions = new SDMXObjectModel.Message.RegistryInterfaceType();
Subscriptions = (SDMXObjectModel.Message.RegistryInterfaceType)Deserializer.LoadFromFile(typeof(SDMXObjectModel.Message.RegistryInterfaceType), UploadedHeaderFolderPath + "\\" + DbNId + "\\" + "sdmx" + "\\" + "Subscriptions" + "\\" + dirSubs.Name + "\\" + subsFile.ToString());
Subscriptions.Header.ID = Header.ID.ToString();
Subscriptions.Header.Prepared = Header.Prepared.ToString();
foreach (PartyType receiver in Header.Receiver)
{
Subscriptions.Header.Receiver.Contact = receiver.Contact;
Subscriptions.Header.Receiver.id = receiver.id;
Subscriptions.Header.Receiver.Name = receiver.Name;
}
Subscriptions.Header.Sender = (SDMXObjectModel.Message.SenderType)Header.Sender;
Subscriptions.Header.Test = Header.Test;
Subscriptions.Footer = null;
SDMXObjectModel.Serializer.SerializeToFile(typeof(SDMXObjectModel.Message.RegistryInterfaceType), Subscriptions, UploadedHeaderFolderPath + "\\" + DbNId + "\\" + "sdmx" + "\\" + "Subscriptions" + "\\" + dirSubs.Name + "\\" + subsFile.ToString());
}
}
}
catch (Exception ex)
{
RetVal = false;
Global.CreateExceptionString(ex, null);
//Global.WriteErrorsInLog("Creating CategoryScheme For Uploaded DSD From Admin");
//Global.WriteErrorsInLog(ex.StackTrace);
//Global.WriteErrorsInLog(ex.Message);
}
finally
{
}
return RetVal;
}
private RegistryInterfaceType Get_QueryRegistrations_Reponse(List<RegistrationType> Registrations, StatusType StatusType, string StatusMessage, string StatusLanguage)
{
RegistryInterfaceType RetVal;
QueryResultType QueryResult;
RetVal = null;
QueryResult = null;
try
{
RetVal = new RegistryInterfaceType();
RetVal.Header = Global.Get_Appropriate_Header();
RetVal.Footer = null;
RetVal.Item = new SDMXObjectModel.Registry.QueryRegistrationResponseType();
((SDMXObjectModel.Registry.QueryRegistrationResponseType)RetVal.Item).QueryResult = new List<QueryResultType>();
foreach (RegistrationType Registration in Registrations)
{
QueryResult = new QueryResultType();
QueryResult.timeSeriesMatch = false;
if (((ProvisionAgreementRefType)Registration.ProvisionAgreement.Items[0]).id.Contains(DevInfo.Lib.DI_LibSDMX.Constants.DFD.Id))
{
QueryResult.ItemElementName = QueryResultChoiceType.DataResult;
}
else
{
QueryResult.ItemElementName = QueryResultChoiceType.MetadataResult;
}
QueryResult.Item = new ResultType();
QueryResult.Item.Registration = Registration;
((SDMXObjectModel.Registry.QueryRegistrationResponseType)RetVal.Item).QueryResult.Add(QueryResult);
}
((SDMXObjectModel.Registry.QueryRegistrationResponseType)RetVal.Item).StatusMessage = new SDMXObjectModel.Registry.StatusMessageType(StatusType, StatusMessage, StatusLanguage);
}
catch (Exception ex)
{
Global.CreateExceptionString(ex, null);
throw ex;
}
finally
{
}
return RetVal;
}
private SDMXObjectModel.Message.RegistryInterfaceType Get_RegistryInterface_Object(SDMXObjectModel.Registry.SubscriptionRequestType SubscriptionRequestType)
{
SDMXObjectModel.Message.RegistryInterfaceType RetVal;
RetVal = new SDMXObjectModel.Message.RegistryInterfaceType();
RetVal.Header = this.Get_Appropriate_Header();
RetVal.Item = new SDMXObjectModel.Registry.SubmitSubscriptionsRequestType();
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)RetVal.Item).SubscriptionRequest = new List<SDMXObjectModel.Registry.SubscriptionRequestType>();
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)RetVal.Item).SubscriptionRequest.Add(SubscriptionRequestType);
RetVal.Footer = null;
return RetVal;
}
public string GetSubscriptionDetails(string requestParam)
{
string RetVal = string.Empty;
string[] Params = Global.SplitString(requestParam, Constants.Delimiters.ParamDelimiter);
string DbNId, UserIdAndType, SubscriptionId;
XmlDocument SubscriptionDetailsXml = new XmlDocument();
string CategoriesGIDAndSchemeIds = string.Empty;
string CategoriesGIDAndSchemeId = string.Empty;
string CategoryGId = string.Empty;
string CategorySchemeId = string.Empty;
string Email = string.Empty;
string WebServiceAddress = string.Empty;
bool IsSOAP = false;
string StartDate = string.Empty;
string EndDate = string.Empty;
string EventType = string.Empty;
string hlngcode = string.Empty;
Registry.RegistryService Service;
XmlDocument Query;
XmlElement Element;
XmlDocument Response;
SDMXObjectModel.Message.RegistryInterfaceType SubRegistryInterface;
int i;
Service = new Registry.RegistryService();
Query = new XmlDocument();
Response = new XmlDocument();
Element = null;
SubRegistryInterface = new SDMXObjectModel.Message.RegistryInterfaceType();
try
{
SubscriptionId = Params[0];
DbNId = Params[1].ToString().Trim();
UserIdAndType = Params[2].ToString();
hlngcode = Params[3].ToString().Trim();
Query = GetQueryXmlDocumentOnTypeBasis(12, string.Empty, string.Empty, string.Empty, UserIdAndType);
Element = Query.DocumentElement;
Service.Url = HttpContext.Current.Request.Url.OriginalString.Substring(0, HttpContext.Current.Request.Url.OriginalString.IndexOf("libraries")) + Constants.FolderName.SDMX.RegistryServicePath;
Service.Url += "?p=" + DbNId.ToString();
Service.QuerySubscription(ref Element);
Response.LoadXml(Element.OuterXml);
SubRegistryInterface = (SDMXObjectModel.Message.RegistryInterfaceType)(SDMXObjectModel.Deserializer.LoadFromXmlDocument(typeof(SDMXObjectModel.Message.RegistryInterfaceType), Response));
foreach (SDMXObjectModel.Registry.SubscriptionType Subscription in ((SDMXObjectModel.Registry.QuerySubscriptionResponseType)(SubRegistryInterface.Item)).Subscription)
{
if (SubscriptionId == Subscription.RegistryURN)
{
Email = Subscription.NotificationMailTo[0].Value.ToString();
WebServiceAddress = Subscription.NotificationHTTP[0].Value.ToString();
IsSOAP = Subscription.NotificationHTTP[0].isSOAP;
StartDate = Subscription.ValidityPeriod.StartDate.ToString("dd-MM-yyyy");
EndDate = Subscription.ValidityPeriod.EndDate.ToString("dd-MM-yyyy");
RetVal = Email;
RetVal += Constants.Delimiters.ValuesDelimiter + WebServiceAddress;
RetVal += Constants.Delimiters.ValuesDelimiter + IsSOAP;
RetVal += Constants.Delimiters.ValuesDelimiter + StartDate;
RetVal += Constants.Delimiters.ValuesDelimiter + EndDate;
if (Subscription.EventSelector[0] is DataRegistrationEventsType)
{
EventType = GetlanguageBasedValueOfKey("lang_Data_Registration", hlngcode, "RegSubscription.xml");
for (i = 0; i < ((DataRegistrationEventsType)(Subscription.EventSelector[0])).Items.Length; i++)
{
CategoryGId = ((SDMXObjectModel.Common.CategoryRefType)(((CategoryReferenceType)(((DataRegistrationEventsType)(Subscription.EventSelector[0])).Items[i])).Items[0])).id;
CategorySchemeId = ((SDMXObjectModel.Common.CategoryRefType)(((CategoryReferenceType)(((DataRegistrationEventsType)(Subscription.EventSelector[0])).Items[i])).Items[0])).maintainableParentID;
CategoriesGIDAndSchemeIds = CategoriesGIDAndSchemeIds + CategoryGId + Constants.Delimiters.PivotColumnDelimiter + CategorySchemeId + ",";
}
CategoriesGIDAndSchemeIds = CategoriesGIDAndSchemeIds.Remove(CategoriesGIDAndSchemeIds.Length - 1, 1);
RetVal += Constants.Delimiters.ValuesDelimiter + EventType;
RetVal += Constants.Delimiters.ValuesDelimiter + CategoriesGIDAndSchemeIds;
}
else if (Subscription.EventSelector[0] is MetadataRegistrationEventsType)
{
EventType = GetlanguageBasedValueOfKey("lang_Metadata_Registration", hlngcode, "RegSubscription.xml");
RetVal += Constants.Delimiters.ValuesDelimiter + EventType;
RetVal += Constants.Delimiters.ValuesDelimiter + ((MaintainableQueryType)((MaintainableEventType)(((MetadataRegistrationEventsType)(Subscription.EventSelector[0])).Items[0])).Item).id;
}
else if (Subscription.EventSelector[0] is StructuralRepositoryEventsType)
{
EventType = GetlanguageBasedValueOfKey("lang_Structural_Metadata_Registration", hlngcode,
"RegSubscription.xml");
RetVal += Constants.Delimiters.ValuesDelimiter + EventType;
}
// get preferred language
RetVal += Constants.Delimiters.ValuesDelimiter + Global.GetPreferredLanguageFromSubscriptionId(SubscriptionId);
break;
}
}
}
catch (Exception ex)
{
RetVal = string.Empty;
Global.CreateExceptionString(ex, null);
}
return RetVal;
}
public string UpdateRegistration(string requestParam)
{
string RetVal;
string[] Params;
string[] DBDetails;
string DbNId, UserNId, DFDOrMFDId, RegistrationId, WebServiceURL, WADLURL, WSDLURL, FileURL, Language, UploadedHeaderFileWPath, UploadedHeaderFolderPath, OriginalDBNId, SDMXFileName;
bool IsREST, IsSOAP, IsMetadata;
RegistryInterfaceType RegistryInterfaceRequest, RegistryInterfaceResponse;
Registry.RegistryService Service;
XmlDocument Request;
XmlElement Element;
XmlDocument UploadedHeaderXml;
SDMXObjectModel.Message.StructureHeaderType Header;
RetVal = string.Empty;
RegistryInterfaceRequest = null;
RegistryInterfaceResponse = null;
Service = null;
Request = new XmlDocument();
Element = null;
Header = new SDMXObjectModel.Message.StructureHeaderType();
UploadedHeaderXml = new XmlDocument();
UploadedHeaderFolderPath = Server.MapPath("../../stock/data");
DBDetails = null;
OriginalDBNId = string.Empty;
SDMXFileName = string.Empty;
try
{
Params = Global.SplitString(requestParam, Constants.Delimiters.ParamDelimiter);
DbNId = Params[0].ToString().Trim();
UserNId = Params[1].ToString().Trim();
IsMetadata = bool.Parse(Params[2].ToString().Trim());
DFDOrMFDId = Params[3].ToString().Trim();
RegistrationId = Params[4].ToString().Trim();
WebServiceURL = Params[5].ToString().Trim();
IsREST = bool.Parse(Params[6].ToString().Trim());
WADLURL = Params[7].ToString().Trim();
IsSOAP = bool.Parse(Params[8].ToString().Trim());
WSDLURL = Params[9].ToString().Trim();
if (Params.Length > 10)
{
FileURL = Params[10].ToString().Trim();
}
else
{
FileURL = string.Empty;
}
if (Params.Length > 11)
{
Language = Params[11].ToString().Trim();
}
else
{
Language = Global.GetDefaultLanguageCode();
}
if (Params.Length > 12)
{
SDMXFileName = Params[12].ToString().Trim();
}
else
{
SDMXFileName = string.Empty;
}
RegistryInterfaceRequest = new RegistryInterfaceType();
//RegistryInterfaceRequest.Header = Global.Get_Appropriate_Header();
DBDetails = Global.GetDbConnectionDetails(DbNId);
if (DBDetails[4] == "true")
{
OriginalDBNId = Convert.ToString(this.Get_AssociatedDB_NId(DbNId));
}
else
{
OriginalDBNId = DbNId;
}
UploadedHeaderFileWPath = UploadedHeaderFolderPath + "/" + OriginalDBNId + "/" + "sdmx" + "/" + DevInfo.Lib.DI_LibSDMX.Constants.Header.FileName;
SDMXObjectModel.Message.StructureType UploadedDSDStructure = new SDMXObjectModel.Message.StructureType();
if (File.Exists(UploadedHeaderFileWPath))
{
UploadedHeaderXml.Load(UploadedHeaderFileWPath);
UploadedDSDStructure = (SDMXObjectModel.Message.StructureType)SDMXObjectModel.Deserializer.LoadFromXmlDocument(typeof(SDMXObjectModel.Message.StructureType), UploadedHeaderXml);
Header = UploadedDSDStructure.Header;
}
RegistryInterfaceRequest = new RegistryInterfaceType();
if (Header == null)
{
RegistryInterfaceRequest.Header = Global.Get_Appropriate_Header();
}
else
{
RegistryInterfaceRequest.Header.ID = Header.ID.ToString();
RegistryInterfaceRequest.Header.Prepared = Header.Prepared.ToString();
foreach (PartyType receiver in Header.Receiver)
{
RegistryInterfaceRequest.Header.Receiver = new PartyType();
RegistryInterfaceRequest.Header.Receiver.Contact = receiver.Contact;
RegistryInterfaceRequest.Header.Receiver.id = receiver.id;
RegistryInterfaceRequest.Header.Receiver.Name = receiver.Name;
}
RegistryInterfaceRequest.Header.Sender = (SDMXObjectModel.Message.SenderType)Header.Sender;
RegistryInterfaceRequest.Header.Test = Header.Test;
}
RegistryInterfaceRequest.Footer = null;
RegistryInterfaceRequest.Item = new SDMXObjectModel.Registry.SubmitRegistrationsRequestType();
((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)RegistryInterfaceRequest.Item).RegistrationRequest = new List<RegistrationRequestType>();
((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)RegistryInterfaceRequest.Item).RegistrationRequest.Add(new RegistrationRequestType(null, ActionType.Replace));
((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)RegistryInterfaceRequest.Item).RegistrationRequest[0].Registration = new RegistrationType(RegistrationId);
((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)RegistryInterfaceRequest.Item).RegistrationRequest[0].Registration.ProvisionAgreement = new ProvisionAgreementReferenceType();
((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)RegistryInterfaceRequest.Item).RegistrationRequest[0].Registration.ProvisionAgreement.Items = new List<object>();
((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)RegistryInterfaceRequest.Item).RegistrationRequest[0].Registration.ProvisionAgreement.Items.Add(new ProvisionAgreementRefType(DevInfo.Lib.DI_LibSDMX.Constants.PA.Prefix + UserNId + "_" + DFDOrMFDId, Global.Get_AgencyId_From_DFD(DbNId), DevInfo.Lib.DI_LibSDMX.Constants.PA.Version));
((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)RegistryInterfaceRequest.Item).RegistrationRequest[0].Registration.Datasource = new List<object>();
if (!string.IsNullOrEmpty(WebServiceURL))
{
((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)RegistryInterfaceRequest.Item).RegistrationRequest[0].Registration.Datasource.Add(new SDMXObjectModel.Registry.QueryableDataSourceType(WebServiceURL, IsREST, WADLURL, IsSOAP, WSDLURL));
}
if (!string.IsNullOrEmpty(FileURL))
{
((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)RegistryInterfaceRequest.Item).RegistrationRequest[0].Registration.Datasource.Add(FileURL);
}
Service = new Registry.RegistryService();
Service.Url = HttpContext.Current.Request.Url.OriginalString.Substring(0, HttpContext.Current.Request.Url.OriginalString.IndexOf("libraries")) + Constants.FolderName.SDMX.RegistryServicePath;
Service.Url += "?p=" + DbNId.ToString();
Request = Serializer.SerializeToXmlDocument(typeof(RegistryInterfaceType), RegistryInterfaceRequest);
Element = Request.DocumentElement;
string languageNid = Global.GetLangNidFromlangCode(Language);
Service.SubmitRegistration(ref Element, SDMXFileName, languageNid);
RegistryInterfaceResponse = (RegistryInterfaceType)Deserializer.LoadFromText(typeof(RegistryInterfaceType), Element.OuterXml);
if (((SDMXObjectModel.Registry.SubmitRegistrationsResponseType)RegistryInterfaceResponse.Item).RegistrationStatus[0].StatusMessage.status == StatusType.Success)
{
this.Frame_Message_And_Send_Registration_Mail(UserNId, RegistrationId, Language);
RetVal = "true" + Constants.Delimiters.ParamDelimiter + ((SDMXObjectModel.Registry.SubmitRegistrationsResponseType)RegistryInterfaceResponse.Item).RegistrationStatus[0].Registration.id;
}
else
{
RetVal = "false" + Constants.Delimiters.ParamDelimiter + ((SDMXObjectModel.Registry.SubmitRegistrationsResponseType)RegistryInterfaceResponse.Item).RegistrationStatus[0].StatusMessage.MessageText[0].Text;
}
}
catch (Exception ex)
{
RetVal = "false" + Constants.Delimiters.ParamDelimiter + ex.Message;
Global.CreateExceptionString(ex, null);
}
finally
{
}
return RetVal;
}
private string BindRegistrationsPerPA(string DbNId, string LanguageCode, string PAId)
{
string RetVal;
string DFDMFDId;
string RegPAId;
string Id;
string QueryableData;
string WADL;
string WSDL;
string SimpleData;
string QueryableDataUrl;
string WADLUrl;
string WSDLUrl;
string SimpleDataUrl;
string DataMetadata;
string DFDMFD;
string Constraints;
string PA;
string DPId;
string Provider;
string UserNId;
string ConstraintPath;
string ConstraintViewPath;
string DFDMFDPath;
string DFDMFDViewPath;
string RegPath;
DIConnection DIConnection;
string Query;
DataTable DtReg;
DataTable DtDFDMFD;
StringBuilder sb;
int i, j, RowCounter;
SDMXObjectModel.Message.RegistryInterfaceType RegistryInterface;
SDMXObjectModel.Message.StructureType DPScheme;
string SimpleDataSource;
SDMXObjectModel.Registry.QueryableDataSourceType QueryableDataSource;
RetVal = string.Empty;
DFDMFDId = string.Empty;
RegPAId = string.Empty;
Id = string.Empty;
QueryableData = string.Empty;
WADL = string.Empty;
WSDL = string.Empty;
SimpleData = string.Empty;
QueryableDataUrl = string.Empty;
WADLUrl = string.Empty;
WSDLUrl = string.Empty;
SimpleDataUrl = string.Empty;
DataMetadata = string.Empty;
DFDMFD = string.Empty;
Constraints = string.Empty;
PA = string.Empty;
DPId = string.Empty;
Provider = string.Empty;
UserNId = string.Empty;
ConstraintPath = string.Empty;
ConstraintViewPath = string.Empty;
DFDMFDPath = string.Empty;
DFDMFDViewPath = string.Empty;
DIConnection = null;
RegPath = string.Empty;
sb = new StringBuilder();
i = 0;
j = 0;
RowCounter = 0;
RegistryInterface = new SDMXObjectModel.Message.RegistryInterfaceType();
DPScheme = new SDMXObjectModel.Message.StructureType();
try
{
DIConnection = new DIConnection(DIServerType.MsAccess, string.Empty, string.Empty, Server.MapPath("~//stock//Database.mdb"), string.Empty, string.Empty);
Query = "SELECT * FROM Artefacts WHERE DBNId = " + Convert.ToInt32(DbNId) + " AND Type=10;";
DtReg = DIConnection.ExecuteDataTable(Query);
if (DtReg != null && DtReg.Rows.Count > 0)
{
for (i = 0; i < DtReg.Rows.Count; i++)
{
RegPath = DtReg.Rows[i]["FileLocation"].ToString();
RegistryInterface = (SDMXObjectModel.Message.RegistryInterfaceType)SDMXObjectModel.Deserializer.LoadFromFile(typeof(SDMXObjectModel.Message.RegistryInterfaceType), RegPath);
RegPAId = ((ProvisionAgreementRefType)((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)(RegistryInterface.Item)).RegistrationRequest[0].Registration.ProvisionAgreement.Items[0]).id;
if (RegPAId == PAId)
{
RowCounter += 1;
Id = ((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)(RegistryInterface.Item)).RegistrationRequest[0].Registration.id;
Global.Retrieve_SimpleAndQueryableDataSource_FromRegistration(((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)(RegistryInterface.Item)).RegistrationRequest[0].Registration, out SimpleDataSource, out QueryableDataSource);
if (!string.IsNullOrEmpty(SimpleDataSource))
{
SimpleDataUrl = SimpleDataSource;
if (SimpleDataSource.Length > 25)
{
SimpleData = SimpleDataSource.Substring(0, 25) + "...";
}
else
{
SimpleData = SimpleDataSource;
}
}
if (QueryableDataSource != null)
{
QueryableDataUrl = QueryableDataSource.DataURL;
if (QueryableDataSource.DataURL.Length > 25)
{
QueryableData = QueryableDataSource.DataURL.Substring(0, 25) + "...";
}
else
{
QueryableData = QueryableDataSource.DataURL;
}
WADLUrl = QueryableDataSource.WADLURL;
if (QueryableDataSource.WADLURL.Length > 25)
{
WADL = QueryableDataSource.WADLURL.Substring(0, 25) + "...";
}
else
{
WADL = QueryableDataSource.WADLURL;
}
WSDLUrl = QueryableDataSource.WSDLURL;
if (QueryableDataSource.WSDLURL.Length > 25)
{
WSDL = QueryableDataSource.WSDLURL.Substring(0, 25) + "...";
}
else
{
WSDL = QueryableDataSource.WSDLURL;
}
}
if (RegPAId.Contains("DF_"))
{
DataMetadata = "Data";
DFDMFDId = "DF_" + Global.SplitString(PAId, "DF_")[1].ToString();
Query = "SELECT * FROM Artefacts WHERE DBNId = " + Convert.ToInt32(DbNId) + " AND Id='" + DFDMFDId + "' AND Type=4 ;";
}
else if (RegPAId.Contains("MF_"))
{
DataMetadata = "Metadata";
DFDMFDId = "MF_" + Global.SplitString(PAId, "MF_")[1].ToString();
Query = "SELECT * FROM Artefacts WHERE DBNId = " + Convert.ToInt32(DbNId) + " AND Id='" + DFDMFDId + "' AND Type=16 ;";
}
DtDFDMFD = DIConnection.ExecuteDataTable(Query);
if (DtDFDMFD != null && DtDFDMFD.Rows.Count > 0)
{
DFDMFDPath = DtDFDMFD.Rows[0]["FileLocation"].ToString();
DFDMFDViewPath = "../../" + DFDMFDPath.Substring(DFDMFDPath.LastIndexOf("stock")).Replace("\\", "/");
UserNId = Global.SplitString(PAId, "_")[1].ToString();
ConstraintPath = "stock/data/" + DbNId + "/sdmx/Constraints/" + UserNId + "/" + "CNS_" + ((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)(RegistryInterface.Item)).RegistrationRequest[0].Registration.id + ".xml";
ConstraintViewPath = "../../stock/data/" + DbNId + "/sdmx/Constraints/" + UserNId + "/" + "CNS_" + ((SDMXObjectModel.Registry.SubmitRegistrationsRequestType)(RegistryInterface.Item)).RegistrationRequest[0].Registration.id + ".xml";
DPId = DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.Prefix + UserNId;
DPScheme = (SDMXObjectModel.Message.StructureType)SDMXObjectModel.Deserializer.LoadFromFile(typeof(SDMXObjectModel.Message.StructureType), Path.Combine(HttpContext.Current.Request.PhysicalApplicationPath, Constants.FolderName.Users + DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.FileName));
if (DPScheme.Structures.OrganisationSchemes.Count > 0)
{
for (j = 0; j < DPScheme.Structures.OrganisationSchemes[0].Organisation.Count; j++)
{
if (((SDMXObjectModel.Structure.DataProviderType)(DPScheme.Structures.OrganisationSchemes[0].Organisation[j])).id == DPId)
{
Provider = GetLangSpecificValue_For_Version_2_1(((SDMXObjectModel.Structure.DataProviderType)(DPScheme.Structures.OrganisationSchemes[0].Organisation[j])).Name, LanguageCode);
}
}
}
}
if (RowCounter % 2 == 0)
{
sb.Append("<tr class=\"DataRowStyle \" style=\"background-color:#D8D8DC \">");
}
else
{
sb.Append("<tr class=\"DataRowStyle \">");
}
sb.Append("<td class=\"DataColumnStyle \">" + Id + "</td>");
sb.Append("<td class=\"DataColumnStyle \">" + "<a href=\"" + QueryableDataUrl + "\" title=\"" + QueryableDataUrl + "\" target=\"_blank \" >" + QueryableData + "</a></td>");
sb.Append("<td class=\"DataColumnStyle \">" + "<a href=\"" + WADLUrl + "\" title=\"" + WADLUrl + "\" target=\"_blank \" >" + WADL + "</a></td>");
sb.Append("<td class=\"DataColumnStyle \">" + "<a href=\"" + WSDLUrl + "\" title=\"" + WSDLUrl + "\" target=\"_blank \" >" + WSDL + "</a></td>");
sb.Append("<td class=\"DataColumnStyle \">" + "<a href=\"" + SimpleDataUrl + "\" title=\"" + SimpleDataUrl + "\" target=\"_blank \" >" + SimpleData + "</a></td>");
sb.Append("<td class=\"DataColumnStyle \">" + DataMetadata + "</td>");
//sb.Append("<td class=\"DataColumnStyle \"><a id=\"aView\" href=\" " + DFDMFDViewPath + "\" target=\"_blank\" name=\"lang_View\"></a> | ");
//sb.Append("<a id=\"aDownload\" style=\"cursor:pointer;\" href='Download.aspx?fileId=" + DFDMFDPath + "' name=\"lang_Download\"></a>");
//sb.Append("</td>");
sb.Append("<td class=\"DataColumnStyle \">");
if (DataMetadata == "Data")
{
sb.Append("<a id=\"aView\" href=\" " + ConstraintViewPath + "\" target=\"_blank\" name=\"lang_View\"></a> | ");
sb.Append("<a id=\"aDownload\" style=\"cursor:pointer;\" href='Download.aspx?fileId=" + ConstraintPath + "' name=\"lang_Download\"></a>");
}
sb.Append("</td>");
//sb.Append("<td class=\"DataColumnStyle \">" + Provider + "</td>");
sb.Append("</tr>");
}
}
}
RetVal = sb.ToString();
}
catch (Exception ex)
{
RetVal += "false" + Constants.Delimiters.ParamDelimiter + ex.Message;
Global.CreateExceptionString(ex, null);
}
finally
{
}
return RetVal;
}
public string GetRegistrationDetails(string requestParam)
{
string RetVal;
string[] Params;
string DbNId, UserNId, RegistrationId, DFDOrMFDId, LanguageCode;
bool IsMetadata;
RegistryInterfaceType RegistryInterfaceRequest, RegistryInterfaceResponse;
RegistrationType Registration;
Registry.RegistryService Service;
XmlDocument Request;
XmlElement Element;
SDMXObjectModel.Registry.QueryableDataSourceType QueryableDataSource = null;
string SimpleDataSource = string.Empty;
string DataUrl = string.Empty;
string WADLUrl = string.Empty;
string WSDLUrl = string.Empty;
string SimpleDataFileUrl = string.Empty;
bool IsRest = false;
bool IsSoap = false;
RetVal = string.Empty;
DbNId = string.Empty;
UserNId = string.Empty;
RegistrationId = string.Empty;
DFDOrMFDId = string.Empty;
LanguageCode = string.Empty;
IsMetadata = false;
RegistryInterfaceRequest = null;
RegistryInterfaceResponse = null;
Registration = null;
Service = null;
Request = new XmlDocument();
Element = null;
try
{
Params = Global.SplitString(requestParam, Constants.Delimiters.ParamDelimiter);
DbNId = Params[0].ToString().Trim();
UserNId = Params[1].ToString().Trim();
RegistrationId = Params[2].ToString().Trim();
LanguageCode = Params[3].ToString().Trim();
RegistryInterfaceRequest = new RegistryInterfaceType();
RegistryInterfaceRequest.Header = Global.Get_Appropriate_Header();
RegistryInterfaceRequest.Footer = null;
RegistryInterfaceRequest.Item = new SDMXObjectModel.Registry.QueryRegistrationRequestType();
((SDMXObjectModel.Registry.QueryRegistrationRequestType)RegistryInterfaceRequest.Item).Item = new DataProviderReferenceType();
((DataProviderReferenceType)((SDMXObjectModel.Registry.QueryRegistrationRequestType)RegistryInterfaceRequest.Item).Item).Items = new List<object>();
((DataProviderReferenceType)((SDMXObjectModel.Registry.QueryRegistrationRequestType)RegistryInterfaceRequest.Item).Item).Items.Add(new DataProviderRefType
(DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.Prefix + UserNId, DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.AgencyId,
DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.Id, DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.Version));
Service = new Registry.RegistryService();
Service.Url = HttpContext.Current.Request.Url.OriginalString.Substring(0, HttpContext.Current.Request.Url.OriginalString.IndexOf("libraries")) + Constants.FolderName.SDMX.RegistryServicePath;
Service.Url += "?p=" + DbNId.ToString();
Request = Serializer.SerializeToXmlDocument(typeof(RegistryInterfaceType), RegistryInterfaceRequest);
Element = Request.DocumentElement;
string languageNid = Global.GetLangNidFromlangCode(LanguageCode);
Service.QueryRegistration(ref Element, languageNid);
RegistryInterfaceResponse = (RegistryInterfaceType)Deserializer.LoadFromText(typeof(RegistryInterfaceType), Element.OuterXml);
foreach (QueryResultType QueryResult in ((SDMXObjectModel.Registry.QueryRegistrationResponseType)RegistryInterfaceResponse.Item).QueryResult)
{
if (QueryResult.Item.Registration.id == RegistrationId)
{
Registration = QueryResult.Item.Registration;
break;
}
}
DFDOrMFDId = ((ProvisionAgreementRefType)(Registration.ProvisionAgreement.Items[0])).id.Replace(DevInfo.Lib.DI_LibSDMX.Constants.PA.Prefix + UserNId + "_", "");
if (Registration.Datasource != null && Registration.Datasource.Count > 0 && Registration.Datasource.Count < 3)
{
if (Registration.Datasource.Count == 1)
{
if (Registration.Datasource[0] is SDMXObjectModel.Registry.QueryableDataSourceType)
{
QueryableDataSource = (SDMXObjectModel.Registry.QueryableDataSourceType)Registration.Datasource[0];
}
else if (Registration.Datasource[0] is string)
{
SimpleDataSource = (string)Registration.Datasource[0];
}
}
else if (Registration.Datasource.Count == 2)
{
if (Registration.Datasource[0] is SDMXObjectModel.Registry.QueryableDataSourceType)
{
QueryableDataSource = (SDMXObjectModel.Registry.QueryableDataSourceType)Registration.Datasource[0];
if (Registration.Datasource[1] is string)
{
SimpleDataSource = (string)Registration.Datasource[1];
}
}
else if (Registration.Datasource[0] is string)
{
SimpleDataSource = (string)Registration.Datasource[0];
if (Registration.Datasource[1] is SDMXObjectModel.Registry.QueryableDataSourceType)
{
QueryableDataSource = (SDMXObjectModel.Registry.QueryableDataSourceType)Registration.Datasource[1];
}
}
}
}
if (!string.IsNullOrEmpty(SimpleDataSource))
{
SimpleDataFileUrl = SimpleDataSource;
}
if (QueryableDataSource != null)
{
DataUrl = QueryableDataSource.DataURL;
WADLUrl = QueryableDataSource.WADLURL;
WSDLUrl = QueryableDataSource.WSDLURL;
IsRest = QueryableDataSource.isRESTDatasource;
IsSoap = QueryableDataSource.isWebServiceDatasource;
}
RetVal = Registration.id + Constants.Delimiters.ParamDelimiter + DataUrl + Constants.Delimiters.ParamDelimiter + IsRest.ToString() +
Constants.Delimiters.ParamDelimiter + WADLUrl + Constants.Delimiters.ParamDelimiter + IsSoap.ToString() + Constants.Delimiters.ParamDelimiter +
WSDLUrl + Constants.Delimiters.ParamDelimiter + SimpleDataFileUrl;
if (DFDOrMFDId == DevInfo.Lib.DI_LibSDMX.Constants.DFD.Id)
{
IsMetadata = false;
}
else
{
IsMetadata = true;
}
RetVal += Constants.Delimiters.ParamDelimiter + IsMetadata;
RetVal += Constants.Delimiters.ParamDelimiter + DFDOrMFDId;
}
catch (Exception ex)
{
RetVal = ex.Message;
Global.CreateExceptionString(ex, null);
}
finally
{
}
return RetVal;
}
private string GetRegistrationsSummaryHTML(string DbNId, string UserNId, string LanguageCode, int StartIndex, int NumberPagingRows)
{
string RetVal;
int TotalRows, Counter, TotalRowCount = 0, TempRowCount = 0;
RegistryInterfaceType RegistryInterfaceRequest, RegistryInterfaceResponse;
Registry.RegistryService Service;
XmlDocument Request;
XmlElement Element;
RetVal = string.Empty;
TotalRows = 0;
Counter = 0;
RegistryInterfaceRequest = null;
RegistryInterfaceResponse = null;
Service = null;
Request = new XmlDocument();
Element = null;
try
{
RegistryInterfaceRequest = new RegistryInterfaceType();
RegistryInterfaceRequest.Header = Global.Get_Appropriate_Header();
RegistryInterfaceRequest.Footer = null;
RegistryInterfaceRequest.Item = new SDMXObjectModel.Registry.QueryRegistrationRequestType();
((SDMXObjectModel.Registry.QueryRegistrationRequestType)RegistryInterfaceRequest.Item).Item = new DataProviderReferenceType();
((DataProviderReferenceType)((SDMXObjectModel.Registry.QueryRegistrationRequestType)RegistryInterfaceRequest.Item).Item).Items = new List<object>();
((DataProviderReferenceType)((SDMXObjectModel.Registry.QueryRegistrationRequestType)RegistryInterfaceRequest.Item).Item).Items.Add(new DataProviderRefType(DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.Prefix + UserNId, DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.AgencyId, DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.Id, DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.Version));
Service = new Registry.RegistryService();
Service.Url = HttpContext.Current.Request.Url.OriginalString.Substring(0, HttpContext.Current.Request.Url.OriginalString.IndexOf("libraries")) + Constants.FolderName.SDMX.RegistryServicePath;
Service.Url += "?p=" + DbNId.ToString();
Request = Serializer.SerializeToXmlDocument(typeof(RegistryInterfaceType), RegistryInterfaceRequest);
Element = Request.DocumentElement;
string languageNid = Global.GetLangNidFromlangCode(LanguageCode);
Service.QueryRegistration(ref Element, languageNid);
RegistryInterfaceResponse = (RegistryInterfaceType)Deserializer.LoadFromText(typeof(RegistryInterfaceType), Element.OuterXml);
TotalRows = ((SDMXObjectModel.Registry.QueryRegistrationResponseType)RegistryInterfaceResponse.Item).QueryResult.Count;
foreach (QueryResultType QueryResult in ((SDMXObjectModel.Registry.QueryRegistrationResponseType)RegistryInterfaceResponse.Item).QueryResult)
{
if (StartIndex + NumberPagingRows <= TotalRows)
{
if ((Counter >= StartIndex) && (Counter < StartIndex + NumberPagingRows))
{
TempRowCount = TotalRowCount;
RetVal += this.Get_InnerHtml_For_Single_Registration(DbNId, UserNId, LanguageCode, QueryResult.Item.Registration, TempRowCount, out TotalRowCount);
RetVal += Constants.Delimiters.PivotRowDelimiter;
}
}
else
{
if ((Counter >= StartIndex) && (Counter < TotalRows))
{
TempRowCount = TotalRowCount;
RetVal += this.Get_InnerHtml_For_Single_Registration(DbNId, UserNId, LanguageCode, QueryResult.Item.Registration, TempRowCount, out TotalRowCount);
RetVal += Constants.Delimiters.PivotRowDelimiter;
}
}
if (RetVal.Contains("#"))
{
RetVal = RetVal.Replace("##########", "#").Replace("#########", "#").Replace("########", "#").Replace("#######", "#").Replace("######", "#").Replace("#####", "#").Replace("####", "#").Replace("###", "#").Replace("##", "#");
if (RetVal.StartsWith("#"))
{
RetVal = RetVal.Substring(1);
}
}
Counter++;
}
RetVal = RetVal.Remove(RetVal.Length - 1, 1);
// TotalRows =TotalRowCount;
RetVal += Constants.Delimiters.ParamDelimiter + StartIndex.ToString() + Constants.Delimiters.ParamDelimiter + NumberPagingRows.ToString() + Constants.Delimiters.ParamDelimiter + TotalRows.ToString();
}
catch (Exception ex)
{
Global.CreateExceptionString(ex, null);
throw ex;
}
finally
{
}
return RetVal;
}
public string DeleteSubscription(string requestParam)
{
string RetVal;
string[] Params;
string Action;
string NotificationMail;
string NotificationHTTP;
int IsSOAP;
string SubscriberAssignedID;
string StartDate;
string EndDate;
string EventSelector;
string CategoriesGIDAndSchemeIds;
string MFDId;
string DbNId;
string CodelistId;
string SubscriberIdAndType;
string SubscriptionId;
string CategoryGID;
string CategorySchemeId;
string UploadedHeaderFileWPath, UploadedHeaderFolderPath;
string OriginalDBNId;
string[] DBDetails;
Registry.RegistryService Service;
XmlDocument Query;
XmlElement Element;
XmlDocument Response;
XmlDocument UploadedHeaderXml;
SDMXObjectModel.Message.RegistryInterfaceType SubRegistryInterface;
SDMXObjectModel.Message.StructureHeaderType Header;
List<bool> isSOAPMailIds;
List<string> notificationMailIds;
List<bool> isSOAPHTTPs;
List<string> notificationHTTPs;
DateTime startDate;
DateTime endDate;
Dictionary<string, string> dictCategories;
string AgencyId;
RetVal = "true";
Service = new Registry.RegistryService();
Query = new XmlDocument();
Response = new XmlDocument();
Element = null;
SubRegistryInterface = new SDMXObjectModel.Message.RegistryInterfaceType();
Action = string.Empty;
NotificationMail = string.Empty;
NotificationHTTP = string.Empty;
IsSOAP = 0;
SubscriberAssignedID = string.Empty;
StartDate = string.Empty;
EndDate = string.Empty;
EventSelector = string.Empty;
CategoriesGIDAndSchemeIds = string.Empty;
MFDId = string.Empty;
DbNId = string.Empty;
CodelistId = string.Empty;
SubscriberIdAndType = string.Empty;
CategoryGID = string.Empty;
CategorySchemeId = string.Empty;
isSOAPMailIds = new List<bool>();
notificationMailIds = new List<string>();
isSOAPHTTPs = new List<bool>();
notificationHTTPs = new List<string>();
dictCategories = new Dictionary<string, string>();
AgencyId = string.Empty;
Header = new SDMXObjectModel.Message.StructureHeaderType();
UploadedHeaderXml = new XmlDocument();
UploadedHeaderFolderPath = Server.MapPath("../../stock/data");
OriginalDBNId = string.Empty;
DBDetails = null;
UploadedHeaderFileWPath = string.Empty;
try
{
Params = Global.SplitString(requestParam, Constants.Delimiters.ParamDelimiter);
Action = Params[0];
NotificationMail = Params[1];
NotificationHTTP = Params[2];
IsSOAP = Convert.ToInt16(Params[3]);
StartDate = Params[4];
EndDate = Params[5];
EventSelector = Params[6];
CategoriesGIDAndSchemeIds = Params[7];
MFDId = Params[8];
DbNId = Params[9];
SubscriberIdAndType = Params[10];
SubscriptionId = Params[11];
OriginalDBNId = Params[12];
AgencyId = Global.Get_AgencyId_From_DFD(DbNId.ToString());
DBDetails = Global.GetDbConnectionDetails(DbNId);
if (DbNId != OriginalDBNId && DBDetails[4] == "true")
{
UploadedHeaderFileWPath = UploadedHeaderFolderPath + "/" + OriginalDBNId + "/" + "sdmx" + "/" + DevInfo.Lib.DI_LibSDMX.Constants.Header.FileName;
}
else
{
UploadedHeaderFileWPath = UploadedHeaderFolderPath + "/" + DbNId + "/" + "sdmx" + "/" + DevInfo.Lib.DI_LibSDMX.Constants.Header.FileName;
}
SDMXObjectModel.Message.StructureType UploadedDSDStructure = new SDMXObjectModel.Message.StructureType();
if (File.Exists(UploadedHeaderFileWPath))
{
UploadedHeaderXml.Load(UploadedHeaderFileWPath);
UploadedDSDStructure = (SDMXObjectModel.Message.StructureType)SDMXObjectModel.Deserializer.LoadFromXmlDocument(typeof(SDMXObjectModel.Message.StructureType), UploadedHeaderXml);
Header = UploadedDSDStructure.Header;
}
if (IsSOAP == 0)
{
isSOAPMailIds = new List<bool>();
isSOAPMailIds.Add(false);
isSOAPHTTPs = new List<bool>();
isSOAPHTTPs.Add(false);
}
else
{
isSOAPMailIds = new List<bool>();
isSOAPMailIds.Add(true);
isSOAPHTTPs = new List<bool>();
isSOAPHTTPs.Add(true);
}
notificationMailIds = new List<string>();
notificationMailIds.Add(NotificationMail);
notificationHTTPs = new List<string>();
notificationHTTPs.Add(NotificationHTTP);
startDate = DateTime.ParseExact(StartDate.ToString().Trim(), "dd-MM-yyyy", null);
endDate = DateTime.ParseExact(EndDate.ToString().Trim(), "dd-MM-yyyy", null);
dictCategories = new Dictionary<string, string>();
if (EventSelector == "Data Registration")
{
foreach (string CategoryGIDAndSchemeId in Global.SplitString(CategoriesGIDAndSchemeIds, ","))
{
CategoryGID = CategoryGIDAndSchemeId.Split('|')[0];
CategorySchemeId = CategoryGIDAndSchemeId.Split('|')[1];
dictCategories.Add(CategoryGID, CategorySchemeId);
}
}
Query = GetQueryXmlDocumentForSubmitSubscription(ActionType.Delete, SubscriberIdAndType, AgencyId, isSOAPMailIds, notificationMailIds, isSOAPHTTPs, notificationHTTPs, startDate, endDate, EventSelector, dictCategories, MFDId, SubscriptionId,Header);
Element = Query.DocumentElement;
Service.Url = HttpContext.Current.Request.Url.OriginalString.Substring(0, HttpContext.Current.Request.Url.OriginalString.IndexOf("libraries")) + Constants.FolderName.SDMX.RegistryServicePath;
Service.Url += "?p=" + DbNId.ToString();
Service.SubmitSubscription(ref Element, string.Empty);
Response.LoadXml(Element.OuterXml);
SubRegistryInterface = (SDMXObjectModel.Message.RegistryInterfaceType)(SDMXObjectModel.Deserializer.LoadFromXmlDocument(typeof(SDMXObjectModel.Message.RegistryInterfaceType), Response));
if (((SDMXObjectModel.Registry.SubmitSubscriptionsResponseType)(SubRegistryInterface.Item)).SubscriptionStatus[0].StatusMessage.status == SDMXObjectModel.Registry.StatusType.Success)
{
RetVal = "true";
}
else
{
RetVal = "false";
}
}
catch (Exception ex)
{
RetVal = "false" + Constants.Delimiters.ParamDelimiter + ex.Message;
Global.CreateExceptionString(ex, null);
}
finally
{
}
return RetVal;
}
private XmlDocument GetQueryXmlDocumentForSubmitSubscription(ActionType Action, string UserIdAndType, string agencyId, List<bool> isSOAPMailIds, List<string> notificationMailIds, List<bool> isSOAPHTTPs, List<string> notificationHTTPs, DateTime startDate, DateTime endDate, string eventSelector, Dictionary<string, string> dictCategories, string mfdId, string RegistryURN,SDMXObjectModel.Message.StructureHeaderType Header)
{
XmlDocument RetVal;
string id;
string userId;
UserTypes userType;
SDMXObjectModel.Message.RegistryInterfaceType RegistryInterface;
int counter = 0;
DIConnection DIConnection;
RetVal = null;
id = string.Empty;
userId = string.Empty;
userType = UserTypes.Consumer;
try
{
DIConnection = new DIConnection(DIServerType.MsAccess, string.Empty, string.Empty, Server.MapPath("~//stock//Database.mdb"),
string.Empty, string.Empty);
if (string.IsNullOrEmpty(RegistryURN))
{
id = Guid.NewGuid().ToString();
}
else
{
id = RegistryURN;
}
userId = UserIdAndType.Split('|')[0];
if (UserIdAndType.Split('|')[1] == "True")
{
userType = UserTypes.Provider;
}
else
{
userType = UserTypes.Consumer;
}
RegistryInterface = new RegistryInterfaceType();
if (Header == null)
{
RegistryInterface.Header = Global.Get_Appropriate_Header();
}
else
{
RegistryInterface.Header.ID = Header.ID.ToString();
RegistryInterface.Header.Prepared = Header.Prepared.ToString();
foreach (PartyType receiver in Header.Receiver)
{
RegistryInterface.Header.Receiver = new PartyType();
RegistryInterface.Header.Receiver.Contact = receiver.Contact;
RegistryInterface.Header.Receiver.id = receiver.id;
RegistryInterface.Header.Receiver.Name = receiver.Name;
}
RegistryInterface.Header.Sender = (SDMXObjectModel.Message.SenderType)Header.Sender;
RegistryInterface.Header.Test = Header.Test;
}
RegistryInterface.Item = new SDMXObjectModel.Registry.SubmitSubscriptionsRequestType();
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest = new List<SubscriptionRequestType>();
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest.Add(new SubscriptionRequestType());
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription = new SDMXObjectModel.Registry.SubscriptionType();
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].action = Action;
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.Organisation = new OrganisationReferenceType();
if (userType == UserTypes.Consumer)
{
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.Organisation.Items.Add(new DataConsumerRefType(DevInfo.Lib.DI_LibSDMX.Constants.DataConsumerScheme.Prefix + userId, DevInfo.Lib.DI_LibSDMX.Constants.DataConsumerScheme.AgencyId, DevInfo.Lib.DI_LibSDMX.Constants.DataConsumerScheme.Id, DevInfo.Lib.DI_LibSDMX.Constants.DataConsumerScheme.Version));
}
else
{
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.Organisation.Items.Add(new DataProviderRefType(DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.Prefix + userId, DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.AgencyId, DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.Id, DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.Version));
}
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.RegistryURN = id;
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.NotificationMailTo = new List<SDMXObjectModel.Registry.NotificationURLType>();
foreach (string notificationMailId in notificationMailIds)
{
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.NotificationMailTo.Add(new SDMXObjectModel.Registry.NotificationURLType(isSOAPMailIds[counter], notificationMailIds[counter]));
counter++;
}
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.NotificationHTTP = new List<SDMXObjectModel.Registry.NotificationURLType>();
counter = 0;
foreach (string notificationHTTP in notificationHTTPs)
{
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.NotificationHTTP.Add(new SDMXObjectModel.Registry.NotificationURLType(isSOAPHTTPs[counter], notificationHTTPs[counter]));
counter++;
}
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.SubscriberAssignedID = Guid.NewGuid().ToString();
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.ValidityPeriod = new SDMXObjectModel.Registry.ValidityPeriodType();
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.ValidityPeriod.StartDate = startDate;
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.ValidityPeriod.EndDate = endDate;
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector = new List<object>();
if (eventSelector == "Data Registration")
{
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector.Add(new DataRegistrationEventsType());
((DataRegistrationEventsType)((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector[0]).Items = new CategoryReferenceType[dictCategories.Keys.Count];
((DataRegistrationEventsType)((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector[0]).ItemsElementName = new SDMXObjectModel.Registry.DataRegistrationEventsChoiceType[dictCategories.Keys.Count];
counter = 0;
foreach (string categoryId in dictCategories.Keys)
{
((DataRegistrationEventsType)((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector[0]).Items[counter] = new CategoryReferenceType();
((DataRegistrationEventsType)((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector[0]).ItemsElementName[counter] = SDMXObjectModel.Registry.DataRegistrationEventsChoiceType.Category;
((CategoryReferenceType)((DataRegistrationEventsType)((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector[0]).Items[counter]).Items.Add(new CategoryRefType(categoryId, agencyId, dictCategories[categoryId], DevInfo.Lib.DI_LibSDMX.Constants.CategoryScheme.Sector.Version));
counter++;
}
}
else if (eventSelector == "Metadata Registration")
{
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector.Add(new MetadataRegistrationEventsType());
((MetadataRegistrationEventsType)((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector[0]).Items = new MaintainableEventType[1];
((MetadataRegistrationEventsType)((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector[0]).Items[0] = new MaintainableEventType();
((MetadataRegistrationEventsType)((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector[0]).ItemsElementName = new MetadataRegistrationEventsChoiceType[1];
((MetadataRegistrationEventsType)((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector[0]).ItemsElementName[0] = SDMXObjectModel.Registry.MetadataRegistrationEventsChoiceType.MetadataflowReference;
((MaintainableEventType)((MetadataRegistrationEventsType)((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector[0]).Items[0]).Item = new MaintainableQueryType();
((MaintainableQueryType)(((MaintainableEventType)((MetadataRegistrationEventsType)((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector[0]).Items[0]).Item)).id = mfdId;
((MaintainableQueryType)(((MaintainableEventType)((MetadataRegistrationEventsType)((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector[0]).Items[0]).Item)).agencyID = agencyId;
((MaintainableQueryType)(((MaintainableEventType)((MetadataRegistrationEventsType)((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector[0]).Items[0]).Item)).version = DevInfo.Lib.DI_LibSDMX.Constants.MFD.Area.Version;
}
else if (eventSelector == "Structural Metadata Registration")
{
((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector.Add(new StructuralRepositoryEventsType());
((StructuralRepositoryEventsType)((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector[0]).AgencyID = new List<string>();
((StructuralRepositoryEventsType)((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector[0]).AgencyID.Add(agencyId);
((StructuralRepositoryEventsType)((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector[0]).Items = new EmptyType[1];
((StructuralRepositoryEventsType)((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector[0]).Items[0] = new EmptyType();
((StructuralRepositoryEventsType)((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector[0]).ItemsElementName = new StructuralRepositoryEventsChoiceType[1];
((StructuralRepositoryEventsType)((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)(RegistryInterface.Item)).SubscriptionRequest[0].Subscription.EventSelector[0]).ItemsElementName[0] = SDMXObjectModel.Registry.StructuralRepositoryEventsChoiceType.AllEvents;
}
RetVal = Serializer.SerializeToXmlDocument(typeof(SDMXObjectModel.Message.RegistryInterfaceType), RegistryInterface);
}
catch (Exception ex)
{
Global.CreateExceptionString(ex, null);
}
finally
{
}
return RetVal;
}
private SDMXObjectModel.Message.RegistryInterfaceType Get_RegistryInterface_Object(SDMXObjectModel.Registry.NotifyRegistryEventType NotifyRegistryEvent)
{
SDMXObjectModel.Message.RegistryInterfaceType RetVal;
RetVal = new SDMXObjectModel.Message.RegistryInterfaceType();
RetVal.Header = this.Get_Appropriate_Header();
RetVal.Item = NotifyRegistryEvent;
RetVal.Footer = null;
return RetVal;
}
private XmlDocument GetQueryXmlDocumentOnTypeBasis(int Type, string Id, string AgencyId, string Version, string UserIdAndType)
{
XmlDocument RetVal;
UserTypes UserType;
string UserID;
string parentAgencyID;
string maintainableParentID;
string maintainableParentVersion;
parentAgencyID=string.Empty;
UserID=string.Empty;
maintainableParentID=string.Empty;
maintainableParentVersion=string.Empty;
RetVal = null;
try
{
switch (Type)
{
case 0:
SDMXObjectModel.Message.DataflowQueryType Dataflow = new SDMXObjectModel.Message.DataflowQueryType();
Dataflow.Header = Global.Get_Appropriate_Header();
Dataflow.Query = new SDMXObjectModel.Query.DataflowQueryType();
Dataflow.Query.ReturnDetails = new StructureReturnDetailsType();
Dataflow.Query.ReturnDetails.References = new ReferencesType();
Dataflow.Query.ReturnDetails.References.ItemElementName = ReferencesChoiceType.None;
Dataflow.Query.ReturnDetails.References.Item = new EmptyType();
Dataflow.Query.Item = new DataflowWhereType();
Dataflow.Query.Item.type = SDMXObjectModel.Common.MaintainableTypeCodelistType.Dataflow;
Dataflow.Query.Item.typeSpecified = true;
Dataflow.Query.Item.ID = new QueryIDType();
Dataflow.Query.Item.ID.Value = Id;
Dataflow.Query.Item.AgencyID = new QueryNestedIDType();
Dataflow.Query.Item.AgencyID.Value = AgencyId;
Dataflow.Query.Item.Version = Version;
Dataflow.Query.Item.Annotation = null;
Dataflow.Query.Item.Name = null;
Dataflow.Query.Item.Description = null;
RetVal = Serializer.SerializeToXmlDocument(typeof(SDMXObjectModel.Message.DataflowQueryType), Dataflow);
break;
case 1:
SDMXObjectModel.Message.MetadataflowQueryType Metadataflow = new SDMXObjectModel.Message.MetadataflowQueryType();
Metadataflow.Header = Global.Get_Appropriate_Header();
Metadataflow.Query = new SDMXObjectModel.Query.MetadataflowQueryType();
Metadataflow.Query.ReturnDetails = new StructureReturnDetailsType();
Metadataflow.Query.ReturnDetails.References = new ReferencesType();
Metadataflow.Query.ReturnDetails.References.ItemElementName = ReferencesChoiceType.None;
Metadataflow.Query.ReturnDetails.References.Item = new EmptyType();
Metadataflow.Query.Item = new MetadataflowWhereType();
Metadataflow.Query.Item.type = SDMXObjectModel.Common.MaintainableTypeCodelistType.Metadataflow;
Metadataflow.Query.Item.typeSpecified = true;
Metadataflow.Query.Item.ID = new QueryIDType();
Metadataflow.Query.Item.ID.Value = Id;
Metadataflow.Query.Item.AgencyID = new QueryNestedIDType();
Metadataflow.Query.Item.AgencyID.Value = AgencyId;
Metadataflow.Query.Item.Version = Version;
Metadataflow.Query.Item.Annotation = null;
Metadataflow.Query.Item.Name = null;
Metadataflow.Query.Item.Description = null;
RetVal = Serializer.SerializeToXmlDocument(typeof(SDMXObjectModel.Message.MetadataflowQueryType), Metadataflow);
break;
case 2:
SDMXObjectModel.Message.DataStructureQueryType DataStructure = new SDMXObjectModel.Message.DataStructureQueryType();
DataStructure.Header = Global.Get_Appropriate_Header();
DataStructure.Query = new SDMXObjectModel.Query.DataStructureQueryType();
DataStructure.Query.ReturnDetails = new StructureReturnDetailsType();
DataStructure.Query.ReturnDetails.References = new ReferencesType();
DataStructure.Query.ReturnDetails.References.ItemElementName = ReferencesChoiceType.None;
DataStructure.Query.ReturnDetails.References.Item = new EmptyType();
DataStructure.Query.Item = new DataStructureWhereType();
DataStructure.Query.Item.type = SDMXObjectModel.Common.MaintainableTypeCodelistType.DataStructure;
DataStructure.Query.Item.typeSpecified = true;
DataStructure.Query.Item.ID = new QueryIDType();
DataStructure.Query.Item.ID.Value = Id;
DataStructure.Query.Item.AgencyID = new QueryNestedIDType();
DataStructure.Query.Item.AgencyID.Value = AgencyId;
DataStructure.Query.Item.Version = Version;
DataStructure.Query.Item.Annotation = null;
DataStructure.Query.Item.Name = null;
DataStructure.Query.Item.Description = null;
RetVal = Serializer.SerializeToXmlDocument(typeof(SDMXObjectModel.Message.DataStructureQueryType), DataStructure);
break;
case 3:
SDMXObjectModel.Message.MetadataStructureQueryType MetadataStructure = new SDMXObjectModel.Message.MetadataStructureQueryType();
MetadataStructure.Header = Global.Get_Appropriate_Header();
MetadataStructure.Query = new SDMXObjectModel.Query.MetadataStructureQueryType();
MetadataStructure.Query.ReturnDetails = new StructureReturnDetailsType();
MetadataStructure.Query.ReturnDetails.References = new ReferencesType();
MetadataStructure.Query.ReturnDetails.References.ItemElementName = ReferencesChoiceType.None;
MetadataStructure.Query.ReturnDetails.References.Item = new EmptyType();
MetadataStructure.Query.Item = new MetadataStructureWhereType();
MetadataStructure.Query.Item.type = SDMXObjectModel.Common.MaintainableTypeCodelistType.MetadataStructure;
MetadataStructure.Query.Item.typeSpecified = true;
MetadataStructure.Query.Item.ID = new QueryIDType();
MetadataStructure.Query.Item.ID.Value = Id;
MetadataStructure.Query.Item.AgencyID = new QueryNestedIDType();
MetadataStructure.Query.Item.AgencyID.Value = AgencyId;
MetadataStructure.Query.Item.Version = Version;
MetadataStructure.Query.Item.Annotation = null;
MetadataStructure.Query.Item.Name = null;
MetadataStructure.Query.Item.Description = null;
RetVal = Serializer.SerializeToXmlDocument(typeof(SDMXObjectModel.Message.MetadataStructureQueryType), MetadataStructure);
break;
case 4:
SDMXObjectModel.Message.CategorySchemeQueryType CategoryScheme = new SDMXObjectModel.Message.CategorySchemeQueryType();
CategoryScheme.Header = Global.Get_Appropriate_Header();
CategoryScheme.Query = new SDMXObjectModel.Query.CategorySchemeQueryType();
CategoryScheme.Query.ReturnDetails = new StructureReturnDetailsType();
CategoryScheme.Query.ReturnDetails.References = new ReferencesType();
CategoryScheme.Query.ReturnDetails.References.ItemElementName = ReferencesChoiceType.None;
CategoryScheme.Query.ReturnDetails.References.Item = new EmptyType();
CategoryScheme.Query.Item = new CategorySchemeWhereType();
CategoryScheme.Query.Item.type = SDMXObjectModel.Common.MaintainableTypeCodelistType.CategoryScheme;
CategoryScheme.Query.Item.typeSpecified = true;
CategoryScheme.Query.Item.ID = new QueryIDType();
CategoryScheme.Query.Item.ID.Value = Id;
CategoryScheme.Query.Item.AgencyID = new QueryNestedIDType();
CategoryScheme.Query.Item.AgencyID.Value = AgencyId;
CategoryScheme.Query.Item.Version = Version;
CategoryScheme.Query.Item.Annotation = null;
CategoryScheme.Query.Item.Name = null;
CategoryScheme.Query.Item.Description = null;
RetVal = Serializer.SerializeToXmlDocument(typeof(SDMXObjectModel.Message.CategorySchemeQueryType), CategoryScheme);
break;
case 5:
SDMXObjectModel.Message.CategorisationQueryType Categorisation = new SDMXObjectModel.Message.CategorisationQueryType();
Categorisation.Header = Global.Get_Appropriate_Header();
Categorisation.Query = new SDMXObjectModel.Query.CategorisationQueryType();
Categorisation.Query.ReturnDetails = new StructureReturnDetailsType();
Categorisation.Query.ReturnDetails.References = new ReferencesType();
Categorisation.Query.ReturnDetails.References.ItemElementName = ReferencesChoiceType.None;
Categorisation.Query.ReturnDetails.References.Item = new EmptyType();
Categorisation.Query.Item = new CategorisationWhereType();
Categorisation.Query.Item.type = SDMXObjectModel.Common.MaintainableTypeCodelistType.Categorisation;
Categorisation.Query.Item.typeSpecified = true;
Categorisation.Query.Item.ID = new QueryIDType();
Categorisation.Query.Item.ID.Value = Id;
Categorisation.Query.Item.AgencyID = new QueryNestedIDType();
Categorisation.Query.Item.AgencyID.Value = AgencyId;
Categorisation.Query.Item.Version = Version;
Categorisation.Query.Item.Annotation = null;
Categorisation.Query.Item.Name = null;
Categorisation.Query.Item.Description = null;
RetVal = Serializer.SerializeToXmlDocument(typeof(SDMXObjectModel.Message.CategorisationQueryType), Categorisation);
break;
case 6:
SDMXObjectModel.Message.ConceptSchemeQueryType ConceptScheme = new SDMXObjectModel.Message.ConceptSchemeQueryType();
ConceptScheme.Header = Global.Get_Appropriate_Header();
ConceptScheme.Query = new SDMXObjectModel.Query.ConceptSchemeQueryType();
ConceptScheme.Query.ReturnDetails = new StructureReturnDetailsType();
ConceptScheme.Query.ReturnDetails.References = new ReferencesType();
ConceptScheme.Query.ReturnDetails.References.ItemElementName = ReferencesChoiceType.None;
ConceptScheme.Query.ReturnDetails.References.Item = new EmptyType();
ConceptScheme.Query.Item = new ConceptSchemeWhereType();
ConceptScheme.Query.Item.type = SDMXObjectModel.Common.MaintainableTypeCodelistType.ConceptScheme;
ConceptScheme.Query.Item.typeSpecified = true;
ConceptScheme.Query.Item.ID = new QueryIDType();
ConceptScheme.Query.Item.ID.Value = Id;
ConceptScheme.Query.Item.AgencyID = new QueryNestedIDType();
ConceptScheme.Query.Item.AgencyID.Value = AgencyId;
ConceptScheme.Query.Item.Version = Version;
ConceptScheme.Query.Item.Annotation = null;
ConceptScheme.Query.Item.Name = null;
ConceptScheme.Query.Item.Description = null;
RetVal = Serializer.SerializeToXmlDocument(typeof(SDMXObjectModel.Message.ConceptSchemeQueryType), ConceptScheme);
break;
case 7:
SDMXObjectModel.Message.CodelistQueryType Codelist = new SDMXObjectModel.Message.CodelistQueryType();
Codelist.Header = Global.Get_Appropriate_Header();
Codelist.Query = new SDMXObjectModel.Query.CodelistQueryType();
Codelist.Query.ReturnDetails = new StructureReturnDetailsType();
Codelist.Query.ReturnDetails.References = new ReferencesType();
Codelist.Query.ReturnDetails.References.ItemElementName = ReferencesChoiceType.None;
Codelist.Query.ReturnDetails.References.Item = new EmptyType();
Codelist.Query.Item = new CodelistWhereType();
Codelist.Query.Item.type = SDMXObjectModel.Common.MaintainableTypeCodelistType.Codelist;
Codelist.Query.Item.typeSpecified = true;
Codelist.Query.Item.ID = new QueryIDType();
Codelist.Query.Item.ID.Value = Id;
Codelist.Query.Item.AgencyID = new QueryNestedIDType();
Codelist.Query.Item.AgencyID.Value = AgencyId;
Codelist.Query.Item.Version = Version;
Codelist.Query.Item.Annotation = null;
Codelist.Query.Item.Name = null;
Codelist.Query.Item.Description = null;
RetVal = Serializer.SerializeToXmlDocument(typeof(SDMXObjectModel.Message.CodelistQueryType), Codelist);
break;
case 8:
SDMXObjectModel.Message.OrganisationSchemeQueryType OrganisationScheme = new SDMXObjectModel.Message.OrganisationSchemeQueryType();
OrganisationScheme.Header = Global.Get_Appropriate_Header();
OrganisationScheme.Query = new SDMXObjectModel.Query.OrganisationSchemeQueryType();
OrganisationScheme.Query.ReturnDetails = new StructureReturnDetailsType();
OrganisationScheme.Query.ReturnDetails.References = new ReferencesType();
OrganisationScheme.Query.ReturnDetails.References.ItemElementName = ReferencesChoiceType.None;
OrganisationScheme.Query.ReturnDetails.References.Item = new EmptyType();
OrganisationScheme.Query.Item = new OrganisationSchemeWhereType();
OrganisationScheme.Query.Item.type = SDMXObjectModel.Common.MaintainableTypeCodelistType.OrganisationScheme;
OrganisationScheme.Query.Item.typeSpecified = true;
OrganisationScheme.Query.Item.ID = new QueryIDType();
OrganisationScheme.Query.Item.ID.Value = Id;
OrganisationScheme.Query.Item.AgencyID = new QueryNestedIDType();
OrganisationScheme.Query.Item.AgencyID.Value = AgencyId;
OrganisationScheme.Query.Item.Version = Version;
OrganisationScheme.Query.Item.Annotation = null;
OrganisationScheme.Query.Item.Name = null;
OrganisationScheme.Query.Item.Description = null;
RetVal = Serializer.SerializeToXmlDocument(typeof(SDMXObjectModel.Message.OrganisationSchemeQueryType), OrganisationScheme);
break;
case 9:
SDMXObjectModel.Message.ProvisionAgreementQueryType ProvisionAgreement = new SDMXObjectModel.Message.ProvisionAgreementQueryType();
ProvisionAgreement.Header = Global.Get_Appropriate_Header();
ProvisionAgreement.Query = new SDMXObjectModel.Query.ProvisionAgreementQueryType();
ProvisionAgreement.Query.ReturnDetails = new StructureReturnDetailsType();
ProvisionAgreement.Query.ReturnDetails.References = new ReferencesType();
ProvisionAgreement.Query.ReturnDetails.References.ItemElementName = ReferencesChoiceType.None;
ProvisionAgreement.Query.ReturnDetails.References.Item = new EmptyType();
ProvisionAgreement.Query.Item = new ProvisionAgreementWhereType();
ProvisionAgreement.Query.Item.type = SDMXObjectModel.Common.MaintainableTypeCodelistType.ProvisionAgreement;
ProvisionAgreement.Query.Item.typeSpecified = true;
ProvisionAgreement.Query.Item.ID = new QueryIDType();
ProvisionAgreement.Query.Item.ID.Value = Id;
ProvisionAgreement.Query.Item.AgencyID = new QueryNestedIDType();
ProvisionAgreement.Query.Item.AgencyID.Value = AgencyId;
ProvisionAgreement.Query.Item.Version = Version;
ProvisionAgreement.Query.Item.Annotation = null;
ProvisionAgreement.Query.Item.Name = null;
ProvisionAgreement.Query.Item.Description = null;
RetVal = Serializer.SerializeToXmlDocument(typeof(SDMXObjectModel.Message.ProvisionAgreementQueryType), ProvisionAgreement);
break;
case 10:
SDMXObjectModel.Message.ConstraintQueryType Constraint = new SDMXObjectModel.Message.ConstraintQueryType();
Constraint.Header = Global.Get_Appropriate_Header();
Constraint.Query = new SDMXObjectModel.Query.ConstraintQueryType();
Constraint.Query.ReturnDetails = new StructureReturnDetailsType();
Constraint.Query.ReturnDetails.References = new ReferencesType();
Constraint.Query.ReturnDetails.References.ItemElementName = ReferencesChoiceType.None;
Constraint.Query.ReturnDetails.References.Item = new EmptyType();
Constraint.Query.Item = new ConstraintWhereType();
Constraint.Query.Item.type = SDMXObjectModel.Common.MaintainableTypeCodelistType.Constraint;
Constraint.Query.Item.typeSpecified = true;
Constraint.Query.Item.ID = new QueryIDType();
Constraint.Query.Item.ID.Value = Id;
Constraint.Query.Item.AgencyID = new QueryNestedIDType();
Constraint.Query.Item.AgencyID.Value = AgencyId;
Constraint.Query.Item.Version = Version;
Constraint.Query.Item.Annotation = null;
Constraint.Query.Item.Name = null;
Constraint.Query.Item.Description = null;
RetVal = Serializer.SerializeToXmlDocument(typeof(SDMXObjectModel.Message.ConstraintQueryType), Constraint);
break;
case 11:
SDMXObjectModel.Message.StructuresQueryType Structures = new SDMXObjectModel.Message.StructuresQueryType();
Structures.Header = Global.Get_Appropriate_Header();
Structures.Query = new SDMXObjectModel.Query.StructuresQueryType();
Structures.Query.ReturnDetails = new StructureReturnDetailsType();
Structures.Query.ReturnDetails.References = new ReferencesType();
Structures.Query.ReturnDetails.References.ItemElementName = ReferencesChoiceType.None;
Structures.Query.ReturnDetails.References.Item = new EmptyType();
Structures.Query.Item = new StructuresWhereType();
Structures.Query.Item.type = SDMXObjectModel.Common.MaintainableTypeCodelistType.Any;
Structures.Query.Item.typeSpecified = true;
Structures.Query.Item.ID = new QueryIDType();
Structures.Query.Item.ID.Value = Id;
Structures.Query.Item.AgencyID = new QueryNestedIDType();
Structures.Query.Item.AgencyID.Value = AgencyId;
Structures.Query.Item.Version = Version;
Structures.Query.Item.Annotation = null;
Structures.Query.Item.Name = null;
Structures.Query.Item.Description = null;
RetVal = Serializer.SerializeToXmlDocument(typeof(SDMXObjectModel.Message.StructuresQueryType), Structures);
break;
case 12:
UserID = UserIdAndType.Split('|')[0];
if (UserIdAndType.Split('|')[1] == "True")
{
UserType=UserTypes.Provider;
}
else
{
UserType=UserTypes.Consumer;
}
SDMXObjectModel.Message.RegistryInterfaceType QuerySubscription = new RegistryInterfaceType();
QuerySubscription.Header = Global.Get_Appropriate_Header();
QuerySubscription.Item = new SDMXObjectModel.Registry.QuerySubscriptionRequestType();
((SDMXObjectModel.Registry.QuerySubscriptionRequestType)QuerySubscription.Item).Organisation = new OrganisationReferenceType();
((SDMXObjectModel.Registry.QuerySubscriptionRequestType)QuerySubscription.Item).Organisation.Items = new List<object>();
if (UserType == UserTypes.Consumer)
{
maintainableParentID = DevInfo.Lib.DI_LibSDMX.Constants.DataConsumerScheme.Id;
parentAgencyID = DevInfo.Lib.DI_LibSDMX.Constants.DataConsumerScheme.AgencyId;
maintainableParentVersion = DevInfo.Lib.DI_LibSDMX.Constants.DataConsumerScheme.Version;
((SDMXObjectModel.Registry.QuerySubscriptionRequestType)QuerySubscription.Item).Organisation.Items.Add(new SDMXObjectModel.Common.DataConsumerRefType());
((SDMXObjectModel.Common.DataConsumerRefType)(((SDMXObjectModel.Registry.QuerySubscriptionRequestType)QuerySubscription.Item).Organisation.Items[0])).id = DevInfo.Lib.DI_LibSDMX.Constants.DataConsumerScheme.Prefix + UserID;
((SDMXObjectModel.Common.DataConsumerRefType)(((SDMXObjectModel.Registry.QuerySubscriptionRequestType)QuerySubscription.Item).Organisation.Items[0])).agencyID = parentAgencyID;
((SDMXObjectModel.Common.DataConsumerRefType)(((SDMXObjectModel.Registry.QuerySubscriptionRequestType)QuerySubscription.Item).Organisation.Items[0])).maintainableParentID = maintainableParentID;
((SDMXObjectModel.Common.DataConsumerRefType)(((SDMXObjectModel.Registry.QuerySubscriptionRequestType)QuerySubscription.Item).Organisation.Items[0])).maintainableParentVersion = maintainableParentVersion;
}
else
{
maintainableParentID = DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.Id;
parentAgencyID = DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.AgencyId;
maintainableParentVersion = DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.Version;
((SDMXObjectModel.Registry.QuerySubscriptionRequestType)QuerySubscription.Item).Organisation.Items.Add(new SDMXObjectModel.Common.DataProviderRefType());
((SDMXObjectModel.Common.DataProviderRefType)(((SDMXObjectModel.Registry.QuerySubscriptionRequestType)QuerySubscription.Item).Organisation.Items[0])).id = DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.Prefix + UserID;
((SDMXObjectModel.Common.DataProviderRefType)(((SDMXObjectModel.Registry.QuerySubscriptionRequestType)QuerySubscription.Item).Organisation.Items[0])).agencyID = parentAgencyID;
((SDMXObjectModel.Common.DataProviderRefType)(((SDMXObjectModel.Registry.QuerySubscriptionRequestType)QuerySubscription.Item).Organisation.Items[0])).maintainableParentID = maintainableParentID;
((SDMXObjectModel.Common.DataProviderRefType)(((SDMXObjectModel.Registry.QuerySubscriptionRequestType)QuerySubscription.Item).Organisation.Items[0])).maintainableParentVersion = maintainableParentVersion;
}
RetVal = Serializer.SerializeToXmlDocument(typeof(SDMXObjectModel.Message.RegistryInterfaceType), QuerySubscription);
break;
case 13:
UserID = UserIdAndType.Split('|')[0];
maintainableParentID = DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.Id;
parentAgencyID = DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.AgencyId;
maintainableParentVersion = DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.Version;
SDMXObjectModel.Message.RegistryInterfaceType QueryRegistration = new RegistryInterfaceType();
QueryRegistration.Header = Global.Get_Appropriate_Header();
QueryRegistration.Item= new SDMXObjectModel.Registry.QueryRegistrationRequestType();
((SDMXObjectModel.Registry.QueryRegistrationRequestType)(QueryRegistration.Item)).QueryType = QueryTypeType.AllSets;
((SDMXObjectModel.Registry.QueryRegistrationRequestType)(QueryRegistration.Item)).Item = new DataProviderReferenceType();
((DataProviderReferenceType)((SDMXObjectModel.Registry.QueryRegistrationRequestType)(QueryRegistration.Item)).Item).Items = new List<object>();
((DataProviderReferenceType)((SDMXObjectModel.Registry.QueryRegistrationRequestType)(QueryRegistration.Item)).Item).Items.Add(new SDMXObjectModel.Common.DataProviderRefType());
((DataProviderRefType)((DataProviderReferenceType)((SDMXObjectModel.Registry.QueryRegistrationRequestType)(QueryRegistration.Item)).Item).Items[0]).id = DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.Prefix + UserID;
((DataProviderRefType)((DataProviderReferenceType)((SDMXObjectModel.Registry.QueryRegistrationRequestType)(QueryRegistration.Item)).Item).Items[0]).agencyID = parentAgencyID;
((DataProviderRefType)((DataProviderReferenceType)((SDMXObjectModel.Registry.QueryRegistrationRequestType)(QueryRegistration.Item)).Item).Items[0]).maintainableParentID = maintainableParentID;
((DataProviderRefType)((DataProviderReferenceType)((SDMXObjectModel.Registry.QueryRegistrationRequestType)(QueryRegistration.Item)).Item).Items[0]).maintainableParentVersion = maintainableParentVersion;
((SDMXObjectModel.Registry.QueryRegistrationRequestType)(QueryRegistration.Item)).ReferencePeriod = null;
RetVal = Serializer.SerializeToXmlDocument(typeof(SDMXObjectModel.Message.RegistryInterfaceType), QueryRegistration);
break;
case 14:
default:
RetVal = new XmlDocument();
XmlDeclaration Declaration = RetVal.CreateXmlDeclaration("1.0", null, null);
RetVal.AppendChild(Declaration);
XmlElement Element = RetVal.CreateElement("Root");
RetVal.AppendChild(Element);
break;
}
}
catch (Exception ex)
{
Global.CreateExceptionString(ex, null);
}
finally
{
}
return RetVal;
}
public string GetLoggedInUserSubscriptions(string requestParam)
{
string RetVal;
string[] Params;
string DBNId;
string UserIdAndType;
string hlngcode;
StringBuilder sb;
Registry.RegistryService Service;
XmlDocument Query;
XmlElement Element;
XmlDocument Response;
SDMXObjectModel.Message.RegistryInterfaceType SubRegistryInterface;
string RegistryURN;
string Email;
string WebServiceAddress;
string StartDate;
string EndDate;
string EventType;
string Action;
string prefLang;
RetVal = string.Empty;
Params = Global.SplitString(requestParam, Constants.Delimiters.ParamDelimiter);
DBNId = Params[0];
UserIdAndType = Params[1];
hlngcode = Params[2];
sb = new StringBuilder();
Service = new Registry.RegistryService();
Query = new XmlDocument();
Response = new XmlDocument();
Element = null;
SubRegistryInterface = new SDMXObjectModel.Message.RegistryInterfaceType();
RegistryURN = string.Empty;
Email = string.Empty;
WebServiceAddress = string.Empty;
StartDate = string.Empty;
EndDate = string.Empty;
EventType = string.Empty;
Action = string.Empty;
prefLang = string.Empty;
Query = GetQueryXmlDocumentOnTypeBasis(12, string.Empty, string.Empty, string.Empty, UserIdAndType);
Element = Query.DocumentElement;
Service.Url = HttpContext.Current.Request.Url.OriginalString.Substring(0, HttpContext.Current.Request.Url.OriginalString.IndexOf("libraries")) + Constants.FolderName.SDMX.RegistryServicePath;
Service.Url += "?p=" + DBNId.ToString();
Service.QuerySubscription(ref Element);
Response.LoadXml(Element.OuterXml);
SubRegistryInterface = (SDMXObjectModel.Message.RegistryInterfaceType)(SDMXObjectModel.Deserializer.LoadFromXmlDocument(typeof(SDMXObjectModel.Message.RegistryInterfaceType), Response));
foreach (SDMXObjectModel.Registry.SubscriptionType Subscription in ((SDMXObjectModel.Registry.QuerySubscriptionResponseType)(SubRegistryInterface.Item)).Subscription)
{
RegistryURN = Subscription.RegistryURN;
Email = Subscription.NotificationMailTo[0].Value.ToString();
WebServiceAddress = Subscription.NotificationHTTP[0].Value.ToString();
StartDate = Subscription.ValidityPeriod.StartDate.ToString("dd-MM-yyyy");
EndDate = Subscription.ValidityPeriod.EndDate.ToString("dd-MM-yyyy");
if (Subscription.EventSelector[0] is DataRegistrationEventsType)
{
EventType = GetlanguageBasedValueOfKey("lang_Data_Registration", hlngcode, "RegSubscription.xml");
}
else if (Subscription.EventSelector[0] is MetadataRegistrationEventsType)
{
EventType = GetlanguageBasedValueOfKey("lang_Metadata_Registration", hlngcode, "RegSubscription.xml");
}
else if (Subscription.EventSelector[0] is StructuralRepositoryEventsType)
{
EventType = GetlanguageBasedValueOfKey("lang_Structural_Metadata_Registration", hlngcode, "RegSubscription.xml");
}
// Get preferred language
prefLang = Global.GetLanguageNameFromNid(Global.GetPreferredLanguageFromSubscriptionId(RegistryURN));
sb.Append(RegistryURN);
sb.Append("~");
sb.Append(Email);
sb.Append("~");
sb.Append(WebServiceAddress);
sb.Append("~");
sb.Append(StartDate);
sb.Append("~");
sb.Append(EndDate);
sb.Append("~");
sb.Append(EventType);
sb.Append("~");
// Append preferred language
sb.Append(prefLang);
sb.Append("~");
sb.Append("<a style=\"cursor:pointer;\" href=\"javascript:void(0);\" onclick=\"OpenSubscriptionDetailsPopup('V','" + Subscription.RegistryURN + "' );\" name=\"lang_View\"></a> | ");
sb.Append("<a style=\"cursor:pointer;\" href=\"javascript:void(0);\" onclick=\"OpenSubscriptionDetailsPopup('U','" + Subscription.RegistryURN + "');\" name=\"lang_Edit\"></a> | ");
sb.Append("<a style=\"cursor:pointer;\" href=\"javascript:void(0);\" onclick=\"OpenSubscriptionDetailsPopup('D','" + Subscription.RegistryURN + "');\" name=\"lang_Delete\"></a>");
sb.Append(Constants.Delimiters.PivotRowDelimiter);
}
sb.Remove(sb.Length - 1, 1);
RetVal = sb.ToString();
return RetVal;
}
