C# DIConnection.ExecuteDataTable方法代码示例

 //Returns the requires area levels
 public static DataTable GetAreaLevels(DIConnection dBConnection, DIQueries dBQueries)
 {
     DataTable dtAreaLevel = null;
     try
     {
         dtAreaLevel = dBConnection.ExecuteDataTable(dBQueries.Area.GetAreaLevel(FilterFieldType.None, string.Empty));
     }
     catch (Exception)
     {
     }
     return dtAreaLevel;
 }

        //Returns the all time periods
        public static DataTable GetAllTimePeriods(DIConnection dBConnection, DIQueries dBQueries)
        {
            DataTable dtTimePeriod=null;
            try
            {
                dtTimePeriod = dBConnection.ExecuteDataTable(dBQueries.Timeperiod.GetTimePeriod(FilterFieldType.None, string.Empty, Timeperiods.TimePeriod + " DESC"));
            }
            catch (Exception)
            {

            }
            return dtTimePeriod;
        }

        /// <summary>
        /// Returns the instance of SubgroupInfo on the basis of Subgroup Nid
        /// </summary>
        /// <param name="sourceQuery"></param>
        /// <param name="sourceDBConnection"></param>
        /// <param name="subgroupNid"></param>
        /// <returns></returns>
        public static DI6SubgroupInfo GetSubgroupInfo(DIQueries queries, DIConnection dbConnection, FilterFieldType filterClause, string filterText)
        {
            string Query = string.Empty;
            DI6SubgroupInfo RetVal = new DI6SubgroupInfo();
            DataTable SubgroupTable;
            DI6SubgroupTypeBuilder SGTypeBuilder;
            try
            {
                Query = queries.Subgroup.GetSubgroup(filterClause, filterText);
                SubgroupTable = dbConnection.ExecuteDataTable(Query);

                //set Subgroup info
                if (SubgroupTable != null)
                {
                    if (SubgroupTable.Rows.Count > 0)
                    {
                        RetVal.GID = SubgroupTable.Rows[0][Subgroup.SubgroupGId].ToString();
                        RetVal.Global = Convert.ToBoolean(SubgroupTable.Rows[0][Subgroup.SubgroupGlobal]);
                        RetVal.Name = SubgroupTable.Rows[0][Subgroup.SubgroupName].ToString();
                        RetVal.Nid = Convert.ToInt32(SubgroupTable.Rows[0][Subgroup.SubgroupNId].ToString());
                        RetVal.Type = Convert.ToInt32(SubgroupTable.Rows[0][Subgroup.SubgroupType].ToString());

                        // Get subgrouptype info
                        if (RetVal.Type > 0)
                        {
                            SGTypeBuilder = new DI6SubgroupTypeBuilder(dbConnection, queries);
                            RetVal.DISubgroupType = SGTypeBuilder.GetSubgroupTypeInfoByNid(RetVal.Type);

                        }

                    }
                }
            }
            catch (Exception)
            {
                RetVal = null;
            }
            return RetVal;
        }

        /// <summary>
        /// Getting MetaData and writing them to Rtf file.
        /// </summary>
        public static string ExtractRtfMetadata(ICType ICType, int ICNId, DIConnection DIConnection, DIQueries DIQueries, String outputFolder, String outputFileName)
        {
            string RetVal = string.Empty;
            string RtfFilePath = System.IO.Path.Combine(outputFolder, outputFileName + ".rtf");
            DataTable RtfDataTable = new DataTable();
            try
            {
                if (System.IO.File.Exists(RtfFilePath))
                {
                    System.IO.File.Delete(RtfFilePath);
                }
                // getting metadata informationn from Database into DataTable RtfDataTable
                string sSql = DIQueries.IndicatorClassification.GetIC(FilterFieldType.NId, ICNId.ToString(), ICType, FieldSelection.Heavy);
                RtfDataTable = DIConnection.ExecuteDataTable(sSql);
                if (RtfDataTable != null & RtfDataTable.Rows.Count > 0)
                {
                    RetVal = RtfDataTable.Rows[0][IndicatorClassifications.ICName].ToString();
                    if (!Convert.IsDBNull(RtfDataTable.Rows[0][IndicatorClassifications.ICInfo]))
                    {
                        string RtfString = RtfDataTable.Rows[0][IndicatorClassifications.ICInfo].ToString();

                        // Writng  metadata into  a rtf file in output directory
                        if (RtfString.Trim().Length > 0)
                        {
                            WriteToFile(RtfString, RtfFilePath);

                        }
                    }
                }
            }
            catch (Exception)
            {
                //throw ex;
            }

            return RetVal;
        }

    //Added to check gallery existence
    public int GalleryExistence(string requestParam)
    {
        int RetVal;
        DataTable dtPresentation;
        DIConnection DIConnection;
        string GetPresentationsQuery;
        string[] Params;
        int UserNId ; ;
        int AdminNId ;
        DIConnection = null;
        try
        {
            Params = Global.SplitString(requestParam, Constants.Delimiters.ParamDelimiter);
            UserNId = Convert.ToInt32(Params[0].Trim());
            AdminNId = Convert.ToInt32(this.Get_AdminNId());
            DIConnection = new DIConnection(DIServerType.MsAccess, string.Empty, string.Empty, Server.MapPath("~//stock//Database.mdb"),
                          string.Empty, string.Empty);

            GetPresentationsQuery = "SELECT * FROM Presentations WHERE user_nid = " + UserNId + " OR user_nid = " + AdminNId + "";
            dtPresentation = DIConnection.ExecuteDataTable(GetPresentationsQuery);
            RetVal = dtPresentation.Rows.Count;
            return RetVal;
        }
        catch (Exception ex)
        {
            Global.CreateExceptionString(ex, null);
            throw ex;
        }
        finally
        {
            if (DIConnection != null)
            {
                DIConnection.Dispose();
            }
        }
    }

    public string GetIndicativeIdAgencyIdVersionValues(string requestParam)
    {
        string RetVal;
        string DBNId, SelectedFunction, FileName;
        string Id, AgencyId, Version;
        string[] Params;
        SDMXObjectModel.Message.StructureType Structure_Two_One;
        SDMXApi_2_0.Message.StructureType Structure_Two_Zero;
        DIConnection DIConnection;
        DataTable DtTable;

        RetVal = string.Empty;

        DBNId = string.Empty;
        SelectedFunction = string.Empty;
        FileName = string.Empty;

        Id = string.Empty;
        AgencyId = string.Empty;
        Version = string.Empty;

        Params = null;
        Structure_Two_One = null;
        Structure_Two_Zero = null;
        DIConnection = null;
        DtTable = null;

        try
        {
            Params = Global.SplitString(requestParam, Constants.Delimiters.ParamDelimiter);
            DBNId = Params[0].ToString().Trim();
            SelectedFunction = Params[1].ToString().Trim();
            DIConnection = new DIConnection(DIServerType.MsAccess, string.Empty, string.Empty, Server.MapPath("~//stock//Database.mdb"), string.Empty, string.Empty);

            switch (SelectedFunction)
            {
                case "GetDataflow":
                    DtTable = DIConnection.ExecuteDataTable("SELECT FileLocation FROM Artefacts Where DBNId = " + DBNId + " AND Type = " + Convert.ToInt32(DevInfo.Lib.DI_LibSDMX.ArtefactTypes.DFD).ToString());

                    if (DtTable != null && DtTable.Rows.Count > 0)
                    {
                        FileName = DtTable.Rows[0]["FileLocation"].ToString();
                    }

                    Structure_Two_One = (SDMXObjectModel.Message.StructureType)Deserializer.LoadFromFile(typeof(SDMXObjectModel.Message.StructureType), FileName);

                    if (Structure_Two_One != null && Structure_Two_One.Structures != null && Structure_Two_One.Structures.Dataflows != null && Structure_Two_One.Structures.Dataflows.Count > 0)
                    {
                        Id = Structure_Two_One.Structures.Dataflows[0].id;
                        AgencyId = Structure_Two_One.Structures.Dataflows[0].agencyID;
                        Version = Structure_Two_One.Structures.Dataflows[0].version;
                    }
                    break;
                case "GetMetadataflow":
                    DtTable = DIConnection.ExecuteDataTable("SELECT FileLocation FROM Artefacts Where DBNId = " + DBNId + " AND Type = " + Convert.ToInt32(DevInfo.Lib.DI_LibSDMX.ArtefactTypes.MFD).ToString());

                    if (DtTable != null && DtTable.Rows.Count > 0)
                    {
                        FileName = DtTable.Rows[0]["FileLocation"].ToString();
                    }

                    Structure_Two_One = (SDMXObjectModel.Message.StructureType)Deserializer.LoadFromFile(typeof(SDMXObjectModel.Message.StructureType), FileName);

                    if (Structure_Two_One != null && Structure_Two_One.Structures != null && Structure_Two_One.Structures.Metadataflows != null && Structure_Two_One.Structures.Metadataflows.Count > 0)
                    {
                        Id = Structure_Two_One.Structures.Metadataflows[0].id;
                        AgencyId = Structure_Two_One.Structures.Metadataflows[0].agencyID;
                        Version = Structure_Two_One.Structures.Metadataflows[0].version;
                    }
                    break;
                case "GetDataStructure":
                    DtTable = DIConnection.ExecuteDataTable("SELECT FileLocation FROM Artefacts Where DBNId = " + DBNId + " AND Type = " + Convert.ToInt32(DevInfo.Lib.DI_LibSDMX.ArtefactTypes.DSD).ToString());

                    if (DtTable != null && DtTable.Rows.Count > 0)
                    {
                        FileName = DtTable.Rows[0]["FileLocation"].ToString();
                    }

                    if (Global.IsDSDUploadedFromAdmin(Convert.ToInt32(DBNId)) == false)
                    {
                        Structure_Two_One = (SDMXObjectModel.Message.StructureType)Deserializer.LoadFromFile(typeof(SDMXObjectModel.Message.StructureType), FileName);

                        if (Structure_Two_One != null && Structure_Two_One.Structures != null && Structure_Two_One.Structures.DataStructures != null && Structure_Two_One.Structures.DataStructures.Count > 0)
                        {
                            Id = Structure_Two_One.Structures.DataStructures[0].id;
                            AgencyId = Structure_Two_One.Structures.DataStructures[0].agencyID;
                            Version = Structure_Two_One.Structures.DataStructures[0].version;
                        }
                    }
                    else
                    {
                        Structure_Two_Zero = (SDMXApi_2_0.Message.StructureType)SDMXApi_2_0.Deserializer.LoadFromFile(typeof(SDMXApi_2_0.Message.StructureType), FileName);

                        if (Structure_Two_Zero != null && Structure_Two_Zero.KeyFamilies != null && Structure_Two_Zero.KeyFamilies.Count > 0)
                        {
                            Id = Structure_Two_Zero.KeyFamilies[0].id;
                            AgencyId = Structure_Two_Zero.KeyFamilies[0].agencyID;
                            Version = Structure_Two_Zero.KeyFamilies[0].version;
                        }
                    }
//.........这里部分代码省略.........

    private XmlDocument Retrieve_Artefact(string Id, string AgencyId, string Version, string DbNId)
    {
        XmlDocument RetVal;
        string Query, FileNameWPath;
        DIConnection DIConnection;
        DataTable DtTable;

        RetVal = new XmlDocument();
        Query = string.Empty;
        FileNameWPath = string.Empty;
        DIConnection = null;
        DtTable = null;

        try
        {
            if (!string.IsNullOrEmpty(Id) && !string.IsNullOrEmpty(Version))
            {
                if (Id != DevInfo.Lib.DI_LibSDMX.Constants.MaintenanceAgencyScheme.Id &&
                    Id != DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.Id &&
                    Id != DevInfo.Lib.DI_LibSDMX.Constants.DataConsumerScheme.Id)
                {
                    DIConnection = new DIConnection(DIServerType.MsAccess, string.Empty, string.Empty, Server.MapPath("~//stock//Database.mdb"), string.Empty,
                                                    string.Empty);

                    if ((AgencyId == DevInfo.Lib.DI_LibSDMX.Constants.MaintenanceAgencyScheme.AgencyId) || (AgencyId == DevInfo.Lib.DI_LibSDMX.Constants.DataConsumerScheme.AgencyId) || (AgencyId == DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.AgencyId))
                    {
                        Query = "SELECT FileLocation FROM Artefacts WHERE Id = '" + Id;
                    }
                    else
                    {
                        Query = "SELECT FileLocation FROM Artefacts WHERE DBNId = " + DbNId + " AND Id = '" + Id;
                    }

                    if (!string.IsNullOrEmpty(AgencyId))
                    {
                        Query += "' AND AgencyId = '" + AgencyId;
                    }

                    if (!string.IsNullOrEmpty(Version))
                    {
                        Query += "' AND Version = '" + Version + "';";
                    }

                    DtTable = DIConnection.ExecuteDataTable(Query);

                    if (DtTable != null && DtTable.Rows.Count > 0)
                    {
                        FileNameWPath = DtTable.Rows[0]["FileLocation"].ToString();
                        RetVal.Load(FileNameWPath);
                    }
                }
                else
                {
                    switch (Id)
                    {
                        case DevInfo.Lib.DI_LibSDMX.Constants.MaintenanceAgencyScheme.Id:
                            FileNameWPath = Path.Combine(HttpContext.Current.Request.PhysicalApplicationPath, Constants.FolderName.Users + DevInfo.Lib.DI_LibSDMX.Constants.MaintenanceAgencyScheme.FileName);
                            break;
                        case DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.Id:
                            FileNameWPath = Path.Combine(HttpContext.Current.Request.PhysicalApplicationPath, Constants.FolderName.Users + DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.FileName);
                            break;
                        case DevInfo.Lib.DI_LibSDMX.Constants.DataConsumerScheme.Id:
                            FileNameWPath = Path.Combine(HttpContext.Current.Request.PhysicalApplicationPath, Constants.FolderName.Users + DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.FileName);
                            break;
                        default:
                            break;
                    }

                    RetVal.Load(FileNameWPath);
                }
            }
            else
            {
                throw new Exception(DevInfo.Lib.DI_LibSDMX.Constants.SDMXWebServices.Exceptions.InvalidSyntax.Message);
            }
        }
        catch (Exception ex)
        {
            Global.CreateExceptionString(ex, null);
            throw ex;
        }
        finally
        {
        }

        return RetVal;
    }

    public XmlDocument SubmitSubscription([XmlAnyElement] XmlDocument Input, string langPrefNid)
    {
        RegistryInterfaceType RegistryInterfaceRequest, RegistryInterfaceResponse;
        SubscriptionRequestType SubscriptionRequest;
        ActionType Action;
        DIConnection DIConnection;
        DataTable DtTable;
        string UserId, UserNId;
        string MaxNId, RegistryURN, SubscriberAssignedId;
        string FileNameWPath, Query;

        RegistryInterfaceRequest = null;
        RegistryInterfaceResponse = null;
        SubscriptionRequest = null;
        DIConnection = null;
        DtTable = null;
        UserId = string.Empty;
        UserNId = string.Empty;
        MaxNId = string.Empty;
        RegistryURN = string.Empty;
        SubscriberAssignedId = string.Empty;
        FileNameWPath = string.Empty;
        Query = string.Empty;

        try
        {
            try
            {
                RegistryInterfaceRequest = (RegistryInterfaceType)Deserializer.LoadFromXmlDocument(typeof(RegistryInterfaceType), Input);
            }
            catch (Exception)
            {
                throw new Exception(DevInfo.Lib.DI_LibSDMX.Constants.SDMXWebServices.Exceptions.InvalidSyntax.Message);
            }

            DIConnection = new DIConnection(DIServerType.MsAccess, string.Empty, string.Empty, Server.MapPath("~//stock//Database.mdb"),
                           string.Empty, string.Empty);

            if (RegistryInterfaceRequest.Item != null)
            {
                if (((SubmitSubscriptionsRequestType)RegistryInterfaceRequest.Item).SubscriptionRequest != null && ((SubmitSubscriptionsRequestType)RegistryInterfaceRequest.Item).SubscriptionRequest.Count > 0)
                {
                    SubscriptionRequest = ((SubmitSubscriptionsRequestType)RegistryInterfaceRequest.Item).SubscriptionRequest[0];

                    if (SubscriptionRequest.Subscription != null)
                    {
                        if (SubscriptionRequest.Subscription.Organisation != null && SubscriptionRequest.Subscription.Organisation.Items != null && SubscriptionRequest.Subscription.Organisation.Items.Count > 0)
                        {
                            if (SubscriptionRequest.Subscription.Organisation.Items[0] is DataProviderRefType)
                            {
                                UserId = ((DataProviderRefType)SubscriptionRequest.Subscription.Organisation.Items[0]).id;
                            }
                            else
                            {
                                UserId = ((DataConsumerRefType)SubscriptionRequest.Subscription.Organisation.Items[0]).id;
                            }
                            UserNId = UserId.Split('_')[1];

                            Action = SubscriptionRequest.action;
                            SubscriberAssignedId = SubscriptionRequest.Subscription.SubscriberAssignedID;
                            RegistryInterfaceRequest.Footer = null;
                            if (!string.IsNullOrEmpty(SubscriberAssignedId))
                            {
                                switch (Action)
                                {
                                    case ActionType.Append:
                                        if (UserId.Contains(DevInfo.Lib.DI_LibSDMX.Constants.DataProviderScheme.Prefix))
                                        {
                                            Global.Create_Provider_In_DPScheme_And_Update_Folder_Structures_Per_Database(UserNId, DevInfo.Lib.DI_LibSDMX.Constants.DefaultLanguage);
                                        }
                                        else
                                        {
                                            Global.Create_Consumer_In_DCScheme_And_Update_Folder_Structures_Per_Database(UserNId, DevInfo.Lib.DI_LibSDMX.Constants.DefaultLanguage);
                                        }

                                        Query = "SELECT MAX(ArtefactsNId) AS MaxNId FROM Artefacts;";
                                        DtTable = DIConnection.ExecuteDataTable(Query);

                                        MaxNId = (Convert.ToInt32(DtTable.Rows[0]["MaxNId"].ToString()) + 1).ToString();
                                        RegistryURN = Guid.NewGuid().ToString();
                                        SubscriptionRequest.Subscription.RegistryURN = RegistryURN;
                                        FileNameWPath = Path.Combine(Server.MapPath("~"), "stock/data/" + DBNId.ToString() + "/sdmx/Subscriptions/" + UserNId + "/" + RegistryURN + ".xml");
                                        Serializer.SerializeToFile(typeof(RegistryInterfaceType), RegistryInterfaceRequest, FileNameWPath);

                                        // validate Artefact schema for langPrefNid
                                        Global.BaselineAccessDbSchema();

                                        Query = "INSERT INTO Artefacts (DBNId, Id, AgencyId, Version, URN, Type, FileLocation, LangPrefNid)" +
                                                " VALUES(" + DBNId.ToString() + ",'" + RegistryURN + "','" + string.Empty + "','" +
                                                string.Empty + "','" + string.Empty + "'," + Convert.ToInt32(ArtefactTypes.Subscription).ToString() +
                                                ",'" + FileNameWPath + "', '" + Int32.Parse(langPrefNid) + "');";
                                        DIConnection.ExecuteDataTable(Query);

                                        RegistryInterfaceResponse = this.Get_SubmitSubscriptions_Reponse(SubscriberAssignedId, RegistryURN, StatusType.Success, string.Empty, string.Empty);
                                        Input = Serializer.SerializeToXmlDocument(typeof(RegistryInterfaceType), RegistryInterfaceResponse);
                                        break;

                                    case ActionType.Delete:
                                        RegistryURN = SubscriptionRequest.Subscription.RegistryURN;
                                        FileNameWPath = Path.Combine(Server.MapPath("~"), "stock/data/" + DBNId.ToString() + "/sdmx/Subscriptions/" + UserNId + "/" + RegistryURN + ".xml");
//.........这里部分代码省略.........

//.........这里部分代码省略.........
            XmlDoc = new XmlDocument();
            XmlDoc.Load(DBFile);

            XmlNodes = XmlDoc.GetElementsByTagName("db");
            if (XmlNodes.Count > 0)
            {
                RetVal = "<table style=\"width:100%; \" border=\"0\" cellSpacing=\"0\" cellSpacing=\"0\">";
                RetVal += "<tr class=\"HeaderRowStyle \">";
                RetVal += "<td class=\"HeaderColumnStyle \"><span  id=\"lang_SNo\"></span></td>";
                RetVal += "<td class=\"HeaderColumnStyle \"><span  id=\"lang_Id\"></span></td>";
                RetVal += "<td class=\"HeaderColumnStyle \"><span  id=\"lang_AgencyId\"></span></td>";
                RetVal += "<td class=\"HeaderColumnStyle \"><span  id=\"lang_Version\"></span></td>";
                RetVal += "<td class=\"HeaderColumnStyle \"><span  id=\"lang_Assosciated_Database\"></span></td>";
                RetVal += "<td class=\"HeaderColumnStyle \"><span  id=\"lang_Publisher_DSD\"></span></td>";
                //   RetVal += "<td class=\"HeaderColumnStyle \"><span  id=\"lang_Details\"></span></td>";
                RetVal += "<td class=\"HeaderColumnStyle \"><span  id=\"lang_Action\"></span></td>";
                RetVal += "<td class=\"HeaderColumnStyle \"><span  id=\"lang_Header\"></span></td>";
                RetVal += "</tr>";
                for (i = 0; i < XmlNodes.Count; i++)
                {
                    if ((XmlNodes[i].Attributes["sdmxdb"].Value == "true") && (XmlNodes[i].Attributes[Constants.XmlFile.Db.Tags.DatabaseAttributes.DSDId] != null) && (XmlNodes[i].Attributes[Constants.XmlFile.Db.Tags.DatabaseAttributes.DSDVersion] != null))
                    {
                        DSDCount = DSDCount + 1;
                        RetVal = RetVal + "<tr class=\"DataRowStyle \">";
                        RetVal += "<td class=\"DataColumnStyle \">" + DSDCount + "</td>";
                        RetVal += "<td class=\"DataColumnStyle \">" + XmlNodes[i].Attributes[Constants.XmlFile.Db.Tags.DatabaseAttributes.DSDId].Value + "</td>";
                        if (XmlNodes[i].Attributes[Constants.XmlFile.Db.Tags.DatabaseAttributes.DSDAgencyId] != null)
                        {
                            RetVal += "<td class=\"DataColumnStyle \">" + XmlNodes[i].Attributes[Constants.XmlFile.Db.Tags.DatabaseAttributes.DSDAgencyId].Value + "</td>";
                        }
                        else
                        {
                            RetVal += "<td class=\"DataColumnStyle \"></td>";
                        }
                        RetVal += "<td class=\"DataColumnStyle \">" + XmlNodes[i].Attributes[Constants.XmlFile.Db.Tags.DatabaseAttributes.DSDVersion].Value + "</td>";
                        if (XmlNodes[i].Attributes[Constants.XmlFile.Db.Tags.DatabaseAttributes.AssosciatedDb] != null)
                        {
                            AssociatedDb = XmlNodes[i].Attributes[Constants.XmlFile.Db.Tags.DatabaseAttributes.AssosciatedDb].Value;
                            RetVal += "<td class=\"DataColumnStyle \">" + Global.GetDbConnectionDetails(AssociatedDb)[0] + "</td>";
                        }
                        else
                        {
                            RetVal += "<td class=\"DataColumnStyle \"></td>";
                        }
                        DSDPath = Path.Combine(HttpContext.Current.Request.PhysicalApplicationPath, Constants.FolderName.Data + XmlNodes[i].Attributes[Constants.XmlFile.Db.Tags.DatabaseAttributes.Id].Value + "\\sdmx\\DSD" + DevInfo.Lib.DI_LibSDMX.Constants.XmlExtension);
                        DSDViewPath = "../../" + Constants.FolderName.Data + XmlNodes[i].Attributes[Constants.XmlFile.Db.Tags.DatabaseAttributes.Id].Value + "/sdmx/DSD" + DevInfo.Lib.DI_LibSDMX.Constants.XmlExtension;
                        Query = "SELECT * FROM Artefacts WHERE Type=" + Convert.ToInt32(ArtefactTypes.DFD).ToString() + " And DbNId = " + XmlNodes[i].Attributes[Constants.XmlFile.Db.Tags.DatabaseAttributes.Id].Value + ";";

                        DtDFD = DIConnection.ExecuteDataTable(Query);
                        if (DtDFD.Rows.Count > 0)
                        {
                            Publisher = DtDFD.Rows[0]["AgencyId"].ToString();
                            RetVal += "<td class=\"DataColumnStyle \">" + Publisher + "</td>";

                        }
                        else
                        {
                            RetVal += "<td class=\"DataColumnStyle \"></td>";
                        }

                        // RetVal += "<td class=\"DataColumnStyle \">" + "<a style=\"cursor:pointer;\" href=\"" + DSDViewPath.Replace("\\", "/") + "\"  target=\"_blank\" name=\"lang_View\"></a> | <a style=\"cursor:pointer;\" href='Download.aspx?fileId=" + DSDPath + "'  name=\"lang_Download\"></a>" + "</td>";
                        if (string.IsNullOrEmpty(Publisher))
                        {
                            RetVal += "<td class=\"DataColumnStyle \"></td>";
                        }
                        else
                        {
                            if (this.isUserAdmin(UserNId) == true)//Global.SplitString(Publisher, "_")[1] == UserNId
                            {

                                RetVal += "<td class=\"DataColumnStyle \">" + "<a style=\"cursor:pointer;\" href=\"javascript:void(0);\" onclick=\"OpenUploadDSDPopup('U','" + XmlNodes[i].Attributes[Constants.XmlFile.Db.Tags.DatabaseAttributes.Id].Value + "','" + AssociatedDb + "');\"  name=\"lang_Edit\"></a> | <a style=\"cursor:pointer;\" href=\"javascript:void(0);\" onclick=\"OpenUploadDSDPopup('D','" + XmlNodes[i].Attributes[Constants.XmlFile.Db.Tags.DatabaseAttributes.Id].Value + "','" + AssociatedDb + "');\" name=\"lang_Delete\"></a>" + "</td>";
                            }
                            else
                            {
                                RetVal += "<td class=\"DataColumnStyle \"></td>";
                            }
                        }
                        DbNid = XmlNodes[i].Attributes[Constants.XmlFile.Db.Tags.DatabaseAttributes.Id].Value;
                        HeaderFilePath = "../../" + Constants.FolderName.Data + DbNid + "\\" + Constants.FolderName.SDMX.sdmx + Constants.FileName.HeaderFileName;
                        RetVal += "<td class=\"DataColumnStyle \">" + "<a style=\"cursor:pointer;\" href=\"" + HeaderFilePath.Replace("\\", "/") + "\"  target=\"_blank\" name=\"lang_View\"></a> | <a style=\"cursor:pointer;\" href=\"javascript:void(0);\" onclick=\"OpenHeaderUpdatePopup(false,'" + DbNid + "');\"  name=\"lang_Edit\"></a>" + "</td>";

                        RetVal = RetVal + "</tr>";
                    }
                }
                RetVal = RetVal + "</table>";
            }

            if (RetVal.Length > 0)
            {
                RetVal = RetVal.Remove(RetVal.Length - 1);
            }

        }
        catch (Exception ex)
        {
            Global.CreateExceptionString(ex, null);
        }

        return RetVal;
    }

    private Dictionary<string, SubscriptionType> Get_Subscriptions_Dictionary_For_Structural_Metadata_Changes(string DbNId)
    {
        Dictionary<string, SubscriptionType> RetVal;
        string Query, FileNameWPath;
        DIConnection DIConnection;
        DataTable DtSubscriptions;
        SDMXObjectModel.Message.RegistryInterfaceType RegistryInterface;
        SDMXObjectModel.Registry.SubscriptionType Subscription;

        RetVal = new Dictionary<string, SubscriptionType>();
        Query = string.Empty;
        FileNameWPath = string.Empty;
        DIConnection = null;

        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 = " + DbNId + " AND Type = " + Convert.ToInt32(ArtefactTypes.Subscription).ToString() + ";";
            DtSubscriptions = DIConnection.ExecuteDataTable(Query);
            foreach (DataRow DrSubscriptions in DtSubscriptions.Rows)
            {
                FileNameWPath = DrSubscriptions["FileLocation"].ToString();
                RegistryInterface = (SDMXObjectModel.Message.RegistryInterfaceType)SDMXObjectModel.Deserializer.LoadFromFile(typeof(SDMXObjectModel.Message.RegistryInterfaceType), FileNameWPath);
                Subscription = ((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)RegistryInterface.Item).SubscriptionRequest[0].Subscription;
                if (Subscription.EventSelector[0] is StructuralRepositoryEventsType)
                {
                    RetVal.Add(Subscription.RegistryURN, Subscription);
                }
            }
        }
        catch (Exception ex)
        {
            Global.CreateExceptionString(ex, null);
            throw ex;
        }
        finally
        {
            if (DIConnection != null)
            {
                DIConnection.Dispose();
            }
        }

        return RetVal;
    }

    private void Delete_SDMXArtefacts_Details_In_Database(string DbNId, string AdminNId)
    {
        string DeleteQuery;
        DIConnection DIConnection;
        DataTable DtTable;
        string RegistrationFolder = string.Empty;
        DeleteQuery = string.Empty;
        DIConnection = null;

        try
        {
            DIConnection = new DIConnection(DIServerType.MsAccess, string.Empty, string.Empty, Server.MapPath("~//stock//Database.mdb"),
                           string.Empty, string.Empty);

            DtTable = DIConnection.ExecuteDataTable("SELECT * FROM Artefacts WHERE DBNId = " + DbNId + " AND Type = " + Convert.ToInt32(ArtefactTypes.Registration).ToString() + ";");
            foreach (DataRow DrTable in DtTable.Rows)
            {
                if (DrTable["FileLocation"].ToString().Contains(@"\" + DbNId + @"\" + Constants.FolderName.SDMX.Registrations + AdminNId + @"\"))
                {
                    Global.Delete_Registration_Artefact(DbNId, AdminNId, DrTable["Id"].ToString());
                    Global.Delete_Constraint_Artefact(DbNId, AdminNId, DrTable["Id"].ToString());
                }
            }

            DeleteQuery = "DELETE FROM Artefacts WHERE DBNId = " + DbNId + " AND (Type NOT IN (" + Convert.ToInt32(ArtefactTypes.Subscription).ToString() + "," + Convert.ToInt32(ArtefactTypes.Registration).ToString() + "," + Convert.ToInt32(ArtefactTypes.Constraint).ToString() + "," + Convert.ToInt32(ArtefactTypes.Mapping).ToString() + "));";
            DIConnection.ExecuteDataTable(DeleteQuery);
        }
        catch (Exception ex)
        {
            Global.CreateExceptionString(ex, null);
            throw ex;
        }
        finally
        {
            if (DIConnection != null)
            {
                DIConnection.Dispose();
            }
        }
    }

    private static DataTable Get_User(int UserNId)
    {
        DataTable RetVal;
        DIConnection DIConnection;
        string Query;

        RetVal = null;
        DIConnection = null;

        try
        {
            DIConnection = new DIConnection(DIServerType.MsAccess, string.Empty, string.Empty, Path.Combine(HttpContext.Current.Request.PhysicalApplicationPath, "stock//Database.mdb"), string.Empty, string.Empty);
            Query = "SELECT * FROM Users WHERE NId = " + UserNId.ToString() + ";";
            RetVal = DIConnection.ExecuteDataTable(Query);
        }
        catch (Exception ex)
        {
            Global.CreateExceptionString(ex, null);

            throw ex;
        }
        finally
        {
            if (DIConnection != null)
            {
                DIConnection.Dispose();
            }
        }

        return RetVal;
    }

    private static Dictionary<string, SubscriptionType> Get_Subscriptions_Dictionary(string DbNId, bool IsMetadata)
    {
        Dictionary<string, SubscriptionType> RetVal;
        string Query, FileNameWPath;
        DIConnection DIConnection;
        DataTable DtSubscriptions;
        SDMXObjectModel.Message.RegistryInterfaceType RegistryInterface;
        SDMXObjectModel.Registry.SubscriptionType Subscription;

        RetVal = new Dictionary<string, SubscriptionType>();
        Query = string.Empty;
        FileNameWPath = string.Empty;
        DIConnection = null;

        try
        {
            DIConnection = new DIConnection(DIServerType.MsAccess, string.Empty, string.Empty, Path.Combine(HttpContext.Current.Request.PhysicalApplicationPath, "stock//Database.mdb"), string.Empty, string.Empty);
            Query = "SELECT * FROM Artefacts WHERE DBNId = " + DbNId + " AND Type = " + Convert.ToInt32(ArtefactTypes.Subscription).ToString() + ";";
            DtSubscriptions = DIConnection.ExecuteDataTable(Query);
            foreach (DataRow DrSubscriptions in DtSubscriptions.Rows)
            {
                FileNameWPath = DrSubscriptions["FileLocation"].ToString();
                RegistryInterface = (SDMXObjectModel.Message.RegistryInterfaceType)Deserializer.LoadFromFile(typeof(SDMXObjectModel.Message.RegistryInterfaceType), FileNameWPath);
                Subscription = ((SDMXObjectModel.Registry.SubmitSubscriptionsRequestType)RegistryInterface.Item).SubscriptionRequest[0].Subscription;

                if (Subscription.EventSelector != null && Subscription.EventSelector.Count > 0)
                {
                    if (IsMetadata == false)
                    {
                        if (Subscription.EventSelector[0] is DataRegistrationEventsType)
                        {
                            RetVal.Add(Subscription.RegistryURN, Subscription);
                        }
                    }
                    else
                    {
                        if (Subscription.EventSelector[0] is MetadataRegistrationEventsType)
                        {
                            RetVal.Add(Subscription.RegistryURN, Subscription);
                        }
                    }
                }
            }
        }
        catch (Exception ex)
        {
            Global.CreateExceptionString(ex, null);

            throw ex;
        }
        finally
        {
            if (DIConnection != null)
            {
                DIConnection.Dispose();
            }
        }

        return RetVal;
    }

    private static void Create_Other_Artefacts_And_Update_Folder_Structures_For_Consumer_Per_Database(string UserNId)
    {
        DataTable DtRegisteredDatabases;
        DIConnection DIConnection;
        string OutputFolder;
        string Query;

        DtRegisteredDatabases = null;
        DIConnection = null;
        OutputFolder = string.Empty;

        try
        {
            DIConnection = new DIConnection(DIServerType.MsAccess, string.Empty, string.Empty, Path.Combine(HttpContext.Current.Request.PhysicalApplicationPath, "stock//Database.mdb"), string.Empty, string.Empty);
            Query = "SELECT DISTINCT DBNId FROM Artefacts WHERE DBNId <> -1;";
            DtRegisteredDatabases = DIConnection.ExecuteDataTable(Query);

            foreach (DataRow DrRegisteredDatabases in DtRegisteredDatabases.Rows)
            {
                #region "--Subscription--"

                OutputFolder = Path.Combine(HttpContext.Current.Request.PhysicalApplicationPath, Constants.FolderName.Data + DrRegisteredDatabases["DBNId"].ToString() + "\\sdmx\\Subscriptions\\" + UserNId);
                Create_Directory_If_Not_Exists(OutputFolder);

                #endregion "--Subscription--"
            }
        }
        catch (Exception ex)
        {
            Global.CreateExceptionString(ex, null);

            throw ex;
        }
        finally
        {
            if (DIConnection != null)
            {
                DIConnection.Dispose();
            }
        }
    }

    public static void Create_Constraint_Artefact_For_Version_2_0_SDMLMLFile(string RegistrationId, string DbNId, string UserNId, string AgencyId, string FileURL)
    {
        string InsertQuery, OutputFolder;
        DIConnection DIConnection;
        XmlDocument SimpleDataFileXML;
        XmlNodeList ObjXmlNodeList;
        SDMXObjectModel.Message.StructureType ConstraintStructure;
        SDMXObjectModel.Structure.ContentConstraintType ContentConstraint;
        DataKeySetType DataKeySet;
        DataKeyValueType DataKeyValue;
        int KeyIndex;

        string SimpleDataFileUrl = string.Empty;
        string ConstraintFileName = string.Empty;
        string ConstraintFileLocation = string.Empty;

        InsertQuery = string.Empty;
        OutputFolder = Path.Combine(HttpContext.Current.Request.PhysicalApplicationPath, Constants.FolderName.Data + DbNId + "\\sdmx\\Constraints\\" + UserNId);
        ConstraintFileName = DevInfo.Lib.DI_LibSDMX.Constants.Constraint.Prefix + RegistrationId + ".xml";
        ConstraintFileLocation = OutputFolder + "\\" + ConstraintFileName;
        DIConnection = null;

        try
        {
            DIConnection = new DIConnection(DIServerType.MsAccess, string.Empty, string.Empty, Path.Combine(HttpContext.Current.Request.PhysicalApplicationPath, "stock//Database.mdb"), string.Empty, string.Empty);
            SimpleDataFileXML = new XmlDocument();
            if (!String.IsNullOrEmpty(FileURL))
            {
                SimpleDataFileXML.Load(FileURL);
            }
            ObjXmlNodeList = SimpleDataFileXML.GetElementsByTagName("sts:Series");
            ConstraintStructure = new SDMXObjectModel.Message.StructureType();
            ConstraintStructure.Structures = new StructuresType();
            ConstraintStructure.Structures.Constraints = new List<ConstraintType>();

            ContentConstraint = new SDMXObjectModel.Structure.ContentConstraintType();
            ContentConstraint.id = DevInfo.Lib.DI_LibSDMX.Constants.Constraint.Prefix + RegistrationId;
            ContentConstraint.Name.Add(new TextType(null, DevInfo.Lib.DI_LibSDMX.Constants.Constraint.Name + RegistrationId));
            ContentConstraint.agencyID = AgencyId;
            ContentConstraint.version = DevInfo.Lib.DI_LibSDMX.Constants.Constraint.Version;
            ContentConstraint.Description.Add(new TextType(null, DevInfo.Lib.DI_LibSDMX.Constants.Constraint.Description));
            ContentConstraint.Annotations = null;
            ContentConstraint.ReleaseCalendar = null;
            ContentConstraint.ConstraintAttachment = new ContentConstraintAttachmentType();

            if (!String.IsNullOrEmpty(FileURL))
            {
                ContentConstraint.ConstraintAttachment.Items = new object[1];
                ContentConstraint.ConstraintAttachment.Items[0] = FileURL;
                ContentConstraint.ConstraintAttachment.ItemsElementName = new ConstraintAttachmentChoiceType[] { ConstraintAttachmentChoiceType.SimpleDataSource };
            }

            DataKeySet = new DataKeySetType();
            DataKeySet.isIncluded = true;
            ContentConstraint.Items.Add(DataKeySet);
            KeyIndex = 0;
            foreach (XmlNode SeriesNode in ObjXmlNodeList)
            {
                ((DataKeySetType)(ContentConstraint.Items[0])).Key.Add(new DataKeyType());
                foreach (XmlAttribute SeriesAttribute in SeriesNode.Attributes)
                {
                    DataKeyValue = new DataKeyValueType();
                    DataKeyValue.id = SeriesAttribute.Name;
                    DataKeyValue.Items.Add(new SimpleKeyValueType());
                    ((SimpleKeyValueType)(DataKeyValue.Items[0])).Value = SeriesAttribute.Value;
                    ((DataKeySetType)(ContentConstraint.Items[0])).Key[KeyIndex].KeyValue.Add(DataKeyValue);
                }
                KeyIndex = KeyIndex + 1;
            }

            ConstraintStructure.Structures.Constraints.Add(ContentConstraint);

            SDMXObjectModel.Serializer.SerializeToFile(typeof(SDMXObjectModel.Message.StructureType), ConstraintStructure, ConstraintFileLocation);
            InsertQuery = "INSERT INTO Artefacts (DBNId, Id, AgencyId, Version, URN, Type, FileLocation)" +
                                " VALUES(" + DbNId + ",'" + ContentConstraint.id + "','" + ContentConstraint.agencyID + "','" + ContentConstraint.version + "','" + string.Empty + "'," + Convert.ToInt32(ArtefactTypes.Constraint).ToString() + ",'" + ConstraintFileLocation + "');";
            DIConnection.ExecuteDataTable(InsertQuery);
        }
        catch (Exception ex)
        {
            Global.CreateExceptionString(ex, null);

            throw ex;
        }
        finally
        {
            if (DIConnection != null)
            {
                DIConnection.Dispose();
            }
        }
    }