public async Task <IHttpActionResult> GetActiveUsers(DateTime?lastActivityThreshold, int?pageIndex = null, int?pageSize = null)
{
if (!lastActivityThreshold.HasValue)
{
return(StatusCode(HttpStatusCode.InternalServerError));
}
ResultPack <IEnumerable <Common.User> > res = null;
if (pageIndex.HasValue && pageSize.HasValue)
{
res = await DataFacade.Current.GetActiveUsers(lastActivityThreshold.Value, pageIndex.Value, pageSize.Value);
}
else if (pageIndex.HasValue)
{
res = await DataFacade.Current.GetActiveUsers(lastActivityThreshold.Value, pageIndex.Value);
}
else
{
res = await DataFacade.Current.GetActiveUsers(lastActivityThreshold.Value);
}
if (!res.IsSucceeded)
{
//TODO: Log in file if is ON
return(StatusCode(HttpStatusCode.InternalServerError));
}
return(Ok(res.ReturnParam));
}
public static Result <TAValue, string> FindAndTransformResultValue <TResult, TRValue, TAValue>(this IEnumerable <ResultPair> evalResults,
Func <TargetItem, bool> filterTargetFunc,
Func <ValuesItem, bool> selectValuesFunc, Func <TRValue, Result <TAValue, string> > selectResultFunc)
where TResult : class, ResultItem
where TRValue : class, ValuesItem
{
ResultPack findResult = evalResults.FirstToResultWithValueAndError(filterTargetFunc, ERROR_TEXT_CONTRACT_NOT_FOUND);
if (findResult.IsFailure)
{
return(Result.Fail <TAValue, string>(findResult.Error));
}
ResultItem itemResult = findResult.Value;
TResult typeResult = itemResult as TResult;
if (typeResult == null)
{
return(Result.Fail <TAValue, string>(itemResult.DecoratedError(ERROR_TEXT_RESULTS_CASTING_FAILED)));
}
Maybe <TRValue> typeValues = typeResult.ReturnValue <TRValue>(selectValuesFunc);
if (typeValues.HasNoValue)
{
return(Result.Fail <TAValue, string>(typeResult.DecoratedError(ERROR_TEXT_RESULTS_LOOKUP_FAILED)));
}
Result <TAValue, string> tranResult = selectResultFunc(typeValues.Value);
if (tranResult.IsFailure)
{
return(Result.Fail <TAValue, string>(typeResult.DecoratedError(ERROR_TEXT_RESULTS_SELECT_FAILED)));
}
return(Result.Ok <TAValue, string>(tranResult.Value));
}
public async Task <IHttpActionResult> GetByDevice(Guid deviceid, int?pageIndex = null, int?pageSize = null)
{
ResultPack <IEnumerable <Common.Log> > res = null;
if (pageIndex.HasValue && pageSize.HasValue)
{
res = await DataFacade.Current.GetLogsOfDevice(deviceid, pageIndex.Value, pageSize.Value);
}
else if (pageIndex.HasValue)
{
res = await DataFacade.Current.GetLogsOfDevice(deviceid, pageIndex.Value);
}
else
{
res = await DataFacade.Current.GetLogsOfDevice(deviceid);
}
if (!res.IsSucceeded)
{
//TODO: Log in file if is ON
return(StatusCode(HttpStatusCode.InternalServerError));
}
return(Ok(res.ReturnParam));
}
public async Task <ResultPack <IEnumerable <Common.Log> > > GetLogsOfDevice(Guid deviceId, int pageIndex = 0, int pageSize = 50)
{
var res = new ResultPack <IEnumerable <Common.Log> >();
using (var db = new DBEntities())
{
try
{
var dbLogs = await(from d in db.Logs
where d.Device.HasValue && d.Device.Value.Equals(deviceId)
orderby d.UtcTime descending
select d).Skip(pageIndex * pageSize).Take(pageSize).ToListAsync();
res.ReturnParam = dbLogs.Select(x => x.ToCommonLog()).ToList();
res.IsSucceeded = true;
}
catch (Exception ex)
{
res.IsSucceeded = false;
res.Message = ex.Message;
res.ErrorMetadata = ex.StackTrace;
}
}
return(res);
}
public async Task <ResultPack <IEnumerable <Common.Log> > > GetLogsOfUser(string username, int pageIndex = 0, int pageSize = 50)
{
if (string.IsNullOrWhiteSpace(username))
{
return new ResultPack <IEnumerable <Common.Log> > {
IsSucceeded = false, Message = "Username is empty or white space"
}
}
;
username = username.ToLower();
var res = new ResultPack <IEnumerable <Common.Log> >();
using (var db = new DBEntities())
{
try
{
var dbLogs = await(from d in db.Logs
where d.Username.ToLower().Contains(username)
orderby d.UtcTime descending
select d).Skip(pageIndex * pageSize).Take(pageSize).ToListAsync();
res.ReturnParam = dbLogs.Select(x => x.ToCommonLog()).ToList();
res.IsSucceeded = true;
}
catch (Exception ex)
{
res.IsSucceeded = false;
res.Message = ex.Message;
res.ErrorMetadata = ex.StackTrace;
}
}
return(res);
}
public async Task <ResultPack <IEnumerable <Common.User> > > GetActiveUsers(DateTime utcLastActivityThreshold, int pageIndex = 0, int pageSize = 50)
{
var res = new ResultPack <IEnumerable <Common.User> >();
using (var db = new DBEntities())
{
try
{
var dbUsers = await(from u in db.Users join l in db.Logs on u.Username equals l.Username into joinedLogs
from j in joinedLogs.DefaultIfEmpty()
where j.UtcTime >= utcLastActivityThreshold /*orderby u.RegisterationUtcDate descending*/
select new { user = u, lastActivity = joinedLogs.Max(jt => jt.UtcTime) })
.Distinct().OrderByDescending(x => x.lastActivity).Skip(pageIndex * pageSize)
.Take(pageSize).ToListAsync();
res.ReturnParam = dbUsers.Select(x => x.user.ToCommonUser(x.lastActivity)).ToList();
res.IsSucceeded = true;
}
catch (Exception ex)
{
res.IsSucceeded = false;
res.Message = ex.Message;
res.ErrorMetadata = ex.StackTrace;
}
}
return(res);
}
public async Task <ResultPack <Common.User> > GetUser(string username)
{
if (string.IsNullOrWhiteSpace(username))
{
return new ResultPack <Common.User> {
IsSucceeded = false,
Message = "Username is not provided"
}
}
;
username = username.ToLower();
var res = new ResultPack <Common.User>();
using (var db = new DBEntities())
{
try
{
var dbUser = await(from u in db.Users where u.Username.ToLower().Equals(username) select u).FirstOrDefaultAsync();
res.ReturnParam = dbUser != null?dbUser.ToCommonUser() : null;
res.IsSucceeded = true;
}
catch (Exception ex)
{
res.IsSucceeded = false;
res.Message = ex.Message;
res.ErrorMetadata = ex.StackTrace;
}
}
return(res);
}
public static Result <TResult, string> FindTypeResult <TResult>(this IEnumerable <ResultPair> evalResults,
Func <TargetItem, bool> filterTargetFunc) where TResult : class, ResultItem
{
ResultPack findResult = evalResults.FirstToResultWithValueAndError(filterTargetFunc, ERROR_TEXT_CONTRACT_NOT_FOUND);
if (findResult.IsFailure)
{
return(Result.Fail <TResult, string>(findResult.Error));
}
ResultItem itemResult = findResult.Value;
TResult typeResult = itemResult as TResult;
if (typeResult == null)
{
return(Result.Fail <TResult, string>(itemResult.DecoratedError(ERROR_TEXT_RESULTS_CASTING_FAILED)));
}
return(Result.Ok <TResult, string>(typeResult));
}
public async Task <ResultPack <IEnumerable <Common.Device> > > GetDevices(int pageIndex = 0, int pageSize = 50)
{
var res = new ResultPack <IEnumerable <Common.Device> >();
using (var db = new DBEntities())
{
try
{
var dbDevices = await(from d in db.Devices orderby d.RegisterationUtcDate descending select d).Skip(pageIndex * pageSize).Take(pageSize).ToListAsync();
res.ReturnParam = dbDevices.Select(x => x.ToCommonDevice());
res.IsSucceeded = true;
}
catch (Exception ex)
{
res.IsSucceeded = false;
res.Message = ex.Message;
res.ErrorMetadata = ex.StackTrace;
}
}
return(res);
}
public async Task <ResultPack <Common.Application> > GetApplication(Guid appId)
{
var res = new ResultPack <Common.Application>();
using (var db = new DBEntities())
{
try
{
var dbApp = await(from a in db.Applications where a.Id.Equals(appId) select a).FirstOrDefaultAsync();
res.ReturnParam = dbApp != null?dbApp.ToCommonApplication() : null;
res.IsSucceeded = true;
}
catch (Exception ex)
{
res.IsSucceeded = false;
res.Message = ex.Message;
res.ErrorMetadata = ex.StackTrace;
}
}
return(res);
}
public async Task <ResultPack <Common.Device> > GetDevice(Guid deviceId)
{
var res = new ResultPack <Common.Device>();
using (var db = new DBEntities())
{
try
{
var dbDevices = await(from d in db.Devices where d.Id.Equals(deviceId) select d).FirstOrDefaultAsync();
res.ReturnParam = dbDevices != null?dbDevices.ToCommonDevice() : null;
res.IsSucceeded = true;
}
catch (Exception ex)
{
res.IsSucceeded = false;
res.Message = ex.Message;
res.ErrorMetadata = ex.StackTrace;
}
}
return(res);
}
public static ResultPack FindResult(this IEnumerable <ResultPair> evalResults, Func <TargetItem, bool> filterTargetFunc)
{
ResultPack findResult = evalResults.FirstToResultWithValueAndError(filterTargetFunc, ERROR_TEXT_CONTRACT_CODE_NOT_FOUND);
return(findResult);
}
