/// <summary>
        /// Rename Data_value and TextualValue column into OrgData_value and OrgTextualValue 
        /// and merge both column value into new column Data_Value
        /// </summary>
        /// <param name="dbConnection"></param>
        /// <param name="dbQueries"></param>
        public static void MergeTextualandNumericDataValueColumn(DIConnection dbConnection, DIQueries dbQueries)
        {
            try
            {
                if (!ISColumnExists(dbConnection, Constants.Data.Orginal_Data_valueColumn, dbQueries.TablesName.Data))
                {

                    //1. Rename Textual_Data_Value & Data_value  to orgTextual_Data_value & orgData_Value respectively
                    RenameOriganalDataTableColumnInDatabase(dbConnection, dbQueries, Data.TextualDataValue, Constants.Data.Orginal_Textual_Data_valueColumn, " Memo");
                    RenameOriganalDataTableColumnInDatabase(dbConnection, dbQueries, Data.DataValue, Constants.Data.Orginal_Data_valueColumn, " Double ");
                    System.Threading.Thread.Sleep(100);
                    //2. Create new column Data_Value of memo data type
                    string SqlQuery = "ALTER Table " + dbQueries.TablesName.Data + " Add Column " + Data.DataValue + " Memo NULL";
                    dbConnection.ExecuteNonQuery(SqlQuery);
                    System.Threading.Thread.Sleep(10);
                    //3. Merge all data values into Data_Value column
                    SqlQuery = "UPDATE " + dbQueries.TablesName.Data + " SET " + Data.DataValue + "=" + Constants.Data.Orginal_Data_valueColumn;
                    dbConnection.ExecuteNonQuery(SqlQuery);

                    SqlQuery = "UPDATE " + dbQueries.TablesName.Data + " SET " + Data.DataValue + "=" + Constants.Data.Orginal_Textual_Data_valueColumn + " WHERE " + Data.IsTextualData + "=" + true;
                    dbConnection.ExecuteNonQuery(SqlQuery);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        //-- Check orgTextual_Data_value exists or not. If column exists then move textual & numeric values into their respective column.
        public static void SeparateTextualandNemericData(DIConnection dbConnection, DIQueries dbQueries)
        {
            string SqlQuery = string.Empty;
            try
            {
                if (ISColumnExists(dbConnection, Constants.Data.Orginal_Data_valueColumn, dbQueries.TablesName.Data))
                {

                    //--Update Textual value true if data value is not Numeric
                    SqlQuery = "UPDATE " + dbQueries.TablesName.Data + " SET " + Data.IsTextualData + " = 1 WHERE NOT ISNUMERIC(" + Data.DataValue + ")";
                    dbConnection.ExecuteNonQuery(SqlQuery);

                    //-- move orgData_Value values into Data_Value
                    SqlQuery = "UPDATE " + dbQueries.TablesName.Data + "	Set " + Constants.Data.Orginal_Data_valueColumn + "=" + Data.DataValue + " WHERE " + Data.IsTextualData + " = 0";
                    dbConnection.ExecuteNonQuery(SqlQuery);

                    //--move orgTextual_Data_value into Textual_Data_value if ISTextual is true
                    SqlQuery = "UPDATE " + dbQueries.TablesName.Data + " Set " + Constants.Data.Orginal_Textual_Data_valueColumn + " = " + Data.DataValue + " WHERE " + Data.IsTextualData + "<>0";
                    dbConnection.ExecuteNonQuery(SqlQuery);

                    //2. Remove Data_Value  column and rename orgTextual_Data_Value and orgData_Value to Textual_Data_Value and Data_value"
                    DIDataValueHelper.RemoveDataValueAndRenameOrgColumns(dbConnection, dbQueries);

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

        internal ExportOnlineDatabase(UserSelection userSelection, DIConnection sourceDBConnection, DIQueries sourceDBQueries)
        {
            if (sourceDBConnection != null && userSelection != null)
            {
                this.UserSelection = userSelection;

                //--  Assign NIDs in userSelection.
                if (userSelection.ShowIUS)
                {
                    this.IUSNIDs = userSelection.IndicatorNIds;
                }
                else
                {
                    this.IndicatorNIDs = userSelection.IndicatorNIds;
                }

                this.AreaNIDs = userSelection.AreaNIds;
                this.TimePeriodNIDs = userSelection.TimePeriodNIds;
                this.SourceNIDs = userSelection.SourceNIds;
                this.ApplyMRD = userSelection.DataViewFilters.MostRecentData;

                this.SourceDBConnection = sourceDBConnection;
                this.SourceDBQueries = sourceDBQueries;         //new DIQueries(this.SourceDBConnection.DIDataSetDefault(), this.SourceDBConnection.DILanguageCodeDefault(this.SourceDBConnection.DIDataSetDefault()));
            }
        }

        internal CategorySchemeUtility(CategorySchemeTypes categorySchemeType, bool completeOrSummaryFlag, string agencyId, string language, Header header, string outputFolder, Dictionary<string, string> DictIndicator, Dictionary<string, string> DictIndicatorMapping, DIConnection DIConnection, DIQueries DIQueries)
            : base(agencyId, language, header, outputFolder)
        {
            this._categorySchemeType = categorySchemeType;
            this._completeOrSummaryFlag = completeOrSummaryFlag;
            this._diConnection = DIConnection;
            this._diQueries = DIQueries;

            if (string.IsNullOrEmpty(language))
            {
                this.Language = this._diQueries.LanguageCode.Substring(1);
                this._multiLanguageHandlingRequired = true;
            }
            else
            {
                if (this._diConnection.IsValidDILanguage(this._diQueries.DataPrefix, language))
                {
                    this.Language = language;
                    this._multiLanguageHandlingRequired = false;
                }
                else
                {
                    this.Language = this._diQueries.LanguageCode.Substring(1);
                    this._multiLanguageHandlingRequired = false;
                }
            }

            this._dictIndicator = DictIndicator;
            this._dictIndicatorMapping = DictIndicatorMapping;
        }

        internal CodelistUtility(CodelistTypes codelistType, bool completeOrSummaryFlag, string agencyId, string language, Header header, string outputFolder, DIConnection DIConnection, DIQueries DIQueries)
            : base(agencyId, language, header, outputFolder)
        {
            this._codelistType = codelistType;
            this._completeOrSummaryFlag = completeOrSummaryFlag;
            this._diConnection = DIConnection;
            this._diQueries = DIQueries;

            if (string.IsNullOrEmpty(language))
            {
                this.Language = this._diQueries.LanguageCode.Substring(1);
                this._multiLanguageHandlingRequired = true;
            }
            else
            {
                if (this._diConnection.IsValidDILanguage(this._diQueries.DataPrefix, language))
                {
                    this.Language = language;
                    this._multiLanguageHandlingRequired = false;
                }
                else
                {
                    this.Language = this._diQueries.LanguageCode.Substring(1);
                    this._multiLanguageHandlingRequired = false;
                }
            }
        }

    public RegistryService()
    {
        int DBNIdOut;

        if (this.Context.Request.QueryString["p"] != null && !string.IsNullOrEmpty(this.Context.Request.QueryString["p"]) &&
            int.TryParse(this.Context.Request.QueryString["p"], out DBNIdOut))
        {
            DBNId = DBNIdOut;
        }
        else
        {
            Global.GetAppSetting();
            DBNId = Convert.ToInt32(Global.GetDefaultDbNId());
        }

        if (Global.IsDSDUploadedFromAdmin(DBNId))
        {
            this.DIConnection = Global.GetDbConnection(this.Get_AssociatedDB_NId(DBNId.ToString()));
        }
        else
        {
            this.DIConnection = Global.GetDbConnection(DBNId);
        }

        this.DIQueries = new DIQueries(this.DIConnection.DIDataSetDefault(), this.DIConnection.DILanguageCodeDefault(this.DIConnection.DIDataSetDefault()));
    }

        internal ImportQueries(DIQueries DBQueries)
        {
            this.DBQueries = DBQueries;

            // Set IUpdateQuery object, (By Default: Traditional)
            this.UpdateQueries = new TraditionalUpdateQuery(this.DBQueries);
        }

        internal MetadataReportUtility(string agencyId, string language, Header header, DIConnection DIConnection, DIQueries DIQueries)
        {
            this._agencyId = agencyId;
            this._header = header;
            this._diConnection = DIConnection;
            this._diQueries = DIQueries;

            if (string.IsNullOrEmpty(language))
            {
                this._language = this._diQueries.LanguageCode.Substring(1);
                this._multiLanguageHandlingRequired = true;
            }
            else
            {
                if (this._diConnection.IsValidDILanguage(this._diQueries.DataPrefix, language))
                {
                    this._language = language;
                    this._multiLanguageHandlingRequired = false;
                }
                else
                {
                    this._language = this._diQueries.LanguageCode.Substring(1);
                    this._multiLanguageHandlingRequired = false;
                }
            }
        }

 public ElementMapper(DIConnection dbConnection, DIQueries dbQueries, Dictionary<TemplateMergeControlType, MergeTableInfo> mappedTables)
 {
     this.DBConnection = dbConnection;
     this.DBQueries = dbQueries;
     this.TemplateQueries = new MergeTemplateQueries(this.DBQueries.DataPrefix, this.DBQueries.LanguageCode);
     this.MappedTables = mappedTables;
 }

        public static List<ArtefactInfo> Generate_Categorization(SDMXSchemaType schemaType, string agencyId, string language, Header header, string outputFolder, DIConnection DIConnection, DIQueries DIQueries,string IcType)
        {
            List<ArtefactInfo> RetVal;
            CategorizationUtility CategorizationUtility;

            RetVal = null;
            CategorizationUtility = null;

            try
            {
                CategorizationUtility = new CategorizationUtility(agencyId, language, header, outputFolder, DIConnection, DIQueries);
               // RetVal = CategorizationUtility.Generate_Artefact();
                RetVal = CategorizationUtility.Generate_CompleteArtefact(IcType);
                CategorizationUtility.Save_Artefacts(RetVal);
            }
            catch (Exception ex)
            {
                RetVal = null;
                throw ex;
            }
            finally
            {
            }

            return RetVal;
        }

    public string GetDataQueryResponseJSON(string dbNId, string language, string key)
    {
        string ResponseString;
        XmlDocument QueryDocument;

        ResponseString = string.Empty;
        QueryDocument = null;

        try
        {
            this.DIConnection = Global.GetDbConnection(Convert.ToInt32(dbNId));
            this.DIQueries = new DIQueries(this.DIConnection.DIDataSetDefault(), this.DIConnection.DILanguageCodeDefault(this.DIConnection.DIDataSetDefault()));

            QueryDocument = this.Get_Query(key, Constants.WSQueryStrings.ResponseFormatTypes.JSON, Constants.WSQueryStrings.SDMXFormatTypes.StructureSpecificTS, language);
            ResponseString = DATAUtility.Get_Data(QueryDocument, DataTypes.JSON, DIConnection, DIQueries);
        }
        catch (Exception ex)
        {
            Global.CreateExceptionString(ex, null);
            throw ex;
        }
        finally
        {
        }

        return ResponseString;
    }

        public static DIData CreateInstance(DIImportFileType importFileType, List<string> sourceFileNamesWPath,
            string tempFolderPath, DIConnection dbConnection, DIQueries dbQueries)
        {
            DIData RetVal = null;
            switch (importFileType)
            {
                case DIImportFileType.DataEntrySpreasheet:
                    break;
                case DIImportFileType.Database:
                    break;
                case DIImportFileType.Template:
                    break;
                case DIImportFileType.SDMXXml:
                    RetVal = new SDMX.SDMXXml(sourceFileNamesWPath, tempFolderPath, dbConnection, dbQueries);
                    break;
                default:
                    break;
            }

            if (RetVal != null)
            {
                RetVal.ImportFileType = importFileType;
            }
            return RetVal;
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="fileNameWPath"></param>
        public DI6ToDI5Converter(string fileNameWPath)
        {
            this.DBConnection = new DIConnection(DIServerType.MsAccess, string.Empty, string.Empty, fileNameWPath, string.Empty, string.Empty);
            this.DBQueries = new DIQueries(this.DBConnection.DIDataSetDefault(), this.DBConnection.DILanguageCodeDefault("UT_"));

            this.FilenameWPath = fileNameWPath;
        }

        internal CategorizationUtility(string agencyId, string language, Header header, string outputFolder, DIConnection DIConnection, DIQueries DIQueries)
            : base(agencyId, language, header, outputFolder)
        {
            this._diConnection = DIConnection;
            this._diQueries = DIQueries;

            if (string.IsNullOrEmpty(language))
            {
                this.Language = this._diQueries.LanguageCode.Substring(1);
                this._multiLanguageHandlingRequired = true;
            }
            else
            {
                if (this._diConnection.IsValidDILanguage(this._diQueries.DataPrefix, language))
                {
                    this.Language = language;
                    this._multiLanguageHandlingRequired = false;
                }
                else
                {
                    this.Language = this._diQueries.LanguageCode.Substring(1);
                    this._multiLanguageHandlingRequired = false;
                }
            }
        }

 internal BaseQueryUtility(Dictionary<string, string> dictUserSelections, DataReturnDetailTypes dataReturnDetailType, string agencyId, DIConnection DIConnection, DIQueries DIQueries)
 {
     this._dictUserSelections = dictUserSelections;
     this._dataReturnDetailType = dataReturnDetailType;
     this._agencyId = agencyId;
     this._diConnection = DIConnection;
     this._diQueries = DIQueries;
 }

 public IndicatorClassificationSelections(DIConnection dIConnection,DIQueries dIQueries)
 {
     // -- DAL connection object
     this.DbConnection = dIConnection;
     // -- DAL query object
     this.DbQueries = dIQueries;
     // -- Intialize the string builder object
     this._XMLString = new StringBuilder();
 }

 public IUSBuilder(DIConnection connection, DIQueries queries)
 {
     this.DBConnection = connection;
     this.DBQueries = queries;
     this.DIIndicator = new IndicatorBuilder(connection, queries);
     this.DIUnit = new UnitBuilder(connection, queries);
     this.DISubgroupVal = new DI6SubgroupValBuilder(connection, queries);
     DIConnection.ConnectionType = this.DBConnection.ConnectionStringParameters.ServerType;
 }

        /// <summary>
        /// Returns the instance of BaseListViewSource. Based on Factory method.
        /// </summary>
        /// <param name="listType"></param>
        /// <param name="dbConnection"></param>
        /// <param name="dbQueries"></param>
        /// <param name="userprefenece"></param>
        /// <returns></returns>
        public static BaseListViewSource CreateListViewSource(ListViewType listType, DIConnection dbConnection, DIQueries dbQueries, UserPreference userprefenece)
        {
            BaseListViewSource RetVal = null;

            switch (listType)
            {
                case ListViewType.Indicator:
                    RetVal = new IndicatorListViewSource();
                    RetVal.RaiseInitializedIndicatorListViewEvent();
                    break;

                case ListViewType.Timeperiod:
                    RetVal = new TimeperiodListViewSource();
                    RetVal.RaiseInitializedTimperiodListViewEvent();
                    break;

                case ListViewType.Area:
                    RetVal = new AreaListViewSource();
                    RetVal.RaiseInitializedAreaListViewEvent();
                    break;

                case ListViewType.Source:
                    RetVal = new DISourceListViewSource();
                    RetVal.RaiseInitializedDISourceListViewEvent();
                    break;

                case ListViewType.Unit:
                    RetVal = new UnitListViewSource();
                    RetVal.RaiseInitializedUnitListViewEvent();
                    break;

                case ListViewType.SubgroupVal:
                    RetVal = new SubgroupValListViewSource();
                    RetVal.RaiseInitializedUnitListViewEvent();
                    break;

                case ListViewType.IC:
                    RetVal = new ICListViewSource();
                    break;

                default:
                    break;
            }

            if (RetVal != null)
            {
                //set variables
                RetVal.DBConnection = dbConnection;
                RetVal.DBQueries = dbQueries;
                RetVal.DIUserPreference = userprefenece;

                //set columns
                RetVal.SetColumnInfo();
            }

            return RetVal;
        }

        internal AssistantImporter(DIConnection targetConnection, DIQueries targetQueries, List<string> sourceDatabaseFileNamesWPath)
        {
            this._TargetDBConnection = targetConnection;
            this._TargetDBQueries = targetQueries;

            this.SourceDatabaseFileNamesWPath = sourceDatabaseFileNamesWPath;

            this.AvailableIndicators = new IndicatorBuilder(this._TargetDBConnection, this._TargetDBQueries);
            this.AvailableUnit= new UnitBuilder(this._TargetDBConnection, this._TargetDBQueries);
            this.AvailableSubgroupVal= new DI6SubgroupValBuilder(this._TargetDBConnection, this._TargetDBQueries);
        }

 //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;
 }