protected override async Task <bool> OnIsSuperUserAsync(int processId, string userId, CancellationToken cancellationToken, IDictionary <object, object> context)
{
try
{
var policy = _connectionFactory.PolicySelector(_logger);
var result = await policy.ExecuteAsync(async() =>
{
using (var connection = _connectionFactory.Create("raa"))
{
string query = $"SELECT dbo.FN_IS_PROCESS_SUPER_USER(@processId, @userId)";
var parameters = new DynamicParameters();
parameters.AddDynamicParams(new { processId, userId });
int temp = await connection.ExecuteScalarAsync <int>(query, parameters);
return(temp == 1);
}
});
return(result);
}
catch (Exception ex)
{
_logger.LogError($"Unable to check if the user with id {userId} is a super user. Reason: {ex}");
throw;
}
}
/// <summary>
/// Asynchronously retrieves a count of <see cref="Process"/>.
/// </summary>
/// <param name="processIds">The list of process identification numbers that we are going to retrieve.</param>
/// <param name="cancellationToken">The optional token to monitor for cancellation requests.</param>
/// <param name="context">The optional execution context that applies to this operation.</param>
/// <returns>A <see cref="Task{TResult}"/> </returns>
private async Task <int> GetProcessCountAsync(IList <int> processIds, CancellationToken cancellationToken = default(CancellationToken), IDictionary <object, object> context = null)
{
try
{
var policy = _connectionFactory.PolicySelector(_logger);
var result = await policy.ExecuteAsync(async() =>
{
using (var connection = _connectionFactory.Create("raa"))
{
string sqlStmnt = @"
SELECT COUNT(P.[PROCESS_ID]) AS ProcessCount
FROM RAA.dbo.PROCESS P
WHERE P.PROCESS_ID in @Ids";
var parameters = new DynamicParameters();
parameters.AddDynamicParams(new { Ids = processIds });
int count = 0;
count = await connection.ExecuteScalarAsync <int>(sqlStmnt, parameters);
//IPagedResult<int, Process> returnResult = new PagedResult<Dictionary<int, Process>>(offset, limit, 0, processList);
return(count);
}
});
return(result);
}
catch (Exception ex)
{
_logger.LogError($"Unable to retrieve process list. Reason: {ex}");
throw;
}
}
/// <summary>
/// Asynchronously retrieves a list of <see cref="Activity"/>.
/// </summary>
/// <param name="activityIds">The list of activity identification numbers that we are going to retrieve.</param>
/// <param name="limit">Maximun number of items that we are going to return per page.</param>
/// <param name="offset">Number of pages that will be skipped.</param>
/// <param name="cancellationToken">The optional token to monitor for cancellation requests.</param>
/// <param name="context">The optional execution context that applies to this operation.</param>
/// <returns>A <see cref="Task{TResult}"/> </returns>
protected override async Task <PagedResult <Activity> > OnGetAsync(IList <int> activityIds, int offset, int limit, CancellationToken cancellationToken = default(CancellationToken), IDictionary <object, object> context = null)
{
try
{
//int count = await GetActivityCountAsync(activityIds);
int count = activityIds.Count;
List <int> subList = activityIds.Skip(offset).Take(limit).ToList <int>();
var policy = _connectionFactory.PolicySelector(_logger);
var result = await policy.ExecuteAsync(async() =>
{
using (var connection = _connectionFactory.Create("raa"))
{
IDictionary <int, Activity> activityList = await GetActivityList(subList, connection);
activityList = PopulateActivitiesNotFound(subList, activityList);
return(new PagedResult <Activity>(offset, limit, count, activityList.Values.ToList()));
}
});
return(result);
}
catch (Exception ex)
{
_logger.LogError($"Unable to retrieve activity list. Reason: {ex}");
throw;
}
}
/// <summary>
/// Asynchronously retrieves a <see cref="PersonIdentification"/>.
/// </summary>
/// <param name="employeeId">The list of process identification numbers that we are going to retrieve.</param>
/// <param name="cancellationToken">The optional token to monitor for cancellation requests.</param>
/// <param name="context">The optional execution context that applies to this operation.</param>
/// <returns>A <see cref="Task{TResult}"/> </returns>
protected override async Task <PersonIdentification> OnGetByEmployeeIdAsync(string employeeId, CancellationToken cancellationToken = default(CancellationToken), IDictionary <object, object> context = null)
{
try
{
var policy = _connectionFactory.PolicySelector(_logger);
var result = await policy.ExecuteAsync(async() =>
{
using (var connection = _connectionFactory.Create("raa"))
{
string sqlStmnt = @"
SELECT EMPLID AS EmployeeId
, HANFORD_ID AS HanfordId
, NETWORK_DOMAIN AS Domain
, NETWORK_ID AS NetworkId
, CASE WHEN ACTIVE_SW = 'Y' THEN
1
ELSE
0
END as IsActive
FROM [opwhse].[dbo].[VW_PUB_PERSON]
WHERE EMPLID = @employeeId";
var parameters = new DynamicParameters();
parameters.AddDynamicParams(new { employeeId = employeeId });
var personIdentification = await connection.QuerySingleAsync <PersonIdentification>(sqlStmnt, parameters);
if (personIdentification == null)
{
throw new RowNotInTableException();
}
return(personIdentification);
}
});
return(result);
}
catch (Exception ex)
{
_logger.LogError($"Unable to retrieve requested item. Reason: {ex}");
throw;
}
}
protected override async Task <PagedResult <ProcessNode> > OnGetByIdsAsync(IList <int> processIds, int offset, int limit, CancellationToken cancellationToken = default(CancellationToken), IDictionary <object, object> context = null)
{
int count = 0;
string query = @"SELECT PROCESS_ID AS ProcessId
, NODE_NAME AS NodeName
, NODE_LABEL AS NodeLabel
, NODE_DATATYPE AS NodeDataType
, NODE_VALUE AS NodeValue
FROM XML_NODE
WHERE PROCESS_ID IN @Ids";
try
{
DynamicParameters parameters = new DynamicParameters();
parameters.AddDynamicParams(new { Ids = processIds });
var policy = _connectionFactory.PolicySelector(_logger);
var result = await policy.ExecuteAsync(async() =>
{
using (var connection = _connectionFactory.Create("raa"))
{
IEnumerable <ProcessNode> processNodes;
IDictionary <int, ProcessNodeResult> processNodeResults = new Dictionary <int, ProcessNodeResult>();
using (SqlMapper.GridReader multi = await cn.QueryMultipleAsync(query, parameters, commandType: CommandType.Text))
{
processNodes = await multi.ReadAsync <ProcessNode>();
}
if (processNodes != null)
{
count = processNodes.Count();
// Group the nodes together by processId.
foreach (var processNode in processNodes)
{
int processId = processNode.ProcessId;
if (!processNodeResults.ContainsKey(processId))
{
processNodeResults.Add(processId, new ProcessNodeResult()
{
ProcessId = processId,
Nodes = new List <Node>()
});
}
processNodeResults[processId].Nodes.Add(new Node()
{
NodeName = processNode.NodeName,
NodeLabel = processNode.NodeLabel,
NodeValue = processNode.NodeValue,
NodeDataType = processNode.NodeDataType
});
}
}
var result = processNodeResults
.Values
.ToList()
.Skip(offset *limit)
.Take(limit);
return(new PagedResult <ProcessNodeResult>(offset, limit, count, result));
}
});
return(result);
}
catch (Exception ex)
{
_logger.LogError($"Unable to retrieve process nodes list. Reason: {ex}");
throw ex;
}
}
