459 lines
19 KiB
C#
459 lines
19 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Security.Claims;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.Extensions.Configuration;
|
|
using OnlineAssessment.Common;
|
|
using OnlineAssessment.Data.EFCore;
|
|
using OnlineAssessment.Domain.Models;
|
|
using OnlineAssessment.Domain.ViewModels;
|
|
|
|
namespace OnlineAssessment.V2.Controllers
|
|
{
|
|
[Route("v{version:apiVersion}/[controller]")]
|
|
[ApiController]
|
|
[ApiVersion("2.0")]
|
|
public class UsersController : BaseController<Users, EfCoreUserRepository>
|
|
{
|
|
private readonly IConfiguration _config;
|
|
EfCoreUserRepository _repository;
|
|
string responseMessage;
|
|
public UsersController(EfCoreUserRepository repository, IConfiguration config) : base(repository)
|
|
{
|
|
_repository = repository;
|
|
_config = config;
|
|
}
|
|
|
|
/*
|
|
/// <summary>
|
|
/// Create a new user
|
|
/// </summary>
|
|
/// <param name="user"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
[AllowAnonymous]
|
|
public IActionResult SignUp([FromBody] UserAddModel user)
|
|
{
|
|
int returnCode = 0;
|
|
string returnMessage = string.Empty;
|
|
IActionResult returnResponse;
|
|
UserViewModel newUser = _repository.SignUp(user, out returnCode, out returnMessage);
|
|
if (newUser != null)
|
|
returnResponse = Ok(ReturnResponse.GetSuccessStatus(newUser as dynamic));
|
|
else
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.ObjectNotAdded.ToString(), Constant.User);
|
|
returnResponse = Ok(ReturnResponse.GetFailureStatus(responseMessage + " " + returnMessage));
|
|
}
|
|
|
|
return returnResponse;
|
|
}
|
|
|
|
/// <summary>
|
|
/// User Log in
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
[Route("[Action]")]
|
|
[Authorize]
|
|
public async System.Threading.Tasks.Task<IActionResult> SignIn()
|
|
{
|
|
string returnMessage = string.Empty;
|
|
IActionResult returnResponse;
|
|
|
|
ClaimsIdentity identity = HttpContext.User.Identity as ClaimsIdentity;
|
|
string uuid = Security.GetValueFromToken("user_id", identity);
|
|
|
|
LoginViewModel login = _repository.SignUpStudent(identity, out returnMessage);
|
|
if(login != null)
|
|
{
|
|
string token = await Security.GetFirebaseTokenAsync(uuid, login.id, login.role_id);
|
|
returnResponse = Ok(ReturnResponse.GetSuccessStatus(login));
|
|
}
|
|
|
|
else
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.NotAllowedToResource.ToString(), Constant.User);
|
|
returnResponse = Ok(ReturnResponse.GetFailureStatus(responseMessage + " " + returnMessage));
|
|
}
|
|
|
|
return returnResponse;
|
|
}
|
|
*/
|
|
|
|
/// <summary>
|
|
/// Admin/ Teacher Log in
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
[Route("[Action]")]
|
|
[Authorize]
|
|
public async System.Threading.Tasks.Task<IActionResult> SignIn()
|
|
{
|
|
string returnMessage = string.Empty;
|
|
IActionResult returnResponse;
|
|
|
|
ClaimsIdentity identity = HttpContext.User.Identity as ClaimsIdentity;
|
|
string uuid = Security.GetValueFromToken("user_id", identity);
|
|
|
|
dynamic login = _repository.SignInAdminTeacher(identity, out returnMessage);
|
|
if (login is LoginViewModel)
|
|
{
|
|
string token = await Security.GetFirebaseTokenAsync(uuid, login.id, login.role_id, 1);
|
|
returnResponse = Ok(ReturnResponse.GetSuccessStatus(login));
|
|
}
|
|
else if (login is int && login == (int)UserMessage.InvalidUser)
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(UserMessage.InvalidUser.ToString(), Constant.User);
|
|
returnResponse = BadRequest(ReturnResponse.GetFailureStatus((int)UserMessage.InvalidUser, responseMessage));
|
|
}
|
|
else if (login is int && login == (int)Message.NotAllowedToResource)
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.NotAllowedToResource.ToString(), Constant.User);
|
|
returnResponse = BadRequest(ReturnResponse.GetFailureStatus((int)Message.NotAllowedToResource, responseMessage));
|
|
}
|
|
else
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.FailedToSignIn.ToString(), Constant.User);
|
|
returnResponse = BadRequest(ReturnResponse.GetFailureStatus((int)Message.FailedToAdd, responseMessage));
|
|
}
|
|
|
|
|
|
return returnResponse;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Add Admin/Teacher
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
[Route("[Action]")]
|
|
[Authorize(Roles = "Admin")]
|
|
public IActionResult AddAdminTeacher([FromBody] AddAdminTeacherModel userDetails)
|
|
{
|
|
string returnMessage = string.Empty;
|
|
IActionResult returnResponse;
|
|
|
|
if (userDetails == null || (userDetails.roleId != 2 && userDetails.roleId != 3))
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.NotAllowedToResource.ToString());
|
|
returnResponse = BadRequest(ReturnResponse.GetFailureStatus(responseMessage));
|
|
}
|
|
|
|
dynamic login = _repository.AddAdminTeacher(InstituteId, userDetails.emailId, userDetails.roleId, out returnMessage);
|
|
|
|
if (login is LoginViewModel)
|
|
{
|
|
returnResponse = Ok(ReturnResponse.GetSuccessStatus(login.email_id));
|
|
}
|
|
else if(login is int && login == (int)UserMessage.InvalidUser)
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(UserMessage.InvalidUser.ToString(), Constant.User);
|
|
returnResponse = BadRequest(ReturnResponse.GetFailureStatus((int)UserMessage.InvalidUser, responseMessage));
|
|
}
|
|
else if(login is int && login == (int)Message.NotAllowedToResource)
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.NotAllowedToResource.ToString(), Constant.User);
|
|
returnResponse = BadRequest(ReturnResponse.GetFailureStatus((int)Message.NotAllowedToResource, responseMessage));
|
|
}
|
|
else if (login is int && login == (int)UserMessage.UserAlreadyExists)
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(UserMessage.UserAlreadyExists.ToString(), Constant.User);
|
|
returnResponse = BadRequest(ReturnResponse.GetFailureStatus((int)UserMessage.UserAlreadyExists, responseMessage));
|
|
}
|
|
else
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.FailedToAdd.ToString(), Constant.User);
|
|
returnResponse = BadRequest(ReturnResponse.GetFailureStatus((int)Message.FailedToAdd, responseMessage));
|
|
}
|
|
|
|
return returnResponse;
|
|
}
|
|
|
|
/*
|
|
/// <summary>
|
|
/// User Log in
|
|
/// </summary>
|
|
/// <param name="loginCredentials"></param>
|
|
/// <returns></returns>
|
|
[AllowAnonymous]
|
|
[HttpPost]
|
|
[Route("[Action]")]
|
|
public IActionResult SignIn([FromBody] UserLogin loginCredentials)
|
|
{
|
|
int returnCode = 0;
|
|
IActionResult returnResponse;
|
|
LoginViewModel loggedOnUser = _repository.SignIn(loginCredentials, out returnCode);
|
|
if (loggedOnUser != null && returnCode > 0)
|
|
{
|
|
//Generate and set the access token
|
|
var secretKey = _config["Jwt:Key"].ToString();
|
|
var issuer = _config["Jwt:Issuer"].ToString();
|
|
var audience = _config["Jwt:Issuer"].ToString();
|
|
|
|
//-----------------------------------------------------------------------------------------------
|
|
loggedOnUser.JwtToken = Security.GetJwtToken(loggedOnUser, secretKey, issuer, audience);
|
|
//-----------------------------------------------------------------------------------------------
|
|
|
|
returnResponse = Ok(ReturnResponse.GetSuccessStatus(loggedOnUser as dynamic));
|
|
}
|
|
else
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.FailedToSignIn.ToString());
|
|
switch (returnCode)
|
|
{
|
|
case (int)UserMessage.InvalidUser:
|
|
responseMessage = string.Concat(responseMessage, ". Reason: ", _repository.GetMessageByCode(UserMessage.InvalidUser.ToString()));
|
|
break;
|
|
case (int)UserMessage.InvalidPasword:
|
|
responseMessage = string.Concat(responseMessage, ". Reason: ", _repository.GetMessageByCode(UserMessage.InvalidPasword.ToString()));
|
|
break;
|
|
case (int)UserMessage.UserNotActive:
|
|
responseMessage = string.Concat(responseMessage, ". Reason:", _repository.GetMessageByCode(UserMessage.UserNotActive.ToString()));
|
|
break;
|
|
}
|
|
|
|
returnResponse = Ok(ReturnResponse.GetFailureStatus(responseMessage));
|
|
}
|
|
|
|
|
|
return returnResponse;
|
|
}
|
|
*/
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Edit an user (accessible to SuperAdmin only)
|
|
/// </summary>
|
|
/// <param name="id">The id of the user to edit</param>
|
|
/// <param name="userEdit">User's data to edit</param>
|
|
/// <returns></returns>
|
|
[HttpPost("{id}")]
|
|
[Authorize(Roles = "SuperAdmin")]
|
|
public IActionResult Put(int id, [FromBody] UserEditModel userEdit)
|
|
{
|
|
IActionResult returnResponse = null;
|
|
if (id != userEdit.Id)
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.IdMismatchBetweenBodyAndQueryString.ToString());
|
|
returnResponse = Ok(ReturnResponse.GetFailureStatus(responseMessage));
|
|
return returnResponse;
|
|
}
|
|
else
|
|
{
|
|
string returnMessage = string.Empty;
|
|
UserViewModel uvm = _repository.UpdateUser(id, userEdit, out returnMessage);
|
|
if (uvm != null)
|
|
{
|
|
returnResponse = Ok(ReturnResponse.GetSuccessStatus(uvm));
|
|
}
|
|
else
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.ObjectNotUpdated.ToString(), Constant.User);
|
|
returnResponse = Ok(ReturnResponse.GetFailureStatus(new List<string> { responseMessage, returnMessage }));
|
|
}
|
|
}
|
|
return returnResponse;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete a record (accessible to SuperAdmin only)
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns></returns>
|
|
[HttpDelete("{id}")]
|
|
[Authorize(Roles = "SuperAdmin")]
|
|
public IActionResult Delete(int id)
|
|
{
|
|
IActionResult returnResponse = null;
|
|
try
|
|
{
|
|
bool isSuccess = _repository.Delete(id);
|
|
if (isSuccess)
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.SucessfullyDeleted.ToString(), Constant.User);
|
|
returnResponse = Ok(ReturnResponse.GetSuccessStatus(responseMessage));
|
|
}
|
|
else
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.ObjectNotDeleted.ToString(), Constant.User);
|
|
returnResponse = Ok(ReturnResponse.GetFailureStatus(responseMessage));
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.ObjectNotDeleted.ToString(), Constant.User);
|
|
returnResponse = Ok(ReturnResponse.GetFailureStatus(new List<string> { responseMessage, ex.Message.ToString(), ex.InnerException.Message.ToString() }));
|
|
}
|
|
return returnResponse;
|
|
}
|
|
|
|
[HttpPost]
|
|
[AllowAnonymous]
|
|
[Route("RegUser")]
|
|
public IActionResult RegisterUser(StudentAddModel data)
|
|
{
|
|
int returnCode = -1;
|
|
string returnMessage = string.Empty;
|
|
IActionResult returnResponse = null;
|
|
int userID = -1;
|
|
try
|
|
{
|
|
userID = _repository.RegisterUser(data, out returnCode, out returnMessage);
|
|
if(userID > 0)
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.SucessfullyAdded.ToString(), Constant.User);
|
|
returnResponse = Ok(ReturnResponse.GetSuccessStatus(responseMessage));
|
|
}
|
|
else if(userID == (int)UserMessage.UserAlreadyExists)
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(UserMessage.UserAlreadyExists.ToString(), Constant.User);
|
|
returnResponse = Ok(ReturnResponse.GetFailureStatus(responseMessage));
|
|
}
|
|
else
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.ObjectNotAdded.ToString(), Constant.User);
|
|
returnResponse = Ok(ReturnResponse.GetFailureStatus(responseMessage));
|
|
}
|
|
}
|
|
catch (ApplicationException ex)
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.ObjectNotAdded.ToString(), Constant.User);
|
|
returnResponse = Ok(ReturnResponse.GetFailureStatus(new List<string> { responseMessage, ex.Message.ToString(), ex.InnerException.Message.ToString() }));
|
|
}
|
|
|
|
return returnResponse;
|
|
}
|
|
|
|
[HttpGet]
|
|
[AllowAnonymous]
|
|
[Route("VerifyAccount/{code}")]
|
|
public IActionResult ActivateUser(string code)
|
|
{
|
|
string returnMessage = string.Empty;
|
|
IActionResult returnResponse = null;
|
|
int userID = -1;
|
|
try
|
|
{
|
|
userID = _repository.VerifyAccount(code, out returnMessage);
|
|
if (userID > 0)
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.Success.ToString(), Constant.User);
|
|
returnResponse = Ok(ReturnResponse.GetSuccessStatus(responseMessage));
|
|
}
|
|
else
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.NotAllowedToResource.ToString(), Constant.User);
|
|
returnResponse = Ok(ReturnResponse.GetFailureStatus(responseMessage));
|
|
}
|
|
}
|
|
catch (ApplicationException ex)
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.NotAllowedToResource.ToString(), Constant.User);
|
|
returnResponse = Ok(ReturnResponse.GetFailureStatus(new List<string> { responseMessage, ex.Message.ToString(), ex.InnerException.Message.ToString() }));
|
|
}
|
|
|
|
return returnResponse;
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Update language
|
|
/// </summary>
|
|
/// <param name="language"></param>
|
|
/// <returns></returns>
|
|
[HttpPost("{language}/UpdatePreference")]
|
|
[Authorize(Roles = "Student")]
|
|
public IActionResult UpdatePreference(string language)
|
|
{
|
|
IActionResult returnResponse = null;
|
|
string return_message = string.Empty;
|
|
int user_id = Security.GetIdFromJwtToken(UserClaim.UserId, HttpContext.User.Identity as ClaimsIdentity);
|
|
|
|
int language_id = _repository.GetLanguageIdByCode(language);
|
|
|
|
if (language_id <= 0)
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.NoData.ToString());
|
|
returnResponse = Ok(ReturnResponse.GetFailureStatus(responseMessage));
|
|
}
|
|
|
|
//TODO: check if works fine
|
|
int langId = _repository.UpdateMyLanguage(user_id, language_id, out return_message);
|
|
if (langId < 0)
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.FailedToAttach.ToString());
|
|
returnResponse = Ok(ReturnResponse.GetFailureStatus(responseMessage));
|
|
}
|
|
else
|
|
{
|
|
returnResponse = Ok(ReturnResponse.GetSuccessStatus(return_message));
|
|
}
|
|
|
|
return returnResponse;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Attch me to usergroup
|
|
/// </summary>
|
|
/// <param name="user_group_id"></param>
|
|
/// <param name="defaultGroup"></param>
|
|
/// <returns></returns>
|
|
[HttpPost("{user_group_id}/AttachBatch")]
|
|
[Authorize(Roles = "Student")]
|
|
public IActionResult AttachMeToUserGroup(int user_group_id, [FromBody] DefaultGroup defaultGroup)
|
|
{
|
|
IActionResult returnResponse = null;
|
|
string return_message = string.Empty;
|
|
int user_id = Security.GetIdFromJwtToken(UserClaim.UserId, HttpContext.User.Identity as ClaimsIdentity);
|
|
|
|
//TODO: check if works fine
|
|
ClassStructureViewModel csvm = _repository.AttachMeToUserGroup(base.InstituteId, user_group_id, user_id, defaultGroup.isDefault, out return_message);
|
|
if (csvm == null)
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.FailedToAttach.ToString());
|
|
returnResponse = Ok(ReturnResponse.GetFailureStatus(responseMessage));
|
|
}
|
|
else
|
|
{
|
|
returnResponse = Ok(ReturnResponse.GetSuccessStatus(csvm));
|
|
}
|
|
|
|
return returnResponse;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Detach user group of a user
|
|
/// </summary>
|
|
/// <param name="user_group_id"></param>
|
|
/// <returns></returns>
|
|
[HttpPost("{user_group_id}/Detach")]
|
|
[Authorize(Roles = "Admin,Teacher,Student")]
|
|
public IActionResult DetachUserGroup(int user_group_id)
|
|
{
|
|
IActionResult returnResponse = null;
|
|
string return_message = string.Empty;
|
|
int user_id = Security.GetIdFromJwtToken(UserClaim.UserId, HttpContext.User.Identity as ClaimsIdentity);
|
|
|
|
int recordsEffected = _repository.DetachUserGroup(base.InstituteId, user_id, user_group_id, out return_message);
|
|
if (recordsEffected < 0)
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.FailedToDetach.ToString());
|
|
returnResponse = Ok(ReturnResponse.GetFailureStatus(responseMessage));
|
|
}
|
|
else
|
|
{
|
|
returnResponse = Ok(ReturnResponse.GetSuccessStatus(return_message));
|
|
}
|
|
|
|
return returnResponse;
|
|
}
|
|
}
|
|
}
|