Example #1
0
        /// <summary>
        ///  It exports Indicators information(IndicatorName, GID) for given indicator NIds, into desired output format (DES, PDF, HTml, etc)
        /// </summary>
        /// <param name="dBConnection">DIConnection object</param>
        /// <param name="dBQueries">DIQueries object</param>
        /// <param name="indicatorNIds">comma delimited indicator NIds, for Filter</param>
        /// <param name="showIUS">true if IUS information need to be shown in output.</param>
        /// <param name="exportOutputType">Output format type enum value.</param>
        /// <param name="outputFileNameWPath">Output fileName With path.</param>
        /// <param name="languageFileNameWPath">language fileName Path.</param>
        /// <returns></returns>
        public static bool ExportIndicator(DIConnection dBConnection, DIQueries dBQueries, string NIdsFilterString, bool isIUSNIds, DIExportOutputType exportOutputType, string outputFileNameWPath, string languageFileNameWPath)
        {
            bool RetVal = false;
            DataTable IndicatorDT = null;

            try
            {
                // Get Distinct Indicator_Name and Indicator_Gid for given IndicatorNIds in a DataView
                if (string.IsNullOrEmpty(NIdsFilterString))
                {
                    NIdsFilterString = string.Empty;
                }

                //-- Check if showIUS is true, then Get IUS gor given indicators,.
                //-- else, get only indicatorsNames, IndicatorGID
                if (isIUSNIds)
                {
                    IndicatorDT = dBConnection.ExecuteDataTable(dBQueries.IUS.GetIUS(FilterFieldType.NId, NIdsFilterString, FieldSelection.Light));

                    //-- Get Only Names columns
                    IndicatorDT = IndicatorDT.DefaultView.ToTable(false, Indicator.IndicatorName, Unit.UnitName, SubgroupVals.SubgroupVal);
                }
                else
                {
                    IndicatorDT = dBConnection.ExecuteDataTable(dBQueries.Indicators.GetIndicator(FilterFieldType.NId, NIdsFilterString, FieldSelection.Light));

                    //-- Get Only Indicator Name column
                    IndicatorDT = IndicatorDT.DefaultView.ToTable(false, new string[] { Indicator.IndicatorName, Indicator.IndicatorGId });
                }

                //-- Language Handling of Columns
                if (IndicatorDT.Columns.Contains(Indicator.IndicatorName))
                {
                    IndicatorDT.Columns[Indicator.IndicatorName].Caption = DILanguage.GetLanguageString("INDICATOR");
                }
                if (IndicatorDT.Columns.Contains(Indicator.IndicatorGId))
                {
                    IndicatorDT.Columns[Indicator.IndicatorGId].Caption = DILanguage.GetLanguageString("GID");
                }
                if (IndicatorDT.Columns.Contains(Unit.UnitName))
                {
                    IndicatorDT.Columns[Unit.UnitName].Caption = DILanguage.GetLanguageString("UNIT");
                }
                if (IndicatorDT.Columns.Contains(SubgroupVals.SubgroupVal))
                {
                    IndicatorDT.Columns[SubgroupVals.SubgroupVal].Caption = DILanguage.GetLanguageString("SUBGROUP");
                }

                // Export Indicators using DataView.
                RetVal = DIExport.ExportIndicator(IndicatorDT.DefaultView, exportOutputType, outputFileNameWPath, languageFileNameWPath);
            }
            catch (Exception ex)
            {
                ExceptionHandler.ExceptionFacade.ThrowException(ex);
            }

            return RetVal;
        }
Example #2
0
        /// <summary>
        /// Export Timeperiods into specified output format.
        /// </summary>
        /// <param name="dBConnection">source database DIConnection object</param>
        /// <param name="dBQueries">source database DiQueries object.</param>
        /// <param name="timePeriodNIds">filter string timeperiod NIds</param>
        /// <param name="exportOutputType">output format type(.pdf, html, xls, csv)</param>
        /// <param name="outputFileNameWPath">output filename path.</param>
        /// <returns></returns>
        public static bool ExportTimePeriods(DIConnection dBConnection, DIQueries dBQueries, string timePeriodNIds, DIExportOutputType exportOutputType, string outputFileNameWPath)
        {
            bool RetVal = false;
            DataView TimePeriodView = null;
            try
            {
                // Get dataView for given timeperiod NIds
                TimePeriodView = dBConnection.ExecuteDataTable(dBQueries.Timeperiod.GetTimePeriod(timePeriodNIds)).DefaultView;

                //-- get dataView having one column "TimePeriod"
                TimePeriodView = TimePeriodView.ToTable(false, Timeperiods.TimePeriod).DefaultView;

                //-- Language Handling of Columns
                if (TimePeriodView.Table.Columns.Contains(Timeperiods.TimePeriod))
                {
                    TimePeriodView.Table.Columns[Timeperiods.TimePeriod].Caption = DILanguage.GetLanguageString("TIMEPERIOD");
                }

                //-- Exporting as general Dataview
                RetVal = DIExport.ExportDataView(TimePeriodView, exportOutputType, outputFileNameWPath);

                return RetVal;
            }
            catch (Exception ex)
            {
                ExceptionHandler.ExceptionFacade.ThrowException(ex);
            }

            return RetVal;
        }
Example #3
0
        /// <summary>
        /// It exports all Indicators present in DataView parameter (IndicatorName, GID) into desired output format (DES, PDF, HTml, etc)
        /// </summary>
        /// <param name="indicatorDataView">DataView having Indicator_Name, Indicator_GId columns.</param>
        /// <param name="outputType">Output format type enum value.</param>
        /// <param name="outputFileNameWPath">Output fileName With path.</param>
        /// <returns>true, if export succesful.</returns>
        public static bool ExportIndicator(DataView indicatorDataView, DIExportOutputType outputType, string outputFileNameWPath, string languageFileNameWPath)
        {
            bool RetVal = false;

            try
            {
                switch (outputType)
                {
                    case DIExportOutputType.Spreadsheet:
                        RetVal = ExportDES.ExportDataView(indicatorDataView, outputFileNameWPath);
                        break;
                    case DIExportOutputType.DES:
                        RetVal = ExportDES.ExportIndicatorEntrySpreadsheet(indicatorDataView, outputFileNameWPath, languageFileNameWPath);
                        break;
                    case DIExportOutputType.PDF:
                        RetVal = ExportPDF.ExportIndicatorFromDataView(indicatorDataView, outputFileNameWPath, languageFileNameWPath);
                        break;
                    case DIExportOutputType.HTML:
                        RetVal = ExportHTML.ExportIndicatorFromDataView(indicatorDataView, outputFileNameWPath, languageFileNameWPath);
                        break;
                    case DIExportOutputType.CSV:
                        RetVal = ExportCSV.ExportDataView(indicatorDataView, outputFileNameWPath);
                        break;
                    default:
                        break;
                }
            }
            catch (Exception ex)
            {
                ExceptionHandler.ExceptionFacade.ThrowException(ex);
            }
            return RetVal;
        }
Example #4
0
        /// <summary>
        ///  It exports all Indicators present in DataBase (IndicatorName, GID) into desired output format (DES, PDF, HTml, etc)
        /// </summary>
        /// <param name="dBConnection">DIConnection object</param>
        /// <param name="dBQueries">DIQueries object</param>
        /// <param name="exportOutputType">Output format type enum value.</param>
        /// <param name="outputFileNameWPath">Output fileName With path.</param>
        /// <param name="languageFileNameWPath">language fileName Path.</param>
        /// <returns></returns>
        public static bool ExportIndicator(DIConnection dBConnection, DIQueries dBQueries, DIExportOutputType exportOutputType, string outputFileNameWPath, string languageFileNameWPath)
        {
            bool RetVal = false;
            DataView IndicatorDataView = null;

            try
            {
                // Export Indicator Entry Spreadsheet using DataView.
                //RetVal = DIExport.ExportIndicator(IndicatorDataView, exportOutputType, outputFileNameWPath, languageFileNameWPath);
                RetVal = DIExport.ExportIndicator(dBConnection, dBQueries, string.Empty, false, exportOutputType, outputFileNameWPath, languageFileNameWPath);
            }
            catch (Exception ex)
            {
                ExceptionHandler.ExceptionFacade.ThrowException(ex);
            }

            return RetVal;
        }
Example #5
0
        /// <summary>
        /// It exports the Indicator Classifications of specified ICType, present in DataView. <para>Exported ICs will be in format: ICLevel 1, ICLevel 2, ...ICLevel n , Indicator, Unit, Subgroup. </para>  
        /// </summary>
        /// <param name="ICElementType">ICType enum value </param>
        /// <param name="ICDataView">DataView having IC Data in format: ICLevel 1, ICLevel 2, ...ICLevel n , Indicator, Unit, Subgroup. </param>
        /// <param name="outputType">Output format type.</param>
        /// <param name="outputFileNameWPath">Output fileName With path.</param>
        /// <returns></returns>
        public static bool ExportIC(ICType ICElementType, DataView ICDataView, DIExportOutputType outputType, string outputFileNameWPath)
        {
            bool RetVal = false;

            try
            {
                switch (outputType)
                {
                    case DIExportOutputType.DES:
                    case DIExportOutputType.Spreadsheet:
                        RetVal = ExportDES.ExportICFromDataView(ICDataView, ICElementType, outputFileNameWPath);
                        break;
                    case DIExportOutputType.PDF:
                        RetVal = ExportPDF.ExportICFromDataView(ICDataView, ICElementType, outputFileNameWPath);
                        break;
                    case DIExportOutputType.HTML:
                        RetVal = ExportHTML.ExportICFromDataView(ICDataView, ICElementType, outputFileNameWPath);
                        break;
                    default:
                        break;
                }
            }
            catch (Exception ex)
            {
                ExceptionHandler.ExceptionFacade.ThrowException(ex);
            }

            return RetVal;
        }
Example #6
0
        /// <summary>
        /// It exports the Indicator Classifications of specified ICType, present in Database. <para>Exported ICs will be in format: ICLevel 1, ICLevel 2, ...ICLevel n , Indicator, Unit, Subgroup. </para>  
        /// </summary>
        /// <param name="ICElementType">ICType enum value</param>
        /// <param name="dBConnection">DIConnection object of source Database,</param>
        /// <param name="dBQueries">DIQueries object of source Database.</param>
        /// <param name="exportOutputType">Output format type.</param>
        /// <param name="outputFileNameWPath">Output fileName With path.</param>
        /// <param name="languageFileNameWPath">language xml file name path.</param>
        /// <returns></returns>
        public static bool ExportIC(ICType ICElementType, DIConnection dBConnection, DIQueries dBQueries, DIExportOutputType exportOutputType, string outputFileNameWPath, string languageFileNameWPath)
        {
            bool RetVal = false;
            DataView ICDataView = null;

            try
            {
                // Get Distinct IndicatorClassification labels for N levels and Indicator, Unit, Subgroup in a DataView.
                ICDataView = DIExport.GetDataViewForICExport(ICElementType, dBConnection, dBQueries).DefaultView;

                // Export Indicator Entry Spreadsheet using DataView.
                RetVal = DIExport.ExportIC(ICElementType, ICDataView, exportOutputType, outputFileNameWPath);
            }
            catch (Exception ex)
            {
                ExceptionHandler.ExceptionFacade.ThrowException(ex);
            }
            return RetVal;
        }
Example #7
0
 /// <summary>
 /// It exports the dataView, passed as parameter, to various fomrat
 /// </summary>
 /// <param name="sourceDataView">dataView as data source.</param>
 /// <param name="RTL">True, if RTL is required for Columns</param>
 /// <param name="columnHeaderFont">font for column headers</param>
 /// <param name="dataRowFont">Desired Font for data to be displayed.</param>
 /// <param name="globalColor">global Color used for global columns (INdicator_global, Unit_global, subgroup_val_global)</param>
 /// <param name="outputType">output format required (pdf, html, xls, csv)</param>
 /// <param name="outputFileNameWPath">Output filename with path.</param>
 /// <returns></returns>
 public static bool ExportDataView(DataView sourceDataView, bool RTL, Font columnHeaderFont, Font dataRowFont, Color globalColor, DIExportOutputType outputType, string outputFileNameWPath)
 {
     bool RetVal = false;
     switch (outputType)
     {
         case DIExportOutputType.Spreadsheet:
             RetVal = ExportDES.ExportDataView(sourceDataView, columnHeaderFont, dataRowFont, globalColor, outputFileNameWPath);
             break;
         case DIExportOutputType.PDF:
             RetVal = ExportPDF.ExportDataView(sourceDataView, RTL, string.Empty, string.Empty, columnHeaderFont, dataRowFont, globalColor, outputFileNameWPath);
             break;
         case DIExportOutputType.HTML:
             RetVal = ExportHTML.ExportDataView(sourceDataView, RTL, columnHeaderFont, dataRowFont, globalColor, outputFileNameWPath);
             break;
         case DIExportOutputType.CSV:
             RetVal = ExportCSV.ExportDataView(sourceDataView, outputFileNameWPath);
             break;
         default:
             break;
     }
     return RetVal;
 }
Example #8
0
        /// <summary>
        /// It exports the dataView, passed as parameter, to various fomrat
        /// </summary>
        /// <param name="sourceDataView">source dataView containing rows and columns</param>
        /// <param name="columnHeaderFont">font for column headings</param>
        /// <param name="dataRowFont">Desired Font for data to be displayed.</param>
        /// <param name="outputType">output type like PDF, HTML, xls, csv</param>
        /// <param name="outputFileNameWPath">output filename with path</param>
        /// <returns>true, if exported succesfully</returns>
        public static bool ExportDataView(DataView sourceDataView, Font columnHeaderFont, Font dataRowFont, DIExportOutputType outputType, string outputFileNameWPath)
        {
            bool RetVal = false;
            // Add Color.Blank as default color.
            switch (outputType)
            {
                case DIExportOutputType.Spreadsheet:
                    RetVal = ExportDES.ExportDataView(sourceDataView, columnHeaderFont, dataRowFont, Color.Black, outputFileNameWPath);
                    break;
                case DIExportOutputType.PDF:
                    RetVal = ExportPDF.ExportDataView(sourceDataView, false, string.Empty, string.Empty, null, null, Color.Black, outputFileNameWPath);
                    break;
                case DIExportOutputType.HTML:
                    RetVal = ExportHTML.ExportDataView(sourceDataView, false, columnHeaderFont, dataRowFont, Color.Black, outputFileNameWPath);
                    break;
                case DIExportOutputType.CSV:
                    RetVal = ExportCSV.ExportDataView(sourceDataView, outputFileNameWPath);
                    break;

                default:
                    break;
            }
            return RetVal;
        }
Example #9
0
 /// <summary>
 /// Exports Data in DataView to output format specified. Output Data format will be same as  DataView.
 /// </summary>
 /// <param name="sourceDataView">DataView having data to export</param>
 /// <param name="outputType">Output format desired.</param>
 /// <param name="outputFileNameWPath">output File Name with path.</param>
 /// <returns>True, if exported succesfully.</returns>
 public static bool ExportDataView(DataView sourceDataView, DIExportOutputType outputType, string outputFileNameWPath)
 {
     bool RetVal = false;
     switch (outputType)
     {
         case DIExportOutputType.Spreadsheet:
             RetVal = ExportDES.ExportDataView(sourceDataView, outputFileNameWPath);
             break;
         case DIExportOutputType.PDF:
             RetVal = ExportPDF.ExportDataView(sourceDataView, string.Empty, string.Empty, null, null, outputFileNameWPath);
             break;
         case DIExportOutputType.HTML:
             RetVal = ExportHTML.ExportDataView(sourceDataView, outputFileNameWPath);
             break;
         case DIExportOutputType.CSV:
             RetVal = ExportCSV.ExportDataView(sourceDataView, outputFileNameWPath);
             break;
         default:
             break;
     }
     return RetVal;
 }
Example #10
0
        /// <summary>
        /// It Areas information (AreaID, AreaName, AreaLevel, AreaGId, ParentAreaId) for given Area NIds, into specified output format.
        /// </summary>
        /// <param name="dBConnection">source database DIConnection object</param>
        /// <param name="dBQueries">source database DiQueries object.</param>
        /// <param name="areaNIds">filter string Area NIds </param>
        /// <param name="exportOutputType">output format type(.pdf, html, xls, csv)</param>
        /// <param name="outputFileNameWPath">output filename path.</param>
        /// <param name="languageFileNameWPath">language xml filename path. (required for xls Areas heading)</param>
        /// <returns></returns>
        public static bool ExportArea(DIConnection dBConnection, DIQueries dBQueries, string areaNIds, DIExportOutputType exportOutputType, string outputFileNameWPath, string languageFileNameWPath)
        {
            bool RetVal = false;
            DataTable AreaDT = null;

            try
            {

                //-- SQL Query to get AreaName, AreaID, Level, ParentID
                // TODO move in DAL.
                string SqlString = "SELECT A1." + Area.AreaID + ", A1." + Area.AreaName + ", A1." + Area.AreaLevel + " , A1." + Area.AreaGId + ", A2." + Area.AreaID + " AS " + Constants.ParentAreaIDColumn + " " +
            " FROM " + dBQueries.TablesName.Area + " AS A1 LEFT JOIN " + dBQueries.TablesName.Area + " AS A2 ON A1." + Area.AreaParentNId + " = A2." + Area.AreaNId;

                if (string.IsNullOrEmpty(areaNIds) == false)
                {
                    SqlString += " WHERE A1." + Area.AreaNId + " IN (" + areaNIds + ")";
                }
                SqlString += " Order by A1." + Area.AreaID + ", A1." + Area.AreaName + ", A1." + Area.AreaLevel + " ASC";

                //-- get Datatable
                AreaDT = dBConnection.ExecuteDataTable(SqlString);

                //-- If ExportOutput type is other than DES,
                //-- then include 3 columns (AreaName, AreaID, AreaLevel)
                if (exportOutputType != DIExportOutputType.DES)
                {
                    AreaDT = AreaDT.DefaultView.ToTable(false, Area.AreaName, Area.AreaID, Area.AreaLevel);
                }

                //-- Language Handling of Columns
                if (AreaDT.Columns.Contains(Area.AreaName))
                {
                    AreaDT.Columns[Area.AreaName].Caption = DILanguage.GetLanguageString("AREANAME");
                }
                if (AreaDT.Columns.Contains(Area.AreaID))
                {
                    AreaDT.Columns[Area.AreaID].Caption = DILanguage.GetLanguageString("AREAID");
                }
                if (AreaDT.Columns.Contains(Area.AreaLevel))
                {
                    AreaDT.Columns[Area.AreaLevel].Caption = DILanguage.GetLanguageString("AREA_LEVEL");
                }
                if (AreaDT.Columns.Contains(Constants.ParentAreaIDColumn))
                {
                    AreaDT.Columns[Constants.ParentAreaIDColumn].Caption = Constants.ParentAreaIDColumnCaption;
                }

                // Export Indicator Entry Spreadsheet using DataView.
                RetVal = DIExport.ExportArea(AreaDT.DefaultView, exportOutputType, outputFileNameWPath, languageFileNameWPath);

            }
            catch (Exception ex)
            {
                ExceptionHandler.ExceptionFacade.ThrowException(ex);
            }

            return RetVal;
        }
Example #11
0
        /// <summary>
        /// It exports all Areas information (AreaID, AreaName, AreaLevel, AreaGId, ParentAreaId) into specified output format.
        /// </summary>
        /// <param name="dBConnection">source database DIConnection object</param>
        /// <param name="dBQueries">source database DiQueries object.</param>
        /// <param name="exportOutputType">output format type(.pdf, html, xls, csv)</param>
        /// <param name="outputFileNameWPath">output filename path.</param>
        /// <param name="languageFileNameWPath">language xml filename path. (required for xls Areas heading)</param>
        /// <returns></returns>
        public static bool ExportArea(DIConnection dBConnection, DIQueries dBQueries, DIExportOutputType exportOutputType, string outputFileNameWPath, string languageFileNameWPath)
        {
            bool RetVal = false;

            //-- Passing empty string as AreaNIds in overloaded function.
            RetVal = DIExport.ExportArea(dBConnection, dBQueries, string.Empty, exportOutputType, outputFileNameWPath, languageFileNameWPath);

            return RetVal;
        }