public async Task CanRunWithKey()
{
var handlerResolver = new TasqHandlerResolver();
handlerResolver.Register <CommandWithKeyAsyncHandler>();
var tasqR = new TasqR(handlerResolver);
var cmd = new CommandWithKeyAsync();
int initialCount = cmd.Keys.Count;
bool allAreTrue = true;
int callCount = 0;
var result = await tasqR.RunAsync(cmd);
foreach (var item in result)
{
callCount++;
if (!item)
{
allAreTrue = false;
}
}
Assert.AreEqual(initialCount, callCount);
Assert.IsTrue(allAreTrue);
}
public QueryResult <PayRunBO> Get([FromQuery] QueryParameter requestParameter)
{
short planYear = requestParameter.GetFromFilter <short>("PlanYear");
var query = TasqR.Run(new GetPayRunQr(planYear));
return(query);
}
public QueryResult <MasterDataSummaryBO> Get([FromQuery] QueryParameter requestParameter)
{
var personId = p_AppSession.PersonID;
var query = TasqR.Run(new GetMasterDataQr(p_AppSession.PlanYear, personId));
return(query);
}
public IProcessTrackerBase Calculate(CalculateParameter parameter)
{
parameter["PersonId"] = p_AppSession.PersonID?.ToString();
var cmd = new MasterProcessCmd(MainConstants.Job.MainCalc, parameter);
return(TasqR.Run(cmd));
}
protected async override Task OnInitializedAsync()
{
var planYearResponse = await TasqR.RunAsync(new GetPlanYearQr());
PlanYearData = planYearResponse.Data;
CanCalculate = await DataService.GetAsync <bool>(AerishAdminConstants.Uri.MasterData + "/CanCalculate");
}
public async Task <QueryResult <EmployeeSummaryBO> > Search([FromQuery] QueryParameter requestParameter, CancellationToken cancellationToken = default)
{
var result = await TasqR.RunAsync(new GetEmployeesQr(requestParameter.Filter.Value, DataResultType.Summary), cancellationToken);
return(new QueryResult <EmployeeSummaryBO>
{
Count = result.Count,
Data = result.Data
});
}
public async Task <NodeItemSetBO> Get
(
int?employeeId = null,
string filter = null,
string currentUri = null
)
{
var navigations = await TasqR.RunAsync(new GetNavigationQr(employeeId, filter, currentUri));
return(navigations);
}
public async Task CanRunWithReturn()
{
var handlerResolver = new TasqHandlerResolver();
handlerResolver.Register <TestCmdWithReturnForAsyncHandler>();
var tasqR = new TasqR(handlerResolver);
var cmd = new TestCmdWithReturnForAsync(2);
var result = await tasqR.RunAsync(cmd);
Assert.AreEqual(3, result);
}
public void CanRunWithKeyBaseType()
{
var handlerResolver = new TasqHandlerResolver();
handlerResolver.Register <CommandWithKeyHandler>();
var tasqR = new TasqR(handlerResolver);
var instance = Activator.CreateInstance(typeof(CommandWithKey));
tasqR.Run((ITasq <int, bool>)instance);
Assert.IsTrue(((CommandWithKey)instance).AllAreCorrect);
}
public void CanRunWithKey()
{
var handlerResolver = new TasqHandlerResolver();
handlerResolver.Register <CommandWithKeyHandler>();
var tasqR = new TasqR(handlerResolver);
var cmd = new CommandWithKey();
tasqR.Run(cmd);
Assert.IsTrue(cmd.AllAreCorrect);
}
public void CanRunWithReturnForAsyncHandler()
{
int startNumber = 8;
var handlerResolver = new TasqHandlerResolver();
handlerResolver.Register <TestCmdWithReturnForAsyncHandler>();
var tasqR = new TasqR(handlerResolver);
var cmd = new TestCmdWithReturnForAsync(startNumber);
int finalNumber = tasqR.Run(cmd);
Assert.AreEqual(9, finalNumber);
}
public void CanRunWithKeyForAsyncHandlerBaseType()
{
var handlerResolver = new TasqHandlerResolver();
handlerResolver.Register <CommandWithKeyAsyncHandler>();
var tasqR = new TasqR(handlerResolver);
var instance = (ITasq)Activator.CreateInstance(typeof(CommandWithKeyAsync));
tasqR.Run(instance);
Assert.IsTrue(true);
}
public void CanRunWithReturn()
{
int startNumber = 8;
var handlerResolver = new TasqHandlerResolver();
handlerResolver.Register <SampleCommandWithReturnHandler>();
var tasqR = new TasqR(handlerResolver);
var cmd = new SampleCommandWithReturn(startNumber);
int finalNumber = tasqR.Run(cmd);
Assert.AreEqual(9, finalNumber);
}
public bool Save([FromBody] string token)
{
try
{
TasqR.Run(new SaveFirebaseTokenCmd(token));
return(true);
}
catch (Exception ex)
{
p_Logger.LogError(ex);
return(false);
}
}
public Task <TokenVerificationResult> VerifyValidity([FromBody] string firebaseToken)
{
return(Task.FromResult(new TokenVerificationResult
{
TokenStatus = TokenStatus.Active
}));
string authorization = Request.Headers["Authorization"];
string token = authorization?.Split(' ').LastOrDefault();
var tokenMgr = (JwtSignInManager)p_SignInManager;
var sessionID = tokenMgr.ExtractSessionIDFromToken(token);
return(TasqR.RunAsync(new VerifyTokenValidityCmd(sessionID.GetValueOrDefault())));
}
public void CanRunWithoutReturn()
{
var testModel = new TestModel {
SampleNumber = 10
};
var handlerResolver = new TasqHandlerResolver();
handlerResolver.Register <SampleCommandWithoutReturnHandler>();
var tasqR = new TasqR(handlerResolver);
var cmd = new SampleCommandWithoutReturn(testModel);
tasqR.Run(cmd);
Assert.AreEqual(11, testModel.SampleNumber);
}
public async Task CanRunWithoutReturn()
{
var testModel = new Test3Model {
StartNumber = 10
};
var handlerResolver = new TasqHandlerResolver();
handlerResolver.Register <CommandWithAsyncWithoutReturnHandler>();
var tasqR = new TasqR(handlerResolver);
var cmd = new CommandWithAsyncWithoutReturn(testModel);
await tasqR.RunAsync(cmd);
Assert.AreEqual(11, testModel.StartNumber);
}
public async Task WillThrowExceptionFromAsyncHandler()
{
try
{
var handlerResolver = new TasqHandlerResolver();
handlerResolver.Register <TestWithErrorCmdHandler>();
var tasqR = new TasqR(handlerResolver);
var cmd = new TestWithErrorCmd();
await tasqR.RunAsync(cmd);
}
catch (AggregateException ex)
{
throw ex.GetBaseException();
}
}
public void CanThrowExceptionIfNoHandlerRegistered()
{
try
{
var handlerResolver = new TasqHandlerResolver();
var tasqR = new TasqR(handlerResolver);
var cmd = new CommandWithKey();
tasqR.Run(cmd);
}
catch (Exception ex)
{
Assert.AreEqual("Type CommandWithKey not registered", ex.Message);
throw;
}
}
public void CannotRunDefaultCmdWithHandlerWithNoParamlessConstructor()
{
try
{
var handlerResolver = new TasqHandlerResolver();
handlerResolver.Register <CmdHandlerWithNoParamlessCtorHandler>();
var tasqR = new TasqR(handlerResolver);
var cmd = new CmdHandlerWithNoParamlessCtor();
tasqR.Run(cmd);
}
catch (Exception ex)
{
Assert.IsTrue(ex.Message.StartsWith("No parameterless constructor defined for type"));
throw;
}
}
public async Task LoadNavigations(int?employeeId = null, string search = null)
{
string navUri = navigationManager.ToBaseRelativePath(navigationManager.Uri);
var result = await TasqR.RunAsync(new GetNavigationQr(employeeId, search, navUri));
FlatData.Clear();
foreach (var item in result.Nodes)
{
FlatData.Add(item);
}
if (result.SelectedNode != null)
{
SelectedNavigations = new List <object>()
{
result.SelectedNode
};
}
}
public async Task CanRunWithKeyBaseType()
{
var handlerResolver = new TasqHandlerResolver();
handlerResolver.Register <CommandWithKeyAsyncHandler>();
var tasqR = new TasqR(handlerResolver);
var instance = (ITasq <int, bool>)Activator.CreateInstance(typeof(CommandWithKeyAsync));
bool allAreTrue = true;
foreach (var item in await tasqR.RunAsync(instance))
{
if (!item)
{
allAreTrue = false;
}
}
Assert.IsTrue(allAreTrue);
}
public void CanRunWithKeyForAsyncHandler()
{
var handlerResolver = new TasqHandlerResolver();
handlerResolver.Register <CommandWithKeyAsyncHandler>();
var tasqR = new TasqR(handlerResolver);
var cmd = new CommandWithKeyAsync();
bool allAreTrue = true;
foreach (var item in tasqR.Run(cmd))
{
if (!item)
{
allAreTrue = false;
}
}
Assert.IsTrue(allAreTrue);
}
private async Task LoadDataCommand()
{
IsBusy = true;
try
{
var bills = await TasqR
.UsingAsHandler <GetTrackedBillsQrHandler_API>()
.RunAsync(new GetTrackBillsQr(AppUser.UserID));
TrackedBills.Clear();
foreach (var item in bills)
{
TrackedBills.Add(item);
}
}
catch (Exception ex)
{
LogError(ex);
}
IsBusy = false;
}
protected async Task OnWindowCalculatePayRun()
{
WindowVisible = false;
CanCalculate = false;
var calcParam = new CalculateParameter
{
PayRunID = NewCalcPayRun.PayRunID.GetValueOrDefault(),
PlanYear = NewCalcPayRun.PlanYear.GetValueOrDefault(),
PersonID = await AppSession.GetEmployeeID()
};
var cmd = new MasterProcessCmd(MainConstants.Job.MainCalc, calcParam);
var result = await TasqR.RunAsync(cmd);
//var calcParam = new CalculateParameterVM
//{
// PayRunID = NewCalcPayRun.PayRunID,
// PlanYear = NewCalcPayRun.PlanYear,
// PersonID = await AppSession.GetEmployeeID()
//};
//var result = await DataService.PostAsync<ProcessTrackerVM, CalculateParameterVM>
// (
// AerishAdminConstants.Uri.CalculateMasterData,
// calcParam
// );
CanCalculate = true;
NewCalcPayRun = new PayRunVM();
PayRunData = null;
lastPlanYear = null;
await OnReload();
}
public IProcessTrackerBase ImportPerson(ImportPersonParameter parameter)
{
var cmd = new MasterProcessCmd(MainConstants.Job.ImportPerson, parameter);
return(TasqR.Run(cmd));
}
public Task <IEnumerable <BillPaymentStepsTemplateSummaryVM> > Search(short billID, string query, CancellationToken cancellationToken = default)
{
return(TasqR.RunAsync(new GetBillPaymentStepsTemplatesQr(billID, query), cancellationToken));
}
public QueryResult <PlanYearBO> Get([FromQuery] QueryParameter requestParameter)
{
return(TasqR.Run(new GetPlanYearQr(requestParameter)));
}
public Task <BillPaymentStepsTemplateVM> FindBillTemplate(int billTemplateID, CancellationToken cancellationToken = default)
{
return(TasqR.RunAsync(new FindBillPaymentStepsTemplateQr(billTemplateID), cancellationToken));
}
public Task <TextTemplateVM> Get(string code, CancellationToken cancellationToken = default)
{
return(TasqR.RunAsync(new FindTextTemplateQr(code), cancellationToken));
}
