public async Task <List <DmsIndex> > GetResult(string source, int id)
{
ConnectParameters connector = await GetConnector(source);
RuleManagement rules = new RuleManagement(_azureConnectionString);
string jsonRule = await rules.GetRule(source, id);
RuleModel rule = JsonConvert.DeserializeObject <RuleModel>(jsonRule);
ManageIndexTable mit = new ManageIndexTable(connector.ConnectionString);
List <DmsIndex> result = await mit.GetQcOrPredictionsFromIndex(rule.RuleKey);
return(result);
}
public async Task ClearQCFlags(string source)
{
try
{
ConnectParameters connector = await GetConnector(source);
IndexAccess idxAccess = new IndexAccess();
idxAccess.ClearAllQCFlags(connector.ConnectionString);
}
catch (Exception ex)
{
Exception error = new Exception($"DataQc: Could not clear qc flags, {ex}");
throw error;
}
}
public async Task <ActionResult <string> > SaveSource(ConnectParameters connectParameters)
{
try
{
string storageAccount = Request.Headers["AzureStorageConnection"];
Sources ss = new Sources(storageAccount);
await ss.SaveSource(connectParameters);
}
catch (Exception ex)
{
return(BadRequest(ex.ToString()));
}
return(Ok($"OK"));
}
protected override Task ConnectToDeviceNativeAsync(IDevice device, ConnectParameters connectParameters, CancellationToken cancellationToken)
{
AddToDeviceOperationRegistry(device);
if (connectParameters.ForceBleTransport)
{
ConnectToGattForceBleTransportAPI(device, connectParameters.AutoConnect);
}
else
{
((BluetoothDevice)device.NativeDevice).ConnectGatt(Application.Context, connectParameters.AutoConnect, _gattCallback);
}
return(Task.FromResult(true));
}
public async Task <string> GetActiveRules(string sourceName)
{
string result = "";
ConnectParameters connector = await Common.GetConnectParameters(azureConnectionString, sourceName);
IEnumerable <RuleModel> rules = await _ruleData.GetRulesFromSP(connector.ConnectionString);
List <RuleModel> activeRules = rules.Where(x => x.Active == "Y").ToList();
if (activeRules != null)
{
result = JsonConvert.SerializeObject(activeRules, Formatting.Indented);
}
return(result);
}
public async Task Throws_When_Initial_Connect_Fails()
{
var connectParams = new ConnectParameters();
// Make the initial connect fail.
_transportConnectorMock.Setup(c => c.ConnectAsync(It.IsAny <CancellationToken>())).Throws <TimeoutException>();
var rfbConnection = new RfbConnection(_protocolMock.Object, new NullLoggerFactory(), connectParams);
// Start should throw.
await Assert.ThrowsAsync <TimeoutException>(() => rfbConnection.StartAsync());
// Connection should still be uninitialized
Assert.Equal(ConnectionState.Uninitialized, rfbConnection.ConnectionState);
}
public void Connect(ConnectParameters connectParameters, CancellationToken cancellationToken)
{
IsOperationRequested = true;
if (connectParameters.ForceBleTransport)
{
ConnectToGattForceBleTransportAPI(connectParameters.AutoConnect, cancellationToken);
}
else
{
var connectGatt = BluetoothDevice.ConnectGatt(Application.Context, connectParameters.AutoConnect, _gattCallback);
_connectCancellationTokenRegistration.Dispose();
_connectCancellationTokenRegistration = cancellationToken.Register(() => DisconnectAndClose(connectGatt));
}
}
public async Task DeleteFunction(string source, int id)
{
ConnectParameters connector = await Common.GetConnectParameters(azureConnectionString, source);
if (connector.SourceType != "DataBase")
{
Exception error = new Exception($"RuleManagement: data source must be a Database type");
throw error;
}
using (var cnn = new SqlConnection(connector.ConnectionString))
{
string sql = "DELETE FROM pdo_rule_functions WHERE Id = @Id";
int recordsAffected = cnn.Execute(sql, new { Id = id });
}
}
public async Task <ActionResult <ConnectParameters> > Get(string name)
{
try
{
string storageAccount = Request.Headers["AzureStorageConnection"];
Sources ss = new Sources(storageAccount);
ConnectParameters connector = await ss.GetSourceParameters(name);
return(connector);
}
catch (Exception ex)
{
return(NotFound(ex.ToString()));
}
}
private void DeleteInDatabase(ConnectParameters connector, IndexModel indexItem)
{
string dataType = indexItem.DataType;
string dataKey = indexItem.DataKey;
List <DataAccessDef> accessDefs = JsonConvert.DeserializeObject <List <DataAccessDef> >(connector.DataAccessDefinition);
DataAccessDef accessDef = accessDefs.First(x => x.DataType == dataType);
string select = accessDef.Select;
string dataTable = Common.GetTable(select);
string dataQuery = "where " + dataKey;
DbUtilities dbConn = new DbUtilities();
dbConn.OpenWithConnectionString(connector.ConnectionString);
dbConn.DBDelete(dataTable, dataQuery);
dbConn.CloseConnection();
}
private async void BtnConnectClicked(object sender, EventArgs e)
{
try
{
if (device != null && !ble.Adapter.IsScanning)
{
try
{
if (device.State == Plugin.BLE.Abstractions.DeviceState.Connected)
{
this.RunOnUiThread(() =>
{
Toast.MakeText(this, "Connection sucessfull!!", ToastLength.Long).Show();
});
}
else
{
var token = new CancellationTokenSource();
ConnectParameters connectParams = new ConnectParameters(false);
await adapter.StopScanningForDevicesAsync();
await adapter.ConnectToDeviceAsync(device, connectParams, token.Token);
token.Cancel();
this.RunOnUiThread(() =>
{
Toast.MakeText(this, "Connection sucessfull!!", ToastLength.Long).Show();
});
}
}
catch (System.Exception exp)
{
this.RunOnUiThread(() =>
{
Toast.MakeText(this, "Notice in connect: " + exp.Message, ToastLength.Long).Show();
});
}
}
else
{
Toast.MakeText(this, "No Device selected", ToastLength.Long).Show();
}
}
catch (System.Exception exp)
{
Toast.MakeText(this, "Notice: " + exp.Message, ToastLength.Long).Show();
}
}
private async Task CreateFunctions(ConnectParameters connector)
{
string sql = await ReadDatabaseFile("Functions.sql");
string[] commandText = sql.Split(new string[] { String.Format("{0}GO{0}", Environment.NewLine) }, StringSplitOptions.RemoveEmptyEntries);
DbUtilities dbConn = new DbUtilities();
dbConn.OpenConnection(connector);
for (int x = 0; x < commandText.Length; x++)
{
if (commandText[x].Trim().Length > 0)
{
dbConn.SQLExecute(commandText[x]);
}
}
}
public void InitializeIndex(ConnectParameters connectionString, ConnectParameters source, string jsonTaxonomy)
{
_connectionString = connectionString.ConnectionString;
_taxonomy = jsonTaxonomy;
myIndex = new IndexDataCollection();
dbConn.OpenConnection(connectionString);
sourceAccess.OpenConnection(source, connectionString);
dataAccessDefs = JsonConvert.DeserializeObject <List <DataAccessDef> >(connectionString.DataAccessDefinition);
JsonIndexArray = JArray.Parse(jsonTaxonomy);
_idxData = new List <IndexFileData>();
foreach (JToken level in JsonIndexArray)
{
_idxData.Add(ProcessJTokens(level));
ProcessIndexArray(JsonIndexArray, level);
}
}
public void CreateRoot(ConnectParameters source)
{
string jsonSource = JsonConvert.SerializeObject(source);
IndexRootJson indexRootJson = new IndexRootJson
{
Source = jsonSource,
Taxonomy = _taxonomy
};
string json = JsonConvert.SerializeObject(indexRootJson);
string table = "pdo_qc_index";
dbConn.DBDelete(table);
myIndex.Add(new IndexData {
DataName = "QCPROJECT", DataType = "QCPROJECT", IndexNode = "/", QcLocation = null, JsonDataObject = json
});
}
public async Task <List <QcResult> > GetQCRules(DataQCParameters qcParms)
{
List <QcResult> qcResult = new List <QcResult>();
ConnectParameters connector = await GetConnector(qcParms.DataConnector);
RuleManagement rules = new RuleManagement(_azureConnectionString);
IndexAccess idxAccess = new IndexAccess();
string jsonString = await rules.GetActiveQCRules(connector.SourceName);
qcResult = JsonConvert.DeserializeObject <List <QcResult> >(jsonString);
foreach (QcResult qcItem in qcResult)
{
string query = $" where QC_STRING like '%{qcItem.RuleKey};%'";
qcItem.Failures = idxAccess.IndexCountByQuery(query, connector.ConnectionString);
}
return(qcResult);
}
private async Task CreateDMSModel(DataModelParameters dmParameters, ConnectParameters connector)
{
try
{
string sql = await ReadDatabaseFile("DataScienceManagement.sql");
string sqlFunctions = await ReadDatabaseFile("InternalRuleFunctions.sql");
DbUtilities dbConn = new DbUtilities();
dbConn.OpenConnection(connector);
dbConn.SQLExecute(sql);
dbConn.SQLExecute(sqlFunctions);
//CreateSqlSources(dbConn);
dbConn.CloseConnection();
string fileName = "WellBore.json";
string taxonomy = await ReadDatabaseFile(fileName);
await _fileStorage.SaveFile(dmParameters.FileShare, fileName, taxonomy);
fileName = "PPDMDataAccess.json";
string definition = await ReadDatabaseFile(fileName);
await _fileStorage.SaveFile("connectdefinition", fileName, definition);
fileName = "LASDataAccess.json";
definition = await ReadDatabaseFile(fileName);
await _fileStorage.SaveFile("connectdefinition", fileName, definition);
fileName = "CSVDataAccess.json";
definition = await ReadDatabaseFile(fileName);
await _fileStorage.SaveFile("connectdefinition", fileName, definition);
fileName = "PPDMReferenceTables.json";
definition = await ReadDatabaseFile(fileName);
await _fileStorage.SaveFile("connectdefinition", fileName, definition);
}
catch (Exception ex)
{
Exception error = new Exception("Create DMS Model Error: ", ex);
throw error;
}
}
private async Task CreateDSMRules(ConnectParameters connector)
{
try
{
RuleManagement rules = new RuleManagement(azureConnectionString);
List <DataAccessDef> accessDefs = await GetDataAccessDefinitions();
string ruleString = await ReadDatabaseFile("StandardRules.json");
await rules.SaveRulesToDatabase(ruleString, connector);
}
catch (Exception ex)
{
Exception error = new Exception("Load DMS Rule Error: ", ex);
throw error;
}
}
private TableEntity MapConnectorModelToTableEntity(ConnectParameters connector)
{
var entity = new TableEntity("PPDM", connector.SourceName)
{
{ "SourceType", connector.SourceType },
{ "Catalog", connector.Catalog },
{ "DatabaseServer", connector.DatabaseServer },
{ "User", connector.User },
{ "Password", connector.User },
{ "DataType", connector.DataType },
{ "FileName", connector.FileName },
{ "CommandTimeOut", connector.CommandTimeOut },
{ "ConnectionString", connector.ConnectionString }
};
return(entity);
}
public async Task <DataTable> GetLASWellHeaders(ConnectParameters source, ConnectParameters target)
{
string accessJson = await fileStorageService.ReadFile("connectdefinition", "PPDMDataAccess.json");
_dataDef = JsonConvert.DeserializeObject <List <DataAccessDef> >(accessJson);
//lasAccessJson = JObject.Parse(await fileStorageService.ReadFile("connectdefinition", "LASDataAccess.json"));
string lasMappingsStr = await fileStorageService.ReadFile("connectdefinition", "LASDataAccess.json");
lasMappings = JsonConvert.DeserializeObject <LASMappings>(lasMappingsStr);
List <string> files = new List <string>();
files = await GetLASFileNames(source.Catalog);
DataAccessDef dataType = _dataDef.First(x => x.DataType == "WellBore");
string select = dataType.Select;
string query = $" where 0 = 1";
_dbConn.OpenConnection(target);
DataTable dt = _dbConn.GetDataTable(select, query);
foreach (string file in files)
{
LASSections ls = await GetLASSections(source.Catalog, file);
lasSections.Add(ls);
GetVersionInfo(ls.versionInfo);
string json = GetHeaderInfo(ls.wellInfo);
DataRow row = dt.NewRow();
JObject jo = JObject.Parse(json);
foreach (JProperty property in jo.Properties())
{
string strValue = property.Value.ToString();
if (!string.IsNullOrEmpty(strValue))
{
if (row.Table.Columns.Contains(property.Name))
{
row[property.Name] = property.Value;
}
}
}
dt.Rows.Add(row);
}
return(dt);
}
private void CreateDMSModel(ConnectParameters connector)
{
try
{
string contentRootPath = _env.ContentRootPath;
string sqlFile = contentRootPath + @"\DataBase\DataScienceManagement.sql";
string sql = System.IO.File.ReadAllText(sqlFile);
DbUtilities dbConn = new DbUtilities();
dbConn.OpenConnection(connector);
dbConn.SQLExecute(sql);
dbConn.CloseConnection();
}
catch (Exception ex)
{
Exception error = new Exception("Create DMS Model Error: ", ex);
throw error;
}
}
private async void ConnectToPreviousDeviceAsync()
{
IDevice device;
try
{
CancellationTokenSource tokenSource = new CancellationTokenSource();
ConnectParameters connectParameters = new ConnectParameters();
var config = new ProgressDialogConfig()
{
Title = $"Searching for '{PreviousGuid}'",
CancelText = "Cancel",
IsDeterministic = false,
OnCancel = tokenSource.Cancel
};
using (var progress = _userDialogs.Progress(config))
{
progress.Show();
device = await Adapter.ConnectToKnownDeviceAsync(PreviousGuid, connectParameters, tokenSource.Token);
}
//_userDialogs.ShowSuccess($"Connected to {device.Name}.");
var deviceItem = Devices.FirstOrDefault(d => d.Device.Id == device.Id);
if (deviceItem == null)
{
deviceItem = new DeviceListItemViewModel(device);
Devices.Add(deviceItem);
//await Task.Delay(9000);
}
else
{
deviceItem.Update(device);
}
}
catch (Exception ex)
{
_userDialogs.ShowError(ex.Message, 5000);
return;
}
}
public void LoadLASFile(ConnectParameters connector, string fileText)
{
string versionInfo = "";
string wellInfo = "";
string curveInfo = "";
string parameterInfo = "";
string dataInfo = "";
string[] sections = fileText.Split("~", StringSplitOptions.RemoveEmptyEntries);
foreach (string section in sections)
{
string flag = section.Substring(0, 1);
if (flag == "V")
{
versionInfo = section;
}
if (flag == "W")
{
wellInfo = section;
}
if (flag == "C")
{
curveInfo = section;
}
if (flag == "P")
{
parameterInfo = section;
}
if (flag == "A")
{
dataInfo = section;
}
}
_dbConn.OpenConnection(connector);
GetVersionInfo(versionInfo);
GetHeaderInfo(wellInfo);
GetCurveInfo(curveInfo);
GetDataInfo(dataInfo);
LoadLogs();
_dbConn.CloseConnection();
}
public async Task <RuleModel> GetRuleAndFunction(string sourceName, int id)
{
ConnectParameters connector = await Common.GetConnectParameters(azureConnectionString, sourceName);
RuleModel rule = await _ruleData.GetRuleFromSP(id, connector.ConnectionString);
IEnumerable <RuleFunctions> functions = await _functionData.GetFunctionsFromSP(connector.ConnectionString);
RuleFunctions function = functions.FirstOrDefault(x => x.FunctionName == rule.RuleFunction);
if (function != null)
{
if (!string.IsNullOrEmpty(function.FunctionKey))
{
rule.RuleFunction = function.FunctionUrl + "?code=" + function.FunctionKey;
}
}
return(rule);
}
public async Task <ActionResult <List <DmsIndex> > > Get(string source)
{
ConnectParameters connector = Common.GetConnectParameters(connectionString, container, source);
if (connector == null)
{
return(BadRequest());
}
DbUtilities dbConn = new DbUtilities();
List <DmsIndex> index = new List <DmsIndex>();
try
{
dbConn.OpenConnection(connector);
DbQueries dbq = new DbQueries();
string select = dbq["Index"];
string query = " where INDEXLEVEL = 1";
DataTable dt = dbConn.GetDataTable(select, query);
foreach (DataRow qcRow in dt.Rows)
{
string dataType = qcRow["Dataname"].ToString();
string indexNode = qcRow["Text_IndexNode"].ToString();
int indexId = Convert.ToInt32(qcRow["INDEXID"]);
string strProcedure = $"EXEC spGetDescendants '{indexNode}'";
query = "";
DataTable qc = dbConn.GetDataTable(strProcedure, query);
int nrOfObjects = qc.Rows.Count - 1;
index.Add(new DmsIndex()
{
Id = indexId,
DataType = dataType,
NumberOfDataObjects = nrOfObjects
});
}
}
catch (Exception)
{
return(BadRequest());
}
dbConn.CloseConnection();
return(index);
}
public async Task <ActionResult <string> > SaveData(FileParameters fileParams)
{
if (fileParams == null)
{
return(BadRequest());
}
try
{
ConnectParameters connector = Common.GetConnectParameters(connectionString, container, fileParams.DataConnector);
CloudStorageAccount account = CloudStorageAccount.Parse(connectionString);
CloudFileClient fileClient = account.CreateCloudFileClient();
CloudFileShare share = fileClient.GetShareReference(fileParams.FileShare);
if (share.Exists())
{
CloudFileDirectory rootDir = share.GetRootDirectoryReference();
CloudFile file = rootDir.GetFileReference(fileParams.FileName);
if (file.Exists())
{
string fileText = file.DownloadTextAsync().Result;
LASLoader ls = new LASLoader(_env);
ls.LoadLASFile(connector, fileText);
//DbUtilities dbConn = new DbUtilities();
//dbConn.OpenConnection(connector);
//dbConn.SQLExecute(sql);
//dbConn.CloseConnection();
}
else
{
return(BadRequest());
}
}
else
{
return(BadRequest());
}
}
catch (Exception ex)
{
return(BadRequest(ex.ToString()));
}
return(Ok($"OK"));
}
public async Task BleDeviceConnect(IDevice selectedDevice)
{
if (selectedDevice == null)
{
return;
}
try
{
var adapter = CrossBluetoothLE.Current.Adapter;
var param = new ConnectParameters(forceBleTransport: true);
await adapter.ConnectToDeviceAsync(selectedDevice, param, CancellationToken.None);
await ReadDevice(selectedDevice, true);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
private async Task MakePredictions(RuleModel rule, ConnectParameters connector)
{
QcRuleSetup qcSetup = new QcRuleSetup();
qcSetup.Database = connector.Catalog;
qcSetup.DatabasePassword = connector.Password;
qcSetup.DatabaseServer = connector.DatabaseServer;
qcSetup.DatabaseUser = connector.User;
string jsonRules = JsonConvert.SerializeObject(rule);
qcSetup.RuleObject = jsonRules;
string predictionURL = rule.RuleFunction;
bool externalQcMethod = rule.RuleFunction.StartsWith("http");
indexTable = manageIndexTable.GetIndexTable();
foreach (DataRow idxRow in indexTable.Rows)
{
string jsonData = idxRow["JSONDATAOBJECT"].ToString();
if (!string.IsNullOrEmpty(jsonData))
{
qcSetup.IndexId = Convert.ToInt32(idxRow["INDEXID"]);
qcSetup.IndexNode = idxRow["TextIndexNode"].ToString();
qcSetup.DataObject = jsonData;
PredictionResult result;
if (externalQcMethod)
{
result = ProcessPrediction(qcSetup, predictionURL, rule);
if (result.Status == "Server error")
{
break;
}
}
else
{
Type type = typeof(PredictionMethods);
MethodInfo info = type.GetMethod(rule.RuleFunction);
result = (PredictionResult)info.Invoke(null, new object[] { qcSetup, _dbConn });
}
await ProcessResult(result, rule);
}
}
}
public async Task <List <PredictionCorrection> > GetPredictions(string source)
{
List <PredictionCorrection> predictionResults = new List <PredictionCorrection>();
ConnectParameters connector = await GetConnector(source);
RuleManagement rules = new RuleManagement(_azureConnectionString);
string jsonString = await rules.GetActivePredictionRules(source);
predictionResults = JsonConvert.DeserializeObject <List <PredictionCorrection> >(jsonString);
IndexAccess idxAccess = new IndexAccess();
foreach (PredictionCorrection predItem in predictionResults)
{
string query = $" where QC_STRING like '%{predItem.RuleKey};%'";
predItem.NumberOfCorrections = idxAccess.IndexCountByQuery(query, connector.ConnectionString);
}
return(predictionResults);
}
public async Task CopyFiles(TransferParameters parms)
{
try
{
ConnectParameters sourceConnector = await Common.GetConnectParameters(_azureConnectionString, parms.SourceName);
ConnectParameters targetConnector = await Common.GetConnectParameters(_azureConnectionString, parms.TargetName);
string dataAccessDefinition = await _fileStorage.ReadFile("connectdefinition", "PPDMDataAccess.json");
string referenceJson = await _fileStorage.ReadFile("connectdefinition", "PPDMReferenceTables.json");
targetConnector.DataAccessDefinition = dataAccessDefinition;
if (sourceConnector.SourceType == "DataBase")
{
DatabaseLoader dl = new DatabaseLoader();
dl.CopyTable(parms, sourceConnector.ConnectionString, targetConnector, referenceJson);
}
else if (sourceConnector.SourceType == "File")
{
if (sourceConnector.DataType == "Logs")
{
LASLoader ls = new LASLoader(_fileStorage);
await ls.LoadLASFile(sourceConnector, targetConnector, parms.Table, referenceJson);
}
else
{
CSVLoader cl = new CSVLoader(_fileStorage);
await cl.LoadCSVFile(sourceConnector, targetConnector, parms.Table);
}
}
else
{
Exception error = new Exception($"DataTransfer: Not a valid source type for {sourceConnector.SourceName}");
throw error;
}
}
catch (Exception ex)
{
Exception error = new Exception($"DataTransfer: Problems transfer files/tables, {ex}");
throw error;
}
}
private void ReadIDResponse(object sender, byte[] data, IPEndPoint source)
{
try
{
(sender as TCPConnection).DataReceivedEvent -= ReadIDResponse;
ServerSessionResponse responsePackage = Adapter.CreatePackagesFromStream(data)[0] as ServerSessionResponse;
SessionID = responsePackage.ClientSessionID;
if (responsePackage.GameReconnect)
{
ConnectParameters.SetGameReconnect();
}
}
catch
{
Error = true;
}
ReceivedEvent.Set();
}
/// <summary>
/// Begins an asynchronous connection attempt to the specified host and port.
/// Returns false if the connection attempt immediately failed, in which case the error parameter will be set.
/// If this method succeeds, the delegate will be informed of the
/// connection success/failure via the proper delegate methods.
/// </summary>
/// <param name="host">
/// The host name or IP address to connect to.
/// E.g. "deusty.com" or "70.85.193.226" or "2002:cd9:3ea8:0:88c8:b211:b605:ab59"
/// </param>
/// <param name="port">
/// The port to connect to (eg. 80)
/// </param>
/// <param name="timeout">
/// Timeout in milliseconds. Specify a negative value if no timeout is desired.
/// </param>
/// <param name="error">
/// If this method returns false, the error will contain the reason for it's failure.
/// </param>
/// <returns>
/// True if the socket was able to begin attempting to connect to the given host and port.
/// False otherwise. If false consult the error parameter for more information.
/// </returns>
public bool Connect(String host, UInt16 port, int timeout, out Exception error)
{
error = null;
// Make sure we're not closed
if ((flags & kClosed) != 0)
{
String msg = "Socket is closed.";
error = new Exception(msg);
return false;
}
// Make sure we're not already connected, or listening for connections
if ((flags & kDidPassConnectMethod) > 0)
{
String e = "Attempting to connect while connected or accepting connections.";
error = new Exception(e);
return false;
}
// Attention: Lock within public method.
// Note: Should be fine since we can only get this far if the socket is null.
lock (lockObj)
{
try
{
// We're about to start resolving the host name asynchronously.
ConnectParameters parameters = new ConnectParameters(host, port);
// Start time-out timer
if (timeout >= 0)
{
connectTimer = new System.Threading.Timer(new TimerCallback(socket_DidNotConnect),
parameters,
timeout,
Timeout.Infinite);
}
// Start resolving the host
Dns.BeginGetHostAddresses(host, new AsyncCallback(Dns_DidResolve), parameters);
}
catch (Exception e)
{
error = e;
return false;
}
flags |= kDidPassConnectMethod;
}
return true;
}
