public async Task <IActionResult> Stats()
{
const int back = 30;
var data = new StatsComposite()
{
CurrentUser = CurrentUser, Back = back
};
await DataHandler.Execute(data);
var meetingDays = new DayDisplay <MeetingDisplay>()
{
DateFrom = DateHelper.FormatDayStart(DateTime.UtcNow.AddDays(-back)),
Days = back,
Source = data.Result.Meetings
};
await LogicHandler.Execute(meetingDays);
var msgDays = new DayDisplay <MsgDisplay>()
{
DateFrom = DateHelper.FormatDayStart(DateTime.UtcNow.AddDays(-back)),
Days = back,
Source = data.Result.Msgs
};
await LogicHandler.Execute(msgDays);
return(Ok(new StatsViewModel()
{
Meetings = meetingDays.Result,
Messages = msgDays.Result,
Tenant = data.Result.Tenant,
Success = true
}));
}
public async Task <IActionResult> Delete(string id)
{
var query = new Loader <VisibleFile> {
Id = id
};
await DataHandler.Execute(query);
if (query.Result != null && AuthoriseWrite(query.Result))
{
var delete = new FileDelete {
CloudHandler = CloudHandler, File = query.Result
};
await LogicHandler.Execute(delete);
if (delete.Result.Success)
{
await DataHandler.Commit();
return(Ok(ConfirmViewModel.CreateSuccess(id)));
}
return(Ok(ConfirmViewModel.CreateFailure("Failed to delete file")));
}
return(Unauthorized());
}
public async Task <IActionResult> Reconnect([FromBody] ReconnectViewModel viewModel)
{
if (viewModel.Key.Equals(EncryptHelper.Encrypt(viewModel.Id + Keys.Salty)))
{
var query = new UserById {
Id = viewModel.Id
};
await DataHandler.Execute(query);
if (query.Result != null && query.Result.IsActive &&
(query.ResultTenant == null || query.ResultTenant.IsActive))
{
var logic = new SigninAuth
{
Login = query.Result,
Config = query.ResultConfig,
Tenant = query.ResultTenant,
Settings = CloudHandler.Settings
};
await LogicHandler.Execute(logic);
return(Ok(logic.Result));
}
}
return(Ok(new FailViewModel {
Message = "Reconnect failed"
}));
}
public override async Task <IActionResult> Post([FromBody] MeetingViewModel viewModel)
{
var model = await Parse(viewModel);
if (AuthoriseWrite(model))
{
model.Participants = viewModel.Attendees.Select(f => f.Id).ToList();
var attendCheck = new AttendCheck()
{
CurrentUser = CurrentUser,
DataHandler = DataHandler,
LogicHandler = LogicHandler,
Meeting = model
};
await LogicHandler.Execute(attendCheck);
if (attendCheck.Result)
{
await DataHandler.Commit();
return(Ok(ConfirmViewModel.CreateSuccess(attendCheck.Meeting)));
}
else
{
return(Ok(ConfirmViewModel.CreateFailure("Failed to save Meeting")));
}
}
return(Unauthorized());
}
public override async Task Execute()
{
var token = new WriteToken {
UserId = Login.Id, JwtKey = Settings.Value.JwtKey
};
await LogicHandler.Execute(token);
if (token.Result)
{
Result.Success = true;
Result.Id = Login.Id;
Result.Verification = token.Verification;
Result.Config = Config;
Result.Key = EncryptHelper.Encrypt(Login.Id + Keys.Salty);
Result.User.Id = Login.Id;
Result.User.Name = Login.Name;
Result.User.Email = Login.Email;
Result.User.HasProfile = Login.HasProfile;
Result.User.HasPhone = !string.IsNullOrEmpty(Login.EncryptedPhone);
Result.User.ProfileThumbUrl = Login.ProfileThumbUrl;
Result.Right = Login.Right;
Result.Success = true;
if (Tenant != null)
{
Result.User.TenantId = Tenant.Id;
Result.User.ClientHasProfile = Tenant.HasProfile;
Result.User.TenantName = Tenant.Name;
Result.User.ClientProfileThumbUrl = Tenant.ProfileThumbUrl;
}
}
await Task.CompletedTask;
}
public async Task <IActionResult> Reset([FromBody] ForgotResetViewModel viewModel)
{
var query = new UserByEmail {
Email = viewModel.Email
};
await DataHandler.Execute(query);
if (query.Result != null && query.Result.IsActive &&
(query.ResultTenant == null || query.ResultTenant.IsActive))
{
var config = query.ResultConfig;
if (!string.IsNullOrEmpty(config.ForgotCode) && !string.IsNullOrEmpty(config.ResetCode) && config.ForgotCode == viewModel.Code && config.ResetCode == viewModel.ResetCode)
{
var user = query.Result;
user.EncryptedPwd = EncryptHelper.Encrypt(viewModel.ResetPassword);
config.ResetAuth = string.Empty;
config.ResetCode = string.Empty;
config.ForgotCode = string.Empty;
config.ForgotCounter = 0;
var persistUser = new Persist <User>()
{
Model = user
};
await DataHandler.Execute(persistUser);
var persistConfig = new Persist <UserConfig>()
{
Model = config
};
await DataHandler.Execute(persistConfig);
if (persistUser.Confirm.Success)
{
await DataHandler.Commit();
}
var logic = new SigninAuth
{
Login = query.Result,
Config = query.ResultConfig,
Tenant = query.ResultTenant,
Settings = CloudHandler.Settings
};
await LogicHandler.Execute(logic);
return(Ok(logic.Result));
}
return(Ok(new FailViewModel {
Message = "Code does not match"
}));
}
return(Ok(new FailViewModel {
Message = "Email not found"
}));
}
public async Task <IActionResult> Post([FromBody] SignupViewModel viewModel)
{
var query = new UserByEmail {
Email = viewModel.Email
};
await DataHandler.Execute(query);
if (query.Result == null)
{
var signup = new SignupUser()
{
DataHandler = DataHandler,
Input = viewModel,
LogicHandler = LogicHandler,
CloudHandler = CloudHandler
};
await LogicHandler.Execute(signup);
return(Ok(signup.ResultAuth));
}
return(Ok(new FailViewModel {
Message = "Email already in use"
}));
}
public async Task LogicHandlerTestInit()
{
var command = new FakeLogicCommand();
var logic = new LogicHandler()
{
User = StandardUser
};
await logic.Execute(command);
}
public async Task <IActionResult> Code([FromBody] ForgotViewModel viewModel)
{
var query = new UserByEmail {
Email = viewModel.Email
};
await DataHandler.Execute(query);
if (query.Result != null && query.Result.IsActive &&
(query.ResultTenant == null || query.ResultTenant.IsActive))
{
var config = query.ResultConfig;
if (config.ForgotCounter < 10)
{
config.ForgotCode = StringHelper.GenerateCode(12);
config.ResetAuth = Convert.ToString(EncryptHelper.Randomizer(100000, 999999));
config.ForgotCounter += 1;
var persist = new Persist <UserConfig>()
{
Model = config
};
await DataHandler.Execute(persist);
if (persist.Confirm.Success)
{
await DataHandler.Commit();
}
var notify = new SimpleNotify
{
CloudHandler = CloudHandler,
DataHandler = DataHandler,
CurrentUser = query.Result,
LogicHandler = LogicHandler,
Model = persist.Model,
TemplateName = "forgot"
};
await LogicHandler.Execute(notify);
return(Ok(new ForgotCodeViewModel()
{
Email = viewModel.Email, Code = config.ForgotCode, Success = true
}));
}
return(Ok(new FailViewModel {
Message = "Too many Forgot Password attempts -> " + config.ForgotCounter
}));
}
return(Ok(new FailViewModel {
Message = "Email not found"
}));
}
public void LogicHandlerTestInvalid()
{
var command = new TenantByEntryKey();
var logic = new LogicHandler()
{
User = StandardUser
};
Assert.That(() => logic.Execute(command), Throws.TypeOf <ArgumentException>());
}
public async Task LogicHandlerTestInitData()
{
var command = new FakeLogicCommand();
var data = new FakeApiDataEntityHandler <Tenant>();
var logic = new LogicHandler()
{
DataHandler = data, User = StandardUser
};
await logic.Execute(command);
logic.User.Id.Should().Be(StandardUser.Id);
}
public async Task <IActionResult> TwoFactor([FromBody] TwoFactorViewModel viewModel)
{
var query = new UserById {
Id = viewModel.Id
};
await DataHandler.Execute(query);
if (query.Result != null && query.Result.IsActive &&
(query.ResultTenant == null || query.ResultTenant.IsActive))
{
var config = query.ResultConfig;
if (config.TwoFactorAuth == viewModel.Auth && config.IsTwoFactorActive && config.IsTwoFactor)
{
config.IsTwoFactorActive = false;
config.TwoFactorAuth = string.Empty;
var persist = new Persist <UserConfig>()
{
Model = config
};
await DataHandler.Execute(persist);
if (persist.Confirm.Success)
{
await DataHandler.Commit();
}
var logic = new SigninAuth
{
Login = query.Result,
Config = query.ResultConfig,
Tenant = query.ResultTenant,
Settings = CloudHandler.Settings
};
await LogicHandler.Execute(logic);
return(Ok(logic.Result));
}
return(Ok(new FailViewModel {
Message = "Code does not match"
}));
}
return(Ok(new FailViewModel {
Message = "Identity not found"
}));
}
public async Task <IActionResult> Upload([FromForm] IFormFile file)
{
var process = new ProcessFile {
CloudHandler = CloudHandler, CurrentUser = CurrentUser, Source = file
};
await LogicHandler.Execute(process);
if (process.Result.Success)
{
await DataHandler.Commit();
var result = Mapper.Map <VisibleViewModel>(process.Model);
return(Json(result));
}
return(NotFound());
}
public override async Task <IActionResult> Post([FromBody] MsgViewModel viewModel)
{
var model = await Parse(viewModel);
if (AuthoriseWrite(model))
{
model.Files = viewModel.Files.Select(f => f.Id).ToList();
model.Recipients = viewModel.Recipients.Select(f => f.Id).ToList();
var persist = new Persist <Msg> {
Model = model
};
await DataHandler.Execute(persist);
if (persist.Confirm.Success)
{
await DataHandler.Commit();
}
if (string.IsNullOrEmpty(viewModel.Id) || viewModel.ForceNotify)
{
foreach (var recipient in model.Recipients)
{
var loader = new UserById()
{
Id = recipient
};
await DataHandler.Execute(loader);
var notify = new SimpleNotify
{
CloudHandler = CloudHandler, DataHandler = DataHandler, CurrentUser = loader.Result,
LogicHandler = LogicHandler, Model = persist.Model, TemplateName = "message"
};
await LogicHandler.Execute(notify);
}
}
return(Ok(ConfirmViewModel.CreateFromConfirm(persist.Confirm)));
}
return(Unauthorized());
}
public async Task <IActionResult> Set(string key, string value)
{
var logic = new ChangeConfig
{
CurrentUser = CurrentUser, ResultConfig = CurrentConfig, UserId = CurrentUser.Id, Key = key,
Value = value
};
await LogicHandler.Execute(logic);
if (logic.Result)
{
await DataHandler.Commit();
}
return(Ok(new ConfigViewModel()
{
Config = logic.ResultConfig, Key = key, Success = logic.Result
}));
}
public override async Task <IActionResult> Post([FromBody] TenantViewModel viewModel)
{
var name = string.Empty;
if (!string.IsNullOrEmpty(viewModel.Id))
{
var original = await Load(viewModel.Id);
name = original.Name;
}
var model = await Parse(viewModel);
if (AuthoriseWrite(model))
{
if (string.IsNullOrEmpty(model.Id))
{
model.AuthorId = CurrentUser.Id;
model.AuthorName = CurrentUser.Name;
model.EntryKey = StringHelper.GenerateCode(10).ToLower();
}
var image = new CheckProfileImage {
Model = model
};
await LogicHandler.Execute(image);
var persist = new TenantSave {
Model = model, Original = name
};
await DataHandler.Execute(persist);
if (persist.Confirm.Success)
{
await DataHandler.Commit();
}
return(Ok(ConfirmViewModel.CreateFromConfirm(persist.Confirm)));
}
return(Unauthorized());
}
public override async Task <IActionResult> Post([FromBody] UserViewModel viewModel)
{
var name = string.Empty;
if (!string.IsNullOrEmpty(viewModel.Id))
{
var original = await Load(viewModel.Id);
name = original.Name;
}
var model = await Parse(viewModel);
if (AuthoriseWrite(model))
{
if (!string.IsNullOrEmpty(viewModel.Password))
{
model.EncryptedPwd = EncryptHelper.Encrypt(viewModel.Password);
}
model.EncryptedPhone = viewModel.Phone;
var image = new CheckProfileImage {
Model = model
};
await LogicHandler.Execute(image);
var persist = new UserSave {
Model = model, Original = name
};
await DataHandler.Execute(persist);
if (persist.Confirm.Success)
{
await DataHandler.Commit();
}
return(Ok(ConfirmViewModel.CreateFromConfirm(persist.Confirm)));
}
return(Unauthorized());
}
public async Task <IActionResult> Home()
{
const int forward = 8;
var data = new HomeComposite()
{
CurrentUser = CurrentUser, Forward = forward
};
await DataHandler.Execute(data);
var days = new DayDisplay <AttendanceDisplay>()
{
DateFrom = DateTime.UtcNow, Days = forward, Source = data.Result.Attendances
};
await LogicHandler.Execute(days);
return(Ok(new HomeViewModel()
{
Attendance = days.Result, Msg = data.Result.Msgs, Success = true
}));
}
public override async Task Execute()
{
IProcessCommand processor = null;
if (IsImage())
{
processor = new ProcessImage
{
Source = Source, CurrentUser = CurrentUser, LoadType = "File Upload", CloudHandler = CloudHandler,
DataHandler = DataHandler
};
}
else if (IsVideo())
{
}
else if (IsDocument())
{
}
if (processor != null)
{
await LogicHandler.Execute(processor);
if (processor.Result != null && processor.Result.Success)
{
Model = processor.Result.Value as VisibleFile;
Result = processor.Result;
}
else
{
Result = ActionConfirm.CreateFailure("File " + Source.FileName + " -> failed to load");
}
}
else
{
Result = ActionConfirm.CreateFailure("File " + Source.FileName + " -> type not supported");
}
}
public async Task <IActionResult> Recur([FromBody] RecurViewModel viewModel)
{
var loader = new Loader <Meeting>()
{
Id = viewModel.MeetingId
};
await DataHandler.Execute(loader);
if (loader.Result == null)
{
return(NotFound());
}
if (loader.Result.AuthorId == CurrentUser.Id ||
(loader.Result.TenantId == CurrentUser.TenantId &&
(CurrentUser.Right.CanAdmin || CurrentUser.Right.CanAuth)) || CurrentUser.Right.CanSuperuser)
{
var model = new Meeting()
{
Participants = loader.Result.Participants,
AuthorId = CurrentUser.Id,
AuthorName = CurrentUser.Name,
TenantId = CurrentUser.TenantId,
TenantName = CurrentUser.TenantName,
MeetingTypeId = loader.Result.MeetingTypeId,
RegionKey = CurrentUser.RegionKey,
Text = loader.Result.Text,
Name = loader.Result.Name,
IsPrivate = loader.Result.IsPrivate,
When = viewModel.When,
PreviousId = loader.Result.Id,
ForceNotify = false
};
var attendCheck = new AttendCheck()
{
CurrentUser = CurrentUser,
DataHandler = DataHandler,
LogicHandler = LogicHandler,
Meeting = model
};
await LogicHandler.Execute(attendCheck);
if (attendCheck.Result)
{
loader.Result.NextId = attendCheck.Meeting.Id;
loader.Result.IsComplete = true;
var persist = new Persist <Meeting> {
Model = loader.Result
};
await DataHandler.Execute(persist);
if (persist.Confirm.Success)
{
await DataHandler.Commit();
return(Ok(ConfirmViewModel.CreateSuccess(attendCheck.Meeting)));
}
}
return(Ok(ConfirmViewModel.CreateFailure("Failed to save Meeting")));
}
return(Unauthorized());
}
public async Task <IActionResult> Auth([FromBody] LoginViewModel viewModel)
{
var query = new UserByEmail {
Email = viewModel.Email
};
await DataHandler.Execute(query);
if (query.Result != null && query.Result.IsActive &&
(query.ResultTenant == null || query.ResultTenant.IsActive))
{
if (query.Result.EncryptedPwd.Equals(EncryptHelper.Encrypt(viewModel.Pwd)))
{
if (query.ResultConfig.IsTwoFactor)
{
query.ResultConfig.TwoFactorAuth = Convert.ToString(EncryptHelper.Randomizer(100000, 999999));
query.ResultConfig.IsTwoFactorActive = true;
var persist = new Persist <UserConfig>()
{
Model = query.ResultConfig
};
await DataHandler.Execute(persist);
if (persist.Confirm.Success)
{
await DataHandler.Commit();
}
var notify = new SimpleNotify
{
CloudHandler = CloudHandler,
DataHandler = DataHandler,
CurrentUser = query.Result,
LogicHandler = LogicHandler,
Model = persist.Model,
TemplateName = "twofactor"
};
await LogicHandler.Execute(notify);
return(Ok(new AuthViewModel()
{
Id = query.Result.Id, IsTwoFactor = true
}));
}
else
{
var logic = new SigninAuth
{
Login = query.Result,
Config = query.ResultConfig,
Tenant = query.ResultTenant,
Settings = CloudHandler.Settings
};
await LogicHandler.Execute(logic);
return(Ok(logic.Result));
}
}
}
return(Ok(new FailViewModel {
Message = "Login failed"
}));
}
public override async Task Execute()
{
var regionKey = "GLA";
var tenant = new Tenant()
{
Name = Input.TenantName, TenantName = Input.TenantName, EntryKey = StringHelper.GenerateCode(16),
AuthorName = Input.Name, RegionKey = regionKey
};
var isNew = true;
if (string.IsNullOrEmpty(Input.TenantId))
{
var persistClient = new Persist <Tenant>()
{
Model = tenant
};
await DataHandler.Execute(persistClient);
tenant = persistClient.Model;
}
else
{
var loaderClient = new Loader <Tenant>()
{
Id = Input.TenantId
};
await DataHandler.Execute(loaderClient);
tenant = loaderClient.Result;
isNew = false;
}
if (tenant != null && !string.IsNullOrEmpty(tenant.Id))
{
var user = new User()
{
TenantId = tenant.Id, TenantName = Input.TenantName, Name = Input.Name, Email = Input.Email,
EncryptedPwd = EncryptHelper.Encrypt(Input.Pwd), AuthorName = Input.Name,
Right = new UserRight()
{
CanAuth = isNew, CanAdmin = isNew, CanSuperuser = false
},
RegionKey = regionKey
};
var persistUser = new UserSave {
Model = user
};
await DataHandler.Execute(persistUser);
if (persistUser.Confirm.Success)
{
if (isNew)
{
tenant.AuthorId = persistUser.Model.Id;
tenant.TenantId = tenant.Id;
var persistClient = new Persist <Tenant>()
{
Model = tenant
};
await DataHandler.Execute(persistClient);
tenant = persistClient.Model;
var meetingType = new MeetingType()
{
TenantId = tenant.Id, TenantName = tenant.Name, Name = "Standard", IsRecur = false,
Pretext = "Standard Meeting Type", RegionKey = regionKey, Prename = "Meeting",
AuthorId = persistUser.Model.Id, AuthorName = persistUser.Model.Name
};
var persistType = new Persist <MeetingType>()
{
Model = meetingType
};
await DataHandler.Execute(persistType);
}
persistUser.Model.AuthorId = persistUser.Model.Id;
await DataHandler.Execute(persistUser);
await DataHandler.Commit();
var signin = new SigninAuth()
{
Tenant = tenant, Login = persistUser.Model, LogicHandler = LogicHandler,
DataHandler = DataHandler, Config = persistUser.ResultConfig, Settings = CloudHandler.Settings
};
await LogicHandler.Execute(signin);
ResultAuth = signin.Result;
Result = ActionConfirm.CreateSuccess(persistUser.Model);
var notify = new SimpleNotify
{
CloudHandler = CloudHandler, DataHandler = DataHandler, CurrentUser = persistUser.Model,
LogicHandler = LogicHandler, Model = persistUser.Model,
TemplateName = isNew ? "welcomeclient" : "welcomeuser"
};
await LogicHandler.Execute(notify);
}
else
{
Result = ActionConfirm.CreateFailure(persistUser.Confirm.Message);
}
}
else
{
Result = ActionConfirm.CreateFailure("Error connecting organisation");
}
}
