public virtual FileReportOutput GenerateReport(RunFileReportRequest request)
{
FileReportOutput fileReportOutput = new FileReportOutput();
string fileName = GenerateReportIntoFile(request);
fileReportOutput.OutputFilePath = fileName;
return(fileReportOutput);
}
public FileReportOutput GenerateReport(RunFileReportRequest request)
{
InitReport(request);
ThrowIfInvalidInputTimeSeries();
var inputFields = GetInputFields();
var fileName = WriteValuesToFile(inputFields);
return(MakeReportOutput(fileName));
}
public virtual DataSet GenerateDataSet(RunFileReportRequest request)
{
Assembly.Load("PerpetuumSoft.Reporting.MSChart");
string location = System.IO.Path.GetDirectoryName(_Assembly.Location);
string name = System.IO.Path.GetFileNameWithoutExtension(_Assembly.Location);
FileVersionInfo fileVersionInfo = System.Diagnostics.FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location);
Log.InfoFormat("Report plugin folder = {0}, plugin name = {1}, plugin version = {2}", location, name, fileVersionInfo.ProductVersion);
System.Data.DataSet reportTables = (new Common(request)).GetCommonDataSet(name, location);
AddReportSpecificTables(reportTables);
return(reportTables);
}
public static void AddReportSpecificTables(DataSet dataSet)
{
try
{
RunFileReportRequest runReportRequest = (RunFileReportRequest)dataSet.Tables["RunReportRequest"].Rows[0]["RunReportRequest"];
Common common = (Common)dataSet.Tables["RunReportRequest"].Rows[0]["CommonLibrary"];
common.CheckReportDefinitionVersion("2");
DataTable settingsTable = dataSet.Tables["ReportSettings"];
settingsTable.Columns.Add("ReportTitle", typeof(string));
settingsTable.Rows[0]["ReportTitle"] = "Daily Mean Discharge";
DataTable table = new DataTable("DailyMeanDischargeDataTable");
dataSet.Tables.Add(table);
}
catch (Exception exp)
{
Log.Error("Error creating report specific data tables ", exp);
throw exp;
}
}
public static void AddReportSpecificTables(DataSet dataSet)
{
try
{
if (dataSet.Tables.Contains("DischargeTimeSeriesFromRatingCurve"))
{
dataSet.Tables["DischargeTimeSeriesFromRatingCurve"].TableName = "SourceData";
dataSet.Tables["DischargeTimeSeriesFromRatingCurveLocation"].TableName = "SourceDataLocation";
dataSet.Tables["DischargeTimeSeriesFromRatingCurveLocationExtendedAttributes"].TableName = "SourceDataLocationExtendedAttributes";
}
Common common = (Common)dataSet.Tables["RunReportRequest"].Rows[0]["CommonLibrary"];
DataTable settingsTable = dataSet.Tables["ReportSettings"];
settingsTable.Columns.Add("ReportTitle", typeof(string));
settingsTable.Rows[0]["ReportTitle"] = Resources.ContinuousDataProduction;
DataTable table = new DataTable("ContinuousDataProductionDataTable");
dataSet.Tables.Add(table);
RunFileReportRequest runReportRequest = (RunFileReportRequest)dataSet.Tables["RunReportRequest"].Rows[0]["RunReportRequest"];
IPublishGateway publish = runReportRequest.Publish;
Guid timeSeriesUniqueId = (Guid)dataSet.Tables["SourceData"].Rows[0]["UniqueId"];
string dllName = (string)dataSet.Tables["RunReportRequest"].Rows[0]["DllName"];
Log.DebugFormat("{0} - Document GenerateScript input = {1}", dllName, timeSeriesUniqueId);
///////////////////////////////////////////////////////////////
string timeseriesType = (string)dataSet.Tables["SourceData"].Rows[0]["TimeSeriesType"];
if (timeseriesType != "ProcessorDerived")
{
throw (new Exception("Input is not a derived time-series. Input signal must be a rating curve derived time-series."));
}
Server.Services.PublishService.ServiceModel.RequestDtos.UpchainProcessorListByTimeSeriesServiceRequest upchain = new Server.Services.PublishService.ServiceModel.RequestDtos.UpchainProcessorListByTimeSeriesServiceRequest();
upchain.TimeSeriesUniqueId = timeSeriesUniqueId;
List <Server.Services.PublishService.ServiceModel.Dtos.Processor> processors = publish.Get(upchain).Processors;
string ratingModelIdentifier = "";
foreach (Server.Services.PublishService.ServiceModel.Dtos.Processor processor in processors)
{
if (string.IsNullOrEmpty(processor.InputRatingModelIdentifier))
{
continue;
}
if (processor.InputTimeSeriesUniqueIds.Count == 0)
{
continue;
}
ratingModelIdentifier = processor.InputRatingModelIdentifier;
break;
}
if (string.IsNullOrEmpty(ratingModelIdentifier))
{
throw (new Exception("Input is not a rating model derived time-series. Input time-series must be a derived from a rating model."));
}
double tableIncrement = common.GetParameterDouble("TableIncrement", 0.1);
int httpRepeatCallLimit = common.GetParameterInt("HttpRepeatCallLimit", 4);
int httpCallLimitSize = common.GetParameterInt("HttpCallLimitSize", 2000);
int httpCallTimeoutInSeconds = common.GetParameterInt("HttpCallTimeoutInSeconds", 30);
string httpUrlPrefix = common.GetParameterString("HttpUrlPrefix",
@"http://geo.weather.gc.ca/geomet/features/collections/hydrometric-daily-mean/items?f=json&STATION_NUMBER=");
TimeSpan timezone = TimeSpan.FromHours(common.GetTimeSeriesDescription(timeSeriesUniqueId).UtcOffset);
DateTimeOffsetInterval selectedInterval = (DateTimeOffsetInterval)dataSet.Tables["ReportData"].Rows[0]["SelectedInterval"];
DateTimeOffset ReportTime = DateTimeOffset.Now;
if (selectedInterval.End.HasValue)
{
ReportTime = selectedInterval.End.Value.ToOffset(timezone);
}
else
{
ReportTime = DateTimeOffset.Now.ToOffset(timezone);
}
string locationIdentifier = common.GetTimeSeriesDescription(timeSeriesUniqueId).LocationIdentifier;
int numberOfHistoricalPoints = ReportSpecificFunctions.GetNumberOfHistoricalPointsAvailable(
httpUrlPrefix, locationIdentifier, httpRepeatCallLimit, httpCallTimeoutInSeconds);
settingsTable.Columns.Add("NumberOfHistoricalPoints", typeof(int));
settingsTable.Rows[0]["NumberOfHistoricalPoints"] = numberOfHistoricalPoints;
}
catch (Exception exp)
{
Log.Error("Error creating report specific data tables ", exp);
throw exp;
}
}
public static void AddReportSpecificTables(DataSet dataSet)
{
try
{
Common common = (Common)dataSet.Tables["RunReportRequest"].Rows[0]["CommonLibrary"];
DataTable settingsTable = dataSet.Tables["ReportSettings"];
settingsTable.Columns.Add("ReportTitle", typeof(string));
settingsTable.Rows[0]["ReportTitle"] = Resources.BenchmarkHistory;
DataTable table = new DataTable("BenchmarkHistoryDataTable");
dataSet.Tables.Add(table);
RunFileReportRequest runReportRequest = (RunFileReportRequest)dataSet.Tables["RunReportRequest"].Rows[0]["RunReportRequest"];
IPublishGateway publish = runReportRequest.Publish;
string locationIdentifier = (string)dataSet.Tables["LocationInput"].Rows[0]["Identifier"];
string dllName = (string)dataSet.Tables["RunReportRequest"].Rows[0]["DllName"];
Log.DebugFormat("{0} - Document GenerateScript input location = {1}", dllName, locationIdentifier);
///////////////////////////////////////////////////////////////
DateTimeOffsetInterval reportPeriod = (DateTimeOffsetInterval)dataSet.Tables["ReportPeriods"].Rows[0]["NoGroupBy"];
int formatPrecision = common.GetParameterInt("FormatPrecision", 3);
string formatType = common.GetParameterString("FormatType", "Fixed");
bool formatFixed = (formatType == "Fixed");
int groupSizeLimit = 6;
DataTable benchmarks = dataSet.Tables.Add("Benchmarks");
benchmarks.Columns.Add("Name", typeof(string));
benchmarks.Columns.Add("Elevation", typeof(string));
benchmarks.Columns.Add("DateConstructed", typeof(string));
benchmarks.Columns.Add("DateRemoved", typeof(string));
benchmarks.Columns.Add("Status", typeof(string));
benchmarks.Columns.Add("Description", typeof(string));
DataTable groupBy = dataSet.Tables.Add("GroupBy");
groupBy.Columns.Add("GroupNumber", typeof(int));
for (int i = 0; i < groupSizeLimit; i++)
{
groupBy.Columns.Add("Name" + (i + 1).ToString(), typeof(string));
}
DataTable benchmarkHistory = dataSet.Tables.Add("BenchmarkHistory");
benchmarkHistory.Columns.Add("GroupNumber", typeof(int));
benchmarkHistory.Columns.Add("DateTime", typeof(string));
benchmarkHistory.Columns.Add("Party", typeof(string));
benchmarkHistory.Columns.Add("Comments", typeof(string));
for (int i = 0; i < groupSizeLimit; i++)
{
benchmarkHistory.Columns.Add("Elevation" + (i + 1).ToString(), typeof(string));
benchmarkHistory.Columns.Add("Correction" + (i + 1).ToString(), typeof(string));
}
dataSet.Relations.Add("GroupByBenchmarkHistory", groupBy.Columns["GroupNumber"], benchmarkHistory.Columns["GroupNumber"]);
LocationDataServiceResponse locData = common.GetLocationData(locationIdentifier);
List <ReferencePoint> refPoints = new List <ReferencePoint>();
foreach (ReferencePoint refPoint in locData.ReferencePoints)
{
List <ReferencePointPeriod> refPointPeriods = refPoint.ReferencePointPeriods;
if (refPointPeriods.Count == 0)
{
continue;
}
refPointPeriods.Sort((x, y) => x.ValidFrom.CompareTo(y.ValidFrom));
DateTimeOffset validFrom = refPointPeriods[0].ValidFrom;
if (ReportSpecificFunctions.TimeRangeOverlaps(validFrom, refPoint.DecommissionedDate, reportPeriod))
{
refPoints.Add(refPoint);
}
}
if (refPoints.Count == 0)
{
return;
}
Dictionary <Guid, List <ReferencePointPeriod> > refPointHistories = new Dictionary <Guid, List <ReferencePointPeriod> >();
Dictionary <Guid, int> refPointNumbers = new Dictionary <Guid, int>();
for (int i = 0; i < refPoints.Count; i++)
{
ReferencePoint refPoint = refPoints[i];
refPointNumbers.Add(refPoint.UniqueId, i);
DataRow row = benchmarks.NewRow();
row["Name"] = refPoint.Name;
row["Description"] = refPoint.Description;
if (refPoint.DecommissionedDate.HasValue)
{
row["DateRemoved"] = refPoint.DecommissionedDate.Value.ToString("yyyy-MM-dd");
}
string status = (refPoint.DecommissionedDate.HasValue) ? Resources.InactiveLowerCase : Resources.ActiveLowerCase;
status += (refPoint.PrimarySinceDate.HasValue) ? " " + Resources.PrimaryLowerCase : "";
row["Status"] = status;
DateTimeOffset?primarySince = refPoint.PrimarySinceDate;
List <ReferencePointPeriod> refPointPeriods = refPoint.ReferencePointPeriods;
refPointPeriods.Sort((x, y) => x.ValidFrom.CompareTo(y.ValidFrom));
DateTimeOffset validFrom = refPointPeriods[0].ValidFrom;
row["DateConstructed"] = validFrom.ToString("yyyy-MM-dd");
double elevation = refPointPeriods[refPointPeriods.Count - 1].Elevation;
row["Elevation"] = Common.FormatDoubleValue(elevation, formatFixed, formatPrecision, "");
refPointPeriods.Reverse();
refPointHistories[refPoint.UniqueId] = refPointPeriods;
benchmarks.Rows.Add(row);
}
int numberOfGroups = (int)Math.Ceiling((double)benchmarks.Rows.Count / groupSizeLimit);
FieldVisitDataByLocationServiceRequest fdRequest = new FieldVisitDataByLocationServiceRequest();
fdRequest.LocationIdentifier = locationIdentifier;
fdRequest.Activities = new List <ActivityType> {
ActivityType.LevelSurvey
};
FieldVisitDataByLocationServiceResponse fdResponse = publish.Get(fdRequest);
List <FieldVisit> fieldVisitData = fdResponse.FieldVisitData;
try
{
fieldVisitData.Sort((x, y) => y.StartTime.Value.CompareTo(x.StartTime.Value));
}
catch { }
for (int i = 0; i < numberOfGroups; i++)
{
DataRow groupByRow = dataSet.Tables["GroupBy"].NewRow();
groupByRow["GroupNumber"] = i;
for (int j = 0; j < groupSizeLimit; j++)
{
int index = (i * groupSizeLimit) + j;
if (index < refPoints.Count)
{
ReferencePoint refPoint = refPoints[index];
groupByRow["Name" + (j + 1).ToString()] = refPoint.Name;
}
}
dataSet.Tables["GroupBy"].Rows.Add(groupByRow);
}
foreach (FieldVisit fieldVisit in fieldVisitData)
{
if (!ReportSpecificFunctions.TimeRangeOverlaps(fieldVisit.StartTime.Value, fieldVisit.StartTime.Value, reportPeriod))
{
continue;
}
string dateTime = fieldVisit.StartTime.Value.ToString("yyyy-MM-dd HH:mm");
string comments = fieldVisit.LevelSurveyActivity.Comments;
string party = fieldVisit.LevelSurveyActivity.Party;
int fieldVisitFirstRow = dataSet.Tables["BenchmarkHistory"].Rows.Count;
for (int i = 0; i < numberOfGroups; i++)
{
DataRow row = dataSet.Tables["BenchmarkHistory"].NewRow();
row["GroupNumber"] = i;
row["DateTime"] = dateTime;
row["Party"] = party;
row["Comments"] = comments;
dataSet.Tables["BenchmarkHistory"].Rows.Add(row);
}
List <LevelSurveyMeasurement> levelMeasurements = fieldVisit.LevelSurveyActivity.LevelMeasurements;
foreach (LevelSurveyMeasurement lsm in levelMeasurements)
{
if (!lsm.MeasuredElevation.Numeric.HasValue)
{
continue;
}
Guid id = lsm.ReferencePointUniqueId;
if (!refPointNumbers.ContainsKey(id))
{
continue;
}
int number = refPointNumbers[id];
int theGroupNumber = (int)Math.Floor((double)number / groupSizeLimit);
int thePosition = (int)(number % groupSizeLimit);
double level = lsm.MeasuredElevation.Numeric.Value;
double correction = ReportSpecificFunctions.calculateDifference(lsm, refPointHistories[id]);
DataRow row = dataSet.Tables["BenchmarkHistory"].Rows[fieldVisitFirstRow + theGroupNumber];
row["Elevation" + (1 + thePosition).ToString()] = Common.FormatDoubleValue(level, formatFixed, formatPrecision, "");
row["Correction" + (1 + thePosition).ToString()] = Common.FormatDoubleValue(correction, formatFixed, formatPrecision, "");
}
}
List <DataRow> emptyRows = new List <DataRow>();
for (int i = 0; i < dataSet.Tables["BenchmarkHistory"].Rows.Count; i++)
{
DataRow row = dataSet.Tables["BenchmarkHistory"].Rows[i];
int emptyCount = 0;
for (int j = 0; j < groupSizeLimit; j++)
{
bool empty = string.IsNullOrEmpty(row["Elevation" + (j + 1).ToString()].ToString());
if (empty)
{
emptyCount++;
}
}
if (emptyCount == groupSizeLimit)
{
emptyRows.Add(row);
}
}
for (int i = 0; i < emptyRows.Count; i++)
{
dataSet.Tables["BenchmarkHistory"].Rows.Remove(emptyRows[i]);
}
}
catch (Exception exp)
{
Log.Error("Error creating report specific data tables ", exp);
throw exp;
}
}
public DataTablesBuilder(RunFileReportRequest request, Common common)
{
_RunReportRequest = request;
_Common = common;
}
public static void AddReportSpecificTables(DataSet dataSet)
{
try
{
RunFileReportRequest runReportRequest = (RunFileReportRequest)dataSet.Tables["RunReportRequest"].Rows[0]["RunReportRequest"];
IPublishGateway publish = runReportRequest.Publish;
Guid TimeSeriesUniqueId = (Guid)dataSet.Tables["SourceData"].Rows[0]["UniqueId"];
string timeseriesType = (string)dataSet.Tables["SourceData"].Rows[0]["TimeSeriesType"];
if (timeseriesType != "ProcessorDerived")
{
throw (new Exception("Input is not a derived time-series. Input signal must be a daily mean derived time-series."));
}
Server.Services.PublishService.ServiceModel.RequestDtos.UpchainProcessorListByTimeSeriesServiceRequest upchain = new Server.Services.PublishService.ServiceModel.RequestDtos.UpchainProcessorListByTimeSeriesServiceRequest();
upchain.TimeSeriesUniqueId = TimeSeriesUniqueId;
List <Server.Services.PublishService.ServiceModel.Dtos.Processor> processors = publish.Get(upchain).Processors;
foreach (Server.Services.PublishService.ServiceModel.Dtos.Processor processor in processors)
{
string procType = processor.ProcessorType;
if (procType != "statistics")
{
throw (new Exception("Input is not a statistics derived time-series. Input signal must be a daily mean derived time-series."));
}
else
{
string requireCoverage = null;
string timeStep = null;
string timeStepCount = null;
string statType = null;
string coverageAmountPercent = "";
Dictionary <string, string> settings = processor.Settings;
foreach (var item in settings)
{
string key = item.Key;
string val = item.Value;
if (key == "StatisticType")
{
statType = item.Value;
}
if (key == "RequireMinimumCoverage")
{
requireCoverage = item.Value;
}
if (key == "TimeStep")
{
timeStep = item.Value;
}
if (key == "TimeStepCount")
{
timeStepCount = item.Value;
}
if (key == "MinimumCoverageRequiredForPartialGradeAsPercent")
{
coverageAmountPercent = item.Value;
}
}
if (("Daily" != timeStep) || ("1" != timeStepCount) || ("Mean" != statType))
{
throw (new Exception("Input is not a daily mean derived time-series. Input signal must be a daily mean derived time-series."));
}
ReportJobParameter coverageItem = null;
foreach (ReportJobParameter item in runReportRequest.Parameters)
{
if (item.Name == "DataCoverageThresholdPercent")
{
coverageItem = item;
break;
}
}
if (coverageItem != null)
{
runReportRequest.Parameters.Remove(coverageItem);
}
ReportJobParameter parm = new ReportJobParameter();
parm.Name = "DataCoverageThresholdPercent";
parm.Value = ("true" == requireCoverage) ? coverageAmountPercent : "";
runReportRequest.Parameters.Add(parm);
break;
}
}
Common common = (Common)dataSet.Tables["RunReportRequest"].Rows[0]["CommonLibrary"];
DataTable settingsTable = dataSet.Tables["ReportSettings"];
settingsTable.Columns.Add("ReportTitle", typeof(string));
settingsTable.Rows[0]["ReportTitle"] = "Daily Mean Discharge";
DataTable table = new DataTable("DailyMeanDischargeDataTable");
dataSet.Tables.Add(table);
}
catch (Exception exp)
{
Log.Error("Error creating report specific data tables ", exp);
throw exp;
}
}
public static void AddReportSpecificTables(DataSet dataSet)
{
try
{
Common common = (Common)dataSet.Tables["RunReportRequest"].Rows[0]["CommonLibrary"];
DataTable settingsTable = dataSet.Tables["ReportSettings"];
settingsTable.Columns.Add("ReportTitle", typeof(string));
settingsTable.Rows[0]["ReportTitle"] = Resources.Instrumentation;
DataTable table = new DataTable("InstrumentationDataTable");
dataSet.Tables.Add(table);
RunFileReportRequest runReportRequest = (RunFileReportRequest)dataSet.Tables["RunReportRequest"].Rows[0]["RunReportRequest"];
IPublishGateway publish = runReportRequest.Publish;
string locationIdentifier = (string)dataSet.Tables["LocationInput"].Rows[0]["Identifier"];
string dllName = (string)dataSet.Tables["RunReportRequest"].Rows[0]["DllName"];
Log.DebugFormat("{0} - Document GenerateScript input location = {1}", dllName, locationIdentifier);
///////////////////////////////////////////////////////////////
DateTimeOffsetInterval reportPeriod = (DateTimeOffsetInterval)dataSet.Tables["ReportPeriods"].Rows[0]["NoGroupBy"];
string sortOrder = common.GetParameterString("SortOrder", "ReverseChronologicalOnMeasurementTime");
DataTable table1 = dataSet.Tables.Add("Instrumentation");
table1.Columns.Add("Date", typeof(string));
table1.Columns.Add("Time", typeof(string));
table1.Columns.Add("Timezone", typeof(string));
table1.Columns.Add("ActivityType", typeof(string));
table1.Columns.Add("Stage", typeof(string));
table1.Columns.Add("StageUnit", typeof(string));
table1.Columns.Add("Discharge", typeof(string));
table1.Columns.Add("DischargeUnit", typeof(string));
table1.Columns.Add("ControlCondition", typeof(string));
table1.Columns.Add("ActivityRemarks", typeof(string));
table1.Columns.Add("FieldVisitComments", typeof(string));
table1.Columns.Add("Method", typeof(string));
table1.Columns.Add("InstrumentType", typeof(string));
table1.Columns.Add("Software", typeof(string));
table1.Columns.Add("Firmware", typeof(string));
table1.Columns.Add("SerialNumber", typeof(string));
table1.Columns.Add("Manufacturer", typeof(string));
table1.Columns.Add("Model", typeof(string));
ActiveMetersAndCalibrationsServiceRequest amcRequest = new ActiveMetersAndCalibrationsServiceRequest();
ActiveMetersAndCalibrationsServiceResponse amcResponse = publish.Get(amcRequest);
List <ActiveMeterDetails> activeMeterDetailsList = amcResponse.ActiveMeterDetails;
FieldVisitDataByLocationServiceRequest fdRequest = new FieldVisitDataByLocationServiceRequest();
fdRequest.LocationIdentifier = locationIdentifier;
fdRequest.Activities = new List <ActivityType> {
ActivityType.Reading, ActivityType.DischargeSummary, ActivityType.DischargePointVelocity, ActivityType.DischargeAdcp
};
fdRequest.ApplyRounding = true;
fdRequest.IncludeVerticals = true;
FieldVisitDataByLocationServiceResponse fdResponse = publish.Get(fdRequest);
List <FieldVisit> fieldVisitData = fdResponse.FieldVisitData;
try
{
if (sortOrder != "ReverseChronologicalOnMeasurementTime")
{
fieldVisitData.Sort((x, y) => x.StartTime.Value.CompareTo(y.StartTime.Value));
}
else
{
fieldVisitData.Sort((x, y) => y.StartTime.Value.CompareTo(x.StartTime.Value));
}
}
catch { }
foreach (FieldVisit fieldVisit in fieldVisitData)
{
if (!ReportSpecificFunctions.TimeRangeOverlaps(fieldVisit.StartTime.Value, fieldVisit.StartTime.Value, reportPeriod))
{
continue;
}
string controlCondition = (fieldVisit.ControlConditionActivity != null) ? fieldVisit.ControlConditionActivity.ControlCondition.ToString() : "";
var activities = fieldVisit.DischargeActivities;
if (activities != null)
{
if (sortOrder != "ReverseChronologicalOnMeasurementTime")
{
activities.Sort((x, y) => x.DischargeSummary.MeasurementTime.CompareTo(y.DischargeSummary.MeasurementTime));
}
else
{
activities.Sort((x, y) => y.DischargeSummary.MeasurementTime.CompareTo(x.DischargeSummary.MeasurementTime));
}
foreach (DischargeActivity dischargeActivity in activities)
{
DataRow row = table1.NewRow();
row["Date"] = (fieldVisit.StartTime.HasValue) ? fieldVisit.StartTime.Value.ToString("yyyy-MM-dd") : "";
row["ControlCondition"] = controlCondition;
row["FieldVisitComments"] = fieldVisit.Remarks;
row["ActivityType"] = Resources.DischargeSummary;
row["Method"] = dischargeActivity.DischargeSummary.DischargeMethod;
DischargeSummary dischargeSummary = dischargeActivity.DischargeSummary;
row["Time"] = dischargeSummary.MeasurementTime.ToString("HH:mm");
row["Timezone"] = dischargeSummary.MeasurementTime.ToString("zzz");
string discharge = (dischargeSummary.Discharge != null) ? dischargeSummary.Discharge.Numeric.ToString() : "";
string dischargeUnit = (dischargeSummary.Discharge != null) ? dischargeSummary.Discharge.Unit : "";
if (dischargeUnit != "m^3/s")
{
discharge += " " + dischargeUnit;
}
row["Discharge"] = discharge;
string stage = (dischargeSummary.MeanGageHeight != null) ? dischargeSummary.MeanGageHeight.Numeric.ToString() : "";
string stageUnit = (dischargeSummary.MeanGageHeight != null) ? dischargeSummary.MeanGageHeight.Unit : "";
if (!string.IsNullOrEmpty(stage) && (stageUnit != "m"))
{
stage += " " + stageUnit;
}
row["Stage"] = stage;
row["ActivityRemarks"] = dischargeSummary.Comments;
string serialNumber = "";
string model = "";
string manufacturer = "";
string instrumentType = "";
string software = "";
string firmware = "";
if ((dischargeActivity.PointVelocityDischargeActivities != null) && (dischargeActivity.PointVelocityDischargeActivities.Count > 0))
{
PointVelocityDischargeActivity pointVelocityDischargeActivity = dischargeActivity.PointVelocityDischargeActivities[0];
if ((pointVelocityDischargeActivity.Verticals != null) && (pointVelocityDischargeActivity.Verticals.Count > 0))
{
Vertical vertical = pointVelocityDischargeActivity.Verticals[0];
serialNumber = vertical.CurrentMeter.SerialNumber;
model = vertical.CurrentMeter.Model;
manufacturer = vertical.CurrentMeter.Manufacturer;
foreach (ActiveMeterDetails activeMeterDetails in activeMeterDetailsList)
{
if ((activeMeterDetails.Manufacturer == manufacturer) &&
(activeMeterDetails.SerialNumber == serialNumber) &&
(activeMeterDetails.Model == model))
{
instrumentType = (activeMeterDetails.MeterType.HasValue) ? activeMeterDetails.MeterType.Value.ToString() : "";
software = activeMeterDetails.SoftwareVersion;
firmware = activeMeterDetails.FirmwareVersion;
break;
}
}
}
}
if ((dischargeActivity.AdcpDischargeActivities != null) && (dischargeActivity.AdcpDischargeActivities.Count > 0))
{
AdcpDischargeActivity adcpDischargeActivity = dischargeActivity.AdcpDischargeActivities[0];
instrumentType = adcpDischargeActivity.AdcpDeviceType;
software = adcpDischargeActivity.SoftwareVersion;
firmware = adcpDischargeActivity.FirmwareVersion;
manufacturer = adcpDischargeActivity.Manufacturer;
serialNumber = adcpDischargeActivity.SerialNumber;
model = adcpDischargeActivity.Model;
Log.DebugFormat("AdcpDischargeActivity: {0}, {1}, {2}", instrumentType, software, firmware);
}
row["Software"] = software;
row["InstrumentType"] = instrumentType;
row["Firmware"] = firmware;
row["Manufacturer"] = manufacturer;
row["Model"] = model;
row["SerialNumber"] = serialNumber;
table1.Rows.Add(row);
}
}
}
}
catch (Exception exp)
{
Log.Error("Error creating report specific data tables ", exp);
throw exp;
}
}
public static void AddReportSpecificTables(DataSet dataSet)
{
try
{
Common common = (Common)dataSet.Tables["RunReportRequest"].Rows[0]["CommonLibrary"];
DataTable settingsTable = dataSet.Tables["ReportSettings"];
settingsTable.Columns.Add("ReportTitle", typeof(string));
settingsTable.Rows[0]["ReportTitle"] = "Cross-Section Survey Plot";
RunFileReportRequest runReportRequest = (RunFileReportRequest)dataSet.Tables["RunReportRequest"].Rows[0]["RunReportRequest"];
IPublishGateway publish = runReportRequest.Publish;
Common CommonLibrary = (Common)dataSet.Tables["RunReportRequest"].Rows[0]["CommonLibrary"];
DateTimeOffsetInterval periodSelected = (DateTimeOffsetInterval)dataSet.Tables["ReportData"].Rows[0]["PeriodSelectedAdjustedForReport"];
DataTable crossSectionSurveyDataTable = new DataTable("CrossSectionSurveyPlotDataTable");
dataSet.Tables.Add(crossSectionSurveyDataTable);
string locIdentifier = (string)dataSet.Tables["InputLocation"].Rows[0]["LocationIdentifier"];
TimeSpan utcOffset = (TimeSpan)dataSet.Tables["InputLocation"].Rows[0]["UtcOffset"];
string relativeLocationFilter = CommonLibrary.GetParameterString("RelativeLocationFilterPartialName", "");
string channelFilter = CommonLibrary.GetParameterString("ChannelFilterPartialName", "");
string partyFilter = CommonLibrary.GetParameterString("PartyFilterPartialName", "");
string filterInformationString = Resources.RelativeLocationFilter + ": " + relativeLocationFilter;
filterInformationString += " " + Resources.ChannelFilter + ": " + channelFilter;
filterInformationString += " " + Resources.PartyFilter + ": " + partyFilter;
crossSectionSurveyDataTable.Rows.Add(crossSectionSurveyDataTable.NewRow());
crossSectionSurveyDataTable.Columns.Add("FilterInformationString", typeof(string));
crossSectionSurveyDataTable.Columns.Add("RelativeLocationColumnHeader", typeof(string));
crossSectionSurveyDataTable.Columns.Add("ChannelColumnHeader", typeof(string));
crossSectionSurveyDataTable.Columns.Add("StartingPointColumnHeader", typeof(string));
crossSectionSurveyDataTable.Columns.Add("StartTimeColumnHeader", typeof(string));
crossSectionSurveyDataTable.Columns.Add("EndTimeColumnHeader", typeof(string));
crossSectionSurveyDataTable.Columns.Add("PartyColumnHeader", typeof(string));
crossSectionSurveyDataTable.Columns.Add("SurveyCommentColumnHeader", typeof(string));
crossSectionSurveyDataTable.Columns.Add("TotalPointsColumnHeader", typeof(string));
crossSectionSurveyDataTable.Columns.Add("StageColumnHeader", typeof(string));
crossSectionSurveyDataTable.Rows[0]["FilterInformationString"] = filterInformationString;
string sortOrder = CommonLibrary.GetParameterString("SortOrder", "ReverseChronologicalOnStartTime");
string dateFormat = CommonLibrary.GetParameterString("DateFormat", "yyyy-MM-dd HH:mm");
string stageUnitSymbol = "";
string stageUnitId = "";
DataTable activityTable = dataSet.Tables.Add("CrossSectionSurveyActivity");
activityTable.Columns.Add("ActivityNumber", typeof(int));
activityTable.Columns.Add("RelativeLocation", typeof(string));
activityTable.Columns.Add("Channel", typeof(string));
activityTable.Columns.Add("StartingPoint", typeof(string));
activityTable.Columns.Add("StartTime", typeof(string));
activityTable.Columns.Add("EndTime", typeof(string));
activityTable.Columns.Add("Party", typeof(string));
activityTable.Columns.Add("SurveyComment", typeof(string));
activityTable.Columns.Add("TotalPoints", typeof(string));
activityTable.Columns.Add("Stage", typeof(string));
activityTable.Columns.Add("DistanceUnitSymbol", typeof(string));
activityTable.Columns.Add("ElevationUnitSymbol", typeof(string));
activityTable.Columns.Add("YAxisLabel", typeof(string));
activityTable.Columns.Add("XAxisLabel", typeof(string));
DataTable pointsTable = dataSet.Tables.Add("CrossSectionSurveyPoints");
pointsTable.Columns.Add("ActivityNumber", typeof(int));
pointsTable.Columns.Add("PointOrder", typeof(string));
pointsTable.Columns.Add("Distance", typeof(string));
pointsTable.Columns.Add("Elevation", typeof(string));
pointsTable.Columns.Add("DistanceUnit", typeof(string));
pointsTable.Columns.Add("ElevationUnit", typeof(string));
pointsTable.Columns.Add("DistanceDouble", typeof(double));
pointsTable.Columns.Add("ElevationDouble", typeof(double));
pointsTable.Columns.Add("PointComment", typeof(string));
dataSet.Relations.Add("ActivityPoints", activityTable.Columns["ActivityNumber"], pointsTable.Columns["ActivityNumber"]);
FieldVisitDataByLocationServiceRequest request = new FieldVisitDataByLocationServiceRequest();
request.LocationIdentifier = locIdentifier;
request.ApplyRounding = true;
request.Activities = new List <ActivityType> {
ActivityType.CrossSectionSurvey
};
request.IncludeCrossSectionSurveyProfile = true;
request.IncludeInvalidActivities = false;
FieldVisitDataByLocationServiceResponse response = publish.Get(request);
List <FieldVisit> visits = response.FieldVisitData;
if (sortOrder != "ReverseChronologicalOnStartTime")
{
visits.Sort((x, y) => x.StartTime.Value.CompareTo(y.StartTime.Value));
}
else
{
visits.Sort((x, y) => y.StartTime.Value.CompareTo(x.StartTime.Value));
}
int activityNumber = 0;
foreach (FieldVisit visit in visits)
{
if (visit.CrossSectionSurveyActivity == null)
{
continue;
}
List <CrossSectionSurveyActivity> activities = visit.CrossSectionSurveyActivity;
if (sortOrder != "ReverseChronologicalOnStartTime")
{
activities.Sort((x, y) => {
int ret = x.StartTime.CompareTo(y.StartTime);
return((ret != 0) ? ret : string.Compare(x.RelativeLocation, y.RelativeLocation));
});
}
else
{
activities.Sort((x, y) => {
int ret = y.StartTime.CompareTo(x.StartTime);
return((ret != 0) ? ret : string.Compare(x.RelativeLocation, y.RelativeLocation));
});
}
foreach (CrossSectionSurveyActivity activity in activities)
{
if (periodSelected.Start.HasValue && (activity.StartTime < periodSelected.Start.Value))
{
continue;
}
if (periodSelected.End.HasValue && (activity.StartTime > periodSelected.End.Value))
{
continue;
}
if (!Common.MatchPartialNameFilter(relativeLocationFilter, activity.RelativeLocation))
{
continue;
}
if (!Common.MatchPartialNameFilter(channelFilter, activity.Channel))
{
continue;
}
if (!Common.MatchPartialNameFilter(partyFilter, activity.Party))
{
continue;
}
List <CrossSectionPoint> points = activity.CrossSectionPoints;
string distanceUnitId = "";
string elevationUnitId = "";
activityNumber++;
DataRow activitytRow = activityTable.NewRow();
activitytRow["ActivityNumber"] = activityNumber;
activitytRow["RelativeLocation"] = activity.RelativeLocation;
activitytRow["Channel"] = activity.Channel;
activitytRow["StartingPoint"] = activity.StartingPoint.ToString();
activitytRow["StartTime"] = activity.StartTime.ToOffset(utcOffset).ToString(dateFormat);
activitytRow["EndTime"] = activity.EndTime.ToOffset(utcOffset).ToString(dateFormat);
activitytRow["Party"] = activity.Party;
activitytRow["SurveyComment"] = activity.Comments;
activitytRow["TotalPoints"] = (points == null)? "" : points.Count.ToString();
if (string.IsNullOrEmpty(stageUnitId))
{
stageUnitId = activity.Stage.Unit;
}
string stageUnit = (stageUnitId == activity.Stage.Unit) ? "" : " " + CommonLibrary.GetUnitSymbol(activity.Stage.Unit);
activitytRow["Stage"] = activity.Stage.Display + stageUnit;
activityTable.Rows.Add(activitytRow);
if (points == null)
{
continue;
}
points.Sort((x, y) => x.PointOrder.CompareTo(y.PointOrder));
for (int i = 0; i < points.Count; i++)
{
CrossSectionPoint point = points[i];
if (string.IsNullOrEmpty(distanceUnitId))
{
distanceUnitId = point.Distance.Unit;
}
if (string.IsNullOrEmpty(elevationUnitId))
{
elevationUnitId = point.Elevation.Unit;
}
string distanceUnit = (distanceUnitId == point.Distance.Unit) ? "" : " " + CommonLibrary.GetUnitSymbol(point.Distance.Unit);
string elevationUnit = (elevationUnitId == point.Elevation.Unit) ? "" : " " + CommonLibrary.GetUnitSymbol(point.Elevation.Unit);
DataRow row = pointsTable.NewRow();
row["ActivityNumber"] = activityNumber;
row["PointOrder"] = point.PointOrder.ToString();
row["Distance"] = point.Distance.Display + distanceUnit;
row["Elevation"] = point.Elevation.Display + elevationUnit;
row["DistanceUnit"] = distanceUnit;
row["ElevationUnit"] = elevationUnit;
row["DistanceDouble"] = (point.Distance.Numeric.HasValue)? point.Distance.Numeric.Value : double.NaN;
row["ElevationDouble"] = (point.Elevation.Numeric.HasValue)? +point.Elevation.Numeric.Value : double.NaN;
row["PointComment"] = point.Comments;
pointsTable.Rows.Add(row);
}
string distanceUnitSymbol = CommonLibrary.GetUnitSymbol(distanceUnitId);
string elevationUnitSymbol = CommonLibrary.GetUnitSymbol(elevationUnitId);
activitytRow["DistanceUnitSymbol"] = distanceUnitSymbol;
activitytRow["ElevationUnitSymbol"] = elevationUnitSymbol;
activitytRow["YAxisLabel"] = Resources.Elevation + " (" + elevationUnitSymbol + ")";
activitytRow["XAxisLabel"] = Resources.Distance + " (" + distanceUnitSymbol + ")";
}
stageUnitSymbol = CommonLibrary.GetUnitSymbol(stageUnitId);
crossSectionSurveyDataTable.Rows[0]["RelativeLocationColumnHeader"] = Resources.RelativeLocation;
crossSectionSurveyDataTable.Rows[0]["ChannelColumnHeader"] = Resources.Channel;
crossSectionSurveyDataTable.Rows[0]["StartingPointColumnHeader"] = Resources.StartingPoint;
crossSectionSurveyDataTable.Rows[0]["StartTimeColumnHeader"] = Resources.StartTime;
crossSectionSurveyDataTable.Rows[0]["EndTimeColumnHeader"] = Resources.EndTime;
crossSectionSurveyDataTable.Rows[0]["PartyColumnHeader"] = Resources.Party;
crossSectionSurveyDataTable.Rows[0]["SurveyCommentColumnHeader"] = Resources.CrossSectionSurveyComment;
crossSectionSurveyDataTable.Rows[0]["TotalPointsColumnHeader"] = Resources.TotalPoints;
crossSectionSurveyDataTable.Rows[0]["StageColumnHeader"] = Resources.Stage + " (" + stageUnitSymbol + ")";
}
}
catch (Exception exp)
{
Log.Error("Error creating report specific data tables ", exp);
throw exp;
}
}
public void InitReport(RunFileReportRequest request)
{
_RunReportRequest = request;
_TimeSeriesDescription = GetInputTimeSeriesDescription();
_SensorType = MapSensorType();
}
public static void AddReportSpecificTables(DataSet dataSet)
{
try
{
RunFileReportRequest runReportRequest = (RunFileReportRequest)dataSet.Tables["RunReportRequest"].Rows[0]["RunReportRequest"];
IPublishGateway publish = runReportRequest.Publish;
Guid TimeSeriesUniqueId = (Guid)dataSet.Tables["SourceData"].Rows[0]["UniqueId"];
string timeseriesType = (string)dataSet.Tables["SourceData"].Rows[0]["TimeSeriesType"];
if (timeseriesType != "ProcessorDerived")
{
throw (new Exception("Input is not a derived time-series. Input signal must be a daily selected value derived time-series."));
}
Server.Services.PublishService.ServiceModel.RequestDtos.UpchainProcessorListByTimeSeriesServiceRequest upchain = new Server.Services.PublishService.ServiceModel.RequestDtos.UpchainProcessorListByTimeSeriesServiceRequest();
upchain.TimeSeriesUniqueId = TimeSeriesUniqueId;
List <Server.Services.PublishService.ServiceModel.Dtos.Processor> processors = publish.Get(upchain).Processors;
foreach (Server.Services.PublishService.ServiceModel.Dtos.Processor processor in processors)
{
string procType = processor.ProcessorType;
if (procType != "statistics")
{
throw (new Exception("Input is not a statistics derived time-series. Input signal must be a daily selected value derived time-series."));
}
else
{
string timeStep = null;
string timeStepCount = null;
string statType = null;
Dictionary <string, string> settings = processor.Settings;
foreach (var item in settings)
{
string key = item.Key;
string val = item.Value;
if (key == "StatisticType")
{
statType = item.Value;
}
if (key == "TimeStep")
{
timeStep = item.Value;
}
if (key == "TimeStepCount")
{
timeStepCount = item.Value;
}
}
if (("Daily" != timeStep) || ("1" != timeStepCount) || ("SelectedValue" != statType))
{
throw (new Exception("Input is not a daily selected value derived time-series. Input signal must be a daily selected value derived time-series."));
}
break;
}
}
Common common = (Common)dataSet.Tables["RunReportRequest"].Rows[0]["CommonLibrary"];
DataTable settingsTable = dataSet.Tables["ReportSettings"];
settingsTable.Columns.Add("ReportTitle", typeof(string));
settingsTable.Rows[0]["ReportTitle"] = "Daily Midnight Contents";
DataTable table = new DataTable("DailyMidnightContentsDataTable");
dataSet.Tables.Add(table);
}
catch (Exception exp)
{
Log.Error("Error creating report specific data tables ", exp);
throw exp;
}
}
public string GenerateReportIntoFile(RunFileReportRequest request)
{
Thread.CurrentThread.CurrentCulture.NumberFormat = CultureInfo.InvariantCulture.NumberFormat;
DataSet set = GenerateDataSet(request);
Log.Debug("GenerateReport - after generate dataset");
string dllFolder = (string)set.Tables["RunReportRequest"].Rows[0]["DllFolder"];
string dllName = (string)set.Tables["RunReportRequest"].Rows[0]["DllName"];
string templateFileName = Path.Combine(dllFolder, dllName + ".rst");
Log.DebugFormat("GenerateReport rst template file name is {0}", templateFileName);
string xmlTemplate = File.ReadAllText(templateFileName);
Log.Debug("GenerateReport after read rst template file");
ReportManager reportManager = new ReportManager();
reportManager.DataSources.Add(set.DataSetName, set);
reportManager.OwnerForm = null;
Log.Debug("GenerateReport after init ReportManager");
InlineReportSlot inlineReportSlot = new InlineReportSlot();
inlineReportSlot.DocumentStream = xmlTemplate;
inlineReportSlot.RenderingError += InlineReportSlot_RenderingError;
Log.Debug("GenerateReport after init InlineReportSlot");
reportManager.Reports.Add(inlineReportSlot);
Document document = inlineReportSlot.RenderDocument();
Log.Debug("GenerateReport after RenderDocument");
string outputFormat = request.OutputFormat;
Log.DebugFormat("GenerateReport after RenderDocument, document name is {0}, page count is {1}, outputFormat is {2}",
document.Name, document.Pages.Count, outputFormat);
string tempFileName = Path.GetTempFileName();
string outputFileName = Path.ChangeExtension(tempFileName, outputFormat);
try
{
File.Delete(tempFileName);
}
catch { }
try
{
File.Delete(outputFileName);
}
catch { }
Log.DebugFormat("GenerateReport - the name of file for export report to write to is set to {0}", outputFileName);
try
{
switch (outputFormat.ToUpper())
{
case "PDF":
{
PdfExportFilter exportFilter = new PdfExportFilter();
exportFilter.Compress = true;
exportFilter.Export(document, outputFileName, false);
Log.DebugFormat("GenerateReport after export document to PDF into tempFileName = {0}", outputFileName);
break;
}
case "CSV":
{
CsvExportFilter exportFilter = new CsvExportFilter();
exportFilter.Separator = ",";
exportFilter.Export(document, outputFileName, false);
Log.DebugFormat("GenerateReport after export document to CSV into tempFileName = {0}", outputFileName);
break;
}
case "XLSX":
{
ExcelExportFilter exportFilter = new ExcelExportFilter();
exportFilter.ExportAsData = true;
exportFilter.Export(document, outputFileName, false);
Log.DebugFormat("GenerateReport after export document to XLSX into tempFileName = {0}", outputFileName);
break;
}
case "PNG":
{
PngExportFilter exportFilter = new PngExportFilter();
exportFilter.PagesRange = "1";
exportFilter.Export(document, outputFileName, false);
Log.DebugFormat("GenerateReport after export document to PNG into tempFileName = {0}", outputFileName);
break;
}
default:
{
Log.DebugFormat("Unable to export report - unknown export format '{0}'", outputFormat);
break;
}
}
}
catch (System.Exception exp)
{
Log.Debug("Exception during export report", exp);
throw exp;
}
return(outputFileName);
}
public static void AddReportSpecificTables(DataSet dataSet)
{
try
{
Common common = (Common)dataSet.Tables["RunReportRequest"].Rows[0]["CommonLibrary"];
DataTable settingsTable = dataSet.Tables["ReportSettings"];
settingsTable.Columns.Add("ReportTitle", typeof(string));
settingsTable.Rows[0]["ReportTitle"] = Resources.FieldActivity;
DataTable table = new DataTable("FieldActivityDataTable");
dataSet.Tables.Add(table);
RunFileReportRequest runReportRequest = (RunFileReportRequest)dataSet.Tables["RunReportRequest"].Rows[0]["RunReportRequest"];
IPublishGateway publish = runReportRequest.Publish;
string locationIdentifier = (string)dataSet.Tables["LocationInput"].Rows[0]["Identifier"];
string dllName = (string)dataSet.Tables["RunReportRequest"].Rows[0]["DllName"];
Log.DebugFormat("{0} - Document GenerateScript input location = {1}", dllName, locationIdentifier);
///////////////////////////////////////////////////////////////
DateTimeOffsetInterval reportPeriod = (DateTimeOffsetInterval)dataSet.Tables["ReportPeriods"].Rows[0]["NoGroupBy"];
string sortOrder = common.GetParameterString("SortOrder", "ReverseChronologicalOnMeasurementTime");
DataTable table1 = dataSet.Tables.Add("FieldActivity");
table1.Columns.Add("Date", typeof(string));
table1.Columns.Add("Time", typeof(string));
table1.Columns.Add("Timezone", typeof(string));
table1.Columns.Add("ActivityType", typeof(string));
table1.Columns.Add("Stage", typeof(string));
table1.Columns.Add("StageUnit", typeof(string));
table1.Columns.Add("Discharge", typeof(string));
table1.Columns.Add("DischargeUnit", typeof(string));
table1.Columns.Add("ControlCondition", typeof(string));
table1.Columns.Add("ActivityRemarks", typeof(string));
table1.Columns.Add("FieldVisitComments", typeof(string));
FieldVisitDataByLocationServiceRequest fdRequest = new FieldVisitDataByLocationServiceRequest();
fdRequest.LocationIdentifier = locationIdentifier;
fdRequest.ApplyRounding = true;
fdRequest.Activities = new List <ActivityType> {
ActivityType.Reading, ActivityType.DischargeSummary, ActivityType.ControlCondition
};
FieldVisitDataByLocationServiceResponse fdResponse = publish.Get(fdRequest);
List <FieldVisit> fieldVisitData = fdResponse.FieldVisitData;
try
{
if (sortOrder != "ReverseChronologicalOnMeasurementTime")
{
fieldVisitData.Sort((x, y) => x.StartTime.Value.CompareTo(y.StartTime.Value));
}
else
{
fieldVisitData.Sort((x, y) => y.StartTime.Value.CompareTo(x.StartTime.Value));
}
}
catch { }
foreach (FieldVisit fieldVisit in fieldVisitData)
{
if (!ReportSpecificFunctions.TimeRangeOverlaps(fieldVisit.StartTime.Value, fieldVisit.StartTime.Value, reportPeriod))
{
continue;
}
if (fieldVisit.DischargeActivities != null)
{
var activities = fieldVisit.DischargeActivities;
if (sortOrder != "ReverseChronologicalOnMeasurementTime")
{
activities.Sort((x, y) => x.DischargeSummary.MeasurementTime.CompareTo(y.DischargeSummary.MeasurementTime));
}
else
{
activities.Sort((x, y) => y.DischargeSummary.MeasurementTime.CompareTo(x.DischargeSummary.MeasurementTime));
}
foreach (DischargeActivity dischargeActivity in activities)
{
if (dischargeActivity.DischargeSummary == null)
{
continue;
}
DataRow row = table1.NewRow();
row["Date"] = (fieldVisit.StartTime.HasValue) ? fieldVisit.StartTime.Value.ToString("yyyy-MM-dd") : "";
row["ControlCondition"] = (fieldVisit.ControlConditionActivity != null) ? fieldVisit.ControlConditionActivity.ControlCondition.ToString() : "";
row["FieldVisitComments"] = fieldVisit.Remarks;
row["ActivityType"] = Resources.DischargeSummary;
DischargeSummary dischargeSummary = dischargeActivity.DischargeSummary;
row["Time"] = dischargeSummary.MeasurementTime.ToString("HH:mm");
row["Timezone"] = dischargeSummary.MeasurementTime.ToString("zzz");
string discharge = (dischargeSummary.Discharge != null) ? dischargeSummary.Discharge.Display : "";
string dischargeUnit = (dischargeSummary.Discharge != null) ? dischargeSummary.Discharge.Unit : "";
if (dischargeUnit != "m^3/s")
{
discharge += " " + dischargeUnit;
}
row["Discharge"] = discharge;
string stage = (dischargeSummary.MeanGageHeight != null) ? dischargeSummary.MeanGageHeight.Display : "";
string stageUnit = (dischargeSummary.MeanGageHeight != null) ? dischargeSummary.MeanGageHeight.Unit : "";
if (!string.IsNullOrEmpty(stage) && (stageUnit != "m"))
{
stage += " " + stageUnit;
}
row["Stage"] = stage;
row["ActivityRemarks"] = dischargeSummary.Comments;
table1.Rows.Add(row);
}
}
if ((fieldVisit.InspectionActivity != null) && (fieldVisit.InspectionActivity.Readings != null))
{
foreach (Reading reading in fieldVisit.InspectionActivity.Readings)
{
if (!reading.Publish || !reading.IsValid)
{
continue;
}
if ("Stage" != reading.Parameter)
{
continue;
}
DataRow row = table1.NewRow();
row["Date"] = (fieldVisit.StartTime.HasValue) ? fieldVisit.StartTime.Value.ToString("yyyy-MM-dd") : "";
row["ControlCondition"] = (fieldVisit.ControlConditionActivity != null) ? fieldVisit.ControlConditionActivity.ControlCondition.ToString() : "";
row["FieldVisitComments"] = fieldVisit.Remarks;
row["ActivityType"] = Resources.Reading;
row["Time"] = (reading.Time.HasValue) ? reading.Time.Value.ToString("HH:mm") : "";
row["Timezone"] = (reading.Time.HasValue) ? reading.Time.Value.ToString("zzz") : "";
string stage = reading.Value.Display;
string stageUnit = reading.Unit;
if (stageUnit != "m")
{
stage += " " + stageUnit;
}
row["Stage"] = stage;
row["ActivityRemarks"] = reading.Comments;
table1.Rows.Add(row);
}
}
}
}
catch (Exception exp)
{
Log.Error("Error creating report specific data tables ", exp);
throw exp;
}
}
