public async Task <IActionResult> CreateClaim(string id, ClaimsViewModel model) { var role = await _roleManager.FindByIdAsync(id); if (role == null) { return(NotFound()); } if (ModelState.IsValid) { bool isExist = !String.IsNullOrEmpty(id); if (!isExist) { return(NotFound()); } IdentityRoleClaim <long> claim = new() { RoleId = Convert.ToInt32(id), ClaimType = model.claim.ClaimType, ClaimValue = model.claim.ClaimValue }; _dbContext.RoleClaims.Add(claim); await _dbContext.SaveChangesAsync(); return(RedirectToAction(nameof(Index), new { id })); } return(View(model)); }
public IActionResult GetAccess() { var id = new ClaimsIdentity(User.Claims, "Forms", "name", "role"); // var currentPrincipal = new ClaimsPrincipal(id); // Thread.CurrentPrincipal = currentPrincipal; // var identity = User.Identity as ClaimsIdentity; // var r = User.IsInRole("AO Encoder"); var claims = id.Claims.ToList(); ClaimsViewModel claimsVm = new ClaimsViewModel { name = claims.Where(c => c.Type == "name").SingleOrDefault().Value, rank = claims.Where(c => c.Type == "rank").SingleOrDefault().Value, role = claims.Where(c => c.Type == "role").Select(s => s.Value), access = claims.Where(c => c.Type == "access").Select(s => s.Value) }; // claims.ForEach(v => { // if (v.Type == "role") { // claimsVm.role.Add(v.Value); // } // if (v.Type == "access") { // claimsVm.access.Add(v.Value); // } // }); // var accessToken = await HttpContext.GetTokenAsync("access_token"); // var client = new HttpClient(); // client.SetBearerToken(accessToken); // var userInfoClient = client.GetUserInfoAsync(new UserInfoRequest { Address = "http://localhost:5000/connect/userinfo", Token = accessToken }); // var response = userInfoClient.Result.Claims.ToList(); // var uid = User.Identity.Name; // TODO: Your code here return(Ok(claimsVm)); }
public async Task <IActionResult> DeleteClaim(ClaimsViewModel model) { string responseCode = string.Empty; string responseMessage = string.Empty; try { var claim = await _context.TenantClaims.FirstOrDefaultAsync(x => x.ID == model.ID); _context.TenantClaims.Remove(claim); var result = await _context.SaveChangesAsync(); responseCode = "Success"; responseMessage = string.Format(AccountOptions.API_Response_Deleted, "Claim"); } catch (Exception ex) { responseCode = "Error"; responseMessage = string.Format(AccountOptions.API_Response_Failed, ex.Message); } return(Ok(new { MessageCode = responseCode, MessageDetails = responseMessage })); }
//[ResponseCache(Duration = 100, VaryByQueryKeys = new[] { "page", "searchstring" })] public async Task <IActionResult> Index(int?page, string searchstring, FilterByStatus FilterByStatus, VolumeRanges?Volume, [ModelBinder(typeof(DateTimeModelBinder))] DateTime?startDate, [ModelBinder(typeof(DateTimeModelBinder))] DateTime?endDate) { int pageSize = Int32.Parse(_configuration["DefaultPagesize"]); var carrierId = _carrierService.Carrier.Id; var model = new ClaimsViewModel { StartDate = startDate, EndDate = endDate, Cars = await _carrierService.GetCars(carrierId), Drivers = await _carrierService.GetDrivers(carrierId), CarrierId = carrierId, SearchString = searchstring, FilterByStatus = FilterByStatus, Volume = Volume }; var claimsResult = await _claimService.GetFilteredClaimsAsync(model); model.Claims = claimsResult.ToPagedList(page ?? 1, pageSize); ViewData["pagesize"] = pageSize; return(View(model)); }
public IActionResult Index() { var vm = new ClaimsViewModel { Claims = User.Claims, Name = User.Identity.Name }; return(View(vm)); }
public async Task <IActionResult> Index() { var localAddresses = new string[] { "127.0.0.1", "::1", HttpContext.Connection.LocalIpAddress.ToString() }; var isLocallyRequested = !localAddresses.Contains(HttpContext.Connection.RemoteIpAddress.ToString()); var viewModel = new ClaimsViewModel(await HttpContext.AuthenticateAsync(), isLocallyRequested); return(View(viewModel)); }
public ClaimsViewModel BuscarClaimsPorId(Guid id) { var claim = _agenciaService.BuscarClaimsPorId(id); var result = new ClaimsViewModel() { Permissao = claim.ClaimValue }; return(result); }
public JsonResult BuscarPermissaoUsuario(Guid?id) { ClaimsViewModel claim = new ClaimsViewModel(); if (id != null) { claim = _agenciaappservice.BuscarClaimsPorId(id.Value); } return(Json(new { claim.Permissao }, JsonRequestBehavior.AllowGet)); }
/// <summary> /// Отбор заявок /// </summary> /// <param name="model"></param> /// <returns></returns> public async Task <IList <ClaimWithOneReplyVm> > GetFilteredClaimsAsync(ClaimsViewModel model) { IQueryable <ClaimForTransport> claims = _context.ClaimsForTransport.Include(reply => reply.Replies).ThenInclude(p => p.Driver). Include(reply => reply.Replies).ThenInclude(p => p.Car). Where(p => model.SearchString == null || p.NumberIn1S.Contains(model.SearchString)). Where(p => model.StartDate == null || p.DocDate >= model.StartDate). Where(p => model.EndDate == null || p.DocDate <= model.EndDate); if (model.Volume != null) { claims = claims.Where(p => p.Volume <= (int)model.Volume.Value); } claims = claims.Where(p => p.Status == StatusOfClaim.OnTender || p.CarrierId == model.CarrierId).OrderByDescending(p => p.DocDate); var claimsResult = (await claims.AsNoTracking().ToListAsync()).Select(p => new ClaimWithOneReplyVm { GuidIn1S = p.GuidIn1S, DocDate = p.DocDate, NumberIn1S = p.NumberIn1S, Path = p.Path, ReadyDate = p.ReadyDate, DeadlineDate = p.DeadlineDate, Volume = p.Volume, Comments = p.Comments, Status = p.Status, CarrierId = p.CarrierId, Reply = p.Replies.FirstOrDefault(x => x.CarrierId == model.CarrierId), OtherRepliesExists = p.Replies.Any(reply => reply.CarrierId != model.CarrierId) }); switch (model.FilterByStatus) { case FilterByStatus.OnlyNew: { claimsResult = claimsResult.Where(p => p.Status == StatusOfClaim.OnTender && p.Reply == null); break; } case FilterByStatus.OnlyApproved: { claimsResult = claimsResult.Where(p => p.Status >= StatusOfClaim.Chosen && p.CarrierId == model.CarrierId); break; } default: break; } return(claimsResult.ToList()); }
public async Task <ActionResult> ClaimsUpdate(ClaimsViewModel claims) { await UserManager.RemoveClaimAsync(User.Identity.GetUserId <int>(), new Claim(ClaimsSistema.UsuarioPremium.ToString(), claims.UsuarioPremium)); await UserManager.RemoveClaimAsync(User.Identity.GetUserId <int>(), new Claim(ClaimsSistema.Desenvolvedor.ToString(), claims.Desenvolvedor)); await UserManager.AddClaimAsync(User.Identity.GetUserId <int>(), new Claim(ClaimsSistema.UsuarioPremium.ToString(), claims.UsuarioPremium)); await UserManager.AddClaimAsync(User.Identity.GetUserId <int>(), new Claim(ClaimsSistema.Desenvolvedor.ToString(), claims.Desenvolvedor)); return(RedirectToAction("Index")); }
public async Task CountOfClaimsByCarrierId_ShouldReturns2() { var context = GenerateDbContext(); var service = new ClaimService(context); var model = new ClaimsViewModel { CarrierId = "94637" }; var claims = await service.GetFilteredClaimsAsync(model); Assert.Equal(2, claims.Count); }
public ClaimsViewModel Editar(ClaimsViewModel claimViewModel) { var claims = Mapper.Map <EditarClaimsCommand>(claimViewModel); var claimsRetorno = _claimsService.Editar(claims); if (claimsRetorno.ValidationResult.IsValid) { _unitOfWork.Commit(); } claimViewModel = Mapper.Map <ClaimsViewModel>(claimsRetorno); return(claimViewModel); }
public async Task CountOfClaimsByCarrierId_91111_ShouldReturns(string carrierId, int expectedCount) { var context = GenerateDbContext(); var service = new ClaimService(context); var model = new ClaimsViewModel { CarrierId = carrierId }; var claims = await service.GetFilteredClaimsAsync(model); Assert.Equal(expectedCount, claims.Count); }
public static ClaimsViewModel SelectAllClaimsBySearch(Guid ParlourId, int PageSize, int PageNum, string Keyword, string SortBy, string SortOrder, bool ClaimingForMember, bool ApplyWaitingPeriod) { SqlDataReader dr = ClaimsDAL.SelectAllClaimsBySearch(ParlourId, PageSize, PageNum, Keyword, SortBy, SortOrder, ClaimingForMember, ApplyWaitingPeriod); ClaimsViewModel objViewModel = new ClaimsViewModel(); objViewModel.ClaimsList = FuneralHelper.DataReaderMapToList <ClaimsModel>(dr, true); dr.NextResult(); dr.Read(); objViewModel.TotalRecord = Convert.ToInt64(dr["TotalRecord"]); dr.Close(); dr.Dispose(); return(objViewModel); }
public async Task <IActionResult> Submit([FromBody] ClaimsViewModel claim) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } // Check if claim proposal's status is in 'PENDING' ??? var chk_pending = _context.ClaimsProposals .Where( e => e.PolicyNo == claim.PolicyNo && e.ClaimStatus == Core.Entities.ClaimStatus.Pending) .SingleOrDefault(); if (chk_pending != null) { return(BadRequest()); } // New claim proposal setup... var new_claim = new ClaimsProposal() { Id = new Guid(), PolicyNo = claim.PolicyNo, InsuredName = claim.InsuredName, NIC = claim.NIC, Phone = claim.Phone, InitimatedDate = DateTime.Now, CauseOfLoss = claim.CauseOfLoss, NameOfTreatment = claim.NameOfTreatment, FromHospitalization = claim.FromHospitalization, ToHospitalization = claim.ToHospitalization, ClaimStatus = Core.Entities.ClaimStatus.Pending, ReinvestmentAmt = claim.ReinvestmentAmt, CreatedDate = DateTime.Now, UpdatedDate = null }; try { _context.ClaimsProposals.Add(new_claim); await _context.SaveChangesAsync(); // return CreatedAtAction(nameof(GetClaimsProposal), new { id = new_claim.Id }, new_claim); return(Json(new_claim)); } catch (Exception) { throw; } }
public async Task <IActionResult> UpdateClaim(int claimId, ClaimsViewModel model) { if (ModelState.IsValid) { var claim = _dbContext.RoleClaims.Find(claimId); claim.ClaimType = model.claim.ClaimType; claim.ClaimValue = model.claim.ClaimValue; _dbContext.RoleClaims.Update(claim); await _dbContext.SaveChangesAsync(); return(RedirectToAction(nameof(Index), new { id = claim.RoleId })); } return(View(model)); }
public async Task <IActionResult> CreateClaim(string id) { var role = await _roleManager.FindByIdAsync(id); if (role == null) { return(NotFound()); } var model = new ClaimsViewModel { role = role }; return(View(model)); }
public ActionResult Edit(ClaimsViewModel claimsViewModel) { if (ModelState.IsValid) { claimsViewModel = _claimsAppService.Editar(claimsViewModel); if (!claimsViewModel.ValidationResult.IsValid) { AddModelErrors(claimsViewModel.ValidationResult.Errors); return(View(claimsViewModel)); } TempData["success"] = "Claim atualizado com sucesso!"; return(RedirectToAction("Index", "Claims")); } return(View(claimsViewModel)); }
public async Task <IActionResult> Edit([FromBody] ClaimsViewModel claim) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var upd_claim = await _context.ClaimsProposals .Where( m => m.PolicyNo == claim.PolicyNo && m.ClaimStatus == Core.Entities.ClaimStatus.Pending) .OrderByDescending(m => m.CreatedDate) .FirstOrDefaultAsync(); if (null == upd_claim) { return(NotFound()); } upd_claim.PolicyNo = claim.PolicyNo; upd_claim.InsuredName = claim.InsuredName; upd_claim.NIC = claim.NIC; upd_claim.Phone = claim.Phone; upd_claim.CauseOfLoss = claim.CauseOfLoss; upd_claim.NameOfTreatment = claim.NameOfTreatment; upd_claim.FromHospitalization = claim.FromHospitalization; upd_claim.ToHospitalization = claim.ToHospitalization; upd_claim.ReinvestmentAmt = claim.ReinvestmentAmt; upd_claim.UpdatedDate = DateTime.Now; _context.ClaimsProposals.Update(upd_claim); try { if (await _context.SaveChangesAsync() > 0) { return(Json(upd_claim)); } else { return(BadRequest()); } } catch (Exception) { return(BadRequest()); } }
public async Task <ActionResult> InfoUser() { var claims = new ClaimsViewModel(); var currentClaims = await UserManager.GetClaimsAsync(User.Identity.GetUserId <int>()); if (currentClaims.Any(x => x.Type.Equals(ClaimsSistema.Desenvolvedor.ToString()))) { claims.Desenvolvedor = currentClaims.FirstOrDefault(x => x.Type.Equals(ClaimsSistema.Desenvolvedor.ToString())).Value; } if (currentClaims.Any(x => x.Type.Equals(ClaimsSistema.UsuarioPremium.ToString()))) { claims.UsuarioPremium = currentClaims.FirstOrDefault(x => x.Type.Equals(ClaimsSistema.UsuarioPremium.ToString())).Value; } return(View(claims)); }
public async Task <IActionResult> UpdateClaim(int?claimId) { if (claimId == null) { return(NotFound()); } var Claim = await _dbContext.RoleClaims.FindAsync(claimId); if (Claim == null) { return(NotFound()); } var model = new ClaimsViewModel { claim = Claim }; return(View(model)); }
public IActionResult SubmitClaims([FromBody] ClaimsViewModel model) { if (ModelState.IsValid) { string ownerIp = HttpContext.Connection.RemoteIpAddress.ToString(); var claims = from claim in model.Claims select new ClaimDTO { Type = claim.Type, Value = claim.Value }; _claimService.AddOrUpdateClaims(claims, model.Identity, ownerIp); return(Ok()); } else { return(BadRequest(model)); } }
// GET: Claims public async Task <IActionResult> Index(Guid productId, Guid clientId, Guid policyId) { var claims = await(from c in _context.Claims .Include(c => c.ClaimClass) .Include(c => c.ClaimStatus) .Include(c => c.Incident) .Include(c => c.Region) .OrderBy(r => r.ClaimNumber) .Where(c => c.PolicyID == policyId) select c).ToListAsync(); ClaimsViewModel viewModel = new ClaimsViewModel { ProductID = productId, ClientID = clientId, PolicyID = policyId, Claims = claims }; return(View(viewModel)); }
public async Task <IActionResult> Index(string id) { var role = await _roleManager.FindByIdAsync(id); if (role == null) { return(NotFound()); } var model = new ClaimsViewModel { role = role, claims = await(from c in _dbContext.RoleClaims where c.RoleId == role.Id select new IdentityRoleClaim <long>() { Id = c.Id, ClaimType = c.ClaimType, ClaimValue = c.ClaimValue }).ToListAsync() }; return(View(model)); }
public IActionResult Claims() { ClaimsViewModel vm = new ClaimsViewModel(); foreach (FieldInfo field in typeof(ClaimTypes).GetFields()) { vm.GridData.Add(new ClaimGridRowModel() { ClaimId = null, Name = field.Name, Value = (string)field.GetValue(null), IsReadOnly = true }); } vm.GridControl = new GridControlModel() { PageSize = 10, CurrentPage = 1, TotalRecords = 2 }; return(View(vm)); }
public SelectList Claims() { return(new SelectList(ClaimsViewModel.ListarClaims(), "ClaimType", "ClaimValue")); }
public async Task <IActionResult> ManageUserClaims(string userId, int projectId) { Global.ProjectId = projectId; var project = _projectRepository.GetProject(projectId); Global.Project = project; var uId = userManager.GetUserId(User); var currentUser = await userManager.FindByIdAsync(uId); var uClaims = await userManager.GetClaimsAsync(currentUser); Global.globalCurrentUserClaims = uClaims.ToList(); var user = await userManager.FindByIdAsync(userId); var IsManagerLevel = ClaimsLevel.IsManager(User.Claims.ToList(), projectId); if (IsManagerLevel == false) { return(RedirectToAction("AccessDenied", "Account")); } else if (userId == userManager.GetUserId(User) || userId == project.OwnerId) { return(RedirectToAction("AccessDenied", "Account")); } if (user == null) { ViewBag.ErrorMessage = $"User with id {userId} doesn't exist"; return(View("NotFound")); } var existingUserClaims = await userManager.GetClaimsAsync(user); //foreach(var claim in existingUserClaims) //{ // Console.WriteLine("------"); // Console.WriteLine(claim.Type); // Console.WriteLine(claim.Value); //} var viewModel = new ClaimsViewModel { UserId = userId, ProjectId = projectId }; for (var i = 0; i < ClaimsPile.AllClaims.Count; i++) { UserClaim userClaim = new UserClaim { ClaimType = ClaimsPile.AllClaims[i].Type }; var projectList = new List <string>(); if (existingUserClaims.Count == 4) { projectList = existingUserClaims[i].Value.Split(" ").ToList(); } for (int j = 0; j < projectList.Count; j++) { if (projectList[j] == projectId.ToString()) { userClaim.IsSelected = true; break; } } viewModel.Claims.Add(userClaim); } foreach (var claim in viewModel.Claims) { Console.WriteLine(claim.ClaimType); Console.WriteLine(claim.IsSelected); } return(View(viewModel)); }
public async Task <IActionResult> ManageUserClaims(ClaimsViewModel model) { var uId = userManager.GetUserId(User); var currentUser = await userManager.FindByIdAsync(uId); var uClaims = await userManager.GetClaimsAsync(currentUser); Global.globalCurrentUserClaims = uClaims.ToList(); var user = await userManager.FindByIdAsync(model.UserId); var project = _projectRepository.GetProject(model.ProjectId); if (user == null) { ViewBag.ErrorMessage = $"User with id {model.UserId} doesn't exist"; return(View("NotFound")); } if (model.UserId == userManager.GetUserId(User) || model.UserId == project.OwnerId) { return(RedirectToAction("AccessDenied", "Account")); } var existingUserClaims = await userManager.GetClaimsAsync(user); var currentClaims = existingUserClaims.ToList(); var result = await userManager.RemoveClaimsAsync(user, existingUserClaims); if (result.Succeeded == false) { ModelState.AddModelError("", "Cannot remove user existing claims"); return(View(model)); } var claimsList = new List <Claim>(); for (var i = 0; i < model.Claims.Count; i++) { var projectList = new List <string>(); var projectListString = ""; if (currentClaims.Count == 4) { projectList = currentClaims[i].Value.Split(" ").ToList(); var currentClaimContainsId = ClaimsHelper.ContainsId(model.ProjectId.ToString(), projectList); if (currentClaimContainsId && model.Claims[i].IsSelected) { projectListString = String.Join(" ", projectList.ToArray()); } else if (!currentClaimContainsId && model.Claims[i].IsSelected) { projectList.Add(model.ProjectId.ToString()); projectListString = String.Join(" ", projectList.ToArray()); } else if (currentClaimContainsId && model.Claims[i].IsSelected == false) { var newListWithRemovedId = ClaimsHelper.RemoveProjectId(model.ProjectId.ToString(), projectList); projectListString = String.Join(" ", newListWithRemovedId.ToArray()); } else if (!currentClaimContainsId && model.Claims[i].IsSelected == false) { projectListString = String.Join(" ", projectList.ToArray()); } } claimsList.Add(new Claim(model.Claims[i].ClaimType, projectListString)); } result = await userManager.AddClaimsAsync(user, claimsList); if (result.Succeeded == false) { ModelState.AddModelError("", "Cannot add selected claims to user"); return(View(model)); } return(RedirectToAction("EditUser", new { userId = model.UserId, projectId = model.ProjectId })); }
public async Task <IActionResult> SaveClaim(ClaimsViewModel model) { string responseCode = string.Empty; string responseMessage = string.Empty; try { if (model.ID != Guid.Empty) { //Update var getclaimbyid = await _context.TenantClaims.SingleOrDefaultAsync(d => d.ID == model.ID && d.TenantID == model.TenantID); if (model.Name != getclaimbyid.ClaimName) { if (await _context.TenantClaims.AnyAsync(x => x.ClaimName == model.Name)) { responseCode = "Exists"; responseMessage = string.Format(AccountOptions.API_Response_Exist, "Claim"); } else { getclaimbyid.ClaimName = model.Name; getclaimbyid.IsAvailable = true; await _context.SaveChangesAsync(); responseCode = "Success"; responseMessage = string.Format(AccountOptions.API_Response_Saved, "Claim"); } } } else { //Add if (!await _context.TenantClaims.AnyAsync(x => x.ClaimName == model.Name)) { //Doesnot exist //Add new var claim = new TenantClaims(); claim.ClaimName = model.Name; claim.TenantID = model.TenantID; claim.IsAvailable = true; await _context.TenantClaims.AddAsync(claim); await _context.SaveChangesAsync(); responseCode = "Success"; responseMessage = string.Format(AccountOptions.API_Response_Saved, "Claim"); } else { responseCode = "Exists"; responseMessage = string.Format(AccountOptions.API_Response_Exist, "Claim"); } } } catch (Exception ex) { responseCode = "Error"; responseMessage = string.Format(AccountOptions.API_Response_Failed, ex.Message); } return(Ok(new { MessageCode = responseCode, MessageDetails = responseMessage })); }