public async Task ForgotControllerCodeTest()
{
var data = new ForgotDataHandler();
var logic = new CoreApiLogicHandler();
data.ResultConfig = new UserConfig();
var confirm = ModelConfirm <UserConfig> .CreateSuccess(data.ResultConfig);
var start = ForgotData.GetStart();
data.Result.Setup(m => m.Execute(It.IsAny <UserByEmail>())).Returns(StandardUser);
data.Result.Setup(m => m.Execute(It.IsAny <Persist <UserConfig> >())).Returns(confirm);
logic.Result.Setup(m => m.Execute(It.IsAny <SimpleNotify>())).Returns(ActionConfirm.CreateSuccess("ok"));
var controller = new ForgotController(data, Cloud, logic);
var result = await controller.Code(start) as OkObjectResult;
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
logic.HasExecuted.Should().BeTrue();
logic.Result.Verify(s => s.Execute(It.IsAny <SimpleNotify>()), Times.Once);
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeTrue();
data.Result.Verify(s => s.Execute(It.IsAny <UserByEmail>()), Times.Once);
}
public override async Task Execute()
{
Model = new Fav
{
FilterKey = Key,
UserId = CurrentUser.Id,
TenantId = CurrentUser.TenantId,
TenantName = CurrentUser.TenantName,
AuthorId = CurrentUser.Id,
AuthorName = CurrentUser.Name,
RegionKey = CurrentUser.RegionKey,
Name = CurrentUser.Name + " -> " + Key
};
var existing = await Session.Query <Fav, FavIndex>()
.FirstOrDefaultAsync(u => u.FilterKey == Key && u.UserId == CurrentUser.Id);
if (existing != null)
{
Model = existing;
}
if (Model.EntityIds.Any(f => f == Value))
{
Confirm = ModelConfirm <Fav> .CreateFailure("Already Exists");
return;
}
Model.EntityIds.Add(Value);
await base.Execute();
}
public async Task ForgotControllerReplyTest()
{
var data = new ForgotDataHandler();
var logic = new CoreApiLogicHandler();
data.ResultConfig = new UserConfig()
{
ForgotCode = ForgotData.GetReply().Code, ResetAuth = ForgotData.GetReply().ResetAuth
};
var confirm = ModelConfirm <UserConfig> .CreateSuccess(data.ResultConfig);
var reply = ForgotData.GetReply();
data.Result.Setup(m => m.Execute(It.IsAny <UserByEmail>())).Returns(StandardUser);
data.Result.Setup(m => m.Execute(It.IsAny <Persist <UserConfig> >())).Returns(confirm);
var controller = new ForgotController(data, Cloud, logic);
var result = await controller.Reply(reply) as OkObjectResult;
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
logic.HasExecuted.Should().BeFalse();
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeTrue();
data.Result.Verify(s => s.Execute(It.IsAny <UserByEmail>()), Times.Once);
}
public async Task LoginControllerAuthTwoFactor()
{
var data = new LoginDataHandler();
var logic = new CoreApiLogicHandler();
data.ResultConfig = new UserConfig()
{
IsTwoFactor = true
};
var login = LoginData.GetLogin();
var confirm = ModelConfirm <UserConfig> .CreateSuccess(data.ResultConfig);
data.Result.Setup(m => m.Execute(It.IsAny <UserByEmail>())).Returns(StandardUser);
data.Result.Setup(m => m.Execute(It.IsAny <Persist <UserConfig> >())).Returns(confirm);
logic.Result.Setup(m => m.Execute(It.IsAny <SimpleNotify>())).Returns(ActionConfirm.CreateSuccess("ok"));
var controller = new LoginController(data, Cloud, logic);
var result = await controller.Auth(login) as OkObjectResult;
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
logic.HasExecuted.Should().BeTrue();
logic.Result.Verify(s => s.Execute(It.IsAny <SigninAuth>()), Times.Never);
logic.Result.Verify(s => s.Execute(It.IsAny <SimpleNotify>()), Times.Once);
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeTrue();
data.Result.Verify(s => s.Execute(It.IsAny <UserByEmail>()), Times.Once);
}
public async Task LoginControllerTwoFactorFailWrongCode()
{
var data = new LoginDataHandler();
var logic = new CoreApiLogicHandler();
data.ResultConfig = new UserConfig()
{
IsTwoFactor = true, TwoFactorAuth = "654321", IsTwoFactorActive = true
};
var login = LoginData.GetTwoFactor();
var confirm = ModelConfirm <UserConfig> .CreateSuccess(data.ResultConfig);
data.Result.Setup(m => m.Execute(It.IsAny <UserById>())).Returns(StandardUser);
data.Result.Setup(m => m.Execute(It.IsAny <Persist <UserConfig> >())).Returns(confirm);
var controller = new LoginController(data, Cloud, logic);
var result = await controller.TwoFactor(login) as OkObjectResult;
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
logic.HasExecuted.Should().BeFalse();
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeFalse();
data.Result.Verify(s => s.Execute(It.IsAny <UserById>()), Times.Once);
}
public void ModelConfirmTestFailure()
{
var msg = ModelConfirm <Tenant> .CreateFailure("Message");
msg.Message.Should().Be("Message");
msg.Success.Should().BeFalse();
}
public void ModelConfirmTestSuccess()
{
var msg = ModelConfirm <Tenant> .CreateSuccess(new Tenant());
msg.Success.Should().BeTrue();
var model = msg.Model;
model.Should().NotBeNull();
}
public override async Task Execute()
{
Model = await Session.Query <Attendance, AttendanceIndex>()
.FirstOrDefaultAsync(a => a.MeetingId == MeetingId && a.UserId == AttendeeId);
if (Model != null)
{
if (!Model.IsNoShow && Model.NoShowUser != CurrentUserId)
{
if (!Model.HasAttended && Model.UserId == CurrentUserId)
{
Model.HasAttended = true;
Model.AttendedWhen = DateTime.UtcNow;
Model.IsNoShow = false;
if (Model.IsCheckedIn)
{
Model.IsConfirmed = true;
}
Result = true;
}
else if (!Model.IsCheckedIn && Model.UserId != CurrentUserId)
{
Model.IsCheckedIn = true;
Model.CheckedInUser = CurrentUserId;
Model.CheckedInWhen = DateTime.UtcNow;
Model.IsNoShow = false;
if (Model.HasAttended)
{
Model.IsConfirmed = true;
}
Result = true;
}
if (Result)
{
await base.Execute();
}
}
}
else
{
Confirm = ModelConfirm <Attendance> .CreateFailure(
"Failed to find Attendance " + MeetingId + "---" + AttendeeId);
}
}
public override async Task Execute()
{
Model = await Session.Query <Fav, FavIndex>()
.FirstOrDefaultAsync(u => u.FilterKey == Key && u.UserId == CurrentUser.Id);
if (Model == null)
{
Confirm = ModelConfirm <Fav> .CreateFailure("Fav does not exist");
return;
}
Model.EntityIds.Remove(Value);
await base.Execute();
}
public override async Task Execute(ICommand command)
{
if (command.GetType().IsSubclassOf(typeof(UserByEmail)) || command.GetType() == typeof(UserByEmail))
{
if (command is UserByEmail output)
{
output.Result = (User)Result.Object.Execute(command);
output.ResultConfig = ResultConfig;
await Register();
}
}
else if (command.GetType().IsSubclassOf(typeof(UserSave)) || command.GetType() == typeof(UserSave))
{
if (command is UserSave output)
{
output.Model = (User)Result.Object.Execute(command);
output.Confirm = ModelConfirm <User> .CreateSuccess(output.Model);
await Register();
}
}
else if (command.GetType().IsSubclassOf(typeof(UserById)) || command.GetType() == typeof(UserById))
{
if (command is UserById output)
{
output.Result = (User)Result.Object.Execute(command);
output.ResultConfig = ResultConfig;
await Register();
}
}
else if (command.GetType().IsSubclassOf(typeof(Persist <UserConfig>)) || command.GetType() == typeof(Persist <UserConfig>))
{
if (command is Persist <UserConfig> output)
{
output.Confirm = ModelConfirm <UserConfig> .CreateSuccess(ResultConfig);
await Register();
}
}
else
{
await base.Execute(command);
}
}
public override async Task Execute()
{
try
{
Model.DateModified = DateTime.UtcNow;
if (string.IsNullOrEmpty(Model.Id))
{
Model.DateCreated = Model.DateModified;
}
await Session.StoreAsync(Model);
Confirm = ModelConfirm <T> .CreateSuccess(Model);
}
catch (Exception error)
{
Confirm = ModelConfirm <T> .CreateFailure(error.Message);
}
}
public async Task FavControllerRemoveMissing()
{
var data = new FavApiDataHandler();
data.Result.Setup(m => m.Execute(It.IsAny <FavRemove>())).Returns(null);
data.Confirm = ModelConfirm <Fav> .CreateFailure("Does not exist");
var controller = new FavController(data, Logic)
{
CurrentUser = StandardUser
};
var result = await controller.Remove("user", UserData.FirstId) as OkObjectResult;
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
result.Value.Should().Be(false);
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeFalse();
data.Result.Verify(s => s.Execute(It.IsAny <FavRemove>()), Times.Once);
}
public async Task FavControllerAddFailure()
{
var data = new FavApiDataHandler();
var model = FavData.GetFirst();
data.Result.Setup(m => m.Execute(It.IsAny <FavAdd>())).Returns(model);
data.Confirm = ModelConfirm <Fav> .CreateFailure("Already Exists");
var controller = new FavController(data, Logic)
{
CurrentUser = StandardUser
};
var result = await controller.Add("user", UserData.FirstId) as OkObjectResult;
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
result.Value.Should().Be(true);
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeFalse();
data.Result.Verify(s => s.Execute(It.IsAny <FavAdd>()), Times.Once);
}
public async Task AttendanceControllerNoShowFail()
{
var data = new AttendanceApiDataHandler();
var confirm = ModelConfirm <Attendance> .CreateFailure("Failed");
data.Result.Setup(m => m.Execute(It.IsAny <AttendanceNoShow>())).Returns(false);
data.ResultConfirm = confirm;
var controller = new AttendanceController(data, Logic)
{
CurrentUser = AdminUser
};
var result = await controller.NoShow(MeetingData.FirstId, StandardUser.Id) as OkObjectResult;
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
result.Value.Should().NotBeNull();
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeFalse();
data.Result.Verify(s => s.Execute(It.IsAny <AttendanceNoShow>()), Times.Once);
}
public async Task AttendanceControllerCheckIn()
{
var data = new AttendanceApiDataHandler();
var confirm = ModelConfirm <Attendance> .CreateSuccess(AttendanceData.GetFirst());
data.Result.Setup(m => m.Execute(It.IsAny <AttendanceCheckin>())).Returns(true);
data.ResultConfirm = confirm;
var controller = new AttendanceController(data, Logic)
{
CurrentUser = AdminUser
};
var result = await controller.Checkin(MeetingData.FirstId, StandardUser.Id) as OkObjectResult;
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
result.Value.Should().NotBeNull();
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeTrue();
data.Result.Verify(s => s.Execute(It.IsAny <AttendanceCheckin>()), Times.Once);
}
public override async Task Execute(ICommand command)
{
if (command.GetType() == typeof(NotifyTemplateByName))
{
if (command is NotifyTemplateByName output)
{
output.Result = (NotifyTemplate)Result.Object.Execute(command);
}
}
else if (command.GetType() == typeof(Loader <Tenant>))
{
if (command is Loader <Tenant> output)
{
output.Result = (Tenant)Result.Object.Execute(command);
}
}
else if (command.GetType() == typeof(Loader <UserConfig>))
{
if (command is Loader <UserConfig> output)
{
output.Result = (UserConfig)Result.Object.Execute(command);
}
}
else if (command.GetType().IsSubclassOf(typeof(Single <E>)))
{
if (command is Single <E> output)
{
output.Result = (E)Result.Object.Execute(command);
}
}
else if (command.GetType().IsSubclassOf(typeof(Loader <E>)) || command.GetType() == typeof(Loader <E>))
{
if (command is Loader <E> output)
{
output.Result = (E)Result.Object.Execute(command);
}
}
else if (command.GetType().IsSubclassOf(typeof(Loaders <E>)) || command.GetType() == typeof(Loaders <E>))
{
if (command is Loaders <E> output)
{
output.Result = (IEnumerable <E>)Result.Object.Execute(command);
}
}
else if (command.GetType().IsSubclassOf(typeof(Persist <E>)) || command.GetType() == typeof(Persist <E>))
{
if (command is Persist <E> output)
{
output.Model = (E)Result.Object.Execute(command);
output.Confirm = ModelConfirm <E> .CreateSuccess(output.Model);
}
}
else if (command.GetType().IsSubclassOf(typeof(Delete <E>)) || command.GetType() == typeof(Delete <E>))
{
if (command is Delete <E> output)
{
output.Result = (bool)Result.Object.Execute(command);
}
}
await Register();
}
