public async Task <IActionResult> UpdatePassword(ChangePasswordRequest request)
{
//user identifier
var userId = PlatformUtils.GetIdentityUserId(User);
var user = AuthorizationLayer.GetUserById(userId);
//Tento il signin ed ottengo l'utente se è completato
var result = await AuthorizationLayer.SignIn(user.Username, request.OldPassword);
//Se non ho utente, unauthorized
if (result == null)
{
return(Unauthorized());
}
// recupero il profilo
var validations = AuthorizationLayer.UpdateUserPassword(result, request.Password);
//controllo risultato
if (validations.Count > 0)
{
return(BadRequest(validations));
}
//Se è tutto ok, serializzo e restituisco
return(Ok(new StringResponse {
Value = request.Password
}));
}
public async Task <IActionResult> UpdateRole(RoleUpdateRequest request)
{
//Recupero l'elemento dal business layer
var entity = AuthorizationLayer.GetRole(request.RoleId);
//modifica solo se admin o se utente richiedente è lo stesso che ha creato
if (entity == null)
{
return(NotFound());
}
//Aggiornamento dell'entità
entity.Name = request.Name;
entity.Description = request.Description;
//Salvataggio
var validations = await AuthorizationLayer.UpdateRole(entity, PlatformUtils.GetIdentityUserId(User));
if (validations.Count > 0)
{
return(BadRequest(validations));
}
var permissions = AuthorizationLayer.FetchPermissionsOnRole(entity.Id);
//Confermo
return(Ok(ContractUtils.GenerateContract(entity, permissions)));
}
public async Task <IActionResult> CallShooter(CallShooterRequest request)
{
// For a real application, generate your own
var currentUserId = PlatformUtils.GetIdentityUserId(User);
var existingUser = AuthorizationLayer.GetUserById(currentUserId);
if (existingUser == null)
{
return(NotFound());
}
var subscriptions = BasicLayer.FetchNotificationSubscriptionsByUserId(request.ShooterId);
var vapidDetails = new VapidDetails($"mailto:{_vapidUser}", _publicKey, _privateKey);
var pushSubscriptions = subscriptions.Select(x => new PushSubscription(x.Url, x.P256dh, x.Auth)).ToList();
var webPushClient = new WebPushClient();
try
{
var message = string.Empty;
switch ((int)request.Context)
{
case (int)CallShooterContextEnum.MatchDirector:
var userStage = BasicLayer.GetSOStage(request.MatchId, existingUser.Id);
message = $"{existingUser.FirstName} {existingUser.LastName} ti sta cercando allo stage {userStage.Index}:{userStage.Name}!";
break;
default:
message = $"{existingUser.FirstName} {existingUser.LastName} ti sta cercando!";
break;
}
var payload = JsonSerializer.Serialize(new
{
message,
url = string.Empty,
});
if (pushSubscriptions.Count == 0)
{
return(Ok(new OkResponse {
Status = false, Errors = new List <string> {
"NoSubscriptions"
}
}));
}
var tasks = pushSubscriptions.Select(pushSubscription => webPushClient.SendNotificationAsync(pushSubscription, payload, vapidDetails)).ToList();
await Task.WhenAll(tasks);
return(Ok(new OkResponse()
{
Status = true
}));
}
catch (Exception ex)
{
Console.Error.WriteLine("Error sending push notification: " + ex.Message);
return(Ok(ex));
}
}
public Task <IActionResult> CreateNotificationSubscription(NotificationSubscriptionCreateRequest request)
{
var currentUserId = PlatformUtils.GetIdentityUserId(User);
var existingUser = AuthorizationLayer.GetUserById(currentUserId);
if (existingUser == null)
{
return(Task.FromResult <IActionResult>(NotFound()));
}
var model = new NotificationSubscription
{
UserId = existingUser.Id,
Url = request.Url,
P256dh = request.P256dh,
Auth = request.Auth
};
//Invocazione del service layer
var validations = BasicLayer.CreateNotificationSubscription(model);
if (validations.Count > 0)
{
return(BadRequestTask(validations));
}
//Return contract
return(Reply(new OkResponse {
Status = true
}));
}
public async Task <IActionResult> DeleteUserROle(UserRoleRequest request)
{
//Recupero l'elemento dal business layer
var entity = AuthorizationLayer.GetUserRole(request.UserRoleId);
//Se l'utente non hai i permessi non posso rimuovere entità con userId nullo
if (entity == null)
{
return(NotFound());
}
//Invocazione del service layer
var validations = await AuthorizationLayer.DeleteUserRole(entity, PlatformUtils.GetIdentityUserId(User));
if (validations.Count > 0)
{
return(BadRequest(validations));
}
var userRoles = AuthorizationLayer.FetchUserRole(entity.RoleId);
var userIds = userRoles.Select(x => x.UserId).ToList();
var users = BasicLayer.FetchShootersByIds(userIds);
//Return contract
return(Ok(userRoles.As(x => ContractUtils.GenerateContract(x, users?.FirstOrDefault(s => s.Id == x.UserId)))));
}
public IActionResult UpdateUserPassword(UserPasswordUpdateRequest request)
{
//User id corrente
var userId = PlatformUtils.GetIdentityUserId(User);
//modifica solo se admin o se sè stesso o è autorizzato
if (request.UserId != userId)
{
return(Unauthorized());
}
//Recupero l'elemento dal business layer
var entity = AuthorizationLayer.GetUserById(request.UserId);
if (entity == null)
{
return(NotFound());
}
//Salvataggio
var validations = AuthorizationLayer.UpdateUserPassword(entity, request.Password);
if (validations.Count > 0)
{
return(BadRequest(validations));
}
//Confermo
return(Ok(new BooleanResponse()
{
Value = true
}));
}
public Task <IActionResult> SyncPassword()
{
//Tento il signin ed ottengo l'utente se è completato
var result = AuthorizationLayer.SyncPasswords();
//Se è tutto ok, serializzo il contratto
return(Reply(new OkResponse {
Status = result.Count == 0, Errors = result.Select(x => x.ErrorMessage).ToList()
}));
}
public IActionResult GetProfile()
{
var userId = PlatformUtils.GetIdentityUserId(User);
var entity = AuthorizationLayer.GetUserById(userId);
//verifico validità dell'entità
if (entity == null)
{
return(NotFound());
}
//Serializzazione e conferma
return(Ok(ContractUtils.GenerateContract(entity)));
}
public async Task <IActionResult> SignIn(SignInRequest request)
{
//Tento il signin ed ottengo l'utente se è completato
var result = await AuthorizationLayer.SignIn(request.Username, request.Password);
//Se non ho utente, unauthorized
if (result == null)
{
return(Unauthorized());
}
//Se è tutto ok, serializzo il contratto
return(Ok(
new SignInResponse
{
Shooter = ContractUtils.GenerateContract(result),
Permissions = ContractUtils.GenerateContract(await AuthorizationLayer.GetUserPermissionById(result.Id))
}));
}
public async Task <IActionResult> CreateRole(RoleCreateRequest request)
{
//Creazione modello richiesto da admin
var model = new Role
{
Name = request.Name,
Description = request.Description
};
//Invocazione del service layer
var validations = await AuthorizationLayer.CreateRole(model, PlatformUtils.GetIdentityUserId(User));
if (validations.Count > 0)
{
return(BadRequest(validations));
}
//Return contract
return(Ok(ContractUtils.GenerateContract(model)));
}
public async Task <IActionResult> CreateUserRole(UserRoleCreateRequest request)
{
//Recupero l'elemento dal business layer
var user = BasicLayer.GetShooter(request.UserId);
if (user == null)
{
return(NotFound($"User with {request.UserId} not found"));
}
//Recupero l'elemento dal business layer
var role = AuthorizationLayer.GetRole(request.RoleId);
if (role == null)
{
return(NotFound($"Role with {request.RoleId} not found"));
}
var entity = new UserRole()
{
UserId = user.Id,
RoleId = role.Id,
EntityId = request.EntityId
};
//Invocazione del service layer
var validations = await AuthorizationLayer.CreateUserRole(entity, PlatformUtils.GetIdentityUserId(User));
if (validations.Count > 0)
{
return(BadRequest(validations));
}
var userRoles = AuthorizationLayer.FetchUserRole(role.Id);
var userIds = userRoles.Select(x => x.UserId).ToList();
var users = BasicLayer.FetchShootersByIds(userIds);
//Return contract
return(Ok(userRoles.As(x => ContractUtils.GenerateContract(x, users?.FirstOrDefault(s => s.Id == x.UserId)))));
}
public Task <IActionResult> GetRole(RoleRequest request)
{
var entity = AuthorizationLayer.GetRole(request.RoleId);
//verifico validità dell'entità
if (entity == null)
{
return(Task.FromResult <IActionResult>(NotFound()));
}
var permissions = AuthorizationLayer.FetchPermissionsOnRole(entity.Id);
var userRoles = AuthorizationLayer.FetchUserRole(entity.Id);
var userIds = userRoles.Select(x => x.UserId).ToList();
var users = BasicLayer.FetchShootersByIds(userIds);
//Serializzazione e conferma
return(Reply(ContractUtils.GenerateContract(entity, permissions, userRoles, users)));
}
public async Task <IActionResult> DeleteRole(RoleRequest request)
{
//Recupero l'elemento dal business layer
var entity = AuthorizationLayer.GetRole(request.RoleId);
//Se l'utente non hai i permessi non posso rimuovere entità con userId nullo
if (entity == null)
{
return(NotFound());
}
//Invocazione del service layer
var validations = await AuthorizationLayer.DeleteRole(entity, PlatformUtils.GetIdentityUserId(User));
if (validations.Count > 0)
{
return(BadRequest(validations));
}
//Return contract
return(Ok(ContractUtils.GenerateContract(entity)));
}
public IActionResult UpdateProfile(UserUpdateRequest request)
{
//User id corrente
var userId = PlatformUtils.GetIdentityUserId(User);
//modifica solo se admin o se sè stesso o è autorizzato
if (request.UserId != userId)
{
return(Unauthorized());
}
//Recupero l'elemento dal business layer
var entity = AuthorizationLayer.GetUserById(request.UserId);
if (entity == null)
{
return(NotFound());
}
//Aggiornamento dell'entità
entity.Username = request.Username;
entity.FirstName = request.FirstName;
entity.LastName = request.LastName;
entity.Email = request.Email;
entity.BirthDate = request.BirthDate;
//Salvataggio
var validations = AuthorizationLayer.UpdateUser(entity);
if (validations.Count > 0)
{
return(BadRequest(validations));
}
//Confermo
return(Ok(ContractUtils.GenerateContract(entity)));
}
public async Task <IActionResult> CreatePermissionOnRole(RolePermissionCreateRequest request)
{
//Recupero l'elemento dal business layer
var permission = AuthorizationLayer.GetPermission(request.PermissionId);
if (permission == null)
{
return(NotFound($"Permission with {request.PermissionId} not found"));
}
//Recupero l'elemento dal business layer
var role = AuthorizationLayer.GetRole(request.RoleId);
if (role == null)
{
return(NotFound($"Role with {request.RoleId} not found"));
}
var entity = new PermissionRole()
{
PermissionId = permission.Id,
RoleId = role.Id
};
//Invocazione del service layer
var validations = await AuthorizationLayer.CreatePermissionRole(entity, PlatformUtils.GetIdentityUserId(User));
if (validations.Count > 0)
{
return(BadRequest(validations));
}
var permissions = AuthorizationLayer.FetchPermissionsOnRole(role.Id);
//Return contract
return(Ok(permissions.As(ContractUtils.GenerateContract)));
}
public IActionResult FetchAllRoles() => Ok(AuthorizationLayer.FetchRoles().As(x => ContractUtils.GenerateContract(x)));
public async Task <IActionResult> FetchAllPermissionsOnUser() => Ok(ContractUtils.GenerateContract(await AuthorizationLayer.GetUserPermissionById(PlatformUtils.GetIdentityUserId(User))));
public IActionResult FetchPermissions() => Ok((AuthorizationLayer.FetchPermission()).As(ContractUtils.GenerateContract));
