public DateTimeOffsetInterval FindTimeSeriesTimeRange(Guid timeseriesUniqueId)
{
List <TimeSeriesPoint> points = FindAnnualCountPoints(timeseriesUniqueId);
if (points.Count == 0)
{
return(new DateTimeOffsetInterval());
}
TimeSpan offset = points[0].Timestamp.Offset;
int binAdjust = _Common.GetBinAdjustment(timeseriesUniqueId);
DateTimeOffset FirstYear = new DateTimeOffset(points[0].Timestamp.Year + binAdjust, 1, 1, 0, 0, 0, offset);
DateTimeOffset LastYear = new DateTimeOffset(points[points.Count - 1].Timestamp.Year + binAdjust, 1, 1, 0, 0, 0, offset);
Log.DebugFormat("Found first point is in Year = {0}, last point is in Year = {1}", FirstYear, LastYear);
points = FindDailyCountPoints(timeseriesUniqueId, FirstYear, FirstYear.AddYears(1).AddDays(1));
if (points.Count == 0)
{
return(new DateTimeOffsetInterval());
}
DateTimeOffset firstTime = FirstNonZeroPoint(points).Timestamp;
DateTimeOffset queryFromTime = new DateTimeOffset(firstTime.Year, firstTime.Month, firstTime.Day, 0, 0, 0, offset);
points = _Common.GetTimeSeriesPoints(timeseriesUniqueId, queryFromTime.AddDays(binAdjust), queryFromTime.AddDays(binAdjust + 1));
if (points.Count == 0)
{
return(new DateTimeOffsetInterval());
}
firstTime = points[0].Timestamp;
Log.DebugFormat("Found first point at time = {0}", firstTime.ToString(Common._DateFormat));
points = FindDailyCountPoints(timeseriesUniqueId, LastYear, LastYear.AddYears(1).AddDays(1));
if (points.Count == 0)
{
return(new DateTimeOffsetInterval(firstTime, null));
}
DateTimeOffset lastTime = LastNonZeroPoint(points).Timestamp;
queryFromTime = new DateTimeOffset(lastTime.Year, lastTime.Month, lastTime.Day, 0, 0, 0, offset);
points = _Common.GetTimeSeriesPoints(timeseriesUniqueId, queryFromTime.AddDays(binAdjust), queryFromTime.AddDays(binAdjust + 1));
if (points.Count == 0)
{
return(new DateTimeOffsetInterval(firstTime, null));
}
lastTime = points[points.Count - 1].Timestamp;
Log.DebugFormat("Found last point at time = {0}", lastTime.ToString(Common._DateFormat));
DateTimeOffsetInterval interval = new DateTimeOffsetInterval(firstTime, lastTime);
return(interval);
}
public DateTimeOffsetInterval GetIntervalOfOverlap(DateTimeOffsetInterval SelectedPeriod, DateTimeOffsetInterval TimeSeriesRange, TimeSpan utcOffset)
{
DateTimeOffset?StartTime = null;
DateTimeOffset?EndTime = null;
if (SelectedPeriod.Start.HasValue && TimeSeriesRange.Start.HasValue)
{
StartTime = (SelectedPeriod.Start.Value > TimeSeriesRange.Start.Value) ? SelectedPeriod.Start.Value.ToOffset(utcOffset) :
(SelectedPeriod.End.HasValue && (SelectedPeriod.End.Value < TimeSeriesRange.Start.Value)) ?
SelectedPeriod.End.Value.ToOffset(utcOffset) : TimeSeriesRange.Start.Value;
}
else
{
StartTime = (SelectedPeriod.Start.HasValue) ? SelectedPeriod.Start.Value.ToOffset(utcOffset) : TimeSeriesRange.Start;
}
if (SelectedPeriod.End.HasValue && TimeSeriesRange.End.HasValue)
{
EndTime = (SelectedPeriod.End.Value < TimeSeriesRange.End.Value) ? SelectedPeriod.End.Value.ToOffset(utcOffset) : TimeSeriesRange.End.Value;
}
else
{
EndTime = (SelectedPeriod.End.HasValue) ? SelectedPeriod.End.Value.ToOffset(utcOffset) : TimeSeriesRange.End;
}
if (!TimeSeriesRange.Start.HasValue && !TimeSeriesRange.End.HasValue)
{
// TimeSeries has no range - no points in it and will be no useful time range therefore collapse time range
if (StartTime.HasValue)
{
EndTime = StartTime.Value;
}
else if (EndTime.HasValue)
{
StartTime = EndTime.Value;
}
}
DateTimeOffset now = DateTimeOffset.Now.ToOffset(utcOffset);
DateTimeOffset TheStartTime = (StartTime.HasValue) ? StartTime.Value.ToOffset(utcOffset) : now;
DateTimeOffset TheEndTime = (EndTime.HasValue) ? EndTime.Value.ToOffset(utcOffset) : now;
TheEndTime = (TheEndTime > TheStartTime) ? TheEndTime : TheStartTime; // avoid improper interval
return(new DateTimeOffsetInterval(TheStartTime, TheEndTime));
}
public DataTable ReportPeriodsTable(string tableName, TimeSpan reportUtcOffset)
{
Log.DebugFormat("Create ReportPeriodsTable {0}", tableName);
DateTimeOffsetInterval timeRangeToAdjust = _Common.GetPeriodSelectedAdjustedForReport();
GroupByHandler groupByHandler = new GroupByHandler(_Common);
if ((_RunReportRequest.Inputs != null) && (_RunReportRequest.Inputs.TimeSeriesInputs.Count > 0))
{
Guid firstTimeSeriesUniqueId = _RunReportRequest.Inputs.TimeSeriesInputs[0].UniqueId;
timeRangeToAdjust = groupByHandler.GetIntervalOfOverlap(timeRangeToAdjust, _Common.GetTimeSeriesTimeRange(firstTimeSeriesUniqueId), reportUtcOffset);
for (int i = 1; i < _RunReportRequest.Inputs.TimeSeriesInputs.Count; i++)
{
Guid timeSeriesUniqueId = _RunReportRequest.Inputs.TimeSeriesInputs[i].UniqueId;
timeRangeToAdjust = groupByHandler.GetIntervalOfOverlap(timeRangeToAdjust, _Common.GetTimeSeriesTimeRange(timeSeriesUniqueId), reportUtcOffset);
}
}
DataTable table = new DataTable(tableName);
table.Columns.Add("GroupByYear", typeof(DateTimeOffsetInterval));
table.Columns.Add("GroupByWaterYear", typeof(DateTimeOffsetInterval));
table.Columns.Add("GroupByMonth", typeof(DateTimeOffsetInterval));
table.Columns.Add("GroupByWeek", typeof(DateTimeOffsetInterval));
table.Columns.Add("GroupByDay", typeof(DateTimeOffsetInterval));
table.Columns.Add("NoGroupBy", typeof(DateTimeOffsetInterval));
DataRow row = table.NewRow();
row["GroupByYear"] = groupByHandler.AdjustIntervalToGroupBy(timeRangeToAdjust, "Year");
row["GroupByWaterYear"] = groupByHandler.AdjustIntervalToGroupBy(timeRangeToAdjust, "WaterYear");
row["GroupByMonth"] = groupByHandler.AdjustIntervalToGroupBy(timeRangeToAdjust, "Month");
row["GroupByWeek"] = groupByHandler.AdjustIntervalToGroupBy(timeRangeToAdjust, "Week");
row["GroupByDay"] = groupByHandler.AdjustIntervalToGroupBy(timeRangeToAdjust, "Day");
row["NoGroupBy"] = groupByHandler.AdjustIntervalToGroupBy(timeRangeToAdjust, "NoGroupBy");
table.Rows.Add(row);
return(table);
}
public static DateTimeOffsetInterval GetTrimmedPeriodSelected(DateTimeOffsetInterval periodSelected)
{
DateTimeOffset?endTime = periodSelected.End;
if (endTime.HasValue)
{
if ((endTime.Value.Hour == 0) && (endTime.Value.Minute == 0) && (endTime.Value.Second == 0))
{
endTime = endTime.Value.AddMilliseconds(-1); // avoid having endTime be at exact start of day/month/year
}
}
DateTimeOffset?startTime = periodSelected.Start;
if (startTime.HasValue)
{
startTime = new DateTimeOffset(startTime.Value.Year, startTime.Value.Month, startTime.Value.Day, 0, 0, 0, startTime.Value.Offset);
}
if (startTime.HasValue && endTime.HasValue && endTime.Value < startTime.Value)
{
endTime = startTime.Value;
}
return(new DateTimeOffsetInterval(startTime, endTime));
}
public DateTimeOffsetInterval AdjustIntervalToGroupBy(DateTimeOffsetInterval SelectedPeriod, DateTimeOffsetInterval TimeSeriesRange, string GroupBy, TimeSpan timeseriesOffset)
{
Log.DebugFormat("AdjustIntervalToGroupBy selected interval = {0}, timeseries range = {1}, groupBy = {2}, tsOffset = {3}",
_Common.TimeRangeString(SelectedPeriod), _Common.TimeSeriesRangeString(TimeSeriesRange), GroupBy, timeseriesOffset);
DateTimeOffsetInterval reportPeriod = SelectedPeriod;
try
{
DateTimeOffsetInterval selectedInterval = _Common.GetIntervalInUtcOffset(SelectedPeriod, timeseriesOffset);
DateTimeOffsetInterval trimmedPeriodSelected = GetTrimmedPeriodSelected(selectedInterval);
DateTimeOffsetInterval overlappedInterval = GetIntervalOfOverlap(trimmedPeriodSelected, TimeSeriesRange, timeseriesOffset);
reportPeriod = AdjustIntervalToGroupBy(overlappedInterval, GroupBy);
}
catch (Exception exp)
{
Log.Error("Error in AdjustIntervalToGroupBy", exp);
}
Log.DebugFormat("AdjustIntervalToGroupBy returns report period = {0}", _Common.TimeRangeString(reportPeriod));
return(reportPeriod);
}
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 bool TimeRangeOverlaps(DateTimeOffset start, DateTimeOffset?end, DateTimeOffsetInterval interval)
{
if (interval.End.HasValue && (start > interval.End.Value))
{
return(false);
}
if (interval.Start.HasValue && end.HasValue && (end < interval.Start.Value))
{
return(false);
}
return(true);
}
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 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 DateTimeOffsetInterval AdjustIntervalToGroupBy(DateTimeOffsetInterval timeRange, string GroupBy)
{
Log.DebugFormat("Begin GroupBy '{0}' adjustments for interval {1} - {2}", GroupBy, timeRange.Start, timeRange.End);
if (!timeRange.Start.HasValue || !timeRange.End.HasValue)
{
Log.DebugFormat("AdjustIntervalToGroupBy unable to adjust timeRange interval = {0} because start or end has no value, return unadjusted", _Common.TimeRangeString(timeRange));
return(timeRange);
}
try
{
DateTimeOffset TheStartTime = timeRange.Start.Value;
DateTimeOffset TheEndTime = timeRange.End.Value;
TimeSpan tsOffset = TheStartTime.Offset;
if (GroupBy == "Year")
{
TheStartTime = new DateTimeOffset(TheStartTime.Year, 1, 1, 0, 0, 0, tsOffset);
TheEndTime = (new DateTimeOffset(TheEndTime.Year, 1, 1, 0, 0, 0, tsOffset)).AddYears(1).AddMilliseconds(-1);
}
else if (GroupBy == "WaterYear")
{
int startYear = (TheStartTime.Month >= _WaterYearMonth) ? TheStartTime.Year : TheStartTime.Year - 1;
TheStartTime = new DateTimeOffset(startYear, _WaterYearMonth, 1, 0, 0, 0, tsOffset);
int endYear = (TheEndTime.Month >= _WaterYearMonth) ? TheEndTime.Year : TheEndTime.Year - 1;
TheEndTime = (new DateTimeOffset(endYear, _WaterYearMonth, 1, 0, 0, 0, tsOffset)).AddYears(1).AddMilliseconds(-1);
}
else if (GroupBy == "Month")
{
TheStartTime = new DateTimeOffset(TheStartTime.Year, TheStartTime.Month, 1, 0, 0, 0, tsOffset);
TheEndTime = new DateTimeOffset(TheEndTime.Year, TheEndTime.Month, 1, 0, 0, 0, tsOffset).AddMonths(1).AddMilliseconds(-1);
}
else if (GroupBy == "Week")
{
int numberOfDays = ((int)Math.Ceiling(((TheEndTime - TheStartTime).TotalDays + 1) / 7.0)) * 7;
TheEndTime = TheStartTime.AddDays(numberOfDays);
TheStartTime = new DateTimeOffset(TheStartTime.Year, TheStartTime.Month, TheStartTime.Day, 0, 0, 0, tsOffset);
TheEndTime = new DateTimeOffset(TheEndTime.Year, TheEndTime.Month, TheEndTime.Day, 0, 0, 0, tsOffset).AddMilliseconds(-1);
}
else if (GroupBy == "Day")
{
TheStartTime = new DateTimeOffset(TheStartTime.Year, TheStartTime.Month, TheStartTime.Day, 0, 0, 0, tsOffset);
TheEndTime = new DateTimeOffset(TheEndTime.Year, TheEndTime.Month, TheEndTime.Day, 0, 0, 0, tsOffset).AddDays(1).AddMilliseconds(-1);
}
else
{
TheStartTime = new DateTimeOffset(TheStartTime.Year, TheStartTime.Month, TheStartTime.Day, 0, 0, 0, tsOffset);
TheEndTime = new DateTimeOffset(TheEndTime.Year, TheEndTime.Month, TheEndTime.Day, 0, 0, 0, tsOffset).AddDays(1).AddMilliseconds(-1);
}
Log.DebugFormat("End GroupBy '{0}' adjustments for interval {1} - {2}", GroupBy, TheStartTime, TheEndTime);
timeRange = new DateTimeOffsetInterval(TheStartTime, TheEndTime);
}
catch (Exception exp)
{
Log.Error("Error in AdjustIntervalToGroupBy", exp);
}
Log.DebugFormat("AdjustIntervalToGroupBy returns timeRange interval = {0}", _Common.TimeRangeString(timeRange));
return(timeRange);
}
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;
}
}
