public IActionResult Save(Region_VM region_VM)
{
if (region_VM != null)
{
if (region_VM.RegionId > 0)
{
if (_regionRepository.Update(region_VM, this.loginUserId) > 0)
{
TempData["Status"] = Helper.success_code;
TempData["Message"] = Message.regionUpdated;
}
else
{
TempData["Message"] = Message.regionUpdateError;
}
}
else
{
if (_regionRepository.Add(region_VM, this.loginUserId) > 0)
{
TempData["Status"] = Helper.success_code;
TempData["Message"] = Message.regionAdded;
}
else
{
TempData["Message"] = Message.regionAddedError;
}
}
}
return(RedirectToAction("List", "Region"));
}
public override async Task <int> HandleCommand(AddCommand request, CancellationToken cancellationToken)
{
if (request.Region == null || string.IsNullOrEmpty(request.Region.Code))
{
throw new BusinessException("AddWrongInformation");
}
var region = (await regionQueries.Gets($"r.code = '{request.Region.Code}' and r.is_deleted = 0")).FirstOrDefault();
if (region != null)
{
throw new BusinessException("Region.ExistedCode");
}
var country = await countryQueries.Get(request.Region.CountryId);
if (country == null)
{
throw new BusinessException("Country.NotExisted");
}
request.Region = CreateBuild(request.Region, request.LoginSession);
var rs = await regionRepository.Add(request.Region);
return(rs == 0 ? -1 : 0);
}
public CreateRegionResponse CreateRegion(CreateRegionRequest request)
{
CreateRegionResponse response = new CreateRegionResponse();
Region region = new Region();
region.RegionDescription = request.RegionDescription;
region.Territories = request.Territories.ConvertToTerritories();
if (region.GetBrokenRules().Count() > 0)
{
response.Errors = region.GetBrokenRules().ToList();
}
else
{
try {
_regionRepository.Add(region);
_uow.Commit();
response.Errors = new List <BusinessRule>();
} catch (Exception ex)
{
List <BusinessRule> errors = new List <BusinessRule>();
do
{
errors.Add(new BusinessRule("DAL", "DAL_ERROR: " + ex.Message));
ex = ex.InnerException;
} while (ex != null);
response.Errors = errors;
}
}
return(response);
}
private async Task SetCurrentRegionId(string regionName)
{
var region = await _regionRepository.GetRegionByName(regionName);
if (region == null)
{
region = new Region
{
Name = regionName,
ParentRegionId = XlsImportVariableDataService.CurrentParentRegionId
};
_regionRepository.Add(region);
await _unitOfWork.CompleteAsync();
}
CurrenRegionId = region.Id;
}
public async Task <RegionModel> Handle(CreateRegionCommand request, CancellationToken cancellationToken)
{
Domain.AggregatesModel.RegionAggregate.Region region = new Domain.AggregatesModel.RegionAggregate.Region(request.RegionCode, request.RegionName, request.ParentId, request.TenTantId, request.Description);
_regionRepository.Add(region);
var result = await _regionRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken);
if (!result)
{
return(null);
}
return(_mapper.Map <RegionModel>(region));
}
public CreateResponse Create(RegionRequest request)
{
try
{
var region = TypeAdapter.Adapt <Region>(request);
_regionValidator.ValidateAndThrowException(region, "Base");
_regionRepository.Add(region);
return(new CreateResponse(region.Id));
}
catch (DataAccessException)
{
throw new ApplicationException();
}
}
public Region CreateRegion(CreateRegionParameters param)
{
if (regionRepository.Any(r => r.Name == param.Name && r.CountryCoreID == param.CountryID))
{
Console.WriteLine($"Region {param.Name} exists!");
return(regionRepository.Single(r => r.Name == param.Name && r.CountryCoreID == param.CountryID));
}
var region = new Region()
{
CanSpawn = param.CanSpawn,
CountryID = param.CountryID,
Name = param.Name,
CountryCoreID = param.CountryID
};
regionRepository.Add(region);
regionRepository.SaveChanges();
Console.WriteLine($"Region {param.Name} created!");
return(region);
}
/// <summary>
/// The Save
/// </summary>
/// <param name="entity">The entity<see cref="Region"/></param>
/// <returns>The <see cref="ServiceResult"/></returns>
public ServiceResult Save(Region entity)
{
try
{
if (entity.Identifier == 0)
{
_repository.Add(entity);
}
else
{
_repository.Update(entity);
}
return(new ServiceResult(true));
}
catch (Exception ex)
{
return(new ServiceResult(false)
{
Error = ex.ToString()
});
}
}
/// <summary>
/// Add /Update region
/// </summary>
public Region SaveRegion(Region region)
{
Region dbVersion = regionRepository.Find(region.RegionId);
//Code Duplication Check
if (regionRepository.DoesRegionCodeExist(region))
{
throw new CaresException(Resources.GeographicalHierarchy.Region.RegionCodeDuplicationError); // doit
}
if (dbVersion != null)
{
UpdateRegionPropertie(region, dbVersion);
regionRepository.Update(dbVersion);
}
else
{
dbVersion = new Region();
SetRegionProperties(region, dbVersion);
regionRepository.Add(dbVersion);
}
regionRepository.SaveChanges();
// To Load the proprties
return(regionRepository.LoadRegionWithDetail(dbVersion.RegionId));
}
public int Add(Region Region)
{
return(_regionRepository.Add(Region));
}
public RegionModel Add(RegionModel model)
{
return(_repository.Add(model));
}
public async Task <Region> Add(Region element)
{
var repoResult = await _repository.Add(_mapper.Map <RegionEntity>(element));
return(_mapper.Map <Region>(repoResult));
}
public void Post(Region region)
{
_region.Add(region);
}
public void AddRegion(RegionDTO region)
{
var regionEF = region.MappingRegion();
regionRepository.Add(regionEF);
}
