public IHttpActionResult Get(Guid id)
{
ClaimDto claim = null;
ExecuteInSession(session => claim = ModelMapper.Map <ModelClaim, ClaimDto>(session.Get <ModelClaim>(id)));
return(Ok <ClaimDto>(claim));
}
public async Task <IActionResult> RemoveClaim(string userId, [FromBody] ClaimDto claimDto)
{
logger.LogInformation($"DELETE: api/users/{0}/claim", userId);
if (!ModelState.IsValid)
{
logger.LogWarning("User provided invalid data for request");
return(BadRequest(ModelState));
}
var user = await userManager.FindByIdAsync(userId);
if (user == null)
{
logger.LogWarning($"Cannot find user with provided id: {0}", userId);
return(NotFound($"User with provided id {userId} not exist"));
}
var claim = new Claim(claimDto.Type, claimDto.Value);
var result = await userManager.RemoveClaimAsync(user, claim);
if (result.Succeeded)
{
return(NoContent());
}
logger.LogError($"Cannot add claim: {result.Errors}");
return(StatusCode(StatusCodes.Status500InternalServerError, result.Errors));
}
public async Task <ClaimDto> UpdateAsync(ClaimDto claimDto)
{
var claim = await context.Claims.Include(c => c.User).FirstOrDefaultAsync(c => c.Id == claimDto.Id);
claim.Airline = claimDto.Airline;
claim.ArrivalAirport = claimDto.ArrivalAirport;
claim.Category = claimDto.Category;
claim.CountryCode = claimDto.CountryCode;
claim.DepartureAirport = claimDto.DepartureAirport;
claim.Description = claimDto.Description;
claim.FlightDate = claimDto.FlightDate;
claim.FlightNumber = claimDto.FlightNumber;
claim.PhoneNumber = claimDto.PhoneNumber;
claim.Title = claimDto.Title;
if (claimDto.BPImage != null)
{
using (var ms = new MemoryStream())
{
claimDto.BPImage.CopyTo(ms);
var fileBytes = ms.ToArray();
claim.BoardingPassImage = fileBytes;
}
}
context.Claims.Update(claim);
await context.SaveChangesAsync();
var claimDtoResult = mapper.Map <ClaimDto>(claim);
return(claimDtoResult);
}
public async Task <IActionResult> AssignClaim(string userId, [FromBody] ClaimDto claimDto)
{
logger.LogInformation($"POST: api/users/{0}/claim", userId);
if (!ModelState.IsValid)
{
logger.LogWarning("User provided invalid data for request");
return(BadRequest(ModelState));
}
var user = await userManager.FindByIdAsync(userId);
if (user == null)
{
logger.LogWarning($"Cannot find user with provided id: {0}", userId);
return(NotFound($"User with provided id {userId} not exist"));
}
var claim = new Claim(claimDto.Type, claimDto.Value);
if (await IsClaimDuplicate(user, claim))
{
logger.LogWarning($"User {user.Id} already has claim with type {claim.ValueType} and value {claim.Value}");
return(StatusCode(StatusCodes.Status409Conflict));
}
var result = await userManager.AddClaimAsync(user, claim);
if (result.Succeeded)
{
return(NoContent());
}
logger.LogError($"Cannot add claim: {result.Errors}");
return(StatusCode(StatusCodes.Status500InternalServerError, result.Errors));
}
public ActionResult Login(UserDto entity)
{
if (!ModelState.IsValid)
{
return(View(entity));
}
var user = _databaseContext.Users.FirstOrDefault(x => x.UserName.Trim().ToLower() == entity.UserName.Trim().ToLower() && x.Password.Trim().ToLower() == entity.Password.Trim().ToLower());
if (user != null)
{
var model = new ClaimDto {
UserName = user.UserName, Type = user.Type, Id = user.Id
};
var claims = new List <Claim>
{
new Claim(ClaimTypes.Role, user.Type),
new Claim(ClaimTypes.Name, JsonConvert.SerializeObject(model))
};
var identity = new ClaimsIdentity(claims, "login");
ClaimsPrincipal claimsPrincipal = new ClaimsPrincipal(identity);
HttpContext.SignInAsync(claimsPrincipal);
switch (user.Type)
{
case "Customer":
return(RedirectToAction("Index", "Customer"));
case "ServiceManager":
return(RedirectToAction("Index", "Manager"));
default:
throw new Exception("Not Found User");
}
}
return(View(entity));
}
public async Task <IActionResult> Post([FromBody] ClaimDto claimDto)
{
try
{
if (claimDto == null)
{
return(BadRequest("ClaimDto null"));
}
var officeId = await GetOfficeId();
if (officeId <= 0)
{
throw new ApplicationException("Oficina inválida");
}
var claim = claimDtoMapper.Map(claimDto, officeId);
var claimId = await newClaimService.Save(claim, User.Identity.Name);
return(Created("claim", new { claimId }));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new { message = ex.Message }));
}
}
public void ReturnCollectionOfClaimsFilteredByAirline()
{
// Arrange
var options = TestUtilities.GetOptions(nameof(ReturnCollectionOfClaimsFilteredByAirline));
// Act, Assert
using (var assertContext = new ClaimsDbContext(options))
{
var myProfile = new ClaimProfile();
var configuration = new MapperConfiguration(cfg => cfg.AddProfile(myProfile));
IMapper mapper = new Mapper(configuration);
var claimDto = new ClaimDto();
var claimDto2 = new ClaimDto();
var claimDto3 = new ClaimDto();
IFormFile file = new FormFile(new MemoryStream(Encoding.UTF8.GetBytes("This is a dummy file")), 0, 0, "Data", "dummy.txt");
claimDto.BPImage = file;
claimDto2.BPImage = file;
claimDto3.BPImage = file;
claimDto.Airline = "TestAir";
claimDto2.Airline = "TestAir";
claimDto3.Airline = "AirTest";
var sut = new ClaimServices(assertContext, mapper);
sut.CreateAsync(claimDto).GetAwaiter().GetResult();
sut.CreateAsync(claimDto2).GetAwaiter().GetResult();
sut.CreateAsync(claimDto3).GetAwaiter().GetResult();
var results = sut.FilterByMultipleCriteriaAsync("TestAir", default, default, default).GetAwaiter().GetResult();
public ActionResult <string> Put(int id, [FromBody] ClaimDto fieldsToUpdate)
{
try
{
CommandFactory.CreateUpdateClaimCommand(id, fieldsToUpdate).Execute();
_logger?.LogInformation($"Claim {id} actualizado correctamente");
return(Ok());
}
catch (ClaimNotFoundException ex)
{
_logger?.LogWarning(ex.Message);
return(new BadRequestObjectResult(new ErrorMessage(ex.Message)));
}
catch (AttributeSizeException ex)
{
_logger?.LogWarning($"Tamaño invalido de atributo al actualizar Claim {id}: {ex.Message}");
return(new BadRequestObjectResult(new ErrorMessage(ex.Message)));
}
catch (AttributeValueException ex)
{
_logger?.LogWarning($"Valor invalido de atributo al actualizar Claim {id}: {ex.Message}");
return(new BadRequestObjectResult(new ErrorMessage(ex.Message)));
}
catch (DatabaseException ex)
{
_logger?.LogError(ex, "Error de base de datos al tratar de actualizar Claim");
return(StatusCode(500, ex.Message));
}
}
public async Task <IActionResult> Update(ClaimDto claimDto)
{
if (claimDto.FlightDate.Year < 2000)
{
ModelState.AddModelError(string.Empty, $"Please enter a valid FLight Date. Air Passenger Services does not handle claims regarding flights before the 2000-th year.");
return(View(claimDto));
}
claimDto.User = await userManager.GetUserAsync(HttpContext.User);
if (claimDto.Category != "Voluntary Cancellation" && claimDto.FlightDate > DateTime.UtcNow)
{
ModelState.AddModelError(string.Empty, $"Only claims in the category \"Voluntary Cancellation\" can be submitted with Flight Date that is in the future.");
return(View("Details", claimDto));
}
claimDto.CountryCode = claimDto.CountryCode.ToUpper();
if (!phoneNumberServices.IsValidNumber(claimDto.PhoneNumber, claimDto.CountryCode))
{
ModelState.AddModelError(string.Empty, $"Invalid phone number for {claimDto.CountryCode}. You claim was not updated.");
return(View("Details", claimDto));
}
var updatedClaim = await claimServices.UpdateAsync(claimDto);
ViewData["Message"] = "Success";
return(View("Details", updatedClaim));
}
private void Adjudicate(ClaimDto claim)
{
using (var service = _adjudicationServiceFactory())
{
service.Value.Adjudicate(claim.Id);
}
_claimController.RefreshSelected();
}
public void Put_InvalidClaimStatus_BadRequestReturned()
{
var fieldsToUpdate = new ClaimDto()
{
Status = "NOTVALIDSTATUS"
};
var result = _claimController.Put(-1, fieldsToUpdate);
Assert.IsInstanceOf <BadRequestObjectResult>(result.Result);
}
public Claim Map(ClaimDto claimDto, long officeId)
{
var claim = claimDto.Adapt <Claim>();
if (officeId > 0)
{
claim.OfficeId = officeId;
}
if (claimDto.ClaimAdress != null)
{
claim.Adress = new Adress();
claim.Adress = claimDto.ClaimAdress.Adapt <Adress>();
claim.Adress.Province = null;
claim.Adress.City = null;
}
if (claimDto.ClaimInsuredPersons != null && claimDto.ClaimInsuredPersons.Any())
{
claim.ClaimInsuredPersons = new List <Person>();
claim.ClaimInsuredPersons = claimDto.ClaimInsuredPersons.Adapt <List <Person> >();
claim.ClaimInsuredPersons.ForEach(person => person.PersonType = null);
}
if (claimDto.ClaimInsuredVehicles != null && claimDto.ClaimInsuredVehicles.Any())
{
claim.ClaimInsuredVehicles = new List <Vehicle>();
claim.ClaimInsuredVehicles = claimDto.ClaimInsuredVehicles.Adapt <List <Vehicle> >();
claim.ClaimInsuredVehicles.ForEach(vehicle => vehicle.VehicleType = null);
}
if (claimDto.ClaimThirdInsuredPersons != null && claimDto.ClaimThirdInsuredPersons.Any())
{
claim.ClaimThirdInsuredPersons = new List <Person>();
claim.ClaimThirdInsuredPersons = claimDto.ClaimThirdInsuredPersons.Adapt <List <Person> >();
claim.ClaimThirdInsuredPersons.ForEach(person => person.PersonType = null);
}
if (claimDto.ClaimThirdInsuredVehicles != null && claimDto.ClaimThirdInsuredVehicles.Any())
{
claim.ClaimThirdInsuredVehicles = new List <Vehicle>();
claim.ClaimThirdInsuredVehicles = claimDto.ClaimThirdInsuredVehicles.Adapt <List <Vehicle> >();
claim.ClaimThirdInsuredVehicles.ForEach(vehicle => vehicle.VehicleType = null);
}
if (claimDto.ClaimMessages != null && claimDto.ClaimMessages.Any())
{
claim.ClaimMessages = new List <ClaimMessage>();
claim.ClaimMessages = claimDto.ClaimMessages.Adapt <List <ClaimMessage> >();
}
return(claim);
}
public void Put_InvalidClaim_BadRequestReturned()
{
var fieldsToUpdate = new ClaimDto()
{
Title = "New title",
Description = "New description"
};
var result = _claimController.Put(-1, fieldsToUpdate);
Assert.IsInstanceOf <BadRequestObjectResult>(result.Result);
}
public void ReplaceClaim(string userId, ClaimDto claim, ClaimDto newClaim)
{
var userClaim = Context.Set <IdentityUserClaim <string> >().SingleOrDefault(c => c.ClaimType == claim.ClaimType && c.UserId == userId);
if (userClaim != null)
{
userClaim.ClaimValue = newClaim.ClaimValue;
userClaim.ClaimType = newClaim.ClaimType;
Context.Entry(userClaim).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
}
SaveChanges();
}
public void Put_UpdatedTitleAndDescription_OkResultReturned()
{
var savedClaimId = _postgresClaimDao.Add(_claimMapper.CreateEntity(_claimDto));
_insertedClaims.Add(savedClaimId);
var fieldsToUpdate = new ClaimDto()
{
Title = "New title",
Description = "New description"
};
var result = _claimController.Put(savedClaimId, fieldsToUpdate);
Assert.IsInstanceOf <OkResult>(result.Result);
}
public void Put_InvalidClaimTitle_BadRequestReturned()
{
var savedClaimId = _postgresClaimDao.Add(_claimMapper.CreateEntity(_claimDto));
_insertedClaims.Add(savedClaimId);
var fieldsToUpdate = new ClaimDto()
{
Title = "SUPER LONG TITLE ............................................................................",
Description = "New description"
};
var result = _claimController.Put(savedClaimId, fieldsToUpdate);
Assert.IsInstanceOf <BadRequestObjectResult>(result.Result);
}
public void ValidWhenEmailAndPasswordProvided()
{
// arrange
var validator = new ClaimValidator();
var assignmentDto = new ClaimDto()
{
Type = validClaimType,
Value = validClaimValue
};
// act
var result = validator.Validate(assignmentDto);
// assert
Assert.True(result.IsValid);
}
public void InvalidWhenClaimValueNotProvided(string claimValue)
{
// arrange
var validator = new ClaimValidator();
var assignmentDto = new ClaimDto()
{
Value = claimValue,
Type = validClaimType
};
// act
var result = validator.Validate(assignmentDto);
// assert
Assert.False(result.IsValid);
}
public void Setup()
{
_claimMapper = MapperFactory.CreateClaimMapper();
_claimDto = new ClaimDto()
{
BaggageId = 1,
Description = "Description",
Id = 10,
Status = "CERRADO",
Title = "Titulo!"
};
_claimDtoList = new List <ClaimDto> {
_claimDto
};
}
public void ItShouldWork()
{
// arrange
string input = "#1 @ 2,3: 4x5";
// act
ClaimDto result = ClaimParser.Parse(input);
// assert
Assert.AreEqual(1, result.Id);
Assert.AreEqual(2, result.LeftEdgePosition);
Assert.AreEqual(3, result.TopEdgePosition);
Assert.AreEqual(4, result.Width);
Assert.AreEqual(5, result.Height);
}
public void Setup()
{
_postgresClaimDao = new PostgresClaimDao();
_claimController = new ClaimController(null);
_insertedClaims = new List <int>();
var claim = ClaimBuilder.Create()
.WithStatus("ABIERTO")
.WithDescription("Bolso negro extraviado en el areopuerto de maiquetia")
.WithTitle("Bolso extraviado")
.WithBagagge(6)
.Build();
_claimMapper = MapperFactory.CreateClaimMapper();
_claimDto = _claimMapper.CreateDTO(claim);
}
public async Task UserClaims_OnGet_CallsGetUserClaimsOnClaimsServiceAndReturnsView()
{
var claim = new ClaimDto("type", "value");
var claims = new List <ClaimDto>
{
claim
};
userClaimsService.Setup(x => x.GetUserClaims()).ReturnsAsync(claims);
var result = await controller.UserClaims() as ViewResult;
var model = result.ViewData.Model as ManageUserClaimsModel;
model.Claims.Should().Contain(x => x.Type == claim.Type && x.Value == claim.Value);
}
public IActionResult DeleteAllClaimsWithGivenType(string userName, ClaimDto claim)
{
try
{
var user = userMgr.FindByNameAsync(userName).Result;
if (user == null)
{
var rs = new ListOfCustomMessages()
{
new CustomMessage {
Message = "این کاربر وجود ندارد", MsgTypeEnum = MsgTypeEnum.Error
}
};
return(NotFound(rs));
}
var claimsToDelete = db.VUsersClaims.Where(t => t.UserName.ToLower() == userName.ToLower()).Where(t => t.ClaimType.ToLower() == claim.ClaimType)
.ToList().Select(t => new System.Security.Claims.Claim(type: claim.ClaimType, value: t.ClaimValue)).ToList();
if (claimsToDelete.Count() == 0)
{
var rs = new ListOfCustomMessages()
{
new CustomMessage {
Message = "چیزی پیدا نشد", MsgTypeEnum = MsgTypeEnum.Error
}
};
return(NotFound(rs));
}
var result = userMgr.RemoveClaimsAsync(user, claimsToDelete).Result;
if (!result.Succeeded)
{
throw new Exception(result.Errors.First().Description);
}
return(Ok());
}
catch (Exception ee)
{
Log.Error(ee.Message);
var rs = new ListOfCustomMessages()
{
new CustomMessage(ee)
};
return(BadRequest(rs));
}
}
public void Put_UpdatedTitleAndDescription_FieldsActuallyUpdated()
{
var savedClaimId = _postgresClaimDao.Add(_claimMapper.CreateEntity(_claimDto));
_insertedClaims.Add(savedClaimId);
var fieldsToUpdate = new ClaimDto()
{
Title = "New title",
Description = "New description"
};
_claimController.Put(savedClaimId, fieldsToUpdate);
var claimInDb = _postgresClaimDao.GetById(savedClaimId);
Assert.AreEqual(fieldsToUpdate.Title, claimInDb.Title);
Assert.AreEqual(fieldsToUpdate.Description, claimInDb.Description);
}
public async Task <IActionResult> GetAllRoleClaims()
{
var orgId = User.FindFirst("Organization").Value;
var orgRoles = await _context.Roles.Where(x => x.OrganizationId.ToString() == orgId).ToListAsync();
var rolesWithClaims = new List <RoleWithClaimsDto>();
var allClaims = await _context.Claims.ToListAsync();
foreach (var role in orgRoles)
{
var roleWithClaim = new RoleWithClaimsDto {
Name = role.Name, Id = role.Id, OrganizationId = role.OrganizationId
};
roleWithClaim.Claims = await _roleManager.GetClaimsAsync(role);
var claimsDtos = new List <ClaimDto>();
foreach (var claim in allClaims)
{
var claimDto = new ClaimDto();
claimDto.ClaimType = claim.ClaimType;
claimDto.ClaimValue = claim.ClaimValue;
var found = false;
foreach (var roleClaim in roleWithClaim.Claims)
{
if (claim.ClaimValue == roleClaim.Value)
{
claimDto.HasClaim = true;
claimsDtos.Add(claimDto);
found = true;
}
}
if (!found)
{
claimDto.HasClaim = false;
claimsDtos.Add(claimDto);
}
}
roleWithClaim.ClaimsWithBool = claimsDtos;
rolesWithClaims.Add(roleWithClaim);
}
return(Ok(rolesWithClaims));
}
public async Task <ClaimDto> CreateAsync(ClaimDto claimDto)
{
var claim = mapper.Map <Claim>(claimDto);
claim.CreatedAt = DateTime.UtcNow;
using (var ms = new MemoryStream())
{
claimDto.BPImage.CopyTo(ms);
var fileBytes = ms.ToArray();
claim.BoardingPassImage = fileBytes;
}
context.Claims.Add(claim);
await context.SaveChangesAsync();
claimDto.Id = claim.Id;
return(claimDto);
}
public async Task UserClaims_OnPostWithModel_CallsUpdateUserClaimsServiceAndReturnsView()
{
var claim = new ClaimDto("type", "value");
var claims = new List <ClaimDto>
{
claim
};
var expectedModel = new ManageUserClaimsModel
{
Claims = claims
};
var result = await controller.UserClaims(expectedModel) as RedirectToActionResult;
result.ActionName.Should().Be("UserClaims");
}
public async Task <IActionResult> CreateClaim([FromBody] ClaimDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _userManager.FindByEmailAsync(model.UserName);
if (user == null)
{
return(NotFound());
}
var existingUserClaims = await _userManager.AddClaimAsync(user, new Claim(model.ClaimType, model.ClaimValue));
return(Ok());
}
public void Handle(ClaimRequestAutoSubstantiatedEvent args)
{
var claimsCollection = _mongoDataBase.GetCollection <ClaimDto>("Claims");
var claim = new ClaimDto
{
ClaimAmount = args.Amount,
ClaimType = args.ClaimType,
Id = args.ClaimRequestId,
ParticipantId = args.ParticipantId,
Provider = args.ProviderName,
ServiceDate = args.DateOfTransaction,
AmountPaid = 0.00m,
ClaimState = ClaimStateEnum.Substantiated,
Source = args.Source,
};
var safeModeResult = claimsCollection.Save(claim);
}
public IHttpActionResult Post(ClaimDto dto)
{
ExecuteInTransaction(session =>
{
string user = (User.Identity as ClaimsIdentity).Claims.Where <Claim>(c => c.Type == ClaimTypes.NameIdentifier).Single().Value;
ModelClaim claim = dto.Id.HasValue ?
session.Get <ModelClaim>(dto.Id.Value) :
new ModelClaim()
{
Customer = LoadEntity <Model.User>(session, Guid.Parse(user)),
Created = DateTime.Now
};
ModelMapper.Map <ClaimDto, ModelClaim>(dto, claim);
session.SaveOrUpdate(claim);
dto = ModelMapper.Map <ModelClaim, ClaimDto>(claim, dto);
});
return(Ok <ClaimDto>(dto));
}
