Пример #1
0
 private void EnsureSheetHaveColumns(DataSheet sheet, IEnumerable<string> columnNames)
 {
     var newNames = columnNames.Except(sheet.Rows[0].Keys);
     foreach (var name in newNames)
     {
         foreach (var row in sheet.Rows) row.Add(name, string.Empty);
     }
 }
Пример #2
0
 private void CheckSheetConsistence(DataSheet sheet)
 {
     var columnNames = new HashSet<string>(sheet.Rows[0].Keys);
     foreach (var row in sheet.Rows)
     {
         if (!columnNames.SetEquals(row.Keys))
         {
             throw new Exception(
                 string.Format("{0} columns mismatch: ({1}),({2})",
                 sheet.Name, JsonOperation.Serialize(columnNames), JsonOperation.Serialize(row)));
         }
     }
 }
Пример #3
0
        public void Load(DataFeed dataFeed)
        {
            Debug.Assert(this.m_DataFeed == null);

            this.m_DataFeed = dataFeed;

            this.m_FlowDiagramSheet = dataFeed.Scenario.GetDataSheet(Constants.DATASHEET_FLOW_PATHWAY_DIAGRAM_NAME);
            this.m_FlowDiagramData  = this.m_FlowDiagramSheet.GetData();

            this.m_FlowPathwaySheet = dataFeed.Scenario.GetDataSheet(Constants.DATASHEET_FLOW_PATHWAY_NAME);
            this.m_FlowPathwayData  = this.m_FlowPathwaySheet.GetData();

            this.RefreshDiagram();
        }
Пример #4
0
        protected override void OnDataFeedsRefreshed()
        {
            base.OnDataFeedsRefreshed();

            this.m_TTData = this.GetData();

            this.m_TGDataSheet = this.Project.GetDataSheet(Strings.DATASHEET_TRANSITION_GROUP_NAME);
            this.m_TGData      = this.m_TGDataSheet.GetData();

            this.m_TTGDataSheet = this.Project.GetDataSheet(Strings.DATASHEET_TRANSITION_TYPE_GROUP_NAME);
            this.m_TTGData      = this.m_TTGDataSheet.GetData();

            this.m_TTGDataSheet.RowsAdded += this.OnTTGRowsAdded;
        }
Пример #5
0
        /// <summary>
        /// 找出某工作表在数据库集合中所对应的那一项,如果没有对应项,则返回Nothing
        /// </summary>
        /// <param name="DataSheet">要进行匹配的Excel工作表</param>
        /// <param name="DatasheetCollection">要进行搜索的数据库集合。</param>
        private DataSheet CorrespondingInCollection(Worksheet DataSheet, List <DataSheet> DatasheetCollection)
        {
            DataSheet dtSheet = null;

            foreach (DataSheet dbSheet in this.F_DbSheets)
            {
                if (ExcelFunction.SheetCompare(dbSheet.WorkSheet, DataSheet))
                {
                    dtSheet = dbSheet;
                    break;
                }
            }
            return(dtSheet);
        }
Пример #6
0
        private string GetProjectItemName(string dataSheetName, int id)
        {
            Debug.Assert(id != AttributeValueReference.TST_VALUE_NULL);

            if (id == AttributeValueReference.TST_GROUP_WILD)
            {
                return("NULL");
            }
            else
            {
                DataSheet ds = this.m_Project.GetDataSheet(dataSheetName);
                return(ds.ValidationTable.GetDisplayName(id));
            }
        }
Пример #7
0
        /// <summary>
        /// Initializes tabular output options
        /// </summary>
        /// <remarks></remarks>
        private void InitializeTabularOutputOptions()
        {
            Func <object, int> SafeInt = (object o) =>
            {
                if (o == DBNull.Value)
                {
                    return(0);
                }
                else
                {
                    return(Convert.ToInt32(o, CultureInfo.InvariantCulture));
                }
            };

            DataRow droo = this.ResultScenario.GetDataSheet(Strings.DATASHEET_OO_TABULAR_NAME).GetDataRow();

            this.m_CreateSummaryStateClassOutput                = DataTableUtilities.GetDataBool(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_SC_COLUMN_NAME]);
            this.m_SummaryStateClassOutputTimesteps             = SafeInt(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_SC_TIMESTEPS_COLUMN_NAME]);
            this.m_SummaryStateClassOutputAges                  = DataTableUtilities.GetDataBool(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_SC_AGES_COLUMN_NAME]);
            this.m_SummaryStateClassZeroValues                  = DataTableUtilities.GetDataBool(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_SC_ZERO_VALUES_COLUMN_NAME]);
            this.m_CreateSummaryTransitionOutput                = DataTableUtilities.GetDataBool(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_TR_COLUMN_NAME]);
            this.m_SummaryTransitionOutputTimesteps             = SafeInt(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_TR_TIMESTEPS_COLUMN_NAME]);
            this.m_SummaryTransitionOutputAges                  = DataTableUtilities.GetDataBool(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_TR_AGES_COLUMN_NAME]);
            this.m_SummaryTransitionOutputAsIntervalMean        = DataTableUtilities.GetDataBool(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_TR_INTERVAL_MEAN_COLUMN_NAME]);
            this.m_CreateSummaryTransitionByStateClassOutput    = DataTableUtilities.GetDataBool(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_TRSC_COLUMN_NAME]);
            this.m_SummaryTransitionByStateClassOutputTimesteps = SafeInt(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_TRSC_TIMESTEPS_COLUMN_NAME]);
            this.m_CreateSummaryStateAttributeOutput            = DataTableUtilities.GetDataBool(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_SA_COLUMN_NAME]);
            this.m_SummaryStateAttributeOutputTimesteps         = SafeInt(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_SA_TIMESTEPS_COLUMN_NAME]);
            this.m_SummaryStateAttributeOutputAges              = DataTableUtilities.GetDataBool(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_SA_AGES_COLUMN_NAME]);
            this.m_CreateSummaryTransitionAttributeOutput       = DataTableUtilities.GetDataBool(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_TA_COLUMN_NAME]);
            this.m_SummaryTransitionAttributeOutputTimesteps    = SafeInt(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_TA_TIMESTEPS_COLUMN_NAME]);
            this.m_SummaryTransitionAttributeOutputAges         = DataTableUtilities.GetDataBool(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_TA_AGES_COLUMN_NAME]);
            this.m_CreateSummaryExternalVariableOutput          = DataTableUtilities.GetDataBool(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_EV_COLUMN_NAME]);
            this.m_SummaryExternalVariableOutputTimesteps       = SafeInt(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_EV_TIMESTEPS_COLUMN_NAME]);
            this.m_CreateSummaryTSTOutput     = DataTableUtilities.GetDataBool(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_TST_COLUMN_NAME]);
            this.m_SummaryTSTOutputTimesteps  = SafeInt(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_TST_TIMESTEPS_COLUMN_NAME]);
            this.m_SummaryOmitSecondaryStrata = DataTableUtilities.GetDataBool(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_OMIT_SS_COLUMN_NAME]);
            this.m_SummaryOmitTertiaryStrata  = DataTableUtilities.GetDataBool(droo[Strings.DATASHEET_OO_SUMMARY_OUTPUT_OMIT_TS_COLUMN_NAME]);

            if (this.m_SummaryTransitionOutputAsIntervalMean)
            {
                DataSheet ds = this.Project.GetDataSheet(Strings.DATASHEET_SIZE_CLASS_NAME);

                if (ds.GetData().Rows.Count > 0)
                {
                    this.RecordStatus(StatusType.Information,
                                      "Transition Summary Output won't include size information if Interval Mean selected.");
                }
            }
        }
Пример #8
0
        private void FillInitialStocksNonSpatial()
        {
            Debug.Assert(this.m_InitialStocksNonSpatial.Count == 0);
            DataSheet ds = this.ResultScenario.GetDataSheet(Constants.DATASHEET_INITIAL_STOCK_NON_SPATIAL);

            foreach (DataRow dr in ds.GetData().Rows)
            {
                this.m_InitialStocksNonSpatial.Add(
                    new InitialStockNonSpatial(
                        Convert.ToInt32(dr[ds.PrimaryKeyColumn.Name], CultureInfo.InvariantCulture),
                        Convert.ToInt32(dr[Constants.STOCK_TYPE_ID_COLUMN_NAME], CultureInfo.InvariantCulture),
                        Convert.ToInt32(dr[Constants.STATE_ATTRIBUTE_TYPE_ID_COLUMN_NAME], CultureInfo.InvariantCulture)));
            }
        }
Пример #9
0
        private void UpdateOutputDataSheet(int iteration, int timestep)
        {
            DataSheet ds            = this.ResultScenario.GetDataSheet("Circuitscape_OutputFile");
            string    OutFolderName = this.Library.GetFolderName(LibraryFolderType.Output, ds, true);
            string    BaseName      = string.Format(CultureInfo.InvariantCulture, "Circuitscape-It{0}-Ts{1}_cum_curmap", iteration, timestep);
            string    AsciiName     = Path.Combine(OutFolderName, BaseName + ".asc");
            string    TifName       = Path.Combine(OutFolderName, BaseName + ".tif");

            Spatial.ConvertFromAAIGridFormat(AsciiName, TifName, GeoTiffCompressionType.DEFLATE);

            DataTable dt = ds.GetData();

            dt.Rows.Add(new object[] { iteration, timestep, Path.GetFileName(TifName) });
        }
Пример #10
0
        private static string CreateRawChartDataQueryForGroup(
            DataSheet dataSheet,
            ChartDescriptor descriptor,
            string variableName)
        {
            Debug.Assert(dataSheet.Scenario.Id > 0);

            Debug.Assert(
                variableName == STOCK_GROUP_VAR_NAME ||
                variableName == STOCK_GROUP_DENSITY_VAR_NAME ||
                variableName == FLOW_GROUP_VAR_NAME ||
                variableName == FLOW_GROUP_DENSITY_VAR_NAME);

            string ScenarioClause = string.Format(CultureInfo.InvariantCulture,
                                                  "([{0}]={1})",
                                                  Constants.SCENARIO_ID_COLUMN_NAME, dataSheet.Scenario.Id);

            string SumStatement = string.Format(CultureInfo.InvariantCulture,
                                                "SUM([{0}]) AS {1}",
                                                descriptor.ColumnName, Constants.SUM_OF_AMOUNT_COLUMN_NAME);

            string WhereClause = ScenarioClause;

            if (!string.IsNullOrEmpty(descriptor.DisaggregateFilter))
            {
                WhereClause = string.Format(CultureInfo.InvariantCulture,
                                            "{0} AND ({1})",
                                            WhereClause, descriptor.DisaggregateFilter);
            }

            if (!string.IsNullOrEmpty(descriptor.IncludeDataFilter))
            {
                WhereClause = string.Format(CultureInfo.InvariantCulture,
                                            "{0} AND ({1})",
                                            WhereClause, descriptor.IncludeDataFilter);
            }

            string query = string.Format(CultureInfo.InvariantCulture,
                                         "SELECT {0},{1},{2} FROM {3} WHERE {4} GROUP BY [{5}],[{6}]",
                                         Constants.ITERATION_COLUMN_NAME,
                                         Constants.TIMESTEP_COLUMN_NAME,
                                         SumStatement,
                                         descriptor.DatasheetName,
                                         WhereClause,
                                         Constants.ITERATION_COLUMN_NAME,
                                         Constants.TIMESTEP_COLUMN_NAME);

            return(query);
        }
Пример #11
0
        private void FillActualDeathCollection(DateTime startDate)
        {
            Debug.Assert(this.m_ActualDeaths.Count == 0);
            DataSheet ds = this.ResultScenario.GetDataSheet(Shared.DATASHEET_ACTUAL_DEATH_NAME);

            foreach (DataRow dr in ds.GetData().Rows)
            {
                int?timestep = null;

                if (!TimestepFromDateTime(dr, startDate, out timestep))
                {
                    continue;
                }

                DistributionFrequency?df = null;

                if (dr[Shared.DISTRIBUTION_FREQUENCY_COLUMN_NAME] != DBNull.Value)
                {
                    df = (DistributionFrequency)(long)dr[Shared.DISTRIBUTION_FREQUENCY_COLUMN_NAME];
                }

                ActualDeath Item = new ActualDeath(
                    Shared.GetNullableInt(dr, Shared.ITERATION_COLUMN_NAME),
                    timestep,
                    Shared.GetNullableInt(dr, Shared.JURISDICTION_COLUMN_NAME),
                    Shared.GetNullableDouble(dr, Shared.VALUE_COLUMN_NAME),
                    Shared.GetNullableInt(dr, Shared.DISTRIBUTION_TYPE_COLUMN_NAME),
                    df,
                    Shared.GetNullableDouble(dr, Shared.DISTRIBUTIONSD_COLUMN_NAME),
                    Shared.GetNullableDouble(dr, Shared.DISTRIBUTIONMIN_COLUMN_NAME),
                    Shared.GetNullableDouble(dr, Shared.DISTRIBUTIONMAX_COLUMN_NAME));

                try
                {
                    this.m_DistributionProvider.Validate(
                        Item.DistributionTypeId,
                        Item.DistributionValue,
                        Item.DistributionSD,
                        Item.DistributionMin,
                        Item.DistributionMax);

                    this.m_ActualDeaths.Add(Item);
                }
                catch (Exception ex)
                {
                    throw new ArgumentException(ds.DisplayName + " -> " + ex.Message);
                }
            }
        }
 /* When a new type is chosen in the dialog, switch visibilities */
 private void HandleDataSheetChanged(DataSheet dataSheet)
 {
     if (dataSheet is HeatingUnitDataSheet || dataSheet is SolarCollectorDataSheet)
     {
         IsHeatingOrSolar = true;
         IsContainer      = false;
         OnPropertyChanged("IsWaterContainer");
     }
     else if (dataSheet is ContainerDataSheet)
     {
         IsContainer      = true;
         IsHeatingOrSolar = false;
         IsWaterContainer = false; /* We don't know this yet, so just default it */
     }
 }
Пример #13
0
        public DataSheet Read(string name)
        {
            var sheet = mWorkbook.GetSheet(name);

            var dsheet = new DataSheet() { Name = sheet.SheetName };
            var titles = (from cell in sheet.GetRow(mTitleRow).Cells
                          where !string.IsNullOrEmpty(cell.StringCellValue)
                          select new KeyValuePair<int, string>(cell.ColumnIndex, cell.StringCellValue)).ToArray();
            for (int i = mContentRow, last = sheet.LastRowNum; i <= last; ++i)
            {
                var row = sheet.GetRow(i);
                if (row != null) dsheet.Rows.Add(ReadRow(row, titles));
            }
            return dsheet;
        }
Пример #14
0
        private void RefreshDateTimeControls()
        {
            DataSheet ds = this.Scenario.GetDataSheet(Shared.DATASHEET_RUN_CONTROL_NAME);
            DataRow   dr = ds.GetDataRow();

            if (dr != null && dr[Shared.DATASHEET_RUN_CONTROL_START_DATE_COLUMN_NAME] != DBNull.Value)
            {
                this.DateTimeStart.Value = (DateTime)dr[Shared.DATASHEET_RUN_CONTROL_START_DATE_COLUMN_NAME];
            }

            if (dr != null && dr[Shared.DATASHEET_RUN_CONTROL_END_DATE_COLUMN_NAME] != DBNull.Value)
            {
                this.DateTimeEnd.Value = (DateTime)dr[Shared.DATASHEET_RUN_CONTROL_END_DATE_COLUMN_NAME];
            }
        }
Пример #15
0
        private void OnGridCellBeginEdit(object sender, DataGridViewCellCancelEventArgs e)
        {
            if (e.ColumnIndex == this.m_Grid.Columns[Strings.DATASHEET_TRANSITION_GROUP_ID_COLUMN_NAME].Index)
            {
                DataGridViewRow          dgv    = this.m_Grid.Rows[e.RowIndex];
                DataSheet                ds     = this.Project.GetDataSheet(Strings.DATASHEET_TRANSITION_GROUP_NAME);
                string                   filter = "IsAuto IS NULL OR IsAuto=0";
                DataView                 dv     = new DataView(ds.GetData(), filter, ds.DisplayMember, DataViewRowState.CurrentRows);
                DataGridViewComboBoxCell Cell   = (DataGridViewComboBoxCell)dgv.Cells[Strings.DATASHEET_TRANSITION_GROUP_ID_COLUMN_NAME];

                Cell.DataSource    = dv;
                Cell.ValueMember   = ds.ValueMember;
                Cell.DisplayMember = ds.DisplayMember;
            }
        }
Пример #16
0
        private void InitUserInteractive()
        {
            DataSheet ds = this.Library.GetDataSheet(Shared.APPLICATION_DATASHEET_NAME);
            DataRow   dr = ds.GetDataRow();

            if (dr == null || dr[Shared.APPLICATION_DATASHEET_USER_INTERACTIVE_COLUMN_NAME] == DBNull.Value)
            {
                this.m_IsUserInteractive = false;
            }
            else
            {
                this.m_IsUserInteractive = Booleans.BoolFromValue(
                    dr[Shared.APPLICATION_DATASHEET_USER_INTERACTIVE_COLUMN_NAME]);
            }
        }
Пример #17
0
        public static Dictionary <int, bool> CreateRecordLookup(DataSheet ds, string colName)
        {
            Dictionary <int, bool> d = new Dictionary <int, bool>();
            DataTable dt             = ds.GetData();

            foreach (DataRow dr in dt.Rows)
            {
                if (dr.RowState != DataRowState.Deleted)
                {
                    d.Add(Convert.ToInt32(dr[colName], CultureInfo.InvariantCulture), true);
                }
            }

            return(d);
        }
        private IEnumerable <ParsedDataSet> buildDataSets(DataSheet dataSheet, IEnumerable <string> groupingParameters, Cache <string, ColumnInfo> columnInfos)
        {
            var cachedUnformattedRows = new Cache <string, List <UnformattedRow> >();

            foreach (var row in dataSheet.GetRows(_ => true))
            {
                var id = rowId(groupingParameters, dataSheet, row);
                if (!cachedUnformattedRows.Contains(id))
                {
                    cachedUnformattedRows.Add(id, new List <UnformattedRow>());
                }
                cachedUnformattedRows[id].Add(row);
            }
            return(cachedUnformattedRows.Select(rows => new ParsedDataSet(groupingParameters, dataSheet, rows, parseMappings(rows, dataSheet, columnInfos))));
        }
Пример #19
0
 private AcukwikDataSet.AcukwikAirportsDataTable AttemptToConvertFormat(DataSheet supportedDataSheet, DataTable uploadedSheetTable)
 {
     AcukwikDataSet.AcukwikAirportsDataTable result = new AcukwikDataSet.AcukwikAirportsDataTable();
     try
     {
         if (!supportedDataSheet.PopulateRowsFromData(result, uploadedSheetTable))
         {
             return(null);
         }
     }
     catch (Exception exception)
     {
         throw new Exception(exception.ToString());
     }
     return(result);
 }
Пример #20
0
 private SchedulingDataSet.SchedulingImportsDataTable AttemptToConvertFormat(DataSheet supportedDataSheet)
 {
     SchedulingDataSet.SchedulingImportsDataTable result = new SchedulingDataSet.SchedulingImportsDataTable();
     try
     {
         if (!supportedDataSheet.PopulateRowsFromData(result, _UploadedSheetTable))
         {
             return(null);
         }
     }
     catch (Exception exception)
     {
         throw new Exception(exception.ToString());
     }
     return(result);
 }
Пример #21
0
        private void ButtonChooseTemplate_Click(object sender, System.EventArgs e)
        {
            OpenFileDialog dlg = new OpenFileDialog();

            dlg.Title  = "Choose File";
            dlg.Filter = "NetLogo Files|*.nlogo";

            if (dlg.ShowDialog(this) == DialogResult.OK)
            {
                DataSheet ds = this.DataFeed.GetDataSheet("netlogo_Script");

                ds.AddExternalInputFile(dlg.FileName);
                ds.SetSingleRowData("TemplateFile", Path.GetFileName(dlg.FileName));
                this.RefreshBoundControls();
            }
        }
Пример #22
0
        private void FillFlowMultiplierTypes()
        {
            Debug.Assert(this.m_FlowMultiplierTypes.Count == 0);
            DataSheet ds = this.Project.GetDataSheet(Constants.DATASHEET_FLOW_MULTIPLIER_TYPE_NAME);

            //Always add type with a Null Id because flow multipliers can have null types.
            this.m_FlowMultiplierTypes.Add(new FlowMultiplierType(null, this.ResultScenario, this.m_STSimTransformer.DistributionProvider));

            foreach (DataRow dr in ds.GetData().Rows)
            {
                int FlowMultiplierTypeId = Convert.ToInt32(dr[ds.PrimaryKeyColumn.Name], CultureInfo.InvariantCulture);

                this.m_FlowMultiplierTypes.Add(new FlowMultiplierType
                                                   (FlowMultiplierTypeId, this.ResultScenario, this.m_STSimTransformer.DistributionProvider));
            }
        }
        public IEnumerable <ParsedDataSet> Parse(DataSheet dataSheet, ColumnInfoCache columnInfos)
        {
            var missingColumns = Parameters.Where(p => p.ComesFromColumn() && dataSheet.GetColumnDescription(p.ColumnName) == null).Select(p => p.ColumnName).ToList();

            if (missingColumns.Any())
            {
                throw new MissingColumnException(dataSheet.SheetName, missingColumns);
            }

            var groupingCriteria =
                Parameters
                .Where(p => p.IsGroupingCriterion())
                .Select(p => p.ColumnName);

            return(buildDataSets(dataSheet, groupingCriteria, columnInfos));
        }
Пример #24
0
        private string CreateQuickViewTitle()
        {
            StringBuilder      sb = new StringBuilder();
            FlowPathwayDiagram d  = this.GetFlowDiagram();
            DataSheet          ds = this.DataFeed.Project.GetDataSheet(Constants.DATASHEET_STOCK_TYPE_NAME);

            sb.AppendFormat(CultureInfo.InvariantCulture, "{0} - ", this.DataFeed.Scenario.DisplayName);

            foreach (StockTypeShape s in d.SelectedShapes)
            {
                object v = DataTableUtilities.GetTableValue(ds.GetData(), ds.ValueMember, s.StockTypeId, ds.DisplayMember);
                sb.AppendFormat(CultureInfo.InvariantCulture, "{0},", Convert.ToString(v, CultureInfo.InvariantCulture));
            }

            return(sb.ToString().Trim(','));
        }
Пример #25
0
 protected override void Context()
 {
     sut           = new MixColumnsDataFormat();
     _rawDataSheet = A.Fake <DataSheet>();
     A.CallTo(() => _rawDataSheet.GetHeaders()).ReturnsLazily(() => _headers);
     A.CallTo(() => _rawDataSheet.GetColumnDescription(A <string> .Ignored)).Returns(new ColumnDescription(0)
     {
         Level = ColumnDescription.MeasurementLevel.Numeric
     });
     _columnInfos = new ColumnInfoCache
     {
         new ColumnInfo {
             DisplayName = "Time", Name = "Time"
         },
         new ColumnInfo {
             DisplayName = "Concentration", Name = "Concentration"
         },
         new ColumnInfo {
             DisplayName = "Error", Name = "Error", IsMandatory = false, RelatedColumnOf = "Concentration"
         }
     };
     _columnInfos["Time"].SupportedDimensions.Add(DimensionFactoryForSpecs.TimeDimension);
     _columnInfos["Concentration"].SupportedDimensions.Add(DimensionFactoryForSpecs.ConcentrationDimension);
     _columnInfos["Error"].SupportedDimensions.Add(DimensionFactoryForSpecs.ConcentrationDimension);
     _metaDataCategories = new List <MetaDataCategory>()
     {
         new MetaDataCategory {
             Name = "Organ"
         },
         new MetaDataCategory {
             Name = "Compartment"
         },
         new MetaDataCategory {
             Name = "Species"
         },
         new MetaDataCategory {
             Name = "Dose"
         },
         new MetaDataCategory {
             Name = "Molecule"
         },
         new MetaDataCategory {
             Name = "Route"
         }
     };
 }
Пример #26
0
        private void SetSpatialOutputDefaults(int MaxTimestep)
        {
            Debug.Assert(this.m_IsSpatial);
            DataSheet dsoo = this.ResultScenario.GetDataSheet(Strings.DATASHEET_OO_SPATIAL_NAME);
            DataRow   droo = dsoo.GetDataRow();

            if (droo == null)
            {
                droo = dsoo.GetData().NewRow();
                dsoo.GetData().Rows.Add(droo);
            }

            DataTableUtilities.SetRowValue(droo, Strings.DATASHEET_OO_SPATIAL_RASTER_OUTPUT_SC_COLUMN_NAME, Booleans.BoolToInt(true));
            DataTableUtilities.SetRowValue(droo, Strings.DATASHEET_OO_SPATIAL_RASTER_OUTPUT_SC_TIMESTEPS_COLUMN_NAME, MaxTimestep);
            DataTableUtilities.SetRowValue(droo, Strings.DATASHEET_OO_SPATIAL_RASTER_OUTPUT_TR_COLUMN_NAME, Booleans.BoolToInt(true));
            DataTableUtilities.SetRowValue(droo, Strings.DATASHEET_OO_SPATIAL_RASTER_OUTPUT_TR_TIMESTEPS_COLUMN_NAME, MaxTimestep);
        }
Пример #27
0
        private static void RefreshChartTSTClassValidationTable(string dataSheetName, Project project)
        {
            foreach (Scenario s in project.Results)
            {
                DataSheet       ds  = s.GetDataSheet(dataSheetName);
                DataSheetColumn col = ds.Columns[Strings.DATASHEET_TST_CLASS_COLUMN_NAME];

                col.ValidationTable = CreateClassBinValidationTable(
                    project,
                    Strings.DATASHEET_TST_TYPE_NAME,
                    Strings.DATASHEET_TST_TYPE_FREQUENCY_COLUMN_NAME,
                    Strings.DATASHEET_TST_TYPE_MAXIMUM_COLUMN_NAME,
                    Strings.DATASHEET_TST_GROUP_NAME,
                    Strings.DATASHEET_TST_GROUP_MAXIMUM_COLUMN_NAME,
                    Strings.TST_CLASS_VALIDATION_TABLE_NAME);
            }
        }
        public DataSheetCollection GetDataSheetCollection(int schedulingId)
        {
            XmlDocument         document   = GetTemplateDocument(schedulingId);
            DataSheetCollection collection = new DataSheetCollection();

            if (document == null)
            {
                return(collection);
            }
            foreach (XmlNode node in document.SelectNodes("//SchedulingSheets/SchedulingSheet"))
            {
                DataSheet sheet = new DataSheet();
                sheet.LoadFromNode(node);
                collection.Add(sheet);
            }
            return(collection);
        }
Пример #29
0
        public DataSheetCollection GetDataSheetCollection(string acukwikName)
        {
            XmlDocument         document   = GetTemplateDocument(acukwikName);
            DataSheetCollection collection = new DataSheetCollection();

            if (document == null)
            {
                return(collection);
            }
            foreach (XmlNode node in document.SelectNodes("//AcukwikSheets/AcukwikSheet"))
            {
                DataSheet sheet = new DataSheet();
                sheet.LoadFromNode(node);
                collection.Add(sheet);
            }
            return(collection);
        }
Пример #30
0
        public DataSheetCollection GetDataSheetCollection(string clientName, string supplierName)
        {
            XmlDocument         document   = GetTemplateDocument(clientName, supplierName);
            DataSheetCollection collection = new DataSheetCollection();

            if (document == null)
            {
                return(collection);
            }
            foreach (XmlNode node in document.SelectNodes("//FuelSheets/FuelSheet"))
            {
                DataSheet sheet = new DataSheet();
                sheet.LoadFromNode(node);
                collection.Add(sheet);
            }
            return(collection);
        }
Пример #31
0
        public static string GetJurisdictionLabel(DataSheet terminologyDataSheet)
        {
            DataRow dr = terminologyDataSheet.GetDataRow();
            string  JurisdictionLabel = "Jurisdiction";

            if (dr != null)
            {
                if (dr[Shared.DATASHEET_TERMINOLOGY_JURISDICTION_LABEL_COLUMN_NAME] != DBNull.Value)
                {
                    JurisdictionLabel = Convert.ToString(
                        dr[Shared.DATASHEET_TERMINOLOGY_JURISDICTION_LABEL_COLUMN_NAME],
                        CultureInfo.InvariantCulture);
                }
            }

            return(JurisdictionLabel);
        }
Пример #32
0
        private void FillFlowTypes()
        {
            Debug.Assert(this.m_FlowTypes.Count == 0);
            DataSheet ds = this.Project.GetDataSheet(Constants.DATASHEET_FLOW_TYPE_NAME);

            foreach (DataRow dr in ds.GetData().Rows)
            {
                this.m_FlowTypes.Add(
                    new FlowType(
                        Convert.ToInt32(dr[ds.PrimaryKeyColumn.Name], CultureInfo.InvariantCulture),
                        Convert.ToString(dr[ds.DisplayMember], CultureInfo.InvariantCulture)));
            }

#if DEBUG
            this.m_FlowTypesFilled = true;
#endif
        }
        protected override UnitDescription ExtractUnits(string description, DataSheet dataSheet, List <string> keys, IReadOnlyList <IDimension> supportedDimensions, ref double rank)
        {
            var(_, unit) = UnitExtractor.ExtractNameAndUnit(description);

            if (string.IsNullOrEmpty(unit))
            {
                return(new UnitDescription());
            }

            unit = ValidateUnit(unit, supportedDimensions);
            if (unit != UnitDescription.InvalidUnit)
            {
                rank++;
            }

            return(new UnitDescription(unit));
        }
Пример #34
0
        public void Write(DataSheet dsheet)
        {
            if (dsheet.Rows.Count == 0) return;

            var sheet = mWorkbook.GetSheet(dsheet.Name);
            if (sheet == null) sheet = CreateSheet(dsheet);

            var titleRow = sheet.GetRow(mTitleRow);
            foreach (var newTitle in dsheet.Rows[0].Keys.Except(titleRow.Cells.Select(c => c.StringCellValue)))
            {
                titleRow.CreateCell(titleRow.LastCellNum).SetCellValue(newTitle);
            }

            var titles = (from cell in titleRow.Cells
                          where !string.IsNullOrEmpty(cell.StringCellValue)
                          select new KeyValuePair<int, string>(cell.ColumnIndex, cell.StringCellValue)).ToArray();
            for (int i = mContentRow, end = mContentRow + dsheet.Rows.Count; i < end; ++i)
            {
                var row = sheet.GetRow(i);
                if (row == null) row = sheet.CreateRow(i);
                WriteRow(row, dsheet.Rows[i - mContentRow], titles);
            }
            for (int i = mContentRow + dsheet.Rows.Count, last = sheet.LastRowNum; i <= last; ++i)
            {
                var row = sheet.GetRow(i);
                if (row != null) sheet.RemoveRow(row);
            }
        }
Пример #35
0
        private ISheet CreateSheet(DataSheet dsheet)
        {
            var sheet = mWorkbook.CreateSheet(dsheet.Name);
            for (var i = 0; i < mContentRow; ++i) sheet.CreateRow(i);

            var columnNames = dsheet.Rows[0].Keys.OrderBy(k => k).ToArray();
            var titleRow = sheet.GetRow(mTitleRow);
            for (var i = 0; i < columnNames.Length; ++i)
            {
                titleRow.CreateCell(i).SetCellValue(columnNames[i]);
            }

            return sheet;
        }
Пример #36
0
        private void MergeSheet(DataSheet destSheet, DataSheet srcSheet, string primaryKey)
        {
            CheckSheetConsistence(destSheet);
            CheckSheetConsistence(srcSheet);

            EnsureSheetHaveColumns(destSheet, srcSheet.Rows[0].Keys);

            var id2DestRow = new Dictionary<object, Dictionary<string, object>>();
            foreach (var destRow in destSheet.Rows) id2DestRow[destRow[primaryKey]] = destRow;

            foreach (var srcRow in srcSheet.Rows)
            {
                var id = srcRow[primaryKey];
                if (!id2DestRow.ContainsKey(id))
                {
                    throw new Exception(string.Format("Can't find primary key in dest sheet: {0}", id));
                }

                Dictionary<string, object> destRow = id2DestRow[srcRow[primaryKey]];
                foreach (var kv in srcRow)
                {
                    destRow[kv.Key] = kv.Value;
                }
            }
        }
Пример #37
0
        public override void Execute()
        {
            Log.Info("Start to replace string literals ...");

            Log.Info("Read filter from: {0}", FilterPath);

            string className = Path.GetFileNameWithoutExtension(ResultPath);
            var filter = new HashSet<string>(File.ReadAllLines(FilterPath, Encoding.UTF8));
            var str2Field = new Dictionary<string, string>(1024);

            foreach (var path in GetCSharpFiles(CSharpSrcDirectories))
            {
                Log.Info("\tProcessing file: {0}", path);

                var encoding = Utils.DetectFileEncoding(path);
                var oldText = File.ReadAllText(path, encoding);
                var newText = NRefactoryTool.CodeTransform.ReplaceStringLiteralsWithVariables(oldText, Macros,
                (line, column, lineText, s) =>
                {
                    if (!filter.Contains(string.Format("{0}({1},{2}):{3}", path, line, column, NRefactoryTool.Utils.EscapeString(lineText)))) return null;

                    string field;
                    if (str2Field.TryGetValue(s, out field)) return field;

                    field = string.Format("{0}.kString_{1}", className, str2Field.Count);
                    str2Field.Add(s, field);
                    return field;
                });

                if (oldText != newText)
                {
                    Log.Info("\tPerform replacement!");
                    File.WriteAllText(path, newText, encoding);
                }
            }

            Log.Info("Write sheet to: {0}", ResultPath);

            var sheet = new DataSheet
            {
                Name = className,
                Rows = (from kv in str2Field
                        let fieldName = kv.Value.Split('.').Last()
                        orderby fieldName
                        select new Dictionary<string, object>(){
                              {kNameKey, fieldName },
                              {kDefaultLangKey, kv.Key}
                          }).ToList(),
            };
            File.WriteAllText(ResultPath, JsonOperation.SerializeSheets(new[] { sheet }), Encoding.UTF8);

            Log.Info("Done.");
        }