// GET: ServiceTypes
public async Task <IActionResult> Index(SortState sortState = SortState.StNameAsc, int page = 1)
{
ServiceTypesFilterViewModel filter = HttpContext.Session.Get <ServiceTypesFilterViewModel>(filterKey);
if (filter == null)
{
filter = new ServiceTypesFilterViewModel
{
Name = string.Empty
};
HttpContext.Session.Set(filterKey, filter);
}
string key = $"{typeof(ServiceType).Name}-{page}-{sortState}-{filter.Name}";
if (!_cache.TryGetValue(key, out ServiceTypeViewModel model))
{
model = new ServiceTypeViewModel();
IQueryable <ServiceType> serviceTypes = GetSortedServiceTypes(sortState, filter.Name);
int count = serviceTypes.Count();
model.PageViewModel = new PageViewModel(page, count, pageSize);
model.ServiceTypes = count == 0
? new List <ServiceType>()
: serviceTypes.Skip((model.PageViewModel.PageIndex - 1) * pageSize).Take(pageSize).ToList();
model.SortViewModel = new SortViewModel(sortState);
model.ServiceTypesFilterViewModel = filter;
_cache.Set(key, model);
}
return(View(model));
}
public IEnumerable <ServiceTypeViewModel> SearchServiceTypes([FromBody] String searchKeyWord)
{
int searchKeyWordInt;
if (!int.TryParse(searchKeyWord, out searchKeyWordInt))
{
searchKeyWordInt = -999;
}
IList <ServiceTypeViewModel> aList = new List <ServiceTypeViewModel>();
var aServiceTypesList = aOmsdCustomConext.ServiceType
.Where(x => x.Name.Contains(searchKeyWord) ||
(x.ServiceTypeId == searchKeyWordInt)
).ToList();
if (aServiceTypesList != null && aServiceTypesList.Count > 0)
{
foreach (var aServiceType in aServiceTypesList)
{
ServiceTypeViewModel aServiceTypeViewModel = new ServiceTypeViewModel();
aServiceTypeViewModel.ServiceTypeId = aServiceType.ServiceTypeId;
aServiceTypeViewModel.Editstate = aServiceType.Editstate;
aServiceTypeViewModel.Sublistingid = aServiceType.Sublistingid;
aServiceTypeViewModel.Datecreated = aServiceType.Datecreated;
aServiceTypeViewModel.Name = aServiceType.Name;
aServiceTypeViewModel.Image = aServiceType.Image;
aServiceTypeViewModel.SortOrder = aServiceType.SortOrder;
aList.Add(aServiceTypeViewModel);
}
}
return(aList);
}
public ServiceTypeViewModel GetServiceType(Int32 id)
{
using (aOmsdCustomConext)
{
try
{
var aServiceType = aOmsdCustomConext.ServiceType.SingleOrDefault(y => y.ServiceTypeId == id);
ServiceTypeViewModel aServiceTypeViewModel = new ServiceTypeViewModel();
aServiceTypeViewModel.ServiceTypeId = aServiceType.ServiceTypeId;
aServiceTypeViewModel.Editstate = aServiceType.Editstate;
aServiceTypeViewModel.Sublistingid = aServiceType.Sublistingid;
aServiceTypeViewModel.Datecreated = aServiceType.Datecreated;
aServiceTypeViewModel.Name = aServiceType.Name;
aServiceTypeViewModel.Image = aServiceType.Image;
aServiceTypeViewModel.SortOrder = aServiceType.SortOrder;
return(aServiceTypeViewModel);
}
catch (Exception e)
{
throw e;
}
}
}
public ServiceTypeViewModel UpdateServiceType([FromBody] ServiceTypeViewModel aServiceTypeViewModel)
{
using (aOmsdCustomConext)
{
try
{
bool serviceTypeExist = aOmsdCustomConext.ServiceType.Any(c => (c.ServiceTypeId == aServiceTypeViewModel.ServiceTypeId));
if (!serviceTypeExist)
{
aServiceTypeViewModel.ServiceTypeId = -1;
return(aServiceTypeViewModel);
}
var aServiceType = aOmsdCustomConext.ServiceType.Find(aServiceTypeViewModel.ServiceTypeId);
aServiceType.Name = aServiceTypeViewModel.Name;
aServiceType.Image = aServiceTypeViewModel.Image;
aOmsdCustomConext.SaveChanges();
return(aServiceTypeViewModel);
}
catch (Exception e)
{
throw e;
}
}
}
public ActionResult Index()
{
HttpResponseMessage response = GlobalVariables.WebApiClient.GetAsync("APIServiceType").Result;
var serviceTypes = response.Content.ReadAsAsync <IEnumerable <ServiceType> >().Result;
HttpResponseMessage response1 = GlobalVariables.WebApiClient.GetAsync("APICustomer").Result;
var users = response1.Content.ReadAsAsync <IEnumerable <ApplicationUser> >().Result;
int count = 0;
foreach (var item in users)
{
count++;
}
count -= 1;
var viewModel = new ServiceTypeViewModel
{
ServiceTypes = serviceTypes,
CheckInteger = count
};
return(View(viewModel));
}
public async Task <JsonResult> UpdateServiceType([Required] ServiceTypeViewModel model)
{
if (!ModelState.IsValid)
{
return(JsonModelStateErrors());
}
return(await JsonAsync(_crmVocabulariesService.UpdateServiceTypeAsync(model)));
}
// GET: ServiceType
//public ActionResult Index()
//{
// return View();
//}
#region ServiceType SelectList
public ActionResult ServiceTypeSelectList(string required)
{
ViewBag.IsRequired = required;
ServiceTypeViewModel serviceTypeVM = new ServiceTypeViewModel();
serviceTypeVM.ServiceTypeSelectList = _serviceTypeBusiness.GetServiceTypeSelectList();
return(PartialView("_ServiceTypeSelectList", serviceTypeVM));
}
public ActionResult AddNewService(ServiceTypeViewModel serviceTypeViewModel)
{
if (!ModelState.IsValid)
{
return(View("Index", serviceTypeViewModel));
}
HttpResponseMessage response = GlobalVariables.WebApiClient.PostAsJsonAsync("ServiceTypes", serviceTypeViewModel.ServiceType).Result;
return(RedirectToAction("Index", "ServiceType"));
}
// GET: Customer
public ActionResult Index()
{
HttpResponseMessage response = GlobalVariables.WebApiClient.GetAsync("ServiceTypes").Result;
var servList = response.Content.ReadAsAsync <IEnumerable <ServiceType> >().Result;
var viewModel = new ServiceTypeViewModel
{
ServiceTypes = servList
};
return(View(viewModel));
}
/// <summary>
/// Add service type
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public virtual async Task <ResultModel <Guid> > AddServiceTypeAsync(ServiceTypeViewModel model)
{
if (model == null)
{
return(new InvalidParametersResultModel <Guid>());
}
var serviceType = _mapper.Map <ServiceType>(model);
await _context.ServiceTypes.AddAsync(serviceType);
var result = await _context.PushAsync();
return(result.Map(serviceType.Id));
}
public ServiceTypeViewModel AddServiceType([FromBody] ServiceTypeViewModel aServiceTypeViewModel)
{
ServiceType aServiceType = new ServiceType();
aServiceType.Name = aServiceTypeViewModel.Name;
aServiceType.Image = aServiceTypeViewModel.Image;
aServiceType.Editstate = -4;
aServiceType.Sublistingid = 0;
aServiceType.Datecreated = DateTime.Now;
aServiceType.SortOrder = 100;
aOmsdCustomConext.ServiceType.Add(aServiceType);
aOmsdCustomConext.SaveChanges();
return(aServiceTypeViewModel);
}
public async Task <UserProfileEditViewModel> BuildProfileEditViewModel(ApplicationUser user)
{
UserProfileEditViewModel userProfileEditViewModel = new UserProfileEditViewModel();
userProfileEditViewModel.UserId = user.Id;
userProfileEditViewModel.Description = user.Description;
userProfileEditViewModel.Carer = user.Carer;
if (user.Carer)
{
List <ServiceRateViewModel> serviceRateViewModelList = new List <ServiceRateViewModel>();
List <ServiceType> serviceTypes = (List <ServiceType>) await CommandFactory.CreateCommand(CommandFactory.GET_SERVICE_TYPES, _dbContext).Execute();
foreach (ServiceType service in serviceTypes)
{
ServiceTypeViewModel serviceTypeViewModel = new ServiceTypeViewModel();
ServiceRateViewModel serviceRateViewModel = new ServiceRateViewModel();
ServiceRate serviceRate = user.ServiceRates.FirstOrDefault(rate => rate.ServiceType.Id == service.Id);
//if (!user.ServiceRates.Any(rate => rate.ServiceType == service))
if (serviceRate == null)
{
serviceTypeViewModel.Id = service.Id;
serviceTypeViewModel.Name = service.Name;
serviceRateViewModel.ServiceType = serviceTypeViewModel;
serviceRateViewModel.Rate = 0;
}
else
{
serviceTypeViewModel.Id = service.Id;
serviceTypeViewModel.Name = service.Name;
serviceRateViewModel.ServiceType = serviceTypeViewModel;
serviceRateViewModel.Rate = serviceRate.Rate;
}
serviceRateViewModelList.Add(serviceRateViewModel);
}
userProfileEditViewModel.ServiceRates = serviceRateViewModelList;
}
return(userProfileEditViewModel);
}
public ActionResult AddServiceType(ServiceTypeViewModel model)
{
string userId = User.Identity.GetUserId();
//Send new data to logic layer
LogicService cmLogic = new LogicService();
bool addedSucessfully = cmLogic.AddServiceType(model.ServiceName, decimal.Parse(model.HourlyRate), userId);
//Redirect back to dashbaord, print results to screen
if (addedSucessfully)
{
return(RedirectToAction("Result", "Dashboard", new { statusCode = 0, message = "Service Type Added Successfully" }));
}
else
{
return(RedirectToAction("Result", "Dashboard", new { statusCode = 1, message = "Failed To Add Service Type" }));
}
}
/// <summary>
/// Update service type
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public virtual async Task <ResultModel> UpdateServiceTypeAsync(ServiceTypeViewModel model)
{
if (model == null)
{
return(new InvalidParametersResultModel());
}
var serviceType = await _context.ServiceTypes.AsNoTracking()
.FirstOrDefaultAsync(x => x.Id == model.Id);
if (serviceType == null)
{
return(new NotFoundResultModel());
}
serviceType = _mapper.Map <ServiceType>(model);
_context.ServiceTypes.Update(serviceType);
return(await _context.PushAsync());
}
public IEnumerable <ServiceTypeViewModel> GetServiceTypes()
{
IList <ServiceTypeViewModel> aList = new List <ServiceTypeViewModel>();
using (aOmsdCustomConext)
{
var serviceTypes = aOmsdCustomConext.ServiceType.ToList();
foreach (var aServiceType in serviceTypes)
{
ServiceTypeViewModel aServiceTypeViewModel = new ServiceTypeViewModel();
aServiceTypeViewModel.ServiceTypeId = aServiceType.ServiceTypeId;
aServiceTypeViewModel.Editstate = aServiceType.Editstate;
aServiceTypeViewModel.Sublistingid = aServiceType.Sublistingid;
aServiceTypeViewModel.Datecreated = aServiceType.Datecreated;
aServiceTypeViewModel.Name = aServiceType.Name;
aServiceTypeViewModel.Image = aServiceType.Image;
aServiceTypeViewModel.SortOrder = aServiceType.SortOrder;
aList.Add(aServiceTypeViewModel);
}
return(aList);
}
}
public ActionResult AddServiceType()
{
var model = new ServiceTypeViewModel();
return(View(model));
}
