public async Task <IActionResult> Edit(Guid id, ServiceProvidedVM vm)
        {
            if (ModelState.IsValid)
            {
                var getOperation = await _bo.ReadAsync(id);

                if (!getOperation.Success)
                {
                    return(OperationErrorBackToIndex(getOperation.Exception));
                }

                if (getOperation.Result == null)
                {
                    return(RecordNotFound());
                }

                var result = getOperation.Result;

                if (!vm.CompareToModel(result))
                {
                    result = vm.ToServiceProvided(result);

                    var updateOperation = await _bo.UpdateAsync(result);

                    if (!updateOperation.Success)
                    {
                        TempData["Alert"] = AlertFactory.GenerateAlert(NotificationType.Danger, updateOperation.Exception);
                        return(View(vm));
                    }

                    return(OperationSuccess("The record was successfully updated."));
                }
            }
            return(RedirectToAction(nameof(Index)));
        }
        public async Task <IActionResult> Edit(Guid?id)
        {
            if (id == null)
            {
                return(RecordNotFound());
            }

            var getOperation = await _bo.ReadAsync((Guid)id);

            if (!getOperation.Success)
            {
                return(OperationErrorBackToIndex(getOperation.Exception));
            }

            if (getOperation.Result == null)
            {
                return(RecordNotFound());
            }

            var vm = ServiceProvidedVM.Parse(getOperation.Result);

            var listServiceOperation = await _serviceBO.ListUndeletedAsync();

            if (!listServiceOperation.Success)
            {
                return(OperationErrorBackToIndex(listServiceOperation.Exception));
            }

            var serviceList = new List <SelectListItem>();

            foreach (var item in listServiceOperation.Result)
            {
                var listItem = new SelectListItem()
                {
                    Value = item.Id.ToString(), Text = item.Name
                };

                if (item.Id == vm.ServiceId)
                {
                    listItem.Selected = true;
                }

                serviceList.Add(listItem);
            }

            ViewBag.Services = serviceList;

            var crumbs = GetCrumbs();

            crumbs.Add(new BreadCrumb()
            {
                Action = "Edit", Controller = "ServicesProvided", Icon = "fa-edit", Text = "Edit"
            });

            ViewData["Title"]       = "Edit service provided";
            ViewData["BreadCrumbs"] = crumbs;
            return(View(vm));
        }
        public async Task <IActionResult> New(ServiceProvidedVM vm)
        {
            if (ModelState.IsValid)
            {
                var model           = vm.ToServiceProvided();
                var createOperation = await _bo.CreateAsync(model);

                if (!createOperation.Success)
                {
                    return(OperationErrorBackToIndex(createOperation.Exception));
                }

                return(OperationSuccess("The record was successfully created."));
            }
            return(View(vm));
        }
        public async Task <IActionResult> Details(Guid?id)
        {
            if (id == null)
            {
                return(RecordNotFound());
            }

            var getOperation = await _bo.ReadAsync((Guid)id);

            if (!getOperation.Success)
            {
                return(OperationErrorBackToIndex(getOperation.Exception));
            }

            if (getOperation.Result == null)
            {
                return(RecordNotFound());
            }

            var getServiceOperation = await _serviceBO.ReadAsync(getOperation.Result.ServiceId);

            if (!getServiceOperation.Success)
            {
                return(OperationErrorBackToIndex(getServiceOperation.Exception));
            }

            if (getServiceOperation.Result == null)
            {
                return(RecordNotFound());
            }

            var vm = ServiceProvidedVM.Parse(getOperation.Result);

            var crumbs = GetCrumbs();

            crumbs.Add(new BreadCrumb()
            {
                Action = "Details", Controller = "ServicesProvided", Icon = "fa-info-circle", Text = "Details"
            });

            ViewData["Title"]       = "Service provided details";
            ViewData["BreadCrumbs"] = crumbs;
            ViewData["Service"]     = ServiceVM.Parse(getServiceOperation.Result);
            return(View(vm));
        }
        public async Task <IActionResult> Index()
        {
            var listOperation = await _bo.ListUndeletedAsync();

            if (!listOperation.Success)
            {
                return(OperationErrorBackToIndex(listOperation.Exception));
            }

            var finalList = new List <ServiceProvidedVM>();

            foreach (var item in listOperation.Result)
            {
                finalList.Add(ServiceProvidedVM.Parse(item));
            }

            var serviceList = await GetServiceViewModels(listOperation.Result.Select(x => x.ServiceId).Distinct().ToList());

            ViewData["Title"]       = "Services provided";
            ViewData["BreadCrumbs"] = GetCrumbs();
            ViewData["DeleteHref"]  = GetDeleteRef();
            ViewData["Services"]    = serviceList;
            return(View(finalList));
        }