/
AquariusClient.cs
256 lines (211 loc) · 8.76 KB
/
AquariusClient.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
/****************************** Module Header ******************************\
Module Name: AquariusClient
Project: AquariusLib
Summary: Provides client access to both the AUQARIUS acuisition API
and the public API
Author[s]: Ryan Cooper
Email[s]: rcooper@edwardsaquifer.org
\***************************************************************************/
using AquariusLib.AcquisitionService;
using AquariusLib.PublishService;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
namespace AquariusLib
{
public class AquariusClient
{
#region Private Fields
private readonly AQAcquisitionServiceClient acuisitionClient;
private readonly string passwd;
private readonly AquariusPublishServiceClient publishClient;
private readonly string uid;
#endregion Private Fields
#region Public Constructors
/// <summary>
/// Default constructor
/// </summary>
/// <param name="uid">The user ID for aquarius login</param>
/// <param name="passwd">The user password for aquaiurs login</param>
public AquariusClient(string uid, string passwd)
{
this.uid = uid;
this.passwd = passwd;
acuisitionClient = new AQAcquisitionServiceClient("WSHttpBinding_IAQAcquisitionService");
publishClient = new AquariusPublishServiceClient("BasicHttpBinding_IAquariusPublishService");
}
#endregion Public Constructors
#region Private Properties
private string acuisitionToken => acuisitionClient.GetAuthToken(uid, passwd);
private string publishToken => publishClient.GetAuthToken(uid, passwd);
#endregion Private Properties
#region Public Methods
/// <summary>
/// Creates a new location in the AQUARIUS database
/// </summary>
/// <param name="location">The location to be created</param>
public void CreateLocation(Location location)
{
KeepAlive();
var loc = Location.LOCATION_TO_LOCATIONDTO(location);
acuisitionClient.CreateLocation(acuisitionToken, loc);
}
/// <summary>
/// Gets a location by its ID from aquarius
/// </summary>
/// <param name="id">The locations ID</param>
/// <returns>The requested location</returns>
public Location GetLocationById(long id)
{
KeepAlive();
return new Location(acuisitionClient.GetLocation(acuisitionToken, id));
}
/// <summary>
/// Gets all the locations of a specified type
/// </summary>
/// <param name="type">The location type</param>
/// <returns>A list of locations by type</returns>
public List<Location> GetLocationByType(LocationType type)
{
KeepAlive();
return acuisitionClient.GetAllLocations(acuisitionToken).Where(x => x.LocationTypeName == type.Name).Select(loc => new Location(loc)).ToList();
}
/// <summary>
/// Gets all locations in aquarius
/// </summary>
/// <returns>Returns a list of all locations in aquarius</returns>
public List<Location> GetLocations()
{
KeepAlive();
var tmp = new List<Location>();
var locs = acuisitionClient.GetAllLocations(acuisitionToken);
foreach (var loc in locs)
tmp.Add(new Location(loc));
return tmp;
}
/// <summary>
/// Gets all locations in aquarius asynchronously
/// </summary>
/// <returns>List of all locations in aquarius</returns>
public async Task<List<Location>> GetLocationsAsync()
{
KeepAlive();
var tmp = new List<Location>();
var locs = await acuisitionClient.GetAllLocationsAsync(acuisitionToken);
foreach (var loc in locs.GetAllLocationsResult)
tmp.Add(new Location(loc));
return tmp;
}
/// <summary>
/// Gets a list of all paramerters being used by aquarius
/// </summary>
/// <returns>List of aquarius parameters</returns>
public List<Parameter> GetParameters()
{
KeepAlive();
return Parameter.ParseParameters(publishClient.GetParameterList(publishToken));
}
/// <summary>
/// Gets timeseries data from a specified timeseries and date range
/// </summary>
/// <param name="ts">The timeseries to access</param>
/// <param name="from">The from date</param>
/// <param name="to">The to date</param>
/// <returns>The CSV output from aquarius</returns>
public async Task<string> GetTimeSeriesData(TimeSeries ts, DateTime from, DateTime to)
{
KeepAlive();
var tmp = await acuisitionClient.GetTimeSeriesAsync(acuisitionToken, ts.Id, @"Public", from, to, DateTime.MinValue);
return tmp.GetTimeSeriesResult;
}
/// <summary>
/// Gets the timeseries data from aquarius synchonously
/// </summary>
/// <param name="ts">The timeseries to access</param>
/// <param name="from">The from date</param>
/// <param name="to">The to date</param>
/// <returns>The CVS output from aquarius</returns>
public string GetTimeSeriesDataSync(TimeSeries ts, DateTime from, DateTime to)
{
KeepAlive();
string tmp;
try
{
tmp = acuisitionClient.GetTimeSeries(acuisitionToken, ts.Id, @"Public", from, to, DateTime.MinValue);
}
catch (Exception)
{
var output = string.Empty;
tmp = publishClient.GetTimeSeriesRawData(acuisitionToken, ts.Id.ToString(), @"Public", from.ToString(CultureInfo.CurrentCulture), to.ToString(CultureInfo.CurrentCulture), string.Empty, string.Empty, true, false);
var lines = Regex.Split(tmp, "\r\n|\r|\n");
for (var i = 5; i < lines.Length; i++)
{
var data = lines[i].Split(',');
if (!(data.Length >= 6))
continue;
output += $"{data[1].Replace('T', ' ').Remove(19)},{data[2]},,,{data[3]},{data[4]},\n";
}
return output;
}
return tmp;
}
/// <summary>
/// Gets a list of all timeseries in a particular location
/// </summary>
/// <param name="id">The location id</param>
/// <returns>A list of available timeseries</returns>
public List<TimeSeries> GetTimeSeriesList(long id)
{
KeepAlive();
var tmp = new List<TimeSeries>();
var timeSeries = acuisitionClient.GetTimeSeriesListForLocation(acuisitionToken, id);
foreach (var ts in timeSeries)
tmp.Add(new TimeSeries(ts, this));
return tmp;
}
/// <summary>
/// Gets a list of all timeseries in a particular location asynchonously
/// </summary>
/// <param name="id">The location id</param>
/// <returns>A list of available timeseries</returns>
public async Task<List<TimeSeries>> GetTimeSeriesListAsync(long id)
{
KeepAlive();
var tmp = new List<TimeSeries>();
var timeSeries = await acuisitionClient.GetTimeSeriesListForLocationAsync(acuisitionToken, id);
foreach (var ts in timeSeries.GetTimeSeriesListForLocationResult)
tmp.Add(new TimeSeries(ts, this));
return tmp;
}
/// <summary>
/// Uploads timeseries data to aquarius
/// </summary>
/// <param name="ts">The timeseries to upload</param>
public void UploadTimeSeries(TimeSeriesBuilder ts)
{
KeepAlive();
acuisitionClient.AppendTimeSeriesFromBytes(acuisitionToken, ts.TimeSeriesDescription.AqDataID, Encoding.UTF8.GetBytes(ts.Csv), @"service_acc", @"Automatic Service Upload");
}
/// <summary>
/// Uploads multiple timeseries to aquarius
/// </summary>
/// <param name="ts">A list of timeseries to upload</param>
public void UploadTimeSeries(List<TimeSeriesBuilder> ts)
{
KeepAlive();
foreach (var set in ts)
UploadTimeSeries(set);
}
#endregion Public Methods
#region Internal Methods
internal void KeepAlive()
{
acuisitionClient.KeepConnectionAlive(acuisitionToken);
}
#endregion Internal Methods
}
}