public AddressTypeDto CreateAddressType(AddressTypeDto addressTypeDto)
{
if (addressTypeDto == null)
{
throw new ArgumentNullException(nameof(addressTypeDto), "AddressTypeDto is not provided!");
}
try
{
var addressType = Mappers.AddressTypeRepository.MapToDbEntity(addressTypeDto);
addressType.CreatedDate = DateTime.Now;
_dbContext.Add(addressType);
if (_dbContext.SaveChanges() != 0)
{
return(Mappers.AddressTypeRepository.MapToDto(addressType));
}
}
catch (Exception ex)
{
Console.WriteLine(ex.InnerException);
throw;
}
return(null);
}
public bool EditAddressType(int addressTypeId, AddressTypeDto addressType)
{
if (addressType == null)
{
throw new ArgumentNullException(nameof(addressType), "AddressType argument is not provided!");
}
try
{
var AddressTypeTmp = _dbContext.AddressType.FirstOrDefault(x => x.AddressTypeId == addressTypeId);
if (AddressTypeTmp != null)
{
AddressTypeTmp.AddressTypeName = addressType.AddressTypeName ?? AddressTypeTmp.AddressTypeName;
AddressTypeTmp.ModifiedDate = DateTime.Now;
_dbContext.SaveChanges();
return(true);
}
return(false);
}
catch (Exception ex)
{
Console.WriteLine(ex.InnerException);
throw;
}
}
public async Task <BaseEntity> SaveAndReturnEntityAsync(AddressTypeDto entityDto)
{
var entity = _mapper.Map <AddressType>(entityDto);
var result = await _repository.SaveAndReturnEntityAsync(entity);
return(result);
}
public void GetAddressTypeTest()
{
int id = 1;
string TypeName = "Test";
bool isDeleted = false;
int CreatedByUserId = 1;
var addressType_1 = new AddressTypeDto
{
AddressTypeName = TypeName,
AddressTypeId = id,
IsDeleted = isDeleted,
CustomerId = CreatedByUserId,
CreatedDate = DateTime.Now,
ModifiedDate = DateTime.Now
};
var addresses = new List <AddressTypeDto>
{
addressType_1
};
var mockRepo = new Mock <IAddressTypeRepository>();
mockRepo.Setup(x => x.GetAddressTypes()).Returns(addresses);
var addressTypeManipulation = new AddressTypeManipulation(mockRepo.Object);
var controller = new AddressTypeController(addressTypeManipulation);
var result = controller.GetAddressTypes();
var okObjectResult = result as OkObjectResult;
Assert.NotNull(okObjectResult);
Assert.IsType <OkObjectResult>(result);
}
public IActionResult Post([FromBody] AddressTypeDto addressTypeDto)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var addressType = Mapper.Map <AddressType>(addressTypeDto);
if (_addressTypeRepository.AddressTypeExists(addressType))
{
return(StatusCode(500, "AddressType already exists."));
}
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
var profile = _accountRepository.GetUserProfile(userId);
var createdAddressType = _addressTypeRepository.CreateAddressType(addressType, profile.UserProfileId);
if (createdAddressType == null)
{
return(StatusCode(500, "A problem happened while handling your request."));
}
var createdAddressTypeToReturn = Mapper.Map <AddressTypeDto>(createdAddressType);
return(Created(createdAddressTypeToReturn));
}
catch (Exception ex)
{
_logger.LogError($"Failed in Post /AddressTypes: {ex}");
return(StatusCode(500, "A problem happened while handling your request."));
}
}
public IActionResult PutAddressType(int id, [FromBody] AddressTypeEditModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
AddressTypeDto addressTypeDto = new AddressTypeDto()
{
AddressTypeName = model.AddressTypeName,
CreatedDate = model.CreatedDate,
ModifiedDate = DateTime.Now
};
try
{
if (_addressTypeManipulation.EditAddressType(id, addressTypeDto))
{
return(Ok());
}
return(NoContent());
}
catch (Exception ex)
{
return(BadRequest(ex.InnerException));
}
}
public void GetAddressTypeByIdTest()
{
int id = 1;
string TypeName = "Test";
bool isDeleted = false;
int CreatedByUserId = 1;
var addressType_1 = new AddressTypeDto
{
AddressTypeName = TypeName,
AddressTypeId = id,
IsDeleted = isDeleted,
CustomerId = CreatedByUserId,
CreatedDate = DateTime.Now,
ModifiedDate = DateTime.Now
};
var mockRepo = new Mock <IAddressTypeRepository>();
mockRepo.Setup(x => x.GetAddressTypeById(It.Is <int>(q => q == 1))).Returns(addressType_1);
var addressTypeManipulation = new AddressTypeManipulation(mockRepo.Object);
var controller = new AddressTypeController(addressTypeManipulation);
var result = controller.GetAddressType(1);
var okObjectResult = result as OkObjectResult;
Assert.NotNull(okObjectResult);
var model = okObjectResult.Value as AddressTypeDto;
Assert.NotNull(model);
output.WriteLine(model.AddressTypeName);
Assert.IsType <OkObjectResult>(result);
}
public IActionResult PostAddressType([FromBody] AddressTypeCreateModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
AddressTypeDto addressTypeDto = new AddressTypeDto()
{
AddressTypeName = model.AddressTypeName,
CreatedDate = DateTime.Now,
ModifiedDate = DateTime.Now
};
try
{
var addressType = _addressTypeManipulation.CreateAddressType(addressTypeDto);
if (addressType != null)
{
return(Ok(addressType));
}
}
catch (Exception ex)
{
return(BadRequest(ex.InnerException));
//return BadRequest(ex.Message);
}
return(NoContent());
}
public async Task <AddressTypeDto> PutAddressType(int id, AddressTypeDto model)
{
var url = CRMApiUri + "/AddressType/" + id;
var result = await PutRequestToApi(url, model);
return(result);
}
public async Task <AddressTypeDto> PostAddressType(AddressTypeDto model)
{
var url = CRMApiUri + "/AddressType";
var result = await PostRequestToApi(url, model);
return(result);
}
public async Task <IActionResult> Put(int id, [FromBody] AddressTypeDto addressType)
{
if (id == 0 || addressType.Id == 0)
{
return(StatusCode(StatusCodes.Status400BadRequest, "Id needs to be greater than 0."));
}
return(await SaveAndReturnEntityAsync(async() => await _addressTypeService.SaveAndReturnEntityAsync(addressType)));
}
public async Task <IActionResult> Post([FromBody] AddressTypeDto addressType)
{
if (addressType.Id != 0)
{
return(StatusCode(StatusCodes.Status400BadRequest, "Identity insert is not permitted."));
}
return(await SaveAndReturnEntityAsync(async() => await _addressTypeService.SaveAndReturnEntityAsync(addressType)));
}
public ICollection <AddressTypeDto> SearchAddressTypes(AddressTypeDto searchCriteria)
{
if (searchCriteria == null)
{
throw new ArgumentNullException(nameof(searchCriteria), "SearchCriteria argument is not provided!");
}
return(null);
}
public static AddressType MapToDbEntity(AddressTypeDto addressTypeDto)
{
if (addressTypeDto == null)
{
throw new ArgumentNullException(nameof(addressTypeDto), "AddressTypeDto argument is not provided!");
}
return(new AddressType()
{
AddressTypeId = addressTypeDto.AddressTypeId,
AddressTypeName = addressTypeDto.AddressTypeName,
IsDeleted = addressTypeDto.IsDeleted,
CustomerId = addressTypeDto.CustomerId
});
}
public IActionResult Save(AddressTypeDto model)
{
UpdateAuditInformation(model);
if (!ModelState.IsValid)
{
GetStateSettings(ViewState.Write);
return(PartialView("Edit", model));
}
model = model.Id > 0
? _lookupFacadeApiClient.PutAddressType(model.Id, model).Result
: _lookupFacadeApiClient.PostAddressType(model).Result;
if (!string.IsNullOrWhiteSpace(model.ErrorMessage))
{
return(PartialView("Edit", model));
}
return(Json(new { message = model.SuccessMessage }));
}
public void CreateNewAddressTypeSuccessTest()
{
int id = 1;
string TypeName = "Test";
bool isDeleted = false;
int CreatedByUserId = 1;
NSI.REST.Models.AddressTypeCreateModel addressType_1 = new AddressTypeCreateModel()
{
AddressTypeName = TypeName,
AddressTypeId = id,
IsDeleted = isDeleted,
CustomerId = CreatedByUserId,
CreatedDate = DateTime.Now,
ModifiedDate = DateTime.Now
};
var addressType_2 = new AddressTypeDto
{
AddressTypeName = TypeName,
AddressTypeId = id,
IsDeleted = isDeleted,
CustomerId = CreatedByUserId,
CreatedDate = DateTime.Now,
ModifiedDate = DateTime.Now
};
var mockRepo = new Mock <IAddressTypeRepository>();
mockRepo.Setup(x => x.CreateAddressType(It.IsAny <AddressTypeDto>())).Returns(addressType_2);
var addressTypeManipulation = new AddressTypeManipulation(mockRepo.Object);
var controller = new AddressTypeController(addressTypeManipulation);
var result = controller.PostAddressType(addressType_1);
Assert.IsType <OkObjectResult>(result);
}
public bool EditAddressType(int AddressTypeId, AddressTypeDto AddressType)
{
if (AddressType == null)
{
throw new ArgumentNullException(nameof(AddressType), "AddressType argument is not provided!");
}
try
{
var AddressTypeTmp = _dbContext.AddressType.FirstOrDefault(x => x.AddressTypeId == AddressTypeId);
if (AddressTypeTmp != null)
{
AddressTypeTmp.AddressTypeName = AddressType.AddressTypeName ?? AddressTypeTmp.AddressTypeName;
_dbContext.SaveChanges();
return(true);
}
return(false);
}
catch (Exception ex)
{
//log ex
throw;
}
}
public AddressTypeDto CreateAddressType(AddressTypeDto addressTypeDto)
{
if (addressTypeDto == null)
{
throw new ArgumentNullException(nameof(addressTypeDto), "AddressTypeDto is not provided!");
}
try
{
var addressType = Mappers.AddressTypeRepository.MapToDbEntity(addressTypeDto);
_dbContext.Add(addressType);
if (_dbContext.SaveChanges() != 0)
{
return(Mappers.AddressTypeRepository.MapToDto(addressType));
}
}
catch (Exception ex)
{
//log ex
throw;
}
return(null);
}
public bool EditAddressType(int addressTypeId, AddressTypeDto addressType)
{
return(_addressTypeRepository.EditAddressType(addressTypeId, addressType));
}
public async Task <int> SaveAsync(AddressTypeDto entityDto)
{
var result = await SaveAndReturnEntityAsync(entityDto);
return(result.Id);
}
public AddressTypeDto CreateAddressType(AddressTypeDto addressTypeDto)
{
return(_addressTypeRepository.CreateAddressType(addressTypeDto));
}
public async Task <AddressTypeDto> PutAddressType(int id, AddressTypeDto model)
{
return(await _addressTypeApiClient.PutAddressType(id, model));
}
public async Task <AddressTypeDto> PostAddressType(AddressTypeDto model)
{
return(await _addressTypeApiClient.PostAddressType(model));
}
