public StandardJsonResult ExecSql(ProvinceDto province)
{
return(StandardAction(() =>
{
_provinceService.ExecSql(province);
}));
}
public EditProvinceViewModel(ProvinceDto output)
{
Id = output.Id;
Name = output.Name;
CountryId = output.CountryId;
DisplayOrder = output.DisplayOrder;
}
//Update
public string update(ProvinceDto tProvinceDto)
{
try
{
Province tProvinceUpdate = _context.Province.Find(tProvinceDto.Id);
if (tProvinceUpdate == null)
{
return("1");
}
tProvinceUpdate.Id = tProvinceDto.Id;
tProvinceUpdate.Code = tProvinceDto.Code;
tProvinceUpdate.Name = tProvinceDto.Name;
tProvinceUpdate.Description = tProvinceDto.Description;
tProvinceUpdate.CountryId = tProvinceDto.CountryId;
tProvinceUpdate.Status = tProvinceDto.Status;
tProvinceUpdate.CreateDate = tProvinceDto.CreateDate;
tProvinceUpdate.CreateUser = tProvinceDto.CreateUser;
_context.Province.Update(tProvinceUpdate);
_context.SaveChanges();
return("0");
}
catch (Exception)
{
return("1");
}
}
public StandardJsonResult Delete(ProvinceDto province)
{
return(StandardAction(() =>
{
_provinceService.DeleteProvince(province);
}));
}
private void ParseRegion(String region, out ProvinceDto province, out CityDto city)
{
province = new ProvinceDto();
city = new CityDto();
var regions = region.Split(new char[] { '+', ',', '，' });
if (regions.Length < 1)
{
throw new Exception("地区[" + region + "]格式错误，必须为 省+市");
}
province.provinceName = regions[0];
var provinceId = RegionService.getProvinceIdByName(province.provinceName);
if (provinceId == null)
{
throw new Exception("系统暂时不识别的省份名称:" + province.provinceName);
}
province.provinceId = provinceId;
if (regions.Length > 1)
{
city.cityName = regions[1];
var cityId = RegionService.getCityIdByName(provinceId, regions[1]);
if (cityId == null)
{
throw new Exception("系统暂时不识别的城市（地区）名称:" + regions[1]);
}
city.cityId = cityId;
}
}
public IActionResult CreateProvince([FromBody] ProvinceDto provinceDto)
{
if (provinceDto == null)
{
return(BadRequest(ModelState));
}
if (_pRepo.ProvinceExists(provinceDto.Name))
{
ModelState.AddModelError("", "Province already Exist!");
return(StatusCode(404, ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var provinceObj = _mapper.Map <Province>(provinceDto);
if (!_pRepo.CreateProvince(provinceObj))
{
ModelState.AddModelError("", $"Something went wrong when saving the record {provinceObj.Name}");
return(StatusCode(500, ModelState));
}
return(CreatedAtRoute("GetProvince", new { id = provinceObj.Id }, provinceObj));
}
public async Task Update(ProvinceDto provinceDto)
{
var province = ObjectMapper.Map <Models.Province>(provinceDto);
await _repository.UpdateAsync(province);
return;
}
public ProvinceDto Insert(ProvinceInsertDto dto)
{
ProvinceDto provinceDto = null;
try
{
var province = Mapper.Map <ProvinceInsertDto, Country>(dto);
province.CreatedBy = _appSession.GetUserName();
province.IsEnabled = true;
_unitOfWork.CreateTransaction();
_unitOfWork.GenericRepository <Country>().Insert(province);
_unitOfWork.Save();
_unitOfWork.Commit();
provinceDto = Mapper.Map <Country, ProvinceDto>(province);
}
catch (Exception ex)
{
Tracing.SaveException(ex);
_unitOfWork.Rollback();
}
return(provinceDto);
}
private void GenerateAddressDataInDb()
{
if (_context.Provinces.Any())
{
return;
}
var fileName = "Province_District_Ward.json";
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"App_Data\", fileName);
using (StreamReader streamReader = File.OpenText(path))
{
var json = streamReader.ReadToEndAsync().Result;
var listProvinces = JsonConvert.DeserializeObject <IEnumerable <ProvinceViewModel> >(json);
foreach (var provinceViewModel in listProvinces)
{
var provinceDto = new ProvinceDto()
{
Id = provinceViewModel.Id,
Name = provinceViewModel.Name
};
var province = Mapper.Map <ProvinceDto, Province>(provinceDto);
_context.Provinces.Add(province);
_context.SaveChanges();
var listDistricts = provinceViewModel.Huyen;
foreach (var districtViewModel in listDistricts)
{
var districtDto = new DistrictDto()
{
Id = districtViewModel.Id,
Name = districtViewModel.Name,
ProvinceId = districtViewModel.Tinh_id
};
var district = Mapper.Map <DistrictDto, District>(districtDto);
_context.Districts.Add(district);
_context.SaveChanges();
var listWards = districtViewModel.Xa;
foreach (var wardViewModel in listWards)
{
var wardDto = new WardDto()
{
Id = wardViewModel.Id,
Name = wardViewModel.Name,
DistrictId = wardViewModel.Huyen_id
};
var ward = Mapper.Map <WardDto, Ward>(wardDto);
_context.Wards.Add(ward);
_context.SaveChanges();
}
}
}
}
}
public StandardJsonResult <long> Add(ProvinceDto province)
{
return(StandardAction <long>(() =>
{
return _provinceService.Add(province);
}));
}
public StandardJsonResult Update(ProvinceDto province)
{
return(StandardAction(() =>
{
_provinceService.Modify(province);
}));
}
public ProvinceDto MapToProvinceDto(SqlDataReader sqlDataReader)
{
ProvinceDto provinceDto = new ProvinceDto();
provinceDto.Id = sqlDataReader["Id"].ToInteger();
return(provinceDto);
}
public async Task <ProvinceDto> Insert(ProvinceDto request)
{
var entity = AutoMapper.Mapper.Map <Province>(request);
var result = await entityRepository.InsertAsync(entity);
return(AutoMapper.Mapper.Map <ProvinceDto>(result));
}
public async Task Create(ProvinceDto dto)
{
var province = new Domain.Entities.Province
{
Description = dto.Description,
ErasedState = false
};
await _provinceRepository.Create(province);
}
public static ProvinceViewModel DtoToViewModel(ProvinceDto dto)
{
return(new ProvinceViewModel
{
Id = dto.Id,
Name = dto.Name,
UpdatedBy = dto.UpdatedBy,
UpdatedDate = dto.UpdatedDate,
});
}
public async Task <ProvinceDto> Update(ProvinceDto request)
{
var entity = AutoMapper.Mapper.Map <Province>(request);
request.IsDeleted = true;
var result = await entityRepository.UpdateAsync(entity);
return(AutoMapper.Mapper.Map <ProvinceDto>(result));
}
public ProvinceDto AddProvince(ProvinceDto provinceDto)
{
var entity = provinceFactory.CreateEntity(provinceDto);
entity.IsActive = true;
unitOfWork.ProvinceRepository.Add(entity);
unitOfWork.SaveChanges();
var addedDto = provinceFactory.CreateDto(entity);
return(addedDto);
}
public static ProvinceViewModel MapFromDto(this ProvinceDto provinceDto)
{
ProvinceViewModel provinceViewModel = new ProvinceViewModel();
provinceViewModel.Id = provinceDto.Id;
provinceViewModel.Name = provinceDto.Name;
provinceDto.Cities.ToList().ForEach(item => provinceViewModel.Cities.Add(item.MapFromDto()));
return(provinceViewModel);
}
public void Province_Extension_AsEntity_Null()
{
// Arrange
ProvinceDto province = null;
// Act
var result = province.AsEntity();
// Assert
Assert.IsNull(result);
Assert.AreEqual(null, result);
}
public void Province_Property_Name()
{
// Arrange
var province = new ProvinceDto();
var value = "Test Province";
// Act
province.Name = value;
// Assert
Assert.IsNotNull(province.Name);
Assert.IsInstanceOfType(province.Name, typeof(string));
Assert.AreEqual(value, province.Name);
}
public void Province_Property_ISOCode()
{
// Arrange
var province = new ProvinceDto();
var value = "XXX";
// Act
province.ISOCode = value;
// Assert
Assert.IsNotNull(province.ISOCode);
Assert.IsInstanceOfType(province.ISOCode, typeof(string));
Assert.AreEqual(value, province.ISOCode);
}
public void Province_Property_Abbreviation()
{
// Arrange
var province = new ProvinceDto();
var value = "TP";
// Act
province.Abbreviation = value;
// Assert
Assert.IsNotNull(province.Abbreviation);
Assert.IsInstanceOfType(province.Abbreviation, typeof(string));
Assert.AreEqual(value, province.Abbreviation);
}
public GenericServiceResponse <bool> DeleteProvince(ProvinceDto province)
{
return(TryExecute <GenericServiceResponse <bool> >((response) =>
{
response.Result = Repository.Delete(province.AsEntity());
if (!response.Result)
{
var errorMessage = "'DeleteProvince' was unable to delete the given province record.";
response.Notifications.AddError(errorMessage);
Logger.Error(errorMessage);
}
}));
}
public ProvinceDto MapToProvinceDto(Province province)
{
if (province == null)
{
return(null);
}
ProvinceDto provinceDto = new ProvinceDto();
provinceDto.ProvinceId = province.ProvinceId;
provinceDto.ProvinceName = province.ProvinceName;
return(provinceDto);
}
public static Province AsEntity(this ProvinceDto provinceDto)
{
if (provinceDto == null)
{
return(null);
}
return(new Province
{
ID = provinceDto.Id,
ISOCode = provinceDto.ISOCode,
Abbreviation = provinceDto.Abbreviation,
Name = provinceDto.Name
});
}
public static ProvinceDto Map(this Province value)
{
if (value == null)
{
return(null);
}
var dto = new ProvinceDto
{
Id = value.Id,
Name = value.Name
};
return(dto);
}
public virtual async Task <ProvinceDto> CreateAsync(ProvinceDto dto)
{
var provinceE = await Repository.FindAsync(dto.Id);
if (provinceE != null)
{
throw new BusinessException("Province already exists");
}
provinceE = await Repository.InsertAsync(new ProvinceEntity(dto.Id), autoSave : true);
var provinceDto = new ProvinceDto();
ObjectMapper.Map(provinceE, provinceDto);
return(provinceDto);
}
public string create(ProvinceDto tProvinceDto)
{
try
{
Province tProvinceNew = mapper.Map <ProvinceDto, Province>(tProvinceDto);
tProvinceNew.Id = Guid.NewGuid().ToString();
tProvinceNew.CreateDate = DateTime.Now;
_context.Province.Add(tProvinceNew);
_context.SaveChanges();
return("0");
}
catch (Exception)
{
return("1");
}
}
public void DeleteProvince_Service_Fail()
{
// Arrange
provinceService = new ProvinceService(mockRepository.Object, mockLogger.Object, mockCache.Object, mockTelemetry.Object);
mockRepository.Setup(x => x.Delete(It.IsAny <Province>())).Returns(false).Verifiable();
// Act
var province = new ProvinceDto();
var response = provinceService.DeleteProvince(province);
// Assert
Assert.IsNotNull(response);
Assert.IsFalse(response.Result);
Assert.IsTrue(response.Notifications.HasErrors());
Assert.IsInstanceOfType(response, typeof(GenericServiceResponse <bool>));
mockRepository.Verify(x => x.Delete(It.IsAny <Province>()), Times.Once);
}
public IActionResult UpdateProvince(int id, [FromBody] ProvinceDto provinceDto)
{
if (provinceDto == null || id != provinceDto.Id)
{
return(BadRequest(ModelState));
}
if (_pRepo.ProvinceExists(provinceDto.Name))
{
ModelState.AddModelError("", "Province already Exist!");
return(StatusCode(404, ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok());
}
