public IActionResult RestoreDelAddressTypes(int Id, bool del)
{
var addressT = _addTypeRepo.GetAddressType(Id);
if (addressT == null)
{
return(new NotFoundResult());
}
else
{
_addTypeRepo.AssignAddressTypeDeletedRestored(Id, del);
var addressT2 = _addTypeRepo.getDeletedAddressTypes(false);
if (addressT2 == null)
{
return(new NotFoundResult());
}
else
{
var addressRecords = _addTypeRepo.getDeletedAddressTypes(false);
var addresstypesVm = AddressTypeViewModel.MultipleAccTypesMap(addressRecords);
return(new OkObjectResult(addresstypesVm));
}
}
}
public ActionResult AddressTypePartial(AddressTypeViewModel model)
{
if (ModelState.IsValid && !String.IsNullOrWhiteSpace(model.CustomerID))
{
switch (model.SelectedAddressType)
{
case "Email":
var emailAddressModel = new EmailAddressViewModel()
{
CustomerID = model.CustomerID
};
return(PartialView("CreateEmailAddressPartial", emailAddressModel));
case "Postal":
var postalAddressModel = new PostalAddressEditViewModel()
{
CustomerID = model.CustomerID
};
var countriesRepo = new CountriesRepository();
postalAddressModel.Countries = countriesRepo.GetCountries();
var regionsRepo = new RegionsRepository();
postalAddressModel.Regions = regionsRepo.GetRegions();
return(PartialView("CreatePostalAddressPartial", postalAddressModel));
default:
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
}
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
public IActionResult GetAddressTypes(string filter = null)
{
var pagination = Request.Headers["Pagination"];
List <AddressType> addresstypes = null;
if (!string.IsNullOrEmpty(pagination))
{
string[] vals = pagination.ToString().Split(',');
int.TryParse(vals[0], out page);
int.TryParse(vals[1], out pageSize);
}
int currentPage = page;
int currentPageSize = pageSize;
var totalUsers = _addTypeRepo.CountAddressTypes();
var totalPages = (int)Math.Ceiling((double)totalUsers / pageSize);
if (!string.IsNullOrEmpty(filter))
{
filter = filter.Trim().ToLower();
addresstypes = _addTypeRepo.GetAddressTypesOrdered(currentPage, currentPageSize, filter);
}
else
{
addresstypes = _addTypeRepo.GetAddressTypesOrdered(currentPage, currentPageSize, filter);
//addresstypes = _addTypeRepo.GetAddressTypes();
}
var recordVm = AddressTypeViewModel.MultipleAccTypesMap(addresstypes);
Response.AddPagination(page, pageSize, totalUsers, totalPages);
return(new OkObjectResult(recordVm));
}
/// <summary>
/// To the view model.
/// </summary>
/// <param name="model">The model.</param>
/// <returns></returns>
public static AddressTypeViewModel ToViewModel(this AddressTypeModel model)
{
if (model == null)
{
return(null);
}
var entity = new AddressTypeViewModel
{
AddressTypeID = model.AddressTypeID,
AddressType = model.AddressType
};
return(entity);
}
/// <summary>
/// To the model.
/// </summary>
/// <param name="entity">The entity.</param>
/// <returns></returns>
public static AddressTypeModel ToModel(this AddressTypeViewModel entity)
{
if (entity == null)
{
return(null);
}
var model = new AddressTypeModel
{
AddressTypeID = entity.AddressTypeID,
AddressType = entity.AddressType
};
return(model);
}
public async Task <Result> UpdateAddressTypeAsync(AddressTypeViewModel model)
{
var data = _iMapper.Map <AddressTypeViewModel, AddressType>(model);
var saveChange = await _iAddressTypeRepository.UpdateAddressTypeAsync(data);
if (saveChange > 0)
{
return(Result.Ok(MessageHelper.Update));
}
else
{
return(Result.Fail(MessageHelper.UpdateFail));
}
}
public ActionResult AddressTypePartial(string id)
{
if (!String.IsNullOrWhiteSpace(id))
{
bool isGuid = Guid.TryParse(id, out Guid customerId);
if (isGuid && customerId != Guid.Empty)
{
var repo = new MetadataRepository();
var model = new AddressTypeViewModel()
{
CustomerID = id,
AddressTypes = repo.GetAddressTypes()
};
return(PartialView("AddressTypePartial", model));
}
}
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
public IActionResult AddAddressType(AddressTypeViewModel addresstypeVm)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_addTypeRepo.AddAddressType(addresstypeVm.ReverseMap());
var addressType = _addTypeRepo.GetAddressType(addresstypeVm.ID);
AddressTypeViewModel addTypeVM = new AddressTypeViewModel();
addTypeVM.MapSingleAddressType(addressType);
CreatedAtRouteResult response = CreatedAtRoute("GetAddressType", new { controller = "AddressTypes", id = addTypeVM.ID }, addTypeVM);
return(response);
}
public IActionResult GetAddressType(int Id)
{
var addressT = _addTypeRepo.GetAddressType(Id);
if (addressT == null)
{
//return NotFound();
return(new NotFoundResult());
}
else
{
var account = _addTypeRepo.GetAddressType(Id);
AddressTypeViewModel recordVm = new AddressTypeViewModel();
recordVm.MapSingleAddressType(account);
return(new OkObjectResult(recordVm));
}
}
public async Task <IActionResult> Save(AddressTypeViewModel viewModel)
{
try
{
if (ModelState.IsValid)
{
//add
if (viewModel.TypeId == 0)
{
_result = await _iAddressTypeManager.InsertAddressTypeAsync(viewModel);
}
else if (viewModel.TypeId > 0) //edit
{
_result = await _iAddressTypeManager.UpdateAddressTypeAsync(viewModel);
}
if (_result.Success)
{
this.FlashSuccess(MessageHelper.Save, "AddressTypeMessage");
return(RedirectToAction("Index", "AddressType"));
}
else
{
this.FlashError(_result.Error, "AddressTypeMessage");
return(View(viewModel));
}
}
else
{
this.FlashError(ExceptionHelper.ModelStateErrorFirstFormat(ModelState), "AddressTypeMessage");
return(View(viewModel));
}
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "Save[POST]"));
}
this.FlashError(MessageHelper.UnhandelledError, "AddressTypeMessage");
return(View(viewModel));
}
public IActionResult GetDeletedAddressTypes(bool deleted)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var addressT = _addTypeRepo.getDeletedAddressTypes(deleted);
if (addressT == null)
{
return(NotFound());
}
else
{
var addressRecords = _addTypeRepo.getDeletedAddressTypes(deleted);
var addresstypesVm = AddressTypeViewModel.MultipleAccTypesMap(addressRecords);
return(new OkObjectResult(addresstypesVm));
}
}
public async Task <Result> InsertAddressTypeAsync(AddressTypeViewModel model)
{
try
{
var data = _iMapper.Map <AddressTypeViewModel, AddressType>(model);
var saveChange = await _iAddressTypeRepository.InsertAddressTypeAsync(data);
if (saveChange > 0)
{
return(Result.Ok(MessageHelper.Save));
}
else
{
return(Result.Fail(MessageHelper.SaveFail));
}
}
catch (Exception)
{
throw;
}
}
public IActionResult Add()
{
try
{
var model = new AddressTypeViewModel();
if (model != null)
{
return(View("AddOrEdit", model));
}
else
{
this.FlashError(ExceptionHelper.ExceptionErrorMessageForNullObject(), "AddressTypeMessage");
return(RedirectToAction("Index", "AddressType"));
}
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "Add[GET]"));
}
this.FlashError(MessageHelper.UnhandelledError, "AddressTypeMessage");
return(RedirectToAction("Index", "AddressType"));
}
public IActionResult UpdateAddressType(AddressTypeViewModel addressType)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var addressT = _addTypeRepo.GetAddressType(addressType.ID);
if (addressT == null)
{
return(NotFound());
}
else
{
var newAddressType = addressType.ReverseMap();
_addTypeRepo.UpdateAddressType(newAddressType);
var AddressTVm = new AddressTypeViewModel(newAddressType);
return(new OkObjectResult(AddressTVm));
}
}
public async Task <int> InsertOrUpdatetAddressTypeAsync(AddressTypeViewModel model)
{
var data = _iMapper.Map <AddressTypeViewModel, AddressType>(model);
return(await _iAddressTypeRepository.InsertOrUpdatetAddressTypeAsync(data));
}
