public async Task <IActionResult> GetUser([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var x = await _context.User.FindAsync(id);
if (x == null)
{
return(NotFound());
}
var newUser = new UserById()
{
Username = x.Username,
FirstName = x.FirstName,
LastName = x.LastName,
Email = x.Email,
Picture = x.Picture,
Comment = x.Comment
};
return(Ok(newUser));
}
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 async Task UserByIdDataTest()
{
using var store = GetDocumentStore();
using var session = store.OpenAsyncSession();
var loader = new UserById {
Session = session, Id = UserData.FirstId
};
await loader.Execute();
loader.Result.Should().NotBeNull();
loader.Result.Id.Should().Be(UserData.FirstId);
}
public override async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
var controller = (SecureController)context.Controller;
var query = new UserById
{
Id = controller.User.Claims.First(c => c.Type == ClaimTypes.NameIdentifier).Value
};
await DataHandler.Execute(query);
controller.CurrentUser = query.Result;
controller.CurrentConfig = query.ResultConfig;
await base.OnActionExecutionAsync(context, next);
}
public async Task <object> Delete(UserById request)
{
var response = new BaseResponse();
Expression <Func <User, bool> > keySelector = x => x.Id == request.Id;
var result = await _userService.Delete(keySelector : keySelector);
response.Success = true;
response.Message = $"Delete user with id {request.Id} success";
response.StatusCode = (int)HttpStatusCode.OK;
response.Results = result.ConvertTo <UserDto>();
return(response);
}
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 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 <object> Get(UserById request)
{
var response = new BaseResponse();
Expression <Func <User, bool> > keySelector = x => x.Id == request.Id;
var entity = await _userService.GetById(keySelector : keySelector, includeProperties : "Role");
// check user is owner
if (!base.IsAdminOrOwner(entity.UserName))
{
throw new MethodAccessException();
}
var dto = entity.ConvertTo <UserDto>();
response.Success = true;
response.StatusCode = (int)HttpStatusCode.OK;
response.Results = dto;
return(response);
}
private async Task <bool> Check()
{
ResultUser = CurrentUser;
if (CurrentUser.Id != UserId)
{
var loader = new UserById {
Id = UserId
};
await DataHandler.Execute(loader);
if (loader.Result != null)
{
ResultUser = loader.Result;
ResultConfig = loader.ResultConfig;
if (ResultUser.TenantId != CurrentUser.TenantId || !CurrentUser.Right.CanAdmin)
{
if (CurrentUser.Right.CanSuperuser)
{
return(true);
}
}
else
{
return(true);
}
}
}
else
{
return(true);
}
return(false);
}
