645 lines
26 KiB
C#
645 lines
26 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Security.Claims;
|
|
using System.Threading.Tasks;
|
|
using FirebaseAdmin.Auth;
|
|
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.V1.Controllers
|
|
{
|
|
[Route("v{version:apiVersion}/[controller]")]
|
|
[ApiController]
|
|
[ApiVersion("1.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>
|
|
/// Get All Users (accessible to SuperAdmin only)
|
|
/// </summary>
|
|
/// <returns>All Users of all the institutes</returns>
|
|
[HttpGet]
|
|
[Authorize(Roles = "SuperAdmin")]
|
|
public override IActionResult GetAll()
|
|
{
|
|
|
|
IActionResult returnResponse;
|
|
dynamic userList = _repository.GetUsersList();
|
|
if (userList == null)
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.NoData.ToString());
|
|
returnResponse = Ok(ReturnResponse.GetFailureStatus(responseMessage));
|
|
}
|
|
else
|
|
{
|
|
returnResponse = Ok(ReturnResponse.GetSuccessStatus(userList));
|
|
}
|
|
return returnResponse;
|
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Get details of an user (accessible to SuperAdmin only)
|
|
/// </summary>
|
|
/// <param name="id">Id of the user</param>
|
|
/// <returns>The user's information</returns>
|
|
[HttpGet("{id}")]
|
|
[Authorize(Roles = "SuperAdmin")]
|
|
public override IActionResult Get(int id)
|
|
{
|
|
IActionResult returnResponse;
|
|
dynamic entity = _repository.GetUserById(id);
|
|
if (entity == null)
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.ObjectNotFound.ToString(), Constant.User);
|
|
returnResponse = Ok(ReturnResponse.GetFailureStatus(responseMessage));
|
|
}
|
|
else
|
|
{
|
|
returnResponse = Ok(ReturnResponse.GetSuccessStatus(entity));
|
|
}
|
|
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>
|
|
[HttpPut("{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;
|
|
}
|
|
|
|
|
|
[ HttpPost]
|
|
[AllowAnonymous]
|
|
[Route("SignUpNew")]
|
|
public async System.Threading.Tasks.Task<IActionResult> SignUpNew([FromBody] SignupRequestModel request)
|
|
{
|
|
string returnMessage = string.Empty;
|
|
IActionResult returnResponse = null;
|
|
|
|
try
|
|
{
|
|
|
|
// Create a new user
|
|
var userRecordArgs = new UserRecordArgs
|
|
{
|
|
Email = request.Email,
|
|
Password = request.Password,
|
|
DisplayName = request.DisplayName,
|
|
};
|
|
UserRecord record = await FirebaseAuth.DefaultInstance.CreateUserAsync(userRecordArgs);
|
|
if (record == null)
|
|
{
|
|
responseMessage = _repository.GetMessageByCode(Message.NotAllowedToResource.ToString(), Constant.User);
|
|
returnResponse = Ok(ReturnResponse.GetFailureStatus(responseMessage));
|
|
}
|
|
|
|
int userID = _repository.SignUpDB(record);
|
|
|
|
// Assign custom claims
|
|
//await Security.GetFirebaseTokenAsync(record.Uid, userID, 2, 1);
|
|
var claims = new Dictionary<string, object>()
|
|
{
|
|
{ClaimTypes.Role, "Admin"},
|
|
{ "RoleId", 2},
|
|
{ "InstituteId", 1 },
|
|
{ "UserId", userID},
|
|
};
|
|
await FirebaseAuth.DefaultInstance.SetCustomUserClaimsAsync(record.Uid, claims);
|
|
|
|
|
|
var link = await FirebaseAuth.DefaultInstance.GenerateEmailVerificationLinkAsync(record.Email);
|
|
string sent = _repository.SendEmailLink(record.Email, link);
|
|
Console.WriteLine($"Verification Link: {link}"); // Use email service here
|
|
|
|
/*
|
|
var claims2 = new Dictionary<string, object>
|
|
{
|
|
{ "email_verified", record.EmailVerified }
|
|
};
|
|
|
|
await FirebaseAuth.DefaultInstance.SetCustomUserClaimsAsync(record.Uid, claims2);
|
|
*/
|
|
returnResponse = Ok(ReturnResponse.GetSuccessStatus(link));;
|
|
|
|
}
|
|
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;
|
|
}
|
|
|
|
|
|
[HttpPost]
|
|
[Authorize]
|
|
[Route("SendEmailVerification")]
|
|
public async Task<IActionResult> SendOrResendVerification([FromQuery] bool isResend)
|
|
{
|
|
string returnMessage = string.Empty;
|
|
IActionResult returnResponse = null;
|
|
|
|
try
|
|
{
|
|
// Extract the user's UID from the Firebase token
|
|
ClaimsIdentity identity = HttpContext.User.Identity as ClaimsIdentity;
|
|
string uid = Security.GetValueFromToken("user_id", identity);
|
|
|
|
var userRecord = await FirebaseAuth.DefaultInstance.GetUserAsync(uid);
|
|
if (userRecord.EmailVerified && isResend)
|
|
{
|
|
return BadRequest(new { Message = "Email is already verified" });
|
|
}
|
|
|
|
var link = await FirebaseAuth.DefaultInstance.GenerateEmailVerificationLinkAsync(userRecord.Email);
|
|
_repository.SendEmailLink(userRecord.Email, link);
|
|
|
|
Console.WriteLine($"Verification Link: {link}"); // Use email service here
|
|
|
|
return Ok(new { Message = isResend ? "Verification email resent!" : "Verification email sent!" });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return BadRequest(new { Message = "Error processing request", Error = ex.Message });
|
|
}
|
|
}
|
|
/*
|
|
[HttpPost]
|
|
[AllowAnonymous]
|
|
[Route("SignInAdmin")]
|
|
public async Task<IActionResult> SignInAdmin([FromBody] SignInRequest request)
|
|
{
|
|
if (string.IsNullOrEmpty(request.Email) || string.IsNullOrEmpty(request.Password))
|
|
{
|
|
return BadRequest(new { Message = "Email and Password are required" });
|
|
}
|
|
|
|
try
|
|
{
|
|
// Sign in with Firebase using email and password
|
|
var auth = FirebaseAuth.DefaultInstance;
|
|
var userCredential = await auth.SignInWithEmailAndPasswordAsync(request.Email, request.Password);
|
|
|
|
// Get the user information
|
|
var user = userCredential.User;
|
|
string uid = user.Uid;
|
|
|
|
// Check if the email is verified
|
|
if (user.EmailVerified)
|
|
{
|
|
// If email is verified, return Firebase ID token
|
|
string idToken = await user.GetIdTokenAsync();
|
|
return Ok(new { Message = "Sign-in successful", IdToken = idToken });
|
|
}
|
|
else
|
|
{
|
|
// If the email is not verified, send verification email
|
|
await SendVerificationEmailAsync(user.Email);
|
|
return Ok(new { Message = "Email not verified. A verification email has been sent." });
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Handle sign-in error
|
|
return Unauthorized(new { Message = "Sign-in failed", Error = ex.Message });
|
|
}
|
|
}
|
|
|
|
*/
|
|
|
|
/// <summary>
|
|
/// Update language
|
|
/// </summary>
|
|
/// <param name="language"></param>
|
|
/// <returns></returns>
|
|
[HttpPut("{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;
|
|
}
|
|
}
|
|
}
|