/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="applicationContext"></param>
/// <param name="formmetadataContext"></param>
/// <returns></returns>
public async Task <List <T> > FetchMasterMetadataAsync <T>(ApplicationContext applicationContext, FormMetadataContext formMetadataContext)
{
using (var conn = await _connectionFactory.CreateConnectionAsync(applicationContext, DatabaseType.TransactionDB))
{
if (conn.State != ConnectionState.Closed)
{
conn.Close(); conn.Open();
}
var parameters = new DynamicParameters();
parameters.Add("@i_formId", formMetadataContext.FormId, DbType.Int32, ParameterDirection.Input);
//parameters.Add("@i_fieldCategoryId", formMetadataContext.FormCatId, DbType.Int32, ParameterDirection.Input);
//parameters.Add("@i_fieldId", formMetadataContext.FormFieldId, DbType.Int32, ParameterDirection.Input);
var result = await conn.QueryAsync <T>(StoredProcedures.USP_GETMASTERTABLELIST, parameters, commandType : CommandType.StoredProcedure);
if (result == null)
{
return(null);
}
else
{
return(result.ToList());
}
}
}
public async Task <int> ExecuteAsync(string sql, params QueryParameter[] parameters)
{
await using var connection = await _connectionFactory.CreateConnectionAsync();
await using var command = connection.CreateCommand();
command.CommandText = sql;
await command.PrepareAsync();
SetParams(parameters, command);
return(await TryExecuteStatement(command.ExecuteNonQueryAsync, sql, parameters));
}
public async Task <IEnumerable <T> > QueryObjectSetAsync <T>(
string sqlQuery,
RowMapper <T> rowMapper,
params QueryParameter[] queryParameters) where T : new()
{
using var dbConnection = await connectionFactory.CreateConnectionAsync()
.ConfigureAwait(false);
using var dbCommand = dbConnection.CreateCommand();
dbCommand.CommandText = sqlQuery;
dbCommand.AddParameters(queryParameters);
var resultItems = new List <T>();
using (var dbDataReader = await dbCommand.ExecuteReaderAsync().ConfigureAwait(false))
{
while (await dbDataReader.ReadAsync().ConfigureAwait(false))
{
resultItems.Add(rowMapper.Map(dbDataReader));
}
}
return(resultItems);
}
public async Task AddAsync(DeviceReading reading)
{
if (reading == null)
{
throw new ArgumentNullException(nameof(reading));
}
using (var connection = await _connectionFactory.CreateConnectionAsync())
{
var sql = $"INSERT INTO {DeviceReadingsTableName} ({nameof(DeviceReading.DeviceId)}, {nameof(DeviceReading.DateTime)}, {nameof(DeviceReading.Speed)}," +
$" {nameof(DeviceReading.PackageTrackingAlarmState)}, {nameof(DeviceReading.CurrentBoards)}, {nameof(DeviceReading.CurrentRecipeCount)})"
+ $" VALUES(@{nameof(DeviceReading.DeviceId)}, @{nameof(DeviceReading.DateTime)}, @{nameof(DeviceReading.Speed)}," +
$" @{nameof(DeviceReading.PackageTrackingAlarmState)}, @{nameof(DeviceReading.CurrentBoards)}, @{nameof(DeviceReading.CurrentRecipeCount)})";
await connection.ExecuteAsync(sql, reading);
Log.Information($"A deviceReading with ID '{reading.DeviceId}' added.");
}
}
public async Task <string> AddAsync(Device device)
{
if (device == null)
{
throw new ArgumentNullException(nameof(device));
}
using (var connection = await _connectionFactory.CreateConnectionAsync())
{
var sql = $"INSERT INTO {TableName} (ID, Type)"
+ " VALUES(@Id, @Type)";
await connection.ExecuteAsync(sql, device);
Log.Information($"A device with ID '{device.Id}' added.");
return(device.Id);
}
}
public async Task <IEnumerable <T> > QueryAsync <T>(string sql, QueryParameter[] queryParameters, RowMapper <T> rowMapper)
{
using (DbConnection connection = await connectionFactory.CreateConnectionAsync()) {
using (DbCommand command = connection.CreateCommand()) {
command.Connection = connection;
command.CommandText = sql;
AddParameters(queryParameters, command);
var items = new List <T>();
using (DbDataReader reader = await command.ExecuteReaderAsync()) {
while (await reader.ReadAsync())
{
items.Add(rowMapper(reader));
}
}
return(items);
}
}
}
public async Task WriteAsync(ConveyorSimulator.SimulationResult result)
{
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
using (var connection = await _connectionFactory.CreateConnectionAsync())
{
var sql = "INSERT INTO DeviceReadings (DeviceId, DateTime, Speed," +
" PackageTrackingAlarmState, CurrentBoards, CurrentRecipeCount)" +
$" VALUES(@{nameof(ConveyorSimulator.SimulationResult.Id)}, @{nameof(ConveyorSimulator.SimulationResult.DateTime)}," +
$" @{nameof(ConveyorSimulator.SimulationResult.Speed)}, @{nameof(ConveyorSimulator.SimulationResult.PackageTrackingAlarmState)}," +
$" @{nameof(ConveyorSimulator.SimulationResult.CurrentBoards)}, @{nameof(ConveyorSimulator.SimulationResult.CurrentRecipeCount)})";
await connection.ExecuteAsync(sql, result);
_logger.Information($"A deviceReading with ID '{result.Id}' added.");
}
}
/// <summary>
/// Returns the Global App Context
/// </summary>
/// <param name="missionCode"></param>
/// <param name="countryOpsCode"></param>
/// <param name="unitOpsCode"></param>
/// <returns></returns>
public async Task <ApplicationContext> GetAppContextAsync(string missionCode, string countryOpsCode, string unitOpsCode)
{
var context = new ApplicationContext();
using (IDbConnection connection = await _connectionFactory.CreateConnectionAsync(context, DatabaseType.SharedDB))
{
connection.Open();
var param = new
{
MissionCode = missionCode,
CountryOpsCode = countryOpsCode,
UnitOpsCode = unitOpsCode
};
context = await connection.QueryFirstOrDefaultAsync <ApplicationContext>(BaseSPConstant.usp_GetAppContext
, param, null, null, CommandType.StoredProcedure);
}
return(context);
}
public static async Task <Token> GetTokenAsync(IConnectionFactory connectionFactory)
{
using (SslStream stream = await connectionFactory.CreateConnectionAsync())
{
var msg = await StreamUtils.ReadMessageAsync(stream, i => i.Contains("InvalidateAccount"));
await StreamUtils.SendMessageAsync(stream, "<Request Type=\"GetToken\" />\r\n");
await StreamUtils.ReadMessageAsync(stream, i => i.Contains("<?xml version=\"1.0\" encoding=\"utf-8\" ?><Response Type=\"GetToken\" Status=\"Ready\"/>\r\n"));
msg = await StreamUtils.ReadMessageAsync(stream, i => i.Contains("<Update Type=\"GetToken\" Status=\"Completed\"") || i.Contains("Response Status=\"Fail\" Type=\"Authenticate\" ErrorCode=\"301\""));
if (msg.Contains("Response Status=\"Fail\" Type=\"Authenticate\" ErrorCode=\"301\""))
{
return(null);
}
Regex regex = new Regex(@"(?<=\bToken="")[^""]*");
Match match = regex.Match(msg);
string token = match.Value;
return(new Token(token));
}
}
public virtual async Task <IDbConnection> GetConnectionAsync()
{
IDbConnection con = await connectionFactory.CreateConnectionAsync();
return(con);
}