protected override Task<object> ExecuteNonQuery(DataRequest request, Dictionary<string, object> options)
{
string tableName = GetTableName(request);
string command = null;
List<object> parameters = new List<object>();
if (request.Operation == DataOperation.Insert) {
request.Item["id"] = request.Query.ID;
command = BuildInsertCommand(tableName, request, parameters);
}
else if (request.Operation == DataOperation.Update) {
request.Item["id"] = request.Query.ID;
command = BuildUpdateCommand(tableName, request, parameters);
}
else if (request.Operation == DataOperation.Delete_) {
command = "delete from " + tableName + " where id = @0";
parameters.Add(request.Query.ID);
}
if (command != null) {
Deferred<object> deferred = Deferred.Create<object>();
GetSqlService(request.Partition).Sql(command, parameters)
.Done(delegate(object o) {
deferred.Resolve((int)o == 1);
})
.Fail(delegate(Exception e) {
deferred.Reject(e);
});
return deferred.Task;
}
return Deferred.Create<object>(Script.Undefined).Task;
}
/// <summary>
/// Host receives synchronization request
/// </summary>
/// <param name="timestamp"></param>
/// <param name="id"></param>
/// <param name="ipAndPort">Ip and port of host who calls this method</param>
public void GetSyncRequest_RA(string timestamp, string id, string ipAndPort)
{
LogHelper.WriteStatus("SERVER: RECV " + _module.LocalNodeInfo.GetIpAndPort() + " FROM: " + ipAndPort + " TIME: " + timestamp);
// create request object
var request = new DataRequest()
{
Time = int.Parse(timestamp),
Id = _module.LocalId,
CallerId = long.Parse(id),
IpAndPort = ipAndPort
};
if (_module.State != AccessState.Held && !_module.IsInterested)
{
//Send accept msg to callee
SendAcceptResponse(ipAndPort);
}
else if (_module.State == AccessState.Held)
{
_module.AddRequest(request);
}
else if (_module.IsInterested)
{
if (_module.Clock.CompareTime(int.Parse(timestamp), long.Parse(id)))
{ // request timestamp is smaller than this node's timestamp.
//Send accept msg to callee
SendAcceptResponse(ipAndPort);
}
else
{
_module.AddRequest(request);
}
}
_module.Clock.ReceiveEventHandle(int.Parse(timestamp));
}
protected override Task<object> ExecuteNonQuery(DataRequest request, Dictionary<string, object> options)
{
DataQuery query = request.Query;
string tableName = request.Query.Collection.Name;
if (String.IsNullOrEmpty(request.Partition)) {
throw new Exception("Missing partition information to execute request.");
}
CloudTableEntity entity;
if (request.Item != null) {
entity = (CloudTableEntity)request.Item;
Script.DeleteField(entity, "id");
Script.DeleteField(entity, "_");
}
else {
entity = new CloudTableEntity();
}
entity.PartitionKey = request.Partition;
entity.RowKey = query.ID;
Deferred<object> deferred = Deferred.Create<object>();
if (request.Operation == DataOperation.Insert) {
_tableService.InsertEntity(tableName, entity, delegate(Exception e, CloudTableEntity insertedEntity) {
if (e != null) {
deferred.Reject(e);
}
else {
deferred.Resolve(true);
}
});
}
else if (request.Operation == DataOperation.Update) {
_tableService.MergeEntity(tableName, entity, delegate(Exception e, CloudTableEntity updatedEntity) {
if (e != null) {
deferred.Reject(e);
}
else {
deferred.Resolve(true);
}
});
}
else if (request.Operation == DataOperation.Delete_) {
_tableService.DeleteEntity(tableName, entity, delegate(Exception e, bool successful) {
deferred.Resolve((e == null) && successful);
});
}
else {
deferred.Resolve(Script.Undefined);
}
return deferred.Task;
}
public MainWindowViewModel()
{
Dispatcher dispatcher = Application.Current.Dispatcher;
var schProv = new SchedulerProvider(dispatcher);
IDataRequest dataRequest = new DataRequest();
//IBikeService bikeService = new BikeService(dataRequest);
IBikeService bikeService = new MoqBikeService();
IRealTimeModel realTimeModel = new RealTimeModel(schProv, bikeService);
_liveBikesViewModel = new LiveBikesViewModel(realTimeModel);
}
private async void OnDataRequest(object sender, DataRequest request)
{
try
{
await this.ProcessDataRequest(request);
}
catch (Exception ex)
{
request.SetNoData();
}
}
private async Task ProcessDataRequest(DataRequest request)
{
request.Headers.Add("Access-Control-Allow-Origin", "astral://prototype");
Uri uri = new Uri(request.Url);
AppContainer.SchemeFileDbLink schemeData = this.schemeMap[uri.Scheme];
string path = schemeData.PathPrefix + uri.GetComponents(UriComponents.Path, UriFormat.Unescaped);
string extension = this.GetExtension(path);
string mimeType = this.GetMimeType(extension);
IFileDb database = Instances.FileDatabases[schemeData.DatabaseName];
using (Stream stream = database.GetStream(path.ToLowerInvariant()))
{
MemoryStream memoryStream = new MemoryStream();
await stream.CopyToAsync((Stream) memoryStream);
memoryStream.Seek(0L, SeekOrigin.Begin);
request.SetData((Stream) memoryStream, mimeType);
}
}
protected override Task<object> ExecuteNonQuery(DataRequest request, Dictionary<string, object> options)
{
Dictionary<string, Dictionary<string, object>> set = GetDataSet(request.Query);
string id = request.Query.ID;
object result = false;
if (request.Operation == DataOperation.Insert) {
if (set.ContainsKey(id) == false) {
Dictionary<string, object> item = request.Item;
item["id"] = id;
set[id] = item;
result = true;
}
}
else if (request.Operation == DataOperation.Update) {
if (set.ContainsKey(id)) {
Dictionary<string, object> item = request.Item;
item["id"] = id;
set[id] = item;
result = true;
}
}
else if (request.Operation == DataOperation.Merge) {
if (set.ContainsKey(id)) {
Dictionary<string, object> existingItem = set[id];
Dictionary<string, object> updatedItem = request.Item;
foreach (KeyValuePair<string, object> fieldEntry in updatedItem) {
existingItem[fieldEntry.Key] = fieldEntry.Value;
}
existingItem["id"] = id;
result = true;
}
}
else if (request.Operation == DataOperation.Delete_) {
if (set.ContainsKey(id)) {
set.Remove(id);
result = true;
}
}
return Deferred.Create<object>(result).Task;
}
/// <summary>
/// Master: Get Sync Request msg from hosts
/// </summary>
public void GetSyncRequest_CT(string id, string ipAndPort)
{
var request = new DataRequest()
{
Time = 0,
Id = 0,
CallerId = long.Parse(id),
IpAndPort = ipAndPort
};
LogHelper.WriteStatus("Master: get request from " + id);
if (_module.State == AccessState.Released)
{ // if resource is released
SendAcceptResponse(ipAndPort);
}
else if (_module.State == AccessState.Held)
{ // if resource is held by a host, add the request into queue
_module.AddRequest(request);
}
}
protected override Task<object> ExecuteQuery(DataRequest request, Dictionary<string, object> options)
{
DataQuery query = request.Query;
Dictionary<string, Dictionary<string, object>> set = GetDataSet(query);
object result;
if (query.IsLookup) {
result = Script.Or(set[query.ID], null);
}
else {
// TODO: Apply query
List<Dictionary<string, object>> items = new List<Dictionary<string, object>>();
foreach (KeyValuePair<string, Dictionary<string, object>> itemEntry in set) {
items.Add(itemEntry.Value);
}
result = items;
}
return Deferred.Create<object>(result).Task;
}
public void ShareContent(DataRequest dataRequest, bool supportsHtml = true)
{
ShareContent(dataRequest, SelectedItem, supportsHtml);
}
public void UploadFileAsync(DataRequest request, DataResponse response, DataProvider dataprovider)
{
FileChunk fc = TJson.Parse <FileChunk>(request["P0"]);
response.Value = ToJson(new FileZillaOP(request.LogIn, dataprovider).UploadFileAsync(fc));
}
public static IWidget[] ResolveWidgetsForScope(IRUSDevice scopeDevice, BusyObject busy)
{
if (_models.ContainsKey(scopeDevice))
{
throw new InvalidOperationException("Only one set of widgets per scope is allowed");
}
using (var core = new DICore())
{
registerBasicServices();
instantiateWidgets();
var widgets = core.Container.ResolveAll <IWidget>().ToArray();
_allWidgets.AddRange(widgets.Select(w => new WidgetInfo(w, scopeDevice)));
_models[scopeDevice] = core.Container.TryResolveAll <IDeviceHandler>()?.ToList() ?? new List <IDeviceHandler>();
return(widgets);
void registerBasicServices()
{
core.Container.Register(scopeDevice);
core.Container.Register(scopeDevice.Name); // We're registering string. Dont be confused
core.Container.Register(busy);
}
void instantiateWidgets()
{
var instantiator = core.InstantiationStrategy;
var instantiationCoroutines = widgetsFactory(core.Container).ToArray();
instantiator.ExecuteCoroutines(instantiationCoroutines);
}
}
//////////////////////////////////////
IEnumerable <IEnumerator <ResolutionStepResult> > widgetsFactory(IDIContainer container)
{
string dataViewScope = nameof(dataViewScope);
string flashDumpViewScope = nameof(flashDumpViewScope);
yield return(injectExporters(container, dataViewScope));
yield return(DeviceInitialization.InstantiationCoroutine(dataViewScope, container));
yield return(DeviceFiles.InstantiationCoroutine(dataViewScope, container));
yield return(DeviceStatus.InstantiationCoroutine(dataViewScope, container));
yield return(DataRequest.InstantiationCoroutine(dataViewScope, container));
yield return(DataView.InstantiationCoroutine("Данные", dataViewScope, container));
foreach (var command in getCommands(scopeDevice, busy))
{
if (command == Command.DOWNLOAD_FLASH && Command.DOWNLOAD_FLASH.GetInfo().IsSupportedForDevice(scopeDevice.Id))
{
yield return(FlashUploadCommand.InstantiationCoroutine(flashDumpViewScope, container));
}
yield return(DeviceCommand.InstantiationCoroutine(command, dataViewScope, container));
}
foreach (var calibrator in getCalibrators(scopeDevice, new FileSaver(scopeDevice.Id, FileExtensionFactory.Instance).SaveCalibrationFileAsync, busy).ToArray())
{
yield return(DeviceCalibration.InstantiationCoroutine(calibrator, dataViewScope, container));
yield return(injectCalibrationWidgets(container, calibrator));
}
foreach (var widget in deviceSpecificWidgetsFactory())
{
yield return(widget);
}
yield return(DataViewSettings.InstantiationCoroutine(false, dataViewScope, container));
IEnumerable <IEnumerator <ResolutionStepResult> > deviceSpecificWidgetsFactory()
{
if (scopeDevice.Id.IsOneOf(RUSDeviceId.RUS_TECHNOLOGICAL_MODULE, RUSDeviceId.RUS_MODULE, RUSDeviceId.EMC_MODULE))
{
yield return(FlashDumpLoad.InstantiationCoroutine(flashDumpViewScope, container));
yield return(DataView.InstantiationCoroutine("Данные дампа Flash", flashDumpViewScope, container));
yield return(DataViewSettings.InstantiationCoroutine(true, flashDumpViewScope, container));
yield return(injectExporters(container, flashDumpViewScope));
}
if (scopeDevice.Id.IsOneOf(RUSDeviceId.RUS_MODULE))
{
yield return(RUSModuleSetDirection.InstantiationCoroutine(dataViewScope, container));
yield return(RUSTelemetryStreamSender.InstantiationCoroutine(dataViewScope, container));
}
}
}
}
/// <summary>
/// Pulls a collection of data for a particular user.
/// </summary>
/// <returns>True if the request is successful.</returns>
public bool PullUserData(DataRequest dataRequest)
{
var pauseDelay = 3000;
if (string.IsNullOrWhiteSpace(dataRequest.OutputDirectory))
{
throw new InvalidOperationException("You must provide a path to the directory to output data to.");
}
else if (string.IsNullOrWhiteSpace(dataRequest.FileNameFormat))
{
throw new InvalidOperationException("You must provide a file name format.");
}
else if (string.IsNullOrWhiteSpace(dataRequest.Gamertag) || !IsValidGamertag(dataRequest.Gamertag))
{
throw new InvalidOperationException("You must provide the valid Xbox Live gamertag of the user to get data for.");
}
var outputDirectory = string.Format(dataRequest.OutputDirectory, dataRequest.Gamertag);
var filePath = Path.Combine(outputDirectory, dataRequest.FileNameFormat + ".xml");
if (!Directory.Exists(outputDirectory))
{
Directory.CreateDirectory(outputDirectory);
}
var currentTime = DateTime.Now.ToString("yyyyMMddHHmmss");
if (dataRequest.GetProfile)
{
var profilePath = string.Format(filePath, "profile");
dataRequest.PerformBackup("profile", "__{0}-" + currentTime);
XDocument.Parse(this.GetProfile(dataRequest.Gamertag)).Save(profilePath);
Thread.Sleep(pauseDelay);
}
var gamesPath = string.Format(filePath, "games");
if (dataRequest.GetGames)
{
dataRequest.PerformBackup("games", "__{0}-" + currentTime);
XDocument.Parse(this.GetGames(dataRequest.Gamertag)).Save(gamesPath);
Thread.Sleep(pauseDelay);
}
var friendsPath = string.Format(filePath, "friends");
if (dataRequest.GetFriends)
{
dataRequest.PerformBackup("friends", "__{0}-" + currentTime);
XDocument.Parse(this.GetFriends(dataRequest.Gamertag)).Save(friendsPath);
Thread.Sleep(pauseDelay);
}
if (dataRequest.GetGameAchievementData)
{
if (!File.Exists(gamesPath))
{
throw new NotImplementedException("Games data does not exist. Please GetGames first.");
}
if (dataRequest.GameIds != null && dataRequest.GameIds.Count > 0)
{
// Requesting very specific games.
foreach (var gameId in dataRequest.GameIds)
{
var gamePath = string.Format(filePath, "achievements-" + gameId);
dataRequest.PerformBackup("achievements-" + gameId, "__{0}-" + currentTime);
XDocument.Parse(this.GetAchievements(dataRequest.Gamertag, gameId)).Save(gamePath);
Thread.Sleep(pauseDelay);
}
}
else
{
// We need to get what games the user has played and then get data for them.
var playedGames = XDocument.Load(gamesPath).Root.Descendants("game");
if (dataRequest.GetLastGames.HasValue && dataRequest.GetLastGames.Value > 0)
{
// Limit to only the last x games.
playedGames = playedGames.Take(dataRequest.GetLastGames.Value);
}
foreach (var playedGame in playedGames)
{
var gameId = playedGame.Element("id").Value;
var gamePath = string.Format(filePath, "achievements-" + gameId);
dataRequest.PerformBackup("achievements-" + gameId, "__{0}-" + currentTime);
XDocument.Parse(this.GetAchievements(dataRequest.Gamertag, gameId)).Save(gamePath);
Thread.Sleep(pauseDelay);
}
}
}
return true;
}
public string getStaffSkills()
{
// get staff skills
DataEtcRequest bData = new DataEtcRequest();
bData.token = Token;
bData.output = OutPut;
DataRequest objrequest = new DataRequest();
objrequest.method = "GET";
objrequest.module = "staff.skills";
bData.request = objrequest;
NameValueCollection RequestApi = new NameValueCollection();
JavaScriptSerializer js = new JavaScriptSerializer();
RequestApi.Add("data", js.Serialize(bData));
return perform_request(RequestApi);
}
public string createMessage(string message)
{
// create a new message
DataEtcRequest bData = new DataEtcRequest();
bData.token = Token;
bData.output = OutPut;
DataRequest objrequest = new DataRequest();
objrequest.method = "CREATE";
objrequest.module = "messaging.messages";
bData.request = objrequest;
NameValueCollection RequestApi = new NameValueCollection();
JavaScriptSerializer js = new JavaScriptSerializer();
RequestApi.Add("data", js.Serialize(bData));
return perform_request(RequestApi);
}
public DataResult <VendorModel> List(DataRequest request)
{
return(_db.Vendor.List(request));
}
abstract public void GetShareContent(DataRequest dataRequest);
public Task <IList <Patient> > GetPatientKeysAsync(int skip, int take, DataRequest <Patient> request)
{
throw new NotImplementedException();
}
public Task <int> GetPatientCountAsync(DataRequest <Patient> request)
{
throw new NotImplementedException();
}
public Task <int> GetMemoCountAsync(DataRequest <Memo> request)
{
throw new NotImplementedException();
}
public async Task <PaymentClaim?> ProcessAsync(DataDeliveryReceiptRequest receiptRequest, Signature signature)
{
Keccak depositId = receiptRequest.DepositId;
Consumer?consumer = await _consumerRepository.GetAsync(depositId);
if (consumer is null)
{
if (_logger.IsError)
{
_logger.Error($"Could not find any consumers for deposit {depositId} in the repository.");
}
return(null);
}
DataRequest dataRequest = consumer.DataRequest;
UnitsRange range = receiptRequest.UnitsRange;
uint claimedUnits = range.Units;
BigInteger claimedValue = claimedUnits * (BigInteger)consumer.DataRequest.Value / consumer.DataRequest.Units;
ulong timestamp = _timestamper.UnixTime.Seconds;
Rlp unitsRangeRlp = _unitsRangeRlpDecoder.Encode(range);
Keccak id = Keccak.Compute(Rlp.Encode(Rlp.Encode(depositId), Rlp.Encode(timestamp), unitsRangeRlp).Bytes);
PaymentClaim paymentClaim = new PaymentClaim(id, consumer.DepositId, consumer.DataAsset.Id,
consumer.DataAsset.Name, dataRequest.Units, claimedUnits, range, dataRequest.Value,
(UInt256)claimedValue, dataRequest.ExpiryTime, dataRequest.Pepper, dataRequest.Provider,
dataRequest.Consumer, signature, timestamp, Array.Empty <TransactionInfo>(), PaymentClaimStatus.Unknown);
await _paymentClaimRepository.AddAsync(paymentClaim);
if (_logger.IsInfo)
{
_logger.Info($"Claiming a payment (id: '{paymentClaim.Id}') for deposit: '{depositId}', range: [{range.From}, {range.To}], units: {claimedUnits}.");
}
UInt256 gasPrice = await _gasPriceService.GetCurrentPaymentClaimGasPriceAsync();
Keccak?transactionHash = null;
if (_disableSendingPaymentClaimTransaction)
{
if (_logger.IsWarn)
{
_logger.Warn("*** NDM provider sending payment claim transaction is disabled ***");
}
}
else
{
transactionHash = await SendTransactionAsync(paymentClaim, gasPrice);
if (transactionHash is null)
{
if (_logger.IsInfo)
{
_logger.Info($"Payment claim (id: {paymentClaim.Id}) for deposit: '{paymentClaim.DepositId}' did not receive a transaction hash.");
}
return(paymentClaim);
}
}
if (_logger.IsInfo)
{
_logger.Info($"Payment claim (id: {paymentClaim.Id}) for deposit: '{paymentClaim.DepositId}' received a transaction hash: '{transactionHash}'.");
}
paymentClaim.AddTransaction(TransactionInfo.Default(transactionHash, 0, gasPrice, _paymentService.GasLimit,
timestamp));
paymentClaim.SetStatus(PaymentClaimStatus.Sent);
await _paymentClaimRepository.UpdateAsync(paymentClaim);
string claimedEth = ((decimal)claimedValue / Eth).ToString("0.0000");
if (_logger.IsInfo)
{
_logger.Info($"Sent a payment claim (id: '{paymentClaim.Id}') for deposit: '{depositId}', range: [{range.From}, {range.To}], units: {claimedUnits}, units: {claimedUnits}, value: {claimedValue} wei ({claimedEth} ETH, transaction hash: '{transactionHash}'.");
}
return(paymentClaim);
}
protected override Task<object> ExecuteQuery(DataRequest request, Dictionary<string, object> options)
{
DataQuery query = request.Query;
string tableName = GetTableName(request);
string command;
object[] parameters = null;
if (query.IsLookup) {
command = "select * from " + tableName + " where id = @0";
parameters = new object[] { query.ID };
}
else {
// TODO: Use actual query here to generate a SQL command
command = "select top 10 * from " + tableName;
}
Deferred<object> deferred = Deferred.Create<object>();
List<string> partitions = (options != null) ? (List<string>)options["partitions"] : null;
if (partitions == null) {
GetSqlService(request.Partition).Sql(command, parameters)
.Done(delegate(object o) {
object[] items = (object[])o;
if ((items != null) && (items.Length != 0)) {
if (query.IsLookup) {
deferred.Resolve(items[0]);
}
else {
items = query.Evaluate(items);
deferred.Resolve(items);
}
}
else {
deferred.Resolve(null);
}
})
.Fail(delegate(Exception e) {
deferred.Reject(e);
});
}
else {
List<Task<object>> tasks = partitions.Map<Task<object>>(delegate(string partition) {
return GetSqlService(partition).Sql(command, parameters);
});
Task.All((Task[])tasks).ContinueWith(delegate(Task task) {
if (task.Status == TaskStatus.Done) {
List<object> allItems = new List<object>();
foreach (Task<object> t in tasks) {
object[] items = (object[])t.Result;
foreach (object item in items) {
allItems.Add(item);
}
}
deferred.Resolve(allItems);
}
else {
deferred.Resolve(null);
}
});
}
return deferred.Task;
}
private string BuildInsertCommand(string tableName, DataRequest request, List<object> parameters)
{
StringBuilder sb = new StringBuilder();
sb.Append("insert into ");
sb.Append(tableName);
sb.Append(" (");
foreach (KeyValuePair<string, object> member in request.Item) {
if (parameters.Count != 0) {
sb.Append(",");
}
sb.Append(member.Key);
parameters.Add(member.Value);
}
sb.Append(") values (");
for (int i = 0; i < parameters.Count; i++) {
if (i != 0) {
sb.Append(",");
}
sb.Append("@");
sb.Append(i);
}
sb.Append(")");
return sb.ToString();
}
public async Task <IList <PropertyTypeModel> > GetPropertyTypesAsync(int skip, int take, DataRequest <PropertyType> request)
{
var models = new List <PropertyTypeModel>();
using (var dataService = DataServiceFactory.CreateDataService())
{
var items = await dataService.GetPropertyTypesAsync(skip, take, request);
foreach (var item in items)
{
models.Add(await CreatePropertyTypeModelAsync(item, includeAllFields: false));
}
return(models);
}
}
public async Task <IList <DocumentType> > GetDocumentTypesAsync(int skip, int take, DataRequest <DocumentType> request)
{
IQueryable <DocumentType> items = GetDocumentTypes(request);
var records = await items.Skip(skip).Take(take)
.Select(source => new DocumentType
{
DocumentTypeId = source.DocumentTypeId,
DocumentTypeName = source.DocumentTypeName,
IsDocumentTypeActive = source.IsDocumentTypeActive,
})
.AsNoTracking()
.ToListAsync();
return(records);
}
private static NpgsqlDataReader Get(TeamHttpContext teamContext, string sql, List <string> sortableColumns, DataRequest dataRequest)
{
dataRequest.SortBy = dataRequest.SortBy.ToUpper(CultureInfo.InvariantCulture).Trim();
dataRequest.SortOrder = dataRequest.SortOrder.ToUpper(CultureInfo.InvariantCulture).Trim();
if (!sortableColumns.Contains(dataRequest.SortBy))
{
dataRequest.SortBy = Constants.SORT_BY_ID;
}
if (dataRequest.SortOrder != "ASC" && dataRequest.SortOrder != "DESC")
{
dataRequest.SortOrder = "ASC";
}
sql += $" order by {dataRequest.SortBy} {dataRequest.SortOrder} ";
sql += " limit @limit offset @offset";
PostgresService dl = new PostgresService();
if (dataRequest.HasDateFiltering)
{
dl.AddDateParam("@startDate", dataRequest.From);
dl.AddDateParam("@endDate", dataRequest.To);
}
dl.AddParam("@blankQuery", dataRequest.IsBlankQuery);
dl.AddLikeParam("@query", dataRequest.Query);
dl.AddIntParam("@offset", dataRequest.Offset);
dl.AddIntParam("@limit", dataRequest.Limit);
return(dl.ExecuteSqlReturnReader(Utility.ConnString, sql));
}
public DataRequest CreateRequestTextCommand(string strMainSql, bool bAlreadyHaveWhereStatement, string strOptionalSql, FindKeywordCollection keywords)
{
DataRequest req = new DataRequest(strMainSql, CommandType.Text);
string result = string.Empty;
string con; // = " where ";
if (bAlreadyHaveWhereStatement)
{
con = " and ";
}
else
{
con = " where ";
}
if (keywords != null)
{
foreach (FindKeyword key in keywords)
{
string k1, k2;
if (key.Checked == false)
{
continue;
}
if (key.SelectedOperator == FindOperator.Between)
{
k1 = PARM_PREFIX + key.FieldMapDbVariable + "1";
k2 = PARM_PREFIX + key.FieldMapDbVariable + "2";
result += con + key.FieldMap + key.SelectedOperator.Symbol + k1 + " and " + k2;
req.Parameters.Add(k1, key.SelectedValue1[0]);
req.Parameters.Add(k2, key.SelectedValue2[0]);
con = " and ";
}
else
{
// end if (key.SelectedOperator == FindOperator.Between){
if (key.SelectedValue1.Length == 1)
{
object oValue = key.SelectedValue1[0];
// Calculate for Like Operator
if (oValue != null)
{
if (oValue is string && key.SelectedOperator == FindOperator.Like)
{
string tmp = Convert.ToString(oValue).Trim();
if (tmp.StartsWith("%") == false && tmp.EndsWith("%") == false)
{
tmp = "%" + tmp + "%";
oValue = tmp;
}
}
}
if (oValue == null)
{
result += con + key.FieldMap + " is null ";
con = " and ";
}
else
{
result += con + key.FieldMap + key.SelectedOperator.Symbol + PARM_PREFIX + key.FieldMapDbVariable;
req.Parameters.Add(PARM_PREFIX + key.FieldMapDbVariable, oValue);
con = " and ";
}
}
else
{
//if (key.SelectedValue1.Length == 1), In this case user select muliple value, So must use "in" operator.
string strFields = string.Empty;
for (int i = 0; i < key.SelectedValue1.Length; ++i)
{
if (key.SelectedValue1[i] != null)
{
string field = PARM_PREFIX + key.FieldMapDbVariable + i.ToString();
strFields += field;
req.Parameters.Add(field, key.SelectedValue1[i]);
if (i < key.SelectedValue1.Length - 1)
{
strFields += ", ";
}
}
}
if (key.SelectedOperator == FindOperator.NotEqualTo)
{
result += con + key.FieldMap + " not in (" + strFields + ")";
}
else
{
result += con + key.FieldMap + " in (" + strFields + ")";
}
con = " and ";
}
}
} // end foreach
}
req.CommandText += result + " " + strOptionalSql + " ";
return(req);
}
public DataSet GetDataSet(DataRequest req)
{
return(m_db.ExecuteDataset(req));
}
public string getAdminFiles()
{
// get administrator file listing
DataEtcRequest bData = new DataEtcRequest();
bData.token = Token;
bData.output = OutPut;
DataRequest objrequest = new DataRequest();
objrequest.method = "GET";
objrequest.module = "admin.files";
bData.request = objrequest;
NameValueCollection RequestApi = new NameValueCollection();
JavaScriptSerializer js = new JavaScriptSerializer();
RequestApi.Add("data", js.Serialize(bData));
return perform_request(RequestApi);
}
public DataRequest CreateRequestStoreCommand(string strMainSql, FindKeywordCollection keywords)
{
DataRequest req = new DataRequest(strMainSql, CommandType.StoredProcedure);
if (keywords != null)
{
foreach (FindKeyword key in keywords)
{
object value1;
object value2;
if (key.SelectedOperator == FindOperator.Between)
{
// if between operator is selected so multi value can't be used.
value1 = DBNull.Value;
value2 = DBNull.Value;
if (key.Checked)
{
if (key.SelectedValue1.Length > 0)
{
value1 = key.SelectedValue1[0];
}
if (key.SelectedValue2.Length > 0)
{
value2 = key.SelectedValue2[0];
}
}
req.Parameters.Add(string.Format("{0}{1}", key.FieldMapDbVariable, 1), value1);
req.Parameters.Add(string.Format("{0}{1}", key.FieldMapDbVariable, 2), value2);
}
else
{
// If user not selected between operator
// if type is storeprocedue, i will not care for FineOperator user selected. Because this operation will be operate by stoprocedure in side.
// check for multi value
if (key.SelectedValue1.Length == 1)
{
if (key.Checked)
{
value1 = key.SelectedValue1[0] == null ? DBNull.Value : key.SelectedValue1[0];
req.Parameters.Add(key.FieldMapDbVariable, value1);
}
else
{
req.Parameters.Add(key.FieldMapDbVariable, DBNull.Value);
}
}
else
{
if (key.Checked)
{
req.Parameters.Add(key.FieldMapDbVariable, GetValueStringFromArray(key.SelectedValue1));
}
else
{
req.Parameters.Add(key.FieldMapDbVariable, DBNull.Value);
}
}
}
}
}
return(req);
}
internal DataRequestAdapter( DataRequest request )
{
Contract.Requires( request != null );
this.request = request;
data = new Lazy<IDataPackage>( CreateDataPackage );
}
public async Task <IList <PropertyCheckListModel> > GetPropertyCheckListAsync(DataRequest <PropertyCheckList> request)
{
var collection = new PropertyCheckListCollection(this, LogService);
await collection.LoadAsync(request);
return(collection);
}
private string GetTableName(DataRequest request)
{
string name = request.Query.Collection.Name;
return String.IsNullOrEmpty(_schemaName) ? name : _schemaName + "." + name;
}
/// <summary>
/// Handle circular reference
/// </summary>
/// <param name="request">data request that has caused the circular reference</param>
/// <returns>data request value</returns>
public object HandleCircularReference(DataRequest request)
{
throw new Exception("Circular reference detected creating " + request.RequestedType.FullName);
}
/// <summary>
/// Executes IQueryable list and returns DataResult includes data
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="query"></param>
/// <param name="request"></param>
/// <returns>DataResult</returns>
public static DataResult <T> ToDataResult <T>(this IQueryable <T> query, DataRequest request) where T : class
{
var result = new DataResult <T>
{
draw = request.draw
};
result.recordsTotal = result.recordsFiltered = query.Count();
foreach (var item in request.filters)
{
var exp = GetExpression <T>((Operand)item.Operand, item.Field, item.Value);
if (exp != null)
{
query = query.Where(exp);
}
}
if (!string.IsNullOrEmpty(request.search?.value))
{
Expression <Func <T, bool> > exp = null;
var listExp = new List <FilterDefinition>();
foreach (var item in request.columns.Where(a => a.searchable))
{
ParameterExpression param = Expression.Parameter(typeof(T), "t");
MemberExpression member = Expression.Property(param, item.data);
var operand = member.Type == typeof(string) ? Operand.Contains : Operand.Equal;
listExp.Add(new FilterDefinition {
Operand = operand, Field = item.data, Value = request.search.value
});
}
exp = ExpressionBuilder.GetExpression <T>(listExp);
if (exp != null)
{
query = query.Where(exp);
}
}
if (!string.IsNullOrEmpty(request.search?.value) || request.filters.Any())
{
result.recordsFiltered = query.Count();
}
if (request.draw > 0)
{
if (!request.order.Any())
{
if (request.columns.Any())
{
query = query.OrderBy(request.columns[0].data);
}
}
else
{
foreach (var item in request.order)
{
if (item.dir == "asc")
{
query = query.OrderBy(request.columns[item.column].data);
}
else
{
query = query.OrderByDescending(request.columns[item.column].data);
}
}
}
query = query.Skip(request.start).Take(request.length);
}
result.data = query.ToList();
return(result);
}
public async Task <IList <Payment> > GetPaymentsAsync(DataRequest <Payment> request)
{
IQueryable <Payment> items = GetPayments(request);
return(await items.ToListAsync());
}
public async Task <DataRequestResult <OnCallPhoneAdapterModel> > GetAsync(DataRequest dataRequest)
{
List <OnCallPhoneAdapterModel> data = new List <OnCallPhoneAdapterModel>();
DataRequestResult <OnCallPhoneAdapterModel> result = new DataRequestResult <OnCallPhoneAdapterModel>();
var DataSource = context.OnCallPhone
.AsNoTracking();
#region 進行搜尋動作
if (!string.IsNullOrWhiteSpace(dataRequest.Search))
{
DataSource = DataSource
.Where(x => x.Title.Contains(dataRequest.Search) ||
x.PhoneNumber.Contains(dataRequest.Search));
}
#endregion
#region 進行排序動作
if (dataRequest.Sorted != null)
{
SortCondition CurrentSortCondition = dataRequest.Sorted;
switch (CurrentSortCondition.Id)
{
case (int)OnCallPhoneSortEnum.TitleDescending:
DataSource = DataSource.OrderByDescending(x => x.Title);
break;
case (int)OnCallPhoneSortEnum.TitleAscending:
DataSource = DataSource.OrderBy(x => x.Title);
break;
case (int)OnCallPhoneSortEnum.PhoneNumberDescending:
DataSource = DataSource.OrderByDescending(x => x.PhoneNumber);
break;
case (int)OnCallPhoneSortEnum.PhoneNumberAscending:
DataSource = DataSource.OrderBy(x => x.PhoneNumber);
break;
case (int)OnCallPhoneSortEnum.OrderNumberDescending:
DataSource = DataSource.OrderByDescending(x => x.OrderNumber);
break;
case (int)OnCallPhoneSortEnum.OrderNumberAscending:
DataSource = DataSource.OrderBy(x => x.OrderNumber);
break;
default:
DataSource = DataSource.OrderBy(x => x.Id);
break;
}
}
#endregion
#region 進行分頁
// 取得記錄總數量，將要用於分頁元件面板使用
result.Count = DataSource.Cast <OnCallPhone>().Count();
DataSource = DataSource.Skip(dataRequest.Skip);
if (dataRequest.Take != 0)
{
DataSource = DataSource.Take(dataRequest.Take);
}
#endregion
#region 在這裡進行取得資料與與額外屬性初始化
List <OnCallPhoneAdapterModel> adapterModelObjects =
Mapper.Map <List <OnCallPhoneAdapterModel> >(DataSource);
foreach (var adapterModelItem in adapterModelObjects)
{
await OhterDependencyData(adapterModelItem);
}
#endregion
result.Result = adapterModelObjects;
await Task.Yield();
return(result);
}
public QueryResult GetUpsellRecords(string userId, DataRequest request)
{
using (var db = new UpsellEntities())
{
// get any in-progress record last touched by current user
var inProgressRecords = db.UpsellSubmissions
.Where(r => (r.upsell_status == (int)UpsellStatus.InProgress) &&
r.last_touched_by.Equals(userId, StringComparison.OrdinalIgnoreCase));
if (inProgressRecords.Any())
{
return inProgressRecords.Select(r => new UpsellSubmissionDto
{
RecordId = r.id,
SubscriberId = r.subscriber_id,
SubscriberName = r.subscriber_name,
SubscriberAddress = new AddressDto
{
Address1 = r.subscriber_address1,
Address2 = r.subscriber_address2,
City = r.subscriber_city,
State = r.subscriber_state,
Zip = r.subscriber_zipcode
},
TelephoneNumber = r.telephone_number,
SubmittedBy = r.submitted_by,
SubmissionDateOffset = r.submission_date,
Status = (UpsellStatus)(r.upsell_status ?? 0),
LastTouchedAt = r.last_touched_at,
LastTouchedBy = r.last_touched_by
}).ToQueryResult();
}
// if no in-progress record was found, get all records
return db.UpsellSubmissions.Select(r => new UpsellSubmissionDto
{
RecordId = r.id,
SubscriberId = r.subscriber_id,
SubscriberName = r.subscriber_name,
SubscriberAddress = new AddressDto
{
Address1 = r.subscriber_address1,
Address2 = r.subscriber_address2,
City = r.subscriber_city,
State = r.subscriber_state,
Zip = r.subscriber_zipcode
},
TelephoneNumber = r.telephone_number,
SubmittedBy = r.submitted_by,
SubmissionDateOffset = r.submission_date,
Status = (UpsellStatus)(r.upsell_status ?? 0),
LastTouchedAt = r.last_touched_at,
LastTouchedBy = r.last_touched_by
}).ToQueryResult(request);
}
}
protected virtual void ValidateRequest(string requestId)
{
AppendAuditLogEvent("Loading request with id \"{0}\"", requestId);
_dataRequest = _requestManager.GetDataRequest(requestId);
}
public async Task <IList <RolePermission> > GetRolePermissionsAsync(DataRequest <RolePermission> request)
{
IQueryable <RolePermission> items = GetRolePermissions(request);
return(await items.ToListAsync());
}
public async Task <IList <DocumentType> > GetDocumentTypesAsync(DataRequest <DocumentType> request)
{
IQueryable <DocumentType> items = GetDocumentTypes(request);
return(await items.ToListAsync());
}
public async Task <IList <RolePermission> > GetRolePermissionsAsync(int skip, int take, DataRequest <RolePermission> request)
{
IQueryable <RolePermission> items = GetRolePermissions(request);
var records = await items.Skip(skip).Take(take)
.Select(source => new RolePermission
{
RolePermissionId = source.RolePermissionId,
RoleInfoId = source.RoleInfoId,
ScreenId = source.ScreenId,
OptionId = source.OptionId,
CanView = source.CanView,
})
.AsNoTracking()
.ToListAsync();
return(records);
}
//Call from ajax
public JsonResult IndexData(DataRequest request)
{
var data = _db.Vendors.ToListCustom(request);
return(Json(data, JsonRequestBehavior.AllowGet));
}
public async Task <IList <Village> > GetVillagesAsync(DataRequest <Village> request)
{
IQueryable <Village> items = GetVillages(request);
return(await items.ToListAsync());
}
protected override Task<object> ExecuteQuery(DataRequest request, Dictionary<string, object> options)
{
DataQuery query = request.Query;
string tableName = request.Query.Collection.Name;
Deferred<object> deferred = Deferred.Create<object>();
if (query.IsLookup) {
if (String.IsNullOrEmpty(request.Partition)) {
throw new Exception("Missing partition information to perform lookup.");
}
Runtime.TraceInfo("Querying table service on table %s with pk = %s, rk = %s", tableName, request.Partition, query.ID);
_tableService.QueryEntity(tableName, request.Partition, query.ID, delegate(Exception e, CloudTableEntity entity) {
if (e != null) {
deferred.Resolve(null);
}
else {
CleanEntity(entity);
deferred.Resolve(entity);
}
});
}
else {
Runtime.TraceInfo("Querying table service on table %s", tableName);
// TODO: Apply actual query
CloudTableQuery tableQuery = new CloudTableQuery().From(tableName);
if (String.IsNullOrEmpty(request.Partition) == false) {
tableQuery = tableQuery.WhereKeys(request.Partition, null);
}
_tableService.QueryEntities(tableQuery, delegate(Exception e, List<CloudTableEntity> entities) {
List<string> partitions = null;
if (options != null) {
partitions = (List<string>)options["partitions"];
if (partitions != null) {
entities = entities.Filter(delegate(CloudTableEntity entity) {
return partitions.Contains(entity.PartitionKey);
});
}
}
entities.ForEach(CleanEntity);
object[] items = query.Evaluate((object[])entities);
deferred.Resolve(items);
});
}
return deferred.Task;
}
/// <summary>
/// Add request into queue
/// </summary>
public void AddRequest(DataRequest request)
{
_queue.Add(request);
LogHelper.WriteStatus("Master: Added " + request.CallerId + " into the queue.");
PrintQueue();
}
public string updateAdminSettings(string[] settings)
{
// update admin settings
DataEtcRequest bData = new DataEtcRequest();
bData.token = Token;
bData.output = OutPut;
DataRequest objrequest = new DataRequest();
objrequest.method = "UPDATE";
objrequest.module = "admin.settings";
bData.request = objrequest;
NameValueCollection RequestApi = new NameValueCollection();
JavaScriptSerializer js = new JavaScriptSerializer();
RequestApi.Add("data", js.Serialize(bData));
return perform_request(RequestApi);
}
private static Variable Fetch(this DataSet ds, ClimateParameter parameter, string name, Variable lat, Variable lon, DateTime time, string nameUncertainty, string nameProvenance, EnvironmentalDataSource dataSource)
{
if (ds == null) throw new ArgumentNullException("ds");
if (String.IsNullOrWhiteSpace(name)) throw new ArgumentException("name is incorrect");
if (lat == null) throw new ArgumentNullException("lat");
if (lon == null) throw new ArgumentNullException("lon");
if (lat.Rank != 1) throw new ArgumentException("lat is not one-dimensional");
if (lon.Rank != 1) throw new ArgumentException("lon is not one-dimensional");
DataRequest[] req = new DataRequest[2];
req[0] = DataRequest.GetData(lat);
req[1] = DataRequest.GetData(lon);
var resp = ds.GetMultipleData(req);
double[] _lats = GetDoubles(resp[lat.ID].Data);
double[] _lons = GetDoubles(resp[lon.ID].Data);
return Fetch(ds, parameter, name, _lats, _lons, lat.Dimensions[0].Name, lon.Dimensions[0].Name, nameUncertainty: nameUncertainty, nameProvenance: nameProvenance, dataSource: dataSource, timeSlices: new DateTime[] { time });
}
public string getAdminBackups()
{
// get admin backups
DataEtcRequest bData = new DataEtcRequest();
bData.token = Token;
bData.output = OutPut;
DataRequest objrequest = new DataRequest();
objrequest.method = "GET";
objrequest.module = "admin.backups";
bData.request = objrequest;
NameValueCollection RequestApi = new NameValueCollection();
JavaScriptSerializer js = new JavaScriptSerializer();
RequestApi.Add("data", js.Serialize(bData));
return perform_request(RequestApi);
//return $this->setRequest(
// array(
// 'module' => 'admin.backups',
// 'method' => 'GET'
// )
//);
}
/// <summary>
/// Add a request into queue and order it.
/// </summary>
public void AddRequest(DataRequest request)
{
LogHelper.WriteStatus("Server: Add request to queue: " + request.CallerId + " with timestamp: " + request.Time);
_queue.Add(request);
_queue = _queue.OrderBy(x => x.Time).ToList();
PrintQueue();
}
public string getMessageDetails(int id)
{
//
DataEtcRequest bData = new DataEtcRequest();
bData.token = Token;
bData.output = OutPut;
DataRequest objrequest = new DataRequest();
//bData.id = id.ToString();
objrequest.method = "GET";
objrequest.module = "messaging.messages";
bData.request = objrequest;
NameValueCollection RequestApi = new NameValueCollection();
JavaScriptSerializer js = new JavaScriptSerializer();
RequestApi.Add("data", js.Serialize(bData));
return perform_request(RequestApi);
}
public async Task <IList <Property> > GetPropertiesAsync(DataRequest <Property> request)
{
IQueryable <Property> items = GetProperties(request);
return(await items.ToListAsync());
}
public string getWallMessages()
{
// get message wall
DataEtcRequest bData = new DataEtcRequest();
bData.token = Token;
bData.output = OutPut;
DataRequest objrequest = new DataRequest();
objrequest.method = "GET";
objrequest.module = "messaging.wall";
bData.request = objrequest;
NameValueCollection RequestApi = new NameValueCollection();
JavaScriptSerializer js = new JavaScriptSerializer();
RequestApi.Add("data", js.Serialize(bData));
return perform_request(RequestApi);
}
public async Task <IList <Property> > GetPropertiesAsync(int skip, int take, DataRequest <Property> request)
{
IQueryable <Property> items = GetProperties(request);
var records = await items.Skip(skip).Take(take)
.Select(source => new Property
{
PropertyId = source.PropertyId,
PropertyGuid = source.PropertyGuid,
PropertyName = source.PropertyName,
GroupGuid = source.GroupGuid,
PartyId = source.PartyId,
TalukId = source.TalukId,
HobliId = source.HobliId,
VillageId = source.VillageId,
DocumentTypeId = source.DocumentTypeId,
DateOfExecution = source.DateOfExecution,
DocumentNo = source.DocumentNo,
PropertyTypeId = source.PropertyTypeId,
SurveyNo = source.SurveyNo,
PropertyGMapLink = source.PropertyGMapLink,
//LandAreaInputAcres = source.LandAreaInputAcres,
//LandAreaInputGuntas = source.LandAreaInputGuntas,
//LandAreaInputAanas=source.LandAreaInputAanas,
//LandAreaInAcres = source.LandAreaInAcres,
//LandAreaInGuntas = source.LandAreaInGuntas,
//LandAreaInSqMts = source.LandAreaInSqMts,
//LandAreaInSqft = source.LandAreaInSqft,
//AKarabAreaInputAcres = source.AKarabAreaInputAcres,
//AKarabAreaInputGuntas = source.AKarabAreaInputGuntas,
//AKarabAreaInputAanas=source.AKarabAreaInputAanas,
//AKarabAreaInAcres = source.AKarabAreaInAcres,
//AKarabAreaInGuntas = source.AKarabAreaInGuntas,
//AKarabAreaInSqMts = source.AKarabAreaInSqMts,
//AKarabAreaInSqft = source.AKarabAreaInSqft,
//BKarabAreaInputAcres = source.BKarabAreaInputAcres,
//BKarabAreaInputGuntas = source.BKarabAreaInputGuntas,
//BKarabAreaInputAanas=source.BKarabAreaInputAanas,
//BKarabAreaInAcres = source.BKarabAreaInAcres,
//BKarabAreaInGuntas = source.BKarabAreaInGuntas,
//BKarabAreaInSqMts = source.BKarabAreaInSqMts,
//BKarabAreaInSqft = source.BKarabAreaInSqft,
//SaleValue1 = source.SaleValue1,
//SaleValue2 = source.SaleValue2,
IsSold = source.IsSold,
}).AsNoTracking()
.ToListAsync();
foreach (var prop in records)
{
var propDocumentTypes = (from pd in _dataSource.PropertyDocumentType
join
dt in _dataSource.DocumentTypes on pd.DocumentTypeId equals dt.DocumentTypeId
where (pd.PropertyId == prop.PropertyId)
select new PropertyDocumentType
{
PropertyDocumentTypeId = pd.PropertyDocumentTypeId,
PropertyId = pd.PropertyId,
DocumentTypeName = dt.DocumentTypeName,
DocumentTypeId = pd.DocumentTypeId,
LandAreaInputAcres = pd.LandAreaInputAcres,
LandAreaInputGuntas = pd.LandAreaInputGuntas,
LandAreaInputAanas = pd.LandAreaInputAanas,
LandAreaInAcres = pd.LandAreaInAcres,
LandAreaInGuntas = pd.LandAreaInGuntas,
LandAreaInSqMts = pd.LandAreaInSqMts,
LandAreaInSqft = pd.LandAreaInSqft,
AKarabAreaInputAcres = pd.AKarabAreaInputAcres,
AKarabAreaInputGuntas = pd.AKarabAreaInputGuntas,
AKarabAreaInputAanas = pd.AKarabAreaInputAanas,
AKarabAreaInAcres = pd.AKarabAreaInAcres,
AKarabAreaInGuntas = pd.AKarabAreaInGuntas,
AKarabAreaInSqMts = pd.AKarabAreaInSqMts,
AKarabAreaInSqft = pd.AKarabAreaInSqft,
BKarabAreaInputAcres = pd.BKarabAreaInputAcres,
BKarabAreaInputGuntas = pd.BKarabAreaInputGuntas,
BKarabAreaInputAanas = pd.BKarabAreaInputAanas,
BKarabAreaInAcres = pd.BKarabAreaInAcres,
BKarabAreaInGuntas = pd.BKarabAreaInGuntas,
BKarabAreaInSqMts = pd.BKarabAreaInSqMts,
BKarabAreaInSqft = pd.BKarabAreaInSqft,
SaleValue1 = pd.SaleValue1,
SaleValue2 = pd.SaleValue2,
LandArea = CalculateArea(pd)
}).ToList();
prop.PropertyDocumentType = propDocumentTypes;
}
return(records);
}
private async Task ProcessDataRequest(DataRequest request)
{
request.Headers.Add("Access-Control-Allow-Origin", "astral://prototype");
Uri uri = new Uri(request.Url);
AppContainer.SchemeFileDbLink item = this.schemeMap[uri.Scheme];
string str = string.Concat(item.PathPrefix, uri.GetComponents(UriComponents.Path, UriFormat.Unescaped));
string mimeType = this.GetMimeType(this.GetExtension(str));
IFileDb fileDb = Instances.FileDatabases[item.DatabaseName];
using (Stream stream = fileDb.GetStream(str.ToLowerInvariant()))
{
MemoryStream memoryStream = new MemoryStream();
await stream.CopyToAsync(memoryStream);
memoryStream.Seek((long)0, SeekOrigin.Begin);
request.SetData(memoryStream, mimeType);
}
}
private object GetObjectFromRequest(DataRequest request)
{
LOG.DebugEnter(MethodBase.GetCurrentMethod(), request);
IDbProvider dbProvider = DataProviders[DataProviderParameterType.SourceProvider.ToString()];
LOG.Debug("Provider: {0}", dbProvider);
//Set the static property for conn string
Config.connectionString = dbProvider.ConnectionString;
object returnData = null;
string testServiceName = request.Service.Name.Trim().ToLower();
LOG.Debug("Original Service Name: " + testServiceName);
if (testServiceName.Contains("_"))
{
testServiceName = testServiceName.Substring(testServiceName.IndexOf("_") + 1);
}
if (testServiceName.Contains("."))
{
testServiceName = testServiceName.Substring(testServiceName.IndexOf(".") + 1);
}
LOG.Debug("Parsed Service Name: " + testServiceName);
//??
////update NTransaction set Status = 'error' where Id = '_30093e58-c213-49ab-b58c-ed66885414fc'
int paramCount = CollectionUtils.Count(request.Parameters);
if (paramCount < 22)
{
throw new ArgumentException(string.Format("An invalid number of parameters were supplied to the service. 22 parameters are required, but only {0} were supplied.",
paramCount.ToString()));
}
int rowIndex, maxRows = -1;
if (string.IsNullOrEmpty(request.Parameters[0]))
{
rowIndex = 0;
}
else
{
rowIndex = int.Parse(request.Parameters[0]);
}
if (!string.IsNullOrEmpty(request.Parameters[1]))
{
maxRows = int.Parse(request.Parameters[1]);
}
if (maxRows < -1)
{
throw new ArgumentException(string.Format("An invalid maximum number of rows parameter was specified: {0}",
maxRows.ToString()));
}
if (_maxNumRowsToReturn > 0)
{
if ((maxRows <= 0) || (maxRows > _maxNumRowsToReturn))
{
maxRows = _maxNumRowsToReturn;
}
}
switch (testServiceName)
{
case "getmeasurements":
returnData = (object)PNWWQXProcessor.GetMeasurements
(
rowIndex,
maxRows,
request.Parameters[2],
request.Parameters[3],
request.Parameters[4],
request.Parameters[5],
request.Parameters[6],
request.Parameters[7],
request.Parameters[8],
request.Parameters[9],
request.Parameters[10],
request.Parameters[11],
request.Parameters[12],
request.Parameters[13].Split('|'),
request.Parameters[14].Split('|'),
request.Parameters[15],
request.Parameters[16],
request.Parameters[17],
request.Parameters[18],
request.Parameters[19].Split('|'),
request.Parameters[20].Split('|'),
request.Parameters[21].Split('|')
);
break;
case "getprojects":
returnData = (object)PNWWQXProcessor.GetProjects
(
rowIndex,
maxRows,
request.Parameters[2],
request.Parameters[3],
request.Parameters[4],
request.Parameters[5],
request.Parameters[6],
request.Parameters[7],
request.Parameters[8],
request.Parameters[9],
request.Parameters[10],
request.Parameters[11],
request.Parameters[12],
request.Parameters[13].Split('|'),
request.Parameters[14].Split('|'),
request.Parameters[15],
request.Parameters[16],
request.Parameters[17],
request.Parameters[18],
request.Parameters[19].Split('|'),
request.Parameters[20].Split('|'),
request.Parameters[21].Split('|')
);
break;
case "getstations":
returnData = (object)PNWWQXProcessor.GetStations
(
rowIndex,
maxRows,
request.Parameters[2],
request.Parameters[3],
request.Parameters[4],
request.Parameters[5],
request.Parameters[6],
request.Parameters[7],
request.Parameters[8],
request.Parameters[9],
request.Parameters[10],
request.Parameters[11],
request.Parameters[12],
request.Parameters[13].Split('|'),
request.Parameters[14].Split('|'),
request.Parameters[15],
request.Parameters[16],
request.Parameters[17],
request.Parameters[18],
request.Parameters[19].Split('|'),
request.Parameters[20].Split('|'),
request.Parameters[21].Split('|')
);
break;
case "getdatacatalog":
returnData = (object)PNWWQXDataCatalog.GetDataCatalog();
break;
default:
throw new ApplicationException(
string.Format("Service name not supported: [{0}] (parsed: {1})",
request.Service.Name, testServiceName));
}
return(returnData);
}
internal DataRequestedEventArgs()
{
Request = new DataRequest();
}
private string BuildUpdateCommand(string tableName, DataRequest request, List<object> parameters)
{
StringBuilder sb = new StringBuilder();
sb.Append("update ");
sb.Append(tableName);
sb.Append(" set");
foreach (KeyValuePair<string, object> member in request.Item) {
if (parameters.Count != 0) {
sb.Append(", ");
}
sb.Append(" " + member.Key);
sb.Append("=@");
sb.Append(parameters.Count);
parameters.Add(member.Value);
}
sb.Append(" where id = @");
sb.Append(parameters.Count);
parameters.Add(request.Query.ID);
return sb.ToString();
}
private static Variable Fetch(this DataSet ds, ClimateParameter parameter, string name, Variable lat, Variable lon, Variable timeSlices, string nameUncertainty, string nameProvenance, EnvironmentalDataSource dataSource, TimeBounds[] climatologyBounds = null)
{
if (ds == null) throw new ArgumentNullException("ds");
if (String.IsNullOrWhiteSpace(name)) throw new ArgumentException("name is incorrect");
if (lat == null) throw new ArgumentNullException("lat");
if (lon == null) throw new ArgumentNullException("lon");
if (timeSlices == null) throw new ArgumentNullException("timeSlices");
if (lat.Rank != 1) throw new ArgumentException("lat is not one-dimensional");
if (lon.Rank != 1) throw new ArgumentException("lon is not one-dimensional");
if (timeSlices.Rank != 1) throw new ArgumentException("time is not one-dimensional");
DataRequest[] req = null;
MultipleDataResponse resp = null;
if (climatologyBounds == null)
{
req = new DataRequest[3];
req[0] = DataRequest.GetData(lat);
req[1] = DataRequest.GetData(lon);
req[2] = DataRequest.GetData(timeSlices);
resp = ds.GetMultipleData(req);
}
else
{
req = new DataRequest[2];
req[0] = DataRequest.GetData(lat);
req[1] = DataRequest.GetData(lon);
resp = ds.GetMultipleData(req);
}
double[] _latmaxs = null;
double[] _lonmaxs = null;
double[] _latmins = null;
double[] _lonmins = null;
if (lat.Metadata.ContainsKey("bounds") && lon.Metadata.ContainsKey("bounds")) //case of cells
{
Variable latBounds = ds.Variables[(string)lat.Metadata["bounds"]];
Variable lonBounds = ds.Variables[(string)lon.Metadata["bounds"]];
if (latBounds.Rank == 2 && lonBounds.Rank == 2
&& lonBounds.Dimensions[0].Name == lon.Dimensions[0].Name
&& latBounds.Dimensions[0].Name == lat.Dimensions[0].Name)
{
Array latBoundsData = latBounds.GetData();
Array lonBoundsData = lonBounds.GetData();
int dimLatLen = latBounds.Dimensions[0].Length;
int dimLonLen = lonBounds.Dimensions[0].Length;
_latmins = new double[dimLatLen];
_latmaxs = new double[dimLatLen];
_lonmins = new double[dimLonLen];
_lonmaxs = new double[dimLonLen];
for (int i = 0; i < dimLatLen; i++)
{
_latmins[i] = Convert.ToDouble(latBoundsData.GetValue(i, 0));
_latmaxs[i] = Convert.ToDouble(latBoundsData.GetValue(i, 1));
}
for (int i = 0; i < dimLonLen; i++)
{
_lonmins[i] = Convert.ToDouble(lonBoundsData.GetValue(i, 0));
_lonmaxs[i] = Convert.ToDouble(lonBoundsData.GetValue(i, 1));
}
}
}
if (_latmins == null || _lonmins == null) //case of grid without cells
{
_latmins = GetDoubles(resp[lat.ID].Data);
_lonmins = GetDoubles(resp[lon.ID].Data);
}
DateTime[] _times = null;
if (climatologyBounds == null)
_times = (DateTime[])resp[timeSlices.ID].Data;
if (climatologyBounds != null)
return Fetch(ds, parameter, name, _latmins, _lonmins, lat.Dimensions[0].Name, lon.Dimensions[0].Name, dimTime: timeSlices.Dimensions[0].Name, latmaxs: _latmaxs, lonmaxs: _lonmaxs, climatologyIntervals: climatologyBounds, nameUncertainty: nameUncertainty, nameProvenance: nameProvenance, dataSource: dataSource);
else
return Fetch(ds, parameter, name, _latmins, _lonmins, lat.Dimensions[0].Name, lon.Dimensions[0].Name, dimTime: timeSlices.Dimensions[0].Name, latmaxs: _latmaxs, lonmaxs: _lonmaxs, timeSlices: _times, nameUncertainty: nameUncertainty, nameProvenance: nameProvenance, dataSource: dataSource);
}
public void SetDataNeeds(DataRequest request) => dashClient.SetDataNeeds(request);
