public IActionResult UploadImagesToPost(int id, [FromForm] IFormFileCollection images, IFormFile mainImage)
{
try
{
int?uId = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (uId == null)
{
return(Unauthorized(new ErrorExceptionModel("Sem Autorização ou sem sessão inciada")));
}
PublicationDAO pDAO = new PublicationDAO(_connection);
Publication p = pDAO.FindById(id);
if (p.UtilizadorId != uId)
{
return(NotFound("Publicação não encontrada!"));
}
bool result = pDAO.UploadImagesToPost(id, images, mainImage);
return(Ok(result));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
protected void Session_Start(object sender, EventArgs e)
{
// Note that the application does not go to the database
// to authenticate the user.
// The authentication is done by the issuer.
// WSFederationAuthenticationModule automatically reads the
// user token sent by the IP and sets the user information
// in the thread current principal.
if (this.Context.User.Identity.IsAuthenticated)
{
// At this point we can access the authenticated user information
// by accessing the property Thread.CurrentPrincipal.
string issuer = ClaimHelper.GetCurrentUserClaim(ClaimTypes.Name).OriginalIssuer;
// Note, the GetClaim extension method is defined in the Samples.Web.Utillities project
string givenName = ClaimHelper.GetCurrentUserClaim(WSIdentityConstants.ClaimTypes.GivenName).Value;
string surname = ClaimHelper.GetCurrentUserClaim(WSIdentityConstants.ClaimTypes.Surname).Value;
string costCenter = ClaimHelper.GetCurrentUserClaim(Adatum.ClaimTypes.CostCenter).Value;
var repository = new UserRepository();
string federatedUsername = GetFederatedUserName(issuer, this.User.Identity.Name);
var user = repository.GetUser(federatedUsername);
user.CostCenter = costCenter;
user.FullName = givenName + " " + surname;
// The user is stored in the session because the application
// authentication strategy requires it.
this.Context.Session["LoggedUser"] = user;
}
}
protected override void OnActionExecuted(ActionExecutedContext filterContext)
{
if (filterContext.RequestContext.HttpContext.Request.IsAjaxRequest())
{
return;
}
if (filterContext.Controller.ViewData.Model == null)
{
filterContext.Controller.ViewData.Model = new MasterPageViewModel();
}
var model = (MasterPageViewModel)filterContext.Controller.ViewData.Model;
var organizationName = ClaimHelper.GetCurrentUserClaim(Fabrikam.ClaimTypes.Organization).Value;
var organizationRepository = new OrganizationRepository();
var tenantLogoPath = organizationRepository.GetOrganization(organizationName).LogoPath;
model.TenantLogoPath = tenantLogoPath;
model.ClaimsIssuer =
ClaimHelper.GetCurrentUserClaim(ClaimTypes.Name).
Issuer;
model.ClaimsOriginalIssuer =
ClaimHelper.GetCurrentUserClaim(Fabrikam.ClaimTypes.IdentityProvider).Value;
base.OnActionExecuted(filterContext);
}
public IActionResult deleteImage(int post, ImageName image)
{
int?id = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (id == null)
{
return(Unauthorized(new ErrorMessageModel("Sem Autorização ou sem sessão inciada")));
}
if (image == null)
{
return(BadRequest(new ErrorMessageModel("Nome de imagem não enviado!")));
}
try
{
JobDAO jobDAO = new JobDAO(_connection, this._environment.ContentRootPath);
bool deleted = jobDAO.deleteImage((int)id, post, image);
if (deleted == true)
{
return(Ok(new SuccessMessageModel("Imagem apagada!")));
}
else
{
return(BadRequest(new ErrorMessageModel("Imagem não apagada ou inexistente!")));
}
}
catch (Exception e)
{
return(BadRequest(new ErrorMessageModel(e.Message)));
}
}
public async Task <ActionResult> About()
{
var myGroups = new List <Group>();
var myDirectoryRoles = new List <DirectoryRole>();
try
{
ClaimsIdentity claimsId = ClaimsPrincipal.Current.Identity as ClaimsIdentity;
List <string> objectIds = await ClaimHelper.GetGroups(claimsId);
await GraphHelper.GetDirectoryObjects(objectIds, myGroups, myDirectoryRoles);
}
catch (AdalException e)
{
// If the user doesn't have an access token, they need to re-authorize
if (e.ErrorCode == "failed_to_acquire_token_silently")
{
return(RedirectToAction("Reauth", "Error", new { redirectUri = Request.Url }));
}
return(RedirectToAction("ShowError", "Error", new { errorMessage = "Error while acquiring token." }));
}
catch (Exception e)
{
return(RedirectToAction("ShowError", "Error", new { errorMessage = e.Message }));
}
ViewData["myGroups"] = myGroups;
ViewData["myDirectoryRoles"] = myDirectoryRoles;
ViewData["overageOccurred"] = (ClaimsPrincipal.Current.FindFirst("_claim_names") != null &&
(System.Web.Helpers.Json.Decode(ClaimsPrincipal.Current.FindFirst("_claim_names").Value)).groups != null);
return(View());
}
public ActionResult Index()
{
var repository = new ShipmentRepository();
// users in Shipment Manager role can see all the shipments,
// while others can see only its own shipments
IEnumerable <Shipment> shipments;
var organization = ClaimHelper.GetCurrentUserClaim(Fabrikam.ClaimTypes.Organization).Value;
if (this.User.IsInRole(Fabrikam.Roles.ShipmentManager))
{
shipments = repository.GetShipmentsByOrganization(organization);
}
else
{
var userName = this.User.Identity.Name;
shipments = repository.GetShipmentsByOrganizationAndUserName(organization, userName);
}
var model = new ShipmentListViewModel
{
Shipments = shipments
};
return(View(model));
}
public ActionResult <List <FavoriteModel> > FavoritesList()
{
try
{
int?id = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (id == null)
{
return(Unauthorized(new ErrorMessageModel("Sem Autorização ou sem sessão inciada")));
}
EmployerDAO employerDAO = new EmployerDAO(_connection);
List <FavoriteModel> favorites = employerDAO.FavoritesList((int)id).ToList();
if (favorites == null)
{
return(NotFound(new ErrorMessageModel("Lista de favoritos Inexistente!")));
}
return(favorites);
}
catch (Exception ex)
{
return(BadRequest(new ErrorMessageModel(ex.Message)));
}
}
/// <summary>
/// Add general claims
/// </summary>
public void AddClaimsToIdentity(string role, string name, string userId,
TimeSpan userTimeZoneOffset, ClaimsIdentity identity)
{
ClaimHelper.AddClaim(new Claim(ClaimTypes.Role, role), identity); // role claim
ClaimHelper.AddClaim(new Claim(ClaimTypes.Name, name), identity); // user name claim
ClaimHelper.AddClaim(new Claim(ISTUserClaims.UserTimeZoneOffset, userTimeZoneOffset.ToString()), identity); // User TimeZoneOffset claim
}
public IActionResult deleteProfilePicture()
{
int?id = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (id == null)
{
return(Unauthorized(new ErrorExceptionModel("Sem Autorização ou sem sessão inciada")));
}
try
{
UserDAO userDAO = new UserDAO(_connection);
bool deleted = userDAO.deleteImage((int)id);
if (deleted == true)
{
return(Ok(new SuccessExceptionModel("Imagem apagada!")));
}
else
{
return(BadRequest(new ErrorExceptionModel("Imagem não apagada ou inexistente!")));
}
}
catch (Exception e)
{
return(BadRequest(new ErrorExceptionModel(e.Message)));
}
}
public ActionResult <SuccessMessageModel> Reschedule(int id, DateModel date)
{
try{
int?employerId = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (employerId == null)
{
return(Unauthorized(new ErrorMessageModel("Utilizador não existe!")));
}
WorkDAO workDao = new WorkDAO(_connection);
WorkDetailsModel work = workDao.FindById(id, (int)employerId);
if (work == null)
{
return(BadRequest(new ErrorMessageModel("O trabalho não existe ou não está associado ao Employer!")));
}
bool updated = workDao.updateDate(id, date);
if (updated)
{
return(Ok(new SuccessMessageModel("Data atualizada com sucesso!")));
}
else
{
return(BadRequest(new ErrorMessageModel("Erro! A data não foi atualizada!")));
}
} catch (Exception e) {
return(BadRequest(new ErrorMessageModel(e.Message)));
}
}
/// <summary>
/// Add Domain License Detail Claims
/// </summary>
private void AddDomainLicenseDetailClaims(long domainKey, ClaimsIdentity identity)
{
DomainLicenseDetail domainLicenseDetail = null;
//domainLicenseDetailsRepository.GetDomainLicenseDetailByDomainKey(domainKey);
if (domainLicenseDetail != null)
{
var claim = new Claim(CaresUserClaims.DomainLicenseDetail,
ClaimHelper.Serialize(
new DomainLicenseDetailClaim
{
UserDomainKey = domainLicenseDetail.UserDomainKey,
Branches = domainLicenseDetail.Branches,
FleetPools = domainLicenseDetail.FleetPools,
Employee = domainLicenseDetail.Employee,
RaPerMonth = domainLicenseDetail.RaPerMonth,
Vehicles = domainLicenseDetail.Vehicles
}),
typeof(DomainLicenseDetailClaim).AssemblyQualifiedName);
ClaimHelper.AddClaim(claim, identity);
}
else
{
throw new InvalidOperationException("No Domain License Detail data found!");
}
}
public IActionResult GetUserById(int userId)
{
int?id = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (id == null)
{
return(Unauthorized(new ErrorMessageModel("Sem Autorização ou sem sessão inciada")));
}
try
{
UserDAO userDAO = new UserDAO(_connection, this._environment.ContentRootPath);
User user = userDAO.FindById(userId);
if (user == null)
{
return(BadRequest(new ErrorMessageModel("Utilizador não encontrado!")));
}
return(Ok(user));
}
catch (Exception e)
{
return(BadRequest(new ErrorMessageModel(e.Message)));
}
}
public async Task <IActionResult> Create(PuplicationCreate model)
{
int?uId = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (uId == null)
{
return(Unauthorized(new ErrorExceptionModel("Sem Autorização ou sem sessão inciada")));
}
if (model.ImagePath == null)
{
model.ImagePath = 0;
}
model.UtilizadorId = (int)uId;
PublicationDAO publicationDao = new PublicationDAO(_connection);
Publication resultPublication = publicationDao.Create(model);
resultPublication.UtilizadorId = (int)uId;
resultPublication.Tittle = model.Tittle;
resultPublication.Tradable = model.Tradable;
resultPublication.UserAddress = model.UserAddress;
resultPublication.InstrumentCondition = model.InstrumentCondition;
resultPublication.InitialPrice = model.InitialPrice;
resultPublication.Category = model.Category;
return(Ok(resultPublication));
}
public IActionResult deleteMainPicture(int publicationId, ImageName image)
{
try
{
int?id = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (id == null)
{
return(Unauthorized(new ErrorExceptionModel("Sem Autorização ou sem sessão inciada")));
}
PublicationDAO pDAO = new PublicationDAO(_connection);
bool deleted = pDAO.deleteMainImage(publicationId, image);
if (deleted == true)
{
return(Ok("Imagem apagada!"));
}
else
{
return(BadRequest("Imagem não apagada ou inexistente!"));
}
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
private void AuthorizeUser(AuthorizationContext context)
{
var organizationRequested = (string)context.RouteData.Values["organization"];
var userOrganiation = ClaimHelper.GetCurrentUserClaim(Fabrikam.ClaimTypes.Organization).Value;
if (!organizationRequested.Equals(userOrganiation, StringComparison.OrdinalIgnoreCase))
{
context.Result = new HttpUnauthorizedResult();
return;
}
var authorizedRoles = this.Roles.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries);
bool hasValidRole = false;
foreach (var role in authorizedRoles)
{
if (context.HttpContext.User.IsInRole(role.Trim()))
{
hasValidRole = true;
break;
}
}
if (!hasValidRole)
{
context.Result = new HttpUnauthorizedResult();
return;
}
}
public ActionResult CreateChat(int matchId)
{
int?userId = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (userId == null)
{
return(Unauthorized(new ErrorMessageModel("Utilizador não tem autorização ou não existe!")));
}
try
{
ChatDAO chatDAO = new ChatDAO(_connection);
if (chatDAO.getChatIdWithTargetUser((int)userId, matchId) == null)
{
Chat chat = new Chat();
chat.UserId = (int)userId;
chat.ChatId = chatDAO.CreateChatId();
chatDAO.CreateChat(chat);
chat.UserId = matchId;
chatDAO.CreateChat(chat);
return(Ok(new SuccessMessageModel("Chat criado!")));
}
return(Ok(new SuccessMessageModel("O Chat já existe!")));
}
catch (Exception e)
{
return(BadRequest(new ErrorMessageModel(e.Message)));
}
}
protected async Task <IActionResult> RefreshUserToken(Guid userId)
{
// Look up the user by its refresh token
var user = _userService.GetUserById(userId);
if (user == null)
{
return(Ok(new { Errors = new[] { "UserNotExist" } }));
}
// Reject if user has been locked out
if (user.LockoutEnd >= DateTimeOffset.UtcNow)
{
return(Ok(new { Errors = new[] { "UserLockedOut" } }));
}
// Get roles of current user
var roles = await _userManager.GetRolesAsync(user);
// Generate claims and JWT token
var langs = Utils.GetAllLanguages();
var claims = ClaimHelper.GetClaims(user, roles, langs);
// Generate token
var token = TokenGenerator.Generate(claims, roles, _config, user.SecurityStamp);
return(Ok(token));
}
public ActionResult <Message> getLastMessageFromChat(int id)
{
int?userId = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (userId == null)
{
return(Unauthorized(new ErrorMessageModel("Utilizador não tem autorização ou não existe!")));
}
try
{
ChatDAO chatDao = new ChatDAO(_connection);
Message message = chatDao.GetLastMessageFromChat(id, (int)userId);
if (message != null)
{
return(Ok(message));
}
return(BadRequest(new ErrorMessageModel("Não existe connection ID!")));
}
catch (Exception e)
{
return(BadRequest(new ErrorMessageModel(e.Message)));
}
}
public ActionResult <bool> CreateChat(int matchId, int publicationId, string publicationName)
{
int?userId = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (userId == null)
{
return(Unauthorized(new ErrorExceptionModel("Utilizador não tem autorização!")));
}
UserDAO userDAO = new UserDAO(_connection);
User user = userDAO.FindById(matchId);
if (userId < 0)
{
return(UnprocessableEntity(new ErrorExceptionModel("Utilizador não existe!")));
}
Chat chat = new Chat();
chat.UserId = (int)userId;
chat.PublicationId = publicationId;
chat.PublicationName = publicationName;
ChatDAO chatDAO = new ChatDAO(_connection);
chat.ChatId = chatDAO.CreateChatId();
chatDAO.CreateChat(chat);
chat.UserId = matchId;
chatDAO.CreateChat(chat);
return(Ok("Concluído!"));
}
/// <summary>
/// Check if user is authorized on a given permissionKey
/// </summary>
private bool IsAuthorized(HttpContextBase httpContext)
{
if (httpContext.User != null && ClaimHelper.GetClaimToString(CaresUserClaims.UserDomainKey) == null)
{
httpContext.User = null;
return(false);
}
if (httpContext.User != null && (httpContext.User.IsInRole("Admin") || httpContext.User.IsInRole("SystemAdministrator")))
{
return(true);
}
Claim serializedUserPermissionSet = ClaimHelper.GetClaimToString(CaresUserClaims.UserPermissionSet);
if (serializedUserPermissionSet == null)
{
return(false);
}
var userPermissionSet = JsonConvert.DeserializeObject <List <string> >(serializedUserPermissionSet.Value);
if (!userPermissionSet.Any())
{
return(false);
}
return(userPermissionSet.Any(userPSet => userPSet.Contains(PermissionKey)));
}
public IActionResult UploadImagesToPost(int id,
[FromForm] IFormFileCollection images,
[FromForm] IFormFile mainImage)
{
try
{
int?employerID = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (employerID == null)
{
return(Unauthorized(new ErrorMessageModel("Não Autorizado!")));
}
IJobDAO jobDAO = new JobDAO(_connection, this._environment.ContentRootPath);
if (jobDAO.FindById(id, (int)employerID) == null)
{
return(NotFound(new ErrorMessageModel("Post não encontrado!")));
}
SuccessMessageModel message = jobDAO.UploadImagesToPost(id, images, mainImage);
return(Ok(message));
}
catch (Exception e)
{
return(BadRequest(new ErrorMessageModel(e.Message)));
}
}
private void SetExternalInvitationRoles(ApplicationUser externalUser, string phone)
{
//----------------------------------------------------------------------------------------------------
// when the external user accepts the invitation, we remove the invitation and roles claims for the
// internal user, confirm the email and add phone # for the external user.
//----------------------------------------------------------------------------------------------------
if (externalUser != null)
{
string roleClaim = ClaimHelper.GetSafeClaim(externalUser, AppConstants.ROLES_CLAIM, string.Empty);
string[] roles = roleClaim.Split(new char[] { ',' });
if (roles.Length > 0)
{
_userManager.AddToRoles(externalUser.Id, roles);
}
externalUser.EmailConfirmed = true;
externalUser.PhoneNumber = phone;
_userManager.Update(externalUser);
// remove invitation claim for the internal user
SafeRemoveClaim(externalUser, AppConstants.INVITATION_CLAIM, ClaimHelper.GetSafeClaim(externalUser, AppConstants.INVITATION_CLAIM, "1"));
SafeRemoveClaim(externalUser, AppConstants.EXPIRATION_DATE_CLAIM, ClaimHelper.GetSafeClaim(externalUser, AppConstants.EXPIRATION_DATE_CLAIM, string.Empty));
SafeRemoveClaim(externalUser, AppConstants.ROLES_CLAIM, ClaimHelper.GetSafeClaim(externalUser, AppConstants.ROLES_CLAIM, string.Empty));
}
}
public async Task <IActionResult> RefreshToken([FromBody] RefreshTokenRequest request)
{
ClaimsPrincipal validatedToken = _tokenService.IsTokenAuthentic(request.Token);
if (validatedToken == null)
{
return(BadRequest(new ErrorResponse {
Message = "This token has been tampered with."
}));
}
RefreshToken refreshToken = await _tokenService.CanTokenBeRefreshedAsync(validatedToken, request.RefreshToken);
if (refreshToken == null)
{
return(BadRequest(new ErrorResponse {
Message = "Invalid Token, cannot refresh."
}));
}
string organisationID = ClaimHelper.GetNamedClaim(validatedToken, "OrganisationID");
var transaction = _unitOfWork.RefreshTokenRepository.BeginTransaction();
RefreshTokenResponse refreshTokenResponse = await _tokenService.RefreshTokenAsync(validatedToken, refreshToken, organisationID);
transaction.Commit();
return(Ok(new Response <RefreshTokenResponse>(refreshTokenResponse)));
}
private string GetStartPage(string userName, bool useEmail = false)
{
ViewBag.StartPageClass = "fa-heart-o";
try
{
ApplicationUser appUser = _userManager.FindByName(userName);
if (useEmail)
{
appUser = _userManager.FindByEmail(userName);
}
if (appUser != null)
{
string page = ClaimHelper.GetSafeClaim(appUser, AppConstants.FAVORITE_PAGE);
if (page != string.Empty)
{
ViewBag.StartPageClass = "fa-heart red";
}
return(page);
}
}
catch
{
}
return(string.Empty);
}
public ActionResult AddClaimMapping()
{
// TODO: sanitize input and add AntiForgeryToken
var incomingClaimType = this.Request.Form["IncomingClaimType"];
var incomingValue = this.Request.Form["IncomingValue"];
var roleName = this.Request.Form["NewRole"];
var organization = ClaimHelper.GetCurrentUserClaim(Fabrikam.ClaimTypes.Organization).Value;
var claimMappingsRepository = new ClaimMappingRepository();
var role = claimMappingsRepository.GetRoleByName(roleName);
if (this.ValidateClaimMapping(incomingClaimType, incomingValue, role, organization, claimMappingsRepository))
{
claimMappingsRepository.SaveClaimMapping(
new ClaimMapping
{
IncomingClaimType = incomingClaimType,
IncomingValue = incomingValue,
OutputRole = role,
Organization = organization
});
}
return(this.ClaimMappings());
}
public ActionResult <List <JobPostReturnedModel> > GetAvailableWorks([FromQuery(Name = "categories")] Categories[] categories, [FromQuery(Name = "address")] string address, [FromQuery(Name = "distance")] int?distance, [FromQuery(Name = "rating")] int?rating)
{
try
{
int?mateID = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (mateID == null)
{
return(NotFound(new ErrorMessageModel("Utilizador não existe!")));
}
MateDAO mateDao = new MateDAO(_connection);
Mate mate = mateDao.FindMateById((int)mateID);
if (address == null)
{
address = mate.Address;
}
IJobDAO jobDAO = new JobDAO(_connection);
List <JobPostReturnedModel> postsList = _mapper.Map <List <JobPostReturnedModel> >(jobDAO.GetJobs(categories, address, distance, rating, (int)mateID));
return(Ok(postsList));
}
catch (Exception ex)
{
return(UnprocessableEntity(new ErrorMessageModel(ex.Message)));
}
}
public async Task <RefreshToken> CanTokenBeRefreshedAsync(ClaimsPrincipal validatedToken, string refreshToken)
{
long expiryDateUnix = ClaimHelper.GetUnixExpiryDate(validatedToken);
//if not expired, dont let user refresh
//tokens contain time in unix format.
//unix epoch (1970 1 1 000) is used to calculate unix time
//unix time (nr of seconds elapsed since epoch)
DateTime expiryDateTimeUtc = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)
.AddSeconds(expiryDateUnix);
RefreshToken storedRefreshToken = await _unitOfWork.RefreshTokenRepository.GetRefreshToken(refreshToken);
if (expiryDateTimeUtc > DateTime.UtcNow ||
storedRefreshToken == null ||
DateTime.UtcNow > storedRefreshToken.ExpiryDate ||
storedRefreshToken.Invalidated ||
storedRefreshToken.Used ||
storedRefreshToken.JwtID != ClaimHelper.GetJTI(validatedToken))
{
return(null);
}
return(storedRefreshToken);
}
public JsonResult Retrieve()
{
if (_userManager != null && _userManager.SupportsUserRole)
{
var appUsers = _userManager.Users.ToList();
var filteredUsers = appUsers.Where(u => u.Claims.Any(t => t.ClaimType == AppConstants.INVITATION_CLAIM && t.ClaimValue == "1"));
var invitedUsers = filteredUsers.Select(u =>
new UserInvitationViewModel
{
UserId = u.Id,
UserName = u.UserName,
UserEmail = u.Email,
InvitationCode = ClaimHelper.GetSafeClaim(u, AppConstants.INVITATION_CODE_CLAIM, string.Empty),
ExpirationDate = DateTime.Parse(ClaimHelper.GetSafeClaim(u, AppConstants.EXPIRATION_DATE_CLAIM, DateTime.Today.Date.AddDays(-1).ToShortDateString())),
UserRoles = TuplifyString(ClaimHelper.GetSafeClaim(u, AppConstants.ROLES_CLAIM, string.Empty)),
Password = string.Empty,
ConfirmPassword = string.Empty,
})
.ToList();
string message = string.Format("Total of {0:d} users are retrieved for invitation.", invitedUsers.Count());
DojoLogger.Trace(message, typeof(UserRoleManagerController));
return(Json(invitedUsers, JsonRequestBehavior.AllowGet));
}
else if (!_userManager.SupportsUserRole)
{
return(JsonError("User Role is not suported."));
}
else
{
return(JsonError("Role manager does not exist"));
}
}
private static void AddOrUpdateClaims(User user, ClaimsPrincipal UserClaimsPrincipal)
{
var existingPasswordIsAboutToExpireClaim = ClaimHelper.GetClaim(UserClaimsPrincipal,
CustomClaimTypes.PasswordIsAboutToExpire);
if (existingPasswordIsAboutToExpireClaim != null)
{
((ClaimsIdentity)UserClaimsPrincipal.Identity).RemoveClaim(existingPasswordIsAboutToExpireClaim);
}
((ClaimsIdentity)UserClaimsPrincipal.Identity).AddClaim(new Claim(CustomClaimTypes.PasswordIsAboutToExpire,
JsonConvert.SerializeObject(user.PasswordIsAboutToExpire)));
var existingPasswordExpiryDaysRemaining = ClaimHelper.GetClaim(UserClaimsPrincipal,
CustomClaimTypes.PasswordExpiryDaysRemaining);
if (existingPasswordExpiryDaysRemaining != null)
{
((ClaimsIdentity)UserClaimsPrincipal.Identity).RemoveClaim(existingPasswordExpiryDaysRemaining);
}
((ClaimsIdentity)UserClaimsPrincipal.Identity).AddClaim(
new Claim(CustomClaimTypes.PasswordExpiryDaysRemaining,
JsonConvert.SerializeObject(user.PasswordExpiryDaysRemaining)));
}
private Guid GetUserId()
{
Guid userId;
Guid.TryParse(ClaimHelper.GetClaimValue(Context.User, ClaimTypes.Sid), out userId);
return(userId);
}
