private SeriesDataCart getDataCartFromMetadata(SeriesMetadata series, DataServiceInfo waterOneFlowServiceInfo)
{
var result = new SeriesDataCart();
Site cSite = series.Site;
result.SiteName = cSite.Name;
result.SiteCode = cSite.Code;
result.Latitude = cSite.Latitude;
result.Longitude = cSite.Longitude;
Variable v = series.Variable;
result.VariableName = v.Name;
result.VariableCode = v.Code;
result.DataType = v.DataType;
result.ValueType = v.ValueType;
result.SampleMedium = v.SampleMedium;
result.TimeSupport = Convert.ToDouble(v.TimeSupport, CultureInfo.InvariantCulture);
result.GeneralCategory = v.GeneralCategory;
result.TimeUnit = v.TimeUnit.Name;
result.BeginDate = Convert.ToDateTime(series.BeginDateTime, CultureInfo.InvariantCulture);
result.EndDate = Convert.ToDateTime(series.EndDateTime, CultureInfo.InvariantCulture);
result.ValueCount = series.ValueCount;
result.ServURL = waterOneFlowServiceInfo.EndpointURL;
result.ServCode = titleTextbox.Text;
return(result);
}
/// <summary>
/// Retrieves data from WaterOneFlow services, persists a publicly-accessible copy as a CSV-formatted document
/// (see <a href="http://www.ietf.org/rfc/rfc4180.txt">rfc-4180</a> and <a href="http://www.creativyst.com/Doc/Articles/CSV/CSV01.htm">this discussion</a>),
/// and returns a web-formatted response including a URI to the reference link.
/// </summary>
/// <param name="SeriesID"></param>
/// <param name="lat"></param>
/// <param name="lng"></param>
/// <returns></returns>
public async Task <SeriesData> Get(int SeriesID, double lat, double lng)
{
DateTimeOffset requestTime = DateTimeOffset.UtcNow;
DataExportRequest cachedResult = await wdcStore.CheckIfSeriesExistsInStorage(CUAHSIDataStorage.LogHelper.GetCUAHSIDataStorage(), SeriesID, requestTime);
if (cachedResult == null)
{
//get series from wateroneflow and return response
Tuple <Stream, SeriesData> data = await discoveryService.GetSeriesDataObjectAndStreamFromSeriesTriple(SeriesID, lat, lng);
string nameGuid = Guid.NewGuid().ToString();
var dl = wdcStore.PersistSeriesData(data.Item2, nameGuid, requestTime);
//fire and forget => no reason to require consistency with user download.
var persist = wdcStore.PersistSeriesDocumentStream(data.Item1, SeriesID, nameGuid, DateTime.UtcNow);
await Task.WhenAll(new List <Task>() { dl, persist });
data.Item2.wdcCache = dl.Result.Uri;
return(data.Item2);
}
else
{
//get series from cloud cache and return response
ServerSideHydroDesktop.ObjectModel.Series dataResult = await wdcStore.GetWaterOneFlowFromCloudCache(SeriesID.ToString(), cachedResult.DownloadGuid, cachedResult.ServUrl);
SeriesMetadata meta = await discoveryService.SeriesMetaDataOfSeriesID(SeriesID, lat, lng);
IList <DataValue> dataValues = dataResult.DataValueList.OrderBy(a => a.DateTimeUTC).Select(aa => new DataValue(aa)).ToList();
return(new SeriesData(meta.SeriesID, meta, dataResult.QualityControlLevel.IsValid, dataValues,
dataResult.Variable.VariableUnit.Name, dataResult.Variable.VariableUnit.Abbreviation, dataResult.Site.VerticalDatum, dataResult.Site.Elevation_m));
}
// SeriesData data = await discoveryService.GetSeriesDataObjectFromSeriesTriple(SeriesID, lat, lng);
}
public async Task <Tuple <Stream, SeriesData> > GetSeriesDataObjectAndStreamFromSeriesID(int seriesId)
{
SeriesMetadata meta = getSeriesMetadata(seriesId);
// SeriesMetadata meta = await QueryHelpers.QueryHelpers.SeriesMetaDataOfSeriesID(SeriesID);
if (meta == null)
{
throw new NullReferenceException();
}
else
{
Tuple <Stream, IList <ServerSideHydroDesktop.ObjectModel.Series> > data = await this.SeriesAndStreamOfSeriesID(meta);
if (data == null || data.Item2.FirstOrDefault() == null)
{
throw new KeyNotFoundException();
}
else
{
var dataResult = data.Item2.FirstOrDefault();
IList <DataValue> dataValues = dataResult.DataValueList.OrderBy(a => a.DateTimeUTC).Select(aa => new DataValue(aa)).ToList();
return(new Tuple <Stream, SeriesData>(data.Item1, new SeriesData(meta.SeriesID, meta, dataResult.QualityControlLevel.IsValid, dataValues,
dataResult.Variable.VariableUnit.Name, dataResult.Variable.VariableUnit.Abbreviation, dataResult.Site.VerticalDatum, dataResult.Site.Elevation_m)));
}
}
}
/// <summary>
/// Parses a WaterML SiteInfo XML file
/// </summary>
/// <param name="xmlFile"></param>
/// <returns></returns>
public IList <SeriesMetadata> ParseGetSiteInfo(string xmlFile)
{
IList <SeriesMetadata> seriesList = new List <SeriesMetadata>();
Site site = null;
using (var reader = XmlReader.Create(xmlFile, _readerSettings))
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
string readerName = reader.Name.ToLower();
if (readerName == "siteinfo")
{
//Read the site information
site = ReadSite(reader);
}
else if (site != null && readerName == "series")
{
SeriesMetadata newSeries = ReadSeriesFromSiteInfo(reader, site);
seriesList.Add(newSeries);
}
}
}
}
return(seriesList);
}
public SeriesData(int seriesId, SeriesMetadata myMeta, IList<DataValue> dataValues, Variable variable,
List<Source> sources, List<Method> methods, List<QualityControlLevel> qualityControlLevels)
: this()
{
myMetadata = myMeta;
SeriesID = seriesId;
HasConfirmedTimeStamp = true;
TimeStampMessage = string.Empty;
myVariable = variable;
values = dataValues.ToList();
ontology = new List<OntologyItem>();
tags = new List<HydroTag>();
if (null != sources)
{
mySources = sources;
}
if (null != methods)
{
myMethods = methods;
}
if (null != qualityControlLevels)
{
myQualityControlLevels = qualityControlLevels;
}
}
private SeriesMetadata ReadSeriesFromSiteInfo(XmlReader r, Site site)
{
SeriesMetadata series = new SeriesMetadata();
series.Site = site;
while (r.Read())
{
if (r.NodeType == XmlNodeType.Element)
{
string nodeName = r.Name.ToLower();
if (nodeName == "variable")
{
series.Variable = ReadVariable(r);
}
else if (nodeName == "valuecount")
{
r.Read();
series.ValueCount = Convert.ToInt32(r.Value);
}
else if (nodeName == "begindatetime")
{
r.Read();
series.BeginDateTime = Convert.ToDateTime(r.Value, CultureInfo.InvariantCulture);
series.BeginDateTimeUTC = series.BeginDateTime;
}
else if (nodeName == "enddatetime")
{
r.Read();
series.EndDateTime = Convert.ToDateTime(r.Value, CultureInfo.InvariantCulture);
series.EndDateTimeUTC = series.EndDateTime;
}
else if (nodeName == "method")
{
series.Method = ReadMethod(r);
}
else if (nodeName == "source")
{
series.Source = ReadSource(r);
}
else if (nodeName == "qualitycontrollevel")
{
//TODO: Read QualityControlLevel
}
}
else
{
if (r.NodeType == XmlNodeType.EndElement && r.Name == "series")
{
return(series);
}
}
}
return(series);
}
private static void ValidateSeriesMetadata(
string expectedSeriesInstanceUid,
string expectedModality,
DateTime?expectedPerformedProcedureStepStartDate,
SeriesMetadata actual)
{
Assert.NotNull(actual);
Assert.Equal(expectedSeriesInstanceUid, actual.SeriesInstanceUid);
Assert.Equal(expectedModality, actual.Modality);
Assert.Equal(expectedPerformedProcedureStepStartDate, actual.PerformedProcedureStepStartDate);
}
private static FilteredTimeSeries ReadTimeSeries(
byte version,
BinaryReader reader,
SeriesMetadata seriesMetadata,
Dictionary <int, string> stringTable,
Dictionary <int, SeriesMetadata> metadataTable)
{
if (version >= 3)
{
var index = (int)SerializationUtils.ReadUInt32FromBase128(reader);
seriesMetadata = metadataTable[index];
}
var metricIdentifier = seriesMetadata.MetricIdentifier;
var dimensionNames = seriesMetadata.DimensionNames;
var dimensionsCount = dimensionNames.Length;
var dimensionList = new KeyValuePair <string, string> [dimensionsCount];
for (int k = 0; k < dimensionsCount; k++)
{
dimensionList[k] = new KeyValuePair <string, string>(dimensionNames[k], DeserializeStringByIndex(reader, stringTable));
}
var propertiesCount = reader.ReadByte();
var evaluatedValues = new KeyValuePair <string, double> [propertiesCount];
for (int k = 0; k < propertiesCount; k++)
{
evaluatedValues[k] = new KeyValuePair <string, double>(DeserializeStringByIndex(reader, stringTable), reader.ReadDouble());
}
var samplingTypesCount = reader.ReadByte();
var timeSeriesData = new KeyValuePair <SamplingType, double[]> [samplingTypesCount];
for (int k = 0; k < samplingTypesCount; k++)
{
var samplingTypeString = DeserializeStringByIndex(reader, stringTable);
var samplingType = SamplingType.BuiltInSamplingTypes.ContainsKey(samplingTypeString)
? SamplingType.BuiltInSamplingTypes[samplingTypeString]
: new SamplingType(samplingTypeString);
timeSeriesData[k] = new KeyValuePair <SamplingType, double[]>(samplingType, DoubleValueSerializer.Deserialize(reader));
}
double evaluatedResult = propertiesCount == 0 ? double.NaN : evaluatedValues[0].Value;
return(new FilteredTimeSeries(metricIdentifier, dimensionList, evaluatedResult, timeSeriesData));
}
/// <summary>
/// Format: <servicecode>-<sitename>-<variablename>.<extension>
/// </summary>
/// <param name="meta"></param>
/// <param name="timeSeriesFormat"></param>
/// <returns></returns>
public static string GenerateFileName(SeriesMetadata meta, TimeSeriesFormat timeSeriesFormat = TimeSeriesFormat.CSV)
{
string fileName = string.Format("{0}-{1}-{2}", meta.ServCode.SanitizeForFilename(), meta.SiteName.SanitizeForFilename(), meta.VariableName.SanitizeForFilename());
string extension = String.Empty;
if (TimeSeriesFormat.WaterOneFlow == timeSeriesFormat)
{
extension = ".xml";
}
else if (TimeSeriesFormat.CSV == timeSeriesFormat)
{
//NOTE: Microsoft Excel restricts file path + name + extension to 218 characters max. Truncate file name if indicated...
extension = ".csv";
while (218 < (fileName.Length + extension.Length))
{
fileName = fileName.Substring(0, (fileName.Length - 1));
}
}
return(string.Format("{0}{1}", fileName, extension));
}
public void CanSaveOneSeries()
{
Random random = new Random();
string url = @"http://his.crwr.utexas.edu/TXEvap/cuahsi_1_0.asmx";
MetadataCacheManagerSQL manager = TestConfig.MetadataCacheManager;
WaterOneFlowClient client = new WaterOneFlowClient(url);
IList <Site> sites = client.GetSites();
IList <SeriesMetadata> seriesList = client.GetSiteInfo(sites[0].Code);
SeriesMetadata firstSeries = seriesList[0];
DataServiceInfo service = GeDatatService(random.Next());
manager.SaveDataService(service);
firstSeries.DataService = service;
manager.SaveSeries(firstSeries, service);
}
protected virtual SeriesMetadata ReadSeriesFromSiteInfo(XmlReader r, Site site)
{
var series = new SeriesMetadata {
Site = site
};
while (r.Read())
{
if (r.NodeType == XmlNodeType.Element)
{
if (XmlContext.AdvanceReaderPastEmptyElement(r))
{
//Empty element - advance and continue...
continue;
}
string nodeName = r.Name.ToLower();
if (nodeName == "variable")
{
series.Variable = ReadVariable(r);
}
else if (nodeName == "valuecount")
{
r.Read();
series.ValueCount = Convert.ToInt32(r.Value);
}
else if (nodeName == "begindatetime")
{
r.Read();
series.BeginDateTime = Convert.ToDateTime(r.Value, CultureInfo.InvariantCulture);
series.BeginDateTimeUTC = series.BeginDateTime;
}
else if (nodeName == "enddatetime")
{
r.Read();
series.EndDateTime = Convert.ToDateTime(r.Value, CultureInfo.InvariantCulture);
series.EndDateTimeUTC = series.EndDateTime;
}
else if (nodeName == "begindatetimeutc")
{
r.Read();
series.BeginDateTimeUTC = Convert.ToDateTime(r.Value, CultureInfo.InvariantCulture);
}
else if (nodeName == "enddatetimeutc")
{
r.Read();
series.EndDateTimeUTC = Convert.ToDateTime(r.Value, CultureInfo.InvariantCulture);
}
else if (nodeName == "method")
{
series.Method = ReadMethod(r);
}
else if (nodeName == "source")
{
series.Source = ReadSource(r);
}
else if (nodeName == "qualitycontrollevel")
{
series.QualityControlLevel = ReadQualityControlLevel(r);
}
}
else
{
if (r.NodeType == XmlNodeType.EndElement && r.Name == "series")
{
return(series);
}
}
}
return(series);
}
private SeriesMetadata SeriesFromDataRow(DataRow row)
{
Site site = new Site();
site.Name = Convert.ToString(row["SiteName"]);
site.Code = Convert.ToString(row["SiteCode"]);
site.Latitude = Convert.ToDouble(row["Latitude"]);
site.Longitude = Convert.ToDouble(row["Longitude"]);
Variable v = new Variable();
v.Name = Convert.ToString(row["VariableName"]);
v.Code = Convert.ToString(row["VariableCode"]);
v.DataType = Convert.ToString(row["DataType"]);
v.ValueType = Convert.ToString(row["ValueType"]);
v.Speciation = Convert.ToString(row["Speciation"]);
v.SampleMedium = Convert.ToString(row["SampleMedium"]);
v.TimeSupport = Convert.ToDouble(row["TimeSupport"]);
v.GeneralCategory = Convert.ToString(row["GeneralCategory"]);
v.VariableUnit = Unit.Unknown;
v.VariableUnit.Name = Convert.ToString(row["VariableUnitsName"]);
v.TimeUnit = Unit.UnknownTimeUnit;
v.TimeUnit.Name = Convert.ToString(row["TimeUnitsName"]);
Method m = Method.Unknown;
//m.Description = Convert.ToString(row["MethodDescription"]);
Source src = Source.Unknown;
//src.Description = Convert.ToString(row["SourceDescription"]);
src.Organization = Convert.ToString(row["Organization"]);
src.Citation = Convert.ToString(row["Citation"]);
QualityControlLevel qc = QualityControlLevel.Unknown;
//qc.Code = Convert.ToString(row["QualityControlLevelCode"]);
//qc.Definition = Convert.ToString(row["QualityControlLevelDefinition"]);
SeriesMetadata newSeries = new SeriesMetadata(site, v, m, qc, src);
newSeries.BeginDateTime = Convert.ToDateTime(row["BeginDateTime"]);
newSeries.EndDateTime = Convert.ToDateTime(row["EndDateTime"]);
newSeries.BeginDateTimeUTC = Convert.ToDateTime(row["BeginDateTimeUTC"]);
newSeries.EndDateTimeUTC = Convert.ToDateTime(row["EndDateTimeUTC"]);
newSeries.ValueCount = Convert.ToInt32(row["ValueCount"]);
DataServiceInfo servInfo = new DataServiceInfo();
servInfo.EndpointURL = Convert.ToString(row["ServiceEndpointURL"]);
//servInfo.ServiceCode = Convert.ToString(row["ServiceCode"]);
newSeries.DataService = servInfo;
return newSeries;
}
/// <summary>
/// Saves the series metadata to the metadata cache database.
/// This method also automatically saves the site, variable,
/// method, source and quality control level of the series.
/// </summary>
/// <param name="series">The series to be saved</param>
/// <param name="dataService">The web service containing the series</param>
public void SaveSeries(SeriesMetadata series, DataServiceInfo dataService)
{
string sqlSite = "SELECT SiteID FROM SitesCache WHERE SiteCode = ?";
string sqlVariable = "SELECT VariableID FROM VariablesCache WHERE VariableCode = ?";
string sqlMethod = "SELECT MethodID FROM MethodsCache WHERE MethodDescription = ?";
string sqlSource = "SELECT SourceID FROM SourcesCache WHERE Organization = ?";
string sqlQuality = "SELECT QualityControlLevelID FROM QualityControlLevelsCache WHERE Definition = ?";
string sqlRowID = "; SELECT LAST_INSERT_ROWID();";
string sqlSaveSite = "INSERT INTO SitesCache(SiteCode, SiteName, Latitude, Longitude, LatLongDatumSRSID, LatLongDatumName, " +
"Elevation_m, VerticalDatum, LocalX, LocalY, LocalProjectionSRSID, LocalProjectionName, " +
"PosAccuracy_m, State, County, Comments, ServiceID) " +
"VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)" + sqlRowID;
string sqlSaveVariable = "INSERT INTO variablesCache(VariableCode, VariableName, Speciation, " +
"SampleMedium, ValueType, DataType, GeneralCategory, NoDataValue, VariableUnitsName, VariableUnitsType, VariableUnitsAbbreviation, " +
"IsRegular, TimeSupport, TimeUnitsName, TimeUnitsType, TimeUnitsAbbreviation, ServiceID) " +
"VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)" + sqlRowID;
string sqlSaveMethod = "INSERT INTO MethodsCache(OriginMethodID, MethodDescription, MethodLink, ServiceID) VALUES(?, ?, ?, ?)" + sqlRowID;
string sqlSaveQualityControl = "INSERT INTO QualityControlLevelsCache(OriginQualityControlLevelID, QualityControlLevelCode, Definition, Explanation) " +
"VALUES(?,?,?,?)" + sqlRowID;
string sqlSaveSource = "INSERT INTO SourcesCache(OriginSourceID, Organization, SourceDescription, SourceLink, ContactName, Phone, " +
"Email, Address, City, State, ZipCode, Citation, MetadataID) " +
"VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)" + sqlRowID;
string sqlSaveISOMetadata = "INSERT INTO ISOMetadataCache(TopicCategory, Title, Abstract, ProfileVersion, MetadataLink) " +
"VALUES(?, ?, ?, ?, ?)" + sqlRowID;
string sqlSaveSeries = "INSERT INTO DataSeriesCache(SiteID, VariableID, MethodID, SourceID, QualityControlLevelID, " +
"BeginDateTime, EndDateTime, BeginDateTimeUTC, EndDateTimeUTC, ValueCount, ServiceID) " +
"VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)" + sqlRowID;
int siteID = 0;
int variableID = 0;
int methodID = 0;
int qualityControlLevelID = 0;
int sourceID = 0;
int isoMetadataID = 0;
int seriesID = 0;
//check the ServiceID (must be already set)
if (dataService.Id <= 0)
{
throw new ArgumentException("The DataServiceID must be set.");
}
//Step 1 Begin Transaction
using (DbConnection conn = _db.CreateConnection())
{
conn.Open();
using (DbTransaction tran = conn.BeginTransaction())
{
//****************************************************************
//*** Step 2 Site
//****************************************************************
object siteIDResult = null;
using (DbCommand cmd01 = conn.CreateCommand())
{
cmd01.CommandText = sqlSite;
cmd01.Parameters.Add(_db.CreateParameter(DbType.String, series.Site.Code));
siteIDResult = cmd01.ExecuteScalar();
if (siteIDResult != null)
{
siteID = Convert.ToInt32(siteIDResult);
}
}
if (siteID == 0) //New Site needs to be created
{
//Insert the site to the database
using (DbCommand cmd04 = conn.CreateCommand())
{
Site site = series.Site;
cmd04.CommandText = sqlSaveSite;
cmd04.Parameters.Add(_db.CreateParameter(DbType.String, site.Code));
cmd04.Parameters.Add(_db.CreateParameter(DbType.String, site.Name));
cmd04.Parameters.Add(_db.CreateParameter(DbType.Double, site.Latitude));
cmd04.Parameters.Add(_db.CreateParameter(DbType.Double, site.Longitude));
cmd04.Parameters.Add(_db.CreateParameter(DbType.Int32, site.SpatialReference.SRSID));
cmd04.Parameters.Add(_db.CreateParameter(DbType.String, site.SpatialReference.SRSName));
cmd04.Parameters.Add(_db.CreateParameter(DbType.Double, site.Elevation_m));
cmd04.Parameters.Add(_db.CreateParameter(DbType.String, site.VerticalDatum));
cmd04.Parameters.Add(_db.CreateParameter(DbType.Double, site.LocalX));
cmd04.Parameters.Add(_db.CreateParameter(DbType.Double, site.LocalY));
if (site.LocalProjection != null)
{
cmd04.Parameters.Add(_db.CreateParameter(DbType.Int32, site.LocalProjection.SRSID));
cmd04.Parameters.Add(_db.CreateParameter(DbType.String, site.LocalProjection.SRSName));
}
else
{
cmd04.Parameters.Add(_db.CreateParameter(DbType.Int32, 0));
cmd04.Parameters.Add(_db.CreateParameter(DbType.String, "unknown"));
}
cmd04.Parameters.Add(_db.CreateParameter(DbType.Double, site.PosAccuracy_m));
cmd04.Parameters.Add(_db.CreateParameter(DbType.String, site.State));
cmd04.Parameters.Add(_db.CreateParameter(DbType.String, site.County));
cmd04.Parameters.Add(_db.CreateParameter(DbType.String, site.Comments));
cmd04.Parameters.Add(_db.CreateParameter(DbType.Int32, dataService.Id));
siteIDResult = cmd04.ExecuteScalar();
siteID = Convert.ToInt32(siteIDResult);
}
}
//****************************************************************
//*** Step 3 Variable
//****************************************************************
Variable variable = series.Variable;
object variableIDResult = null;
using (DbCommand cmd05 = conn.CreateCommand())
{
cmd05.CommandText = sqlVariable;
cmd05.Parameters.Add(_db.CreateParameter(DbType.String, variable.Code));
cmd05.Parameters[0].Value = variable.Code;
variableIDResult = cmd05.ExecuteScalar();
if (variableIDResult != null)
{
variableID = Convert.ToInt32(variableIDResult);
}
}
if (variableID == 0) //New variable needs to be created
{
//Insert the variable to the database
using (DbCommand cmd09 = conn.CreateCommand())
{
cmd09.CommandText = sqlSaveVariable;
cmd09.Parameters.Add(_db.CreateParameter(DbType.String, variable.Code));
cmd09.Parameters.Add(_db.CreateParameter(DbType.String, variable.Name));
cmd09.Parameters.Add(_db.CreateParameter(DbType.String, variable.Speciation));
cmd09.Parameters.Add(_db.CreateParameter(DbType.String, variable.SampleMedium));
cmd09.Parameters.Add(_db.CreateParameter(DbType.String, variable.ValueType));
cmd09.Parameters.Add(_db.CreateParameter(DbType.String, variable.DataType));
cmd09.Parameters.Add(_db.CreateParameter(DbType.String, variable.GeneralCategory));
cmd09.Parameters.Add(_db.CreateParameter(DbType.Double, variable.NoDataValue));
cmd09.Parameters.Add(_db.CreateParameter(DbType.String, variable.VariableUnit.Name));
cmd09.Parameters.Add(_db.CreateParameter(DbType.String, variable.VariableUnit.UnitsType));
cmd09.Parameters.Add(_db.CreateParameter(DbType.String, variable.VariableUnit.Abbreviation));
cmd09.Parameters.Add(_db.CreateParameter(DbType.Boolean, variable.IsRegular));
cmd09.Parameters.Add(_db.CreateParameter(DbType.Double, variable.TimeSupport));
cmd09.Parameters.Add(_db.CreateParameter(DbType.String, variable.TimeUnit.Name));
cmd09.Parameters.Add(_db.CreateParameter(DbType.String, variable.TimeUnit.UnitsType));
cmd09.Parameters.Add(_db.CreateParameter(DbType.String, variable.TimeUnit.Abbreviation));
cmd09.Parameters.Add(_db.CreateParameter(DbType.Int32, dataService.Id));
variableIDResult = cmd09.ExecuteScalar();
variableID = Convert.ToInt32(variableIDResult);
}
}
//****************************************************************
//*** Step 4 Method
//****************************************************************
Method method = series.Method;
object methodIDResult = null;
using (DbCommand cmd10 = conn.CreateCommand())
{
cmd10.CommandText = sqlMethod;
cmd10.Parameters.Add(_db.CreateParameter(DbType.String, method.Description));
methodIDResult = cmd10.ExecuteScalar();
if (methodIDResult != null)
{
methodID = Convert.ToInt32(methodIDResult);
}
}
if (methodID == 0)
{
using (DbCommand cmd11 = conn.CreateCommand())
{
cmd11.CommandText = sqlSaveMethod;
cmd11.Parameters.Add(_db.CreateParameter(DbType.Int32, method.Code));
cmd11.Parameters.Add(_db.CreateParameter(DbType.String, method.Description));
cmd11.Parameters.Add(_db.CreateParameter(DbType.String, method.Link));
cmd11.Parameters.Add(_db.CreateParameter(DbType.Int32, dataService.Id));
methodIDResult = cmd11.ExecuteScalar();
methodID = Convert.ToInt32(methodIDResult);
}
}
//****************************************************************
//*** Step 5 Quality Control Level
//****************************************************************
QualityControlLevel qc = series.QualityControlLevel;
object qualityControlLevelIDResult = null;
using (DbCommand cmd12 = conn.CreateCommand())
{
cmd12.CommandText = sqlQuality;
cmd12.Parameters.Add(_db.CreateParameter(DbType.String, qc.Definition));
qualityControlLevelIDResult = cmd12.ExecuteScalar();
if (qualityControlLevelIDResult != null)
{
qualityControlLevelID = Convert.ToInt32(qualityControlLevelIDResult);
}
}
if (qualityControlLevelID == 0)
{
//to set the code
int qcCode = 0;
int.TryParse(qc.Code, out qcCode);
using (DbCommand cmd13 = conn.CreateCommand())
{
cmd13.CommandText = sqlSaveQualityControl;
cmd13.Parameters.Add(_db.CreateParameter(DbType.Int32, qcCode));
cmd13.Parameters.Add(_db.CreateParameter(DbType.String, qc.Code));
cmd13.Parameters.Add(_db.CreateParameter(DbType.String, qc.Definition));
cmd13.Parameters.Add(_db.CreateParameter(DbType.String, qc.Explanation));
cmd13.Parameters.Add(_db.CreateParameter(DbType.Int32, dataService.Id));
qualityControlLevelIDResult = cmd13.ExecuteScalar();
qualityControlLevelID = Convert.ToInt32(qualityControlLevelIDResult);
}
}
//****************************************************************
//*** Step 6 Source
//****************************************************************
Source source = series.Source;
object sourceIDResult = null;
using (DbCommand cmd14 = conn.CreateCommand())
{
cmd14.CommandText = sqlSource;
cmd14.Parameters.Add(_db.CreateParameter(DbType.String, source.Organization));
sourceIDResult = cmd14.ExecuteScalar();
if (sourceIDResult != null)
{
sourceID = Convert.ToInt32(sourceIDResult);
}
}
if (sourceID == 0)
{
using (DbCommand cmd17 = conn.CreateCommand())
{
cmd17.CommandText = sqlSaveSource;
cmd17.Parameters.Add(_db.CreateParameter(DbType.Int32, source.OriginId));
cmd17.Parameters.Add(_db.CreateParameter(DbType.String, source.Organization));
cmd17.Parameters.Add(_db.CreateParameter(DbType.String, source.Description));
cmd17.Parameters.Add(_db.CreateParameter(DbType.String, source.Link));
cmd17.Parameters.Add(_db.CreateParameter(DbType.String, source.ContactName));
cmd17.Parameters.Add(_db.CreateParameter(DbType.String, source.Phone));
cmd17.Parameters.Add(_db.CreateParameter(DbType.String, source.Email));
cmd17.Parameters.Add(_db.CreateParameter(DbType.String, source.Address));
cmd17.Parameters.Add(_db.CreateParameter(DbType.String, source.City));
cmd17.Parameters.Add(_db.CreateParameter(DbType.String, source.State));
cmd17.Parameters.Add(_db.CreateParameter(DbType.Int32, source.ZipCode));
cmd17.Parameters.Add(_db.CreateParameter(DbType.String, source.Citation));
cmd17.Parameters.Add(_db.CreateParameter(DbType.String, isoMetadataID));
cmd17.Parameters.Add(_db.CreateParameter(DbType.Int32, dataService.Id));
sourceIDResult = cmd17.ExecuteScalar();
sourceID = Convert.ToInt32(sourceIDResult);
}
}
//****************************************************************
//*** Step 7 Series
//****************************************************************
using (DbCommand cmd18 = conn.CreateCommand())
{
cmd18.CommandText = sqlSaveSeries;
cmd18.Parameters.Add(_db.CreateParameter(DbType.Int32, siteID));
cmd18.Parameters.Add(_db.CreateParameter(DbType.Int32, variableID));
cmd18.Parameters.Add(_db.CreateParameter(DbType.Int32, methodID));
cmd18.Parameters.Add(_db.CreateParameter(DbType.Int32, sourceID));
cmd18.Parameters.Add(_db.CreateParameter(DbType.Int32, qualityControlLevelID));
cmd18.Parameters.Add(_db.CreateParameter(DbType.DateTime, series.BeginDateTime));
cmd18.Parameters.Add(_db.CreateParameter(DbType.DateTime, series.EndDateTime));
cmd18.Parameters.Add(_db.CreateParameter(DbType.DateTime, series.BeginDateTimeUTC));
cmd18.Parameters.Add(_db.CreateParameter(DbType.DateTime, series.EndDateTimeUTC));
cmd18.Parameters.Add(_db.CreateParameter(DbType.Int32, series.ValueCount));
cmd18.Parameters.Add(_db.CreateParameter(DbType.Int32, dataService.Id));
object seriesIDResult = cmd18.ExecuteScalar();
seriesID = Convert.ToInt32(seriesIDResult);
}
//Commit Transaction
tran.Commit();
}
conn.Close();
}
}
/// <summary>
/// Check if the series with the same site, variable, method,
/// source, quality control level and data service already
/// exists in the database.
/// </summary>
/// <param name="seriesToCheck">the series to be checked</param>
/// <returns>The series from the db, or NULL if it doesn't exist</returns>
/// <remarks>Not implemented</remarks>
private SeriesMetadata CheckIfSeriesExists(SeriesMetadata seriesToCheck)
{
throw new NotImplementedException();
}
// writes the results to a list of data series objects (which is a theme)
private void WriteDataSeriesResults(Object resultObj, PropertyInfo[] properties, IList <SeriesMetadata> lst)
{
if (resultObj == null)
{
return;
}
//we need to get the data service information as well.
IList <DataServiceInfo> servicesList = GetServicesInBox(-179, -89, 179, 89);
Dictionary <string, DataServiceInfo> servicesLookup = new Dictionary <string, DataServiceInfo>();
foreach (DataServiceInfo servInfo in servicesList)
{
if (!servicesLookup.ContainsKey(servInfo.EndpointURL))
{
servicesLookup.Add(servInfo.EndpointURL, servInfo);
}
}
//to prevent duplicate search results - each site code / variable code combination
//is added to the 'uniqueCode' list
Array arr = resultObj as Array;
if (arr != null)
{
foreach (object obj in arr)
{
SeriesMetadata sm = new SeriesMetadata();
sm.Site = new Site();
sm.Variable = new Variable();
sm.DataService = new DataServiceInfo();
foreach (PropertyInfo pi in properties)
{
object val = pi.GetValue(obj, null);
if (val != null)
{
string propertyName = pi.Name.ToLower();
switch (propertyName)
{
case "location":
sm.Site.Code = val.ToString();
break;
case "varcode":
sm.Variable.Code = val.ToString();
break;
case "servcode":
string servCode = val.ToString();
sm.Site.NetworkPrefix = servCode;
sm.Variable.VocabularyPrefix = servCode;
sm.DataService.ServiceCode = servCode;
break;
case "latitude":
sm.Site.Latitude = Convert.ToDouble(val);
break;
case "longitude":
sm.Site.Longitude = Convert.ToDouble(val);
break;
case "sitename":
sm.Site.Name = Convert.ToString(val);
break;
case "varname":
sm.Variable.Name = Convert.ToString(val);
break;
case "servurl":
string url = Convert.ToString(val).ToLower().Trim();
if (url.EndsWith("?wsdl"))
{
url = url.Replace("?wsdl", "");
}
sm.DataService.EndpointURL = url;
break;
case "valuecount":
sm.ValueCount = Convert.ToInt32(val);
break;
case "begindate":
sm.BeginDateTime = Convert.ToDateTime(val);
break;
case "enddate":
sm.EndDateTime = Convert.ToDateTime(val);
break;
case "datatype":
sm.Variable.DataType = val.ToString();
break;
case "valuetype":
sm.Variable.ValueType = val.ToString();
break;
case "samplemedium":
sm.Variable.SampleMedium = val.ToString();
break;
case "timeunits":
sm.Variable.TimeUnit = new Unit(val.ToString(), "time", val.ToString());
break;
case "gencategory":
sm.Variable.GeneralCategory = val.ToString();
break;
case "timesupport":
sm.Variable.TimeSupport = Convert.ToDouble(val);
break;
}
}
}
if (String.IsNullOrEmpty(sm.Variable.Code))
{
continue;
}
string compoundCode = sm.Site.Code + "|" + sm.Variable.Code;
if (_uniqueCodeList.Contains(compoundCode) == false)
{
sm.Source.Organization = ((DataServiceInfo)servicesLookup[sm.DataService.EndpointURL]).ServiceName;
sm.Source.Description = ((DataServiceInfo)servicesLookup[sm.DataService.EndpointURL]).ServiceTitle;
lst.Add(sm);
_uniqueCodeList.Add(compoundCode);
}
}
}
}
private bool ReadPreamble(
BinaryReader reader,
out byte version,
out uint resultTimeSeriesCount,
out Dictionary <int, string> stringTable,
out long stringTableLengthInByte,
out SeriesMetadata seriesMetadata,
out Dictionary <int, SeriesMetadata> metadataTable,
out long metadataTableLengthInByte)
{
resultTimeSeriesCount = 0;
stringTable = null;
stringTableLengthInByte = 0;
seriesMetadata = null;
metadataTable = null;
metadataTableLengthInByte = 0;
version = reader.ReadByte();
if (version == 0)
{
throw new MetricsClientException(
$"The server didn't respond with the right version of serialization - the initial version is 1 but the server responds with version 0.");
}
this.DiagnosticInfo = new DiagnosticInfo();
if (version == VersionToIndicateCompleteFailure)
{
this.ErrorCode = (FilteredTimeSeriesQueryResponseErrorCode)reader.ReadInt16();
// The trace ID and others will be filled in by callers.
this.DiagnosticInfo.ErrorMessage = reader.ReadString();
bool returnRequestObjectOnFailure = reader.ReadBoolean();
if (returnRequestObjectOnFailure)
{
this.QueryRequest = JsonConvert.DeserializeObject <FilteredTimeSeriesQueryRequest>(reader.ReadString());
}
return(false);
}
if (version > NextVersion)
{
throw new MetricsClientException(
$"The server didn't respond with the right version of serialization. CurrentVersion : {CurrentVersion}, NextVersion : {NextVersion}, Responded: {version}.");
}
var hasDataQualityInfo = reader.ReadBoolean();
if (hasDataQualityInfo)
{
var queryResultQualityInfo = new QueryResultQualityInfo();
queryResultQualityInfo.Deserialize(reader);
}
this.StartTimeUtc = new DateTime(
(long)SerializationUtils.ReadUInt64FromBase128(reader) * TimeSpan.TicksPerMinute,
DateTimeKind.Utc);
this.EndTimeUtc = this.StartTimeUtc.AddMinutes(SerializationUtils.ReadUInt32FromBase128(reader));
this.TimeResolutionInMinutes = (int)SerializationUtils.ReadUInt32FromBase128(reader);
resultTimeSeriesCount = SerializationUtils.ReadUInt32FromBase128(reader);
/* Read string table. */
var currentPosition = reader.BaseStream.Position;
var stringTableRelativePosition = reader.ReadUInt64();
reader.BaseStream.Position = currentPosition + (long)stringTableRelativePosition;
var stringTableStartPostion = reader.BaseStream.Position;
var stringTableSize = SerializationUtils.ReadUInt32FromBase128(reader);
stringTable = new Dictionary <int, string>((int)stringTableSize);
for (int i = 0; i < stringTableSize; i++)
{
stringTable.Add(i, reader.ReadString());
}
stringTableLengthInByte = reader.BaseStream.Position - stringTableStartPostion;
// + sizeof (double) since we just read the stringTableRelativePosition as double.
reader.BaseStream.Position = currentPosition + sizeof(double);
if (version >= 3)
{
/* Read metadata table */
currentPosition = reader.BaseStream.Position;
var metadataTableRelativePosition = reader.ReadUInt64();
reader.BaseStream.Position = currentPosition + (long)metadataTableRelativePosition;
var metadataTableStartPostion = reader.BaseStream.Position;
var metadataTableSize = SerializationUtils.ReadUInt32FromBase128(reader);
metadataTable = new Dictionary <int, SeriesMetadata>((int)metadataTableSize);
for (var i = 0; i < metadataTableSize; i++)
{
metadataTable.Add(i, DeserializeTimeSeriesMetadata(reader, stringTable));
}
metadataTableLengthInByte = reader.BaseStream.Position - metadataTableStartPostion;
// + sizeof (double) since we just read the metadataTableRelativePosition as double.
reader.BaseStream.Position = currentPosition + sizeof(double);
}
if (resultTimeSeriesCount > 0)
{
if (version < 3)
{
seriesMetadata = DeserializeTimeSeriesMetadata(reader, stringTable);
this.QueryRequest = new FilteredTimeSeriesQueryRequest(seriesMetadata.MetricIdentifier);
}
else
{
this.QueryRequest = new FilteredTimeSeriesQueryRequest(metadataTable.Values.First().MetricIdentifier);
}
}
return(true);
}
private static string GetSeriesXml(SeriesBase series)
{
var metadata = new SeriesMetadata(series);
return(metadata.AsXml());
}
public async Task <Tuple <Stream, IList <ServerSideHydroDesktop.ObjectModel.Series> > > SeriesAndStreamOfSeriesID(SeriesMetadata meta)
{
WaterOneFlowClient client = new WaterOneFlowClient(meta.ServURL);
return(await client.GetValuesAndRawStreamAsync(
meta.SiteCode,
meta.VarCode,
meta.StartDate,
DateTime.UtcNow,
Convert.ToInt32(10000)));
}
