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
}));
}
