private ServiceTypeModel getServiceTypeModel(int id)
        {
            ServiceTypeModel stm = new ServiceTypeModel();

            try
            {
                queryString = "SELECT ID, serviceType AS 'SERVICE TYPE', price AS 'PRICE' FROM dbspa.tblservicetype WHERE (isDeleted = 0) AND (ID = ?)";
                parameters  = new List <string>();
                parameters.Add(id.ToString());

                MySqlDataReader reader = conDB.getSelectConnection(queryString, parameters);
                while (reader.Read())
                {
                    stm.ServiceType = reader["SERVICE TYPE"].ToString();
                    stm.Price       = reader["price"].ToString();
                    stm.ID1         = reader["ID"].ToString();
                }
                conDB.closeConnection();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }


            return(stm);
        }
 public void ValidateForDuplicate(ServiceTypeModel viewModel)
 {
     if (ServiceTypeRepository.Items.Any(p => p.Name == viewModel.Name && p.Id != viewModel.Id && p.IsActive))
     {
         throw new ValidationException(new ValidationResult("Name already exists.", new string[] { "Name" }), null, viewModel);
     }
 }
        private List <ServiceTypeModel> getServiceWithCommissions()
        {
            List <ServiceTypeModel> lstServiceModel = new List <ServiceTypeModel>();

            try
            {
                queryString = "SELECT dbspa.tblservicetype.ID, dbspa.tblservicetype.serviceType AS 'SERVICE TYPE', dbspa.tblservicetype.price FROM " +
                              "(dbspa.tblservicetype INNER JOIN dbspa.tblcommissions ON dbspa.tblservicetype.ID = dbspa.tblcommissions.serviceTypeID) WHERE " +
                              "(dbspa.tblservicetype.isDeleted = 0) AND (dbspa.tblcommissions.isDeleted = 0)";

                MySqlDataReader reader = conDB.getSelectConnection(queryString, null);

                while (reader.Read())
                {
                    ServiceTypeModel stm = new ServiceTypeModel();
                    stm.ServiceType = reader["SERVICE TYPE"].ToString();
                    stm.Price       = reader["price"].ToString();
                    stm.ID1         = reader["ID"].ToString();
                    lstServiceModel.Add(stm);
                }
                conDB.closeConnection();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }

            return(lstServiceModel);
        }
        private void insertServiceTypeWithCommission()
        {
            try
            {
                queryString = "INSERT INTO dbspa.tblcommissions (serviceTypeID,commission,isDeleted)VALUES(?, ?, ?)";
                parameters  = new List <string>();
                ServiceTypeModel stm = cmbServiceType.SelectedItem as ServiceTypeModel;

                parameters.Add(stm.ID1);
                parameters.Add(String.Format("{0:0.00}", txtCommission.Text));
                parameters.Add(0.ToString());

                conDB.AddRecordToDatabase(queryString, parameters);
                conDB.closeConnection();

                MessageBox.Show("RECORD SAVED SUCCESSFULLY!");
                conDB.writeLogFile("ADDED COMMISSION RECORD: SERVICE TYPE ID: " + stm.ID1 + " COMMISSION: " + String.Format("{0:0.00}", txtCommission.Text));
                this.Close();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
            finally
            {
                getDatagridDetails();
            }
        }
        public void GivenUserIsNotDataAdmin_WhenGenerateCreateViewModel_ThenViewModelIsAdministratorFalse()
        {
            ServiceTypeModel actual = Target.GenerateCreateViewModel(User);

            Assert.IsNotNull(actual);
            Assert.IsFalse(actual.IsAdministrator);
        }
 private void btnAdd_Click(object sender, RoutedEventArgs e)
 {
     if (string.IsNullOrEmpty(txtCommission.Text))
     {
         MessageBox.Show("Please input commission value");
     }
     else if (cmbServiceType.SelectedItem == null)
     {
         MessageBox.Show("Please select Service Type value");
     }
     else
     {
         ServiceTypeModel s = cmbServiceType.SelectedItem as ServiceTypeModel;
         if (s != null)
         {
             if (s.ifPromo)
             {
                 updatePromoNameWithCommission(s.ID1);
             }
             else
             {
                 insertServiceTypeWithCommission();
             }
         }
     }
 }
        public void WhenGenerateCreateViewModel_ThenAPartialViewResultIsReturned()
        {
            ServiceTypeModel actual = Target.GenerateCreateViewModel(User);

            Assert.IsNotNull(actual);
            Assert.IsFalse(actual.IsAdministrator);
        }
        public void WhenGenerateCreateViewModel_ThenAPartialViewResultWithAPopulatedCategoryListIsReturned()
        {
            ServiceTypeModel actual = Target.GenerateCreateViewModel(User);

            Assert.IsNotNull(actual.Categories);
            CollectionAssert.AreEqual(Data.Categories, actual.Categories.Items.Cast <Category>().ToList());
        }
        public void WhenGenerateCreateViewModel_ThenAPartialViewResultWithAPopulatedProgramListIsReturned()
        {
            ServiceTypeModel actual = Target.GenerateCreateViewModel(User);

            Assert.IsNotNull(actual.Programs);
            CollectionAssert.AreEqual(Data.Programs.Where(p => p.IsActive).ToList(), actual.Programs.Items.Cast <Program>().ToList());
        }
        public void WhenGenerateCreateViewModel_ThenViewModelProgramListColumnsAreCorrect()
        {
            ServiceTypeModel actual = Target.GenerateCreateViewModel(User);

            Assert.AreEqual("Id", actual.Programs.DataValueField);
            Assert.AreEqual("Name", actual.Programs.DataTextField);
        }
Example #11
0
        /// <summary>
        /// Insert a new value in the list
        /// </summary>
        /// <param name=<em>"value"</em>>New value to be inserted</param>
        // POST: api/ServiceType
        public IHttpActionResult Post(ServiceTypeModel country)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest("Not a valid model"));
            }

            using (var ctx = new HTMEntities3())
            {
                ctx.ServiceTypes.Add(new ServiceType()
                {
                    id = country.id,
                    ServiceTypeName = country.ServiceTypeName,
                    Description     = country.Description,
                    InsertedBy      = country.InsertedBy,
                    InsertedOn      = country.InsertedOn,
                    IsActive        = country.IsActive,
                    IsDelete        = country.IsDelete
                });

                ctx.SaveChanges();
            }

            return(Ok());
        }
Example #12
0
        private List <ServiceTypeModel> getServiceType(List <ServiceMadeModel> smm)
        {
            List <ServiceTypeModel> lstSTM = new List <ServiceTypeModel>();
            ServiceTypeModel        tm     = new ServiceTypeModel();

            foreach (ServiceMadeModel madeModel in smm)
            {
                queryString = "SELECT ID, serviceType, price FROM dbspa.tblservicetype WHERE ID = ? AND isDeleted=0";
                parameters  = new List <string>();
                parameters.Add(madeModel.ServiceType);
                MySqlDataReader reader = conDB.getSelectConnection(queryString, parameters);

                while (reader.Read())
                {
                    tm.ID1         = reader["ID"].ToString();
                    tm.ServiceType = reader["serviceType"].ToString();
                    tm.Price       = reader["price"].ToString();

                    lstSTM.Add(tm);

                    tm = new ServiceTypeModel();
                }
                conDB.closeConnection();
            }
            return(lstSTM);
        }
        public void fillListBoxServiceType(ComboBox combo, ServiceTypeModel servType)
        {
            try
            {
                queryString = "SELECT dbspa.tblservicetype.ID, dbspa.tblservicetype.serviceType AS 'SERVICE TYPE', dbspa.tblservicetype.price AS 'PRICE', " +
                              "description FROM dbspa.tblservicetype WHERE (isDeleted = 0)";

                MySqlDataReader reader = conDB.getSelectConnection(queryString, null);

                while (reader.Read())
                {
                    ServiceTypeModel stm = new ServiceTypeModel();
                    stm.ServiceType = reader["SERVICE TYPE"].ToString();
                    stm.Price       = reader["price"].ToString();
                    stm.ID1         = reader["ID"].ToString();
                    stm.Description = reader["description"].ToString();
                    combo.Items.Add(stm);

                    if (stm.ID1.Equals(servType.ID1))
                    {
                        combo.SelectedItem = stm;
                    }
                }

                conDB.closeConnection();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
Example #14
0
 private void btnAdd_Click(object sender, RoutedEventArgs e)
 {
     if (cmbPromos.Visibility != Visibility.Hidden)
     {
         if (verifySelection())
         {
             PromoModel promo = cmbPromos.SelectedItem as PromoModel;
             addServiceToPromo(promo.ID);
             //label.Content = "Promo Name: " + promo.PromoName;
             loadDataGridServices(promo.ID);
         }
     }
     else
     {
         ServiceTypeModel selectService = cmbServices.SelectedItem as ServiceTypeModel;
         if (selectService != null)
         {
             addServiceToPromo(insertedPromoID);
             loadDataGridServices(insertedPromoID);
         }
         else
         {
             MessageBox.Show("Please select Service!");
         }
     }
 }
        public void GivenViewModel_WhenCreate_ThenServiceTypeIsActive()
        {
            ServiceTypeModel viewModel = new ServiceTypeModel();

            Target.Create(viewModel);

            Repositories.MockServiceTypeRepository.AssertWasCalled(m => m.Add(Arg <ServiceType> .Matches(s => s.IsActive == true)));
        }
        public void GivenNewServiceTypeState_WhenCreatePosted_ThenLogicManagerCreatesServiceType()
        {
            ServiceTypeModel expected = new ServiceTypeModel();

            Target.Create(expected);

            MockLogicManager.AssertWasCalled(m => m.Create(expected));
        }
        public void GivenANewlyCreatedIsSubmitted_WhenCreatePosted_ThenTrueJsonResultReturned()
        {
            ServiceTypeModel viewModel = new ServiceTypeModel();

            JsonResult result = Target.Create(viewModel) as JsonResult;

            Assert.AreEqual(true, result.Data);
        }
        public void GivenANewlyCreatedIsSubmitted_WhenCreatePosted_ThenTrueJsonResultReturned()
        {
            ServiceTypeModel viewModel = new ServiceTypeModel();

            JsonResult result = Target.Create(viewModel) as JsonResult;

            Assert.AreEqual(true, result.Data);
        }
        public void GivenValidViewModel_WhenCreate_ThenSaveCalled()
        {
            ServiceTypeModel viewModel = new ServiceTypeModel();

            Target.Create(viewModel);

            Repositories.MockRepositoryContainer.AssertWasCalled(m => m.Save());
        }
        public void GivenViewModelHasDuplicateName_AndServiceTypeWithNameIsInactive_WhenValidateForDuplicate_ThenSucceed()
        {
            var model = new ServiceTypeModel {
                Name = Data.ServiceTypes[5].Name
            };

            Target.ValidateForDuplicate(model);
        }
        public void GivenViewModelHasNewName_WhenValidateForDuplicate_ThenSucceed()
        {
            var model = new ServiceTypeModel {
                Name = "Mentoring 2"
            };

            Target.ValidateForDuplicate(model);
        }
        public void GivenInvalidServiceTypeId_WhenEdit_ThenThrowException()
        {
            ServiceTypeModel viewModel = new ServiceTypeModel {
                Id = 100
            };

            Target.ExpectException <EntityNotFoundException>(() => Target.Edit(viewModel));
        }
        public void GivenServiceTypeServiceOfferingsToBeDeactivatedHaveStudentAssignedOfferings_WhenEdit_ThenThrowException()
        {
            var selectedPrograms = new int[] { 3, 4 };
            var viewModel        = new ServiceTypeModel {
                Id = 1, SelectedPrograms = selectedPrograms
            };

            Target.ExpectException <ValidationException>(() => Target.Edit(viewModel));
        }
        public void GivenAnInvalidModelState_WhenIEditType_ThenTheCorrectCategoriesAreAddedToTheViewModel()
        {
            var expected = new ServiceTypeModel { Id = 1, Name = "Mentoring" };
            MockLogicManager.Expect(m => m.ValidateForDuplicate(expected)).Throw(new ValidationException(new ValidationResult("Error!", new[] { "Name" }), null, expected));

            Target.Edit(expected);

            MockLogicManager.AssertWasCalled(m => m.PopulateViewModel(User, expected));
        }
        public void GivenLogicManagerGeneratesViewModel_WhenCreateActionIsCalled_ThenReturnedPartialViewContainsViewModel()
        {
            ServiceTypeModel expected = new ServiceTypeModel();
            MockLogicManager.Expect(m => m.GenerateCreateViewModel(User)).Return(expected);

            PartialViewResult result = Target.Create();

            result.AssertGetViewModel(expected);
        }
        public void GivenViewModelHasInvalidState_WhenCreatePosted_ThenViewResultContainsValidationErrorMessage()
        {
            Target.ModelState.AddModelError("Name", new ValidationException());
            var model = new ServiceTypeModel();

            PartialViewResult result = Target.Create(model) as PartialViewResult;

            result.AssertGetViewModel(model);
        }
        public void GivenViewModel_WhenPopulateViewModel_ThenCategoriesAndProgramsListsSet()
        {
            ServiceTypeModel model = new ServiceTypeModel();

            Target.PopulateViewModel(User, model);

            Assert.IsNotNull(model.Categories);
            Assert.IsNotNull(model.Programs);
        }
        public void GivenViewModelIsGenerated_WhenEditButtonIsClicked_ThenAViewResultIsCreated()
        {
            ServiceTypeModel expected = new ServiceTypeModel();

            MockLogicManager.Expect(m => m.GenerateEditViewModel(User, 1)).Return(expected);

            var result = Target.Edit(1) as PartialViewResult;

            result.AssertGetViewModel(expected);
        }
        public void GivenValidServiceTypeId_WhenICallDelete_ThenAPartialViewResultIsReturned()
        {
            ServiceTypeModel expected = new ServiceTypeModel();

            MockLogicManager.Expect(m => m.GenerateDeleteViewModel(1)).Return(expected);

            var result = Target.Delete(1) as PartialViewResult;

            result.AssertGetViewModel(expected);
        }
        public void GivenLogicManagerGeneratesViewModel_WhenCreateActionIsCalled_ThenReturnedPartialViewContainsViewModel()
        {
            ServiceTypeModel expected = new ServiceTypeModel();

            MockLogicManager.Expect(m => m.GenerateCreateViewModel(User)).Return(expected);

            PartialViewResult result = Target.Create();

            result.AssertGetViewModel(expected);
        }
        public void GivenViewModelHasDuplicateName_WhenValidateForDuplicate_ThenThrowValidationException_AndExceptionMemberNamesIncludesName()
        {
            var model = new ServiceTypeModel {
                Name = "Mentoring"
            };

            ValidationException actual = Target.ExpectException <ValidationException>(() => Target.ValidateForDuplicate(model));

            CollectionAssert.Contains(actual.ValidationResult.MemberNames.ToList(), "Name");
        }
        public void GivenAnEditedServiceTypeIsSubmittedWithoutAUniqueName_WhenEditPosted_ThenReturnViewResultWithViewModel_AndNameHasModelStateErrors()
        {
            var expected = new ServiceTypeModel { Id = 1, Name = "Mentoring" };
            MockLogicManager.Expect(m => m.ValidateForDuplicate(expected)).Throw(new ValidationException(new ValidationResult("Error!", new[] { "Name" }), null, expected));

            PartialViewResult result = Target.Edit(expected) as PartialViewResult;

            result.AssertGetViewModel(expected);
            Assert.IsTrue(Target.ModelState["Name"].Errors.Count > 0);
        }
        public List <ServiceTypeModel> ServiceTypeList()
        {
            var modelView = new ServiceTypeModel {
                FilterOption = FilterOption.GetAll
            };
            var viewJson      = Execute(Option.Get, modelView);
            var responseModel = GetResponseModel <ServiceTypeModel>(viewJson);

            return(responseModel.ModelList);
        }
        public ServiceTypeModel GetServiceTypeById(int id)
        {
            var modelView = new ServiceTypeModel {
                Id = id, FilterOption = FilterOption.ModelByFields
            };
            var viewJson      = Execute(Option.Get, modelView);
            var responseModel = GetResponseModel <ServiceTypeModel>(viewJson);

            return(responseModel.Model);
        }
        public void GivenServiceTypeAssociationsWereMade_WhenEdit_ThenServiceTypeHasSelectedPrograms()
        {
            EducationSecurityPrincipal user = new EducationSecurityPrincipal(new UserRepository(EducationContext).Items.Where(s => s.UserKey == "Bob").Include("UserRoles.Role").Single());
            var selectedPrograms = new int[] { 1, 2 };
            var serviceType = EducationContext.ServiceTypes.Single(s => s.Id == 2);
            var expected = EducationContext.Programs.Where(s => selectedPrograms.Contains(s.Id)).ToList();
            var viewModel = new ServiceTypeModel { Id = serviceType.Id, Name = serviceType.Name, Description = serviceType.Description, SelectedPrograms = selectedPrograms };

            Target.Edit(viewModel);

            var actual = EducationContext.ServiceTypes.Single(s => s.Id == viewModel.Id).ServiceOfferings.Where(s => s.IsActive).Select(s => s.Program).Distinct();

            CollectionAssert.AreEquivalent(expected, actual.ToList());
        }
 public ActionResult Create(ServiceTypeModel viewModel)
 {
     try
     {
         LogicManager.ValidateForDuplicate(viewModel);
     }
     catch (ValidationException e)
     {
         ModelState.AddModelErrors(e);
     }
     if (ModelState.IsValid)
     {
         LogicManager.Create(viewModel);
         return Json(true);
     }
     LogicManager.PopulateViewModel((EducationSecurityPrincipal)HttpContext.User, viewModel);
     return PartialView(viewModel);
 }
 public void Create(ServiceTypeModel viewModel)
 {
     if (viewModel == null)
     {
         throw new ArgumentNullException("viewModel");
     }
     ServiceType item = new ServiceType { IsActive = true };
     viewModel.CopyTo(item);
     if (ServiceTypeRepository.Items.Any(s => s.Name == item.Name && !s.IsActive))
     {
         item = ServiceTypeRepository.Items.Include("ServiceOfferings.Program.Schools").Single(s => s.Name == item.Name);
         item.IsActive = true;
     }
     else
     {
         ServiceTypeRepository.Add(item);
     }
     UpdateTypeCategories(viewModel.SelectedCategories, item);
     UpdateServiceTypePrograms(viewModel.SelectedPrograms, item);
     RepositoryContainer.Save();
 }
 public void ValidateForDuplicate(ServiceTypeModel viewModel)
 {
     if (ServiceTypeRepository.Items.Any(p => p.Name == viewModel.Name && p.Id != viewModel.Id && p.IsActive))
     {
         throw new ValidationException(new ValidationResult("Name already exists.", new string[] { "Name" }), null, viewModel);
     }
 }
 public void WhenACreateActionIsPosted_ThenAActionResultIsReturned()
 {
     ServiceTypeModel model = new ServiceTypeModel
     {
         Id = 0,
         Name = "Bob",
         Description = "Bob's Description"
     };
     ActionResult result = Target.Create(model);
     Assert.IsNotNull(result);
 }
        public void GivenViewModelIsGenerated_WhenEditButtonIsClicked_ThenAViewResultIsCreated()
        {
            ServiceTypeModel expected = new ServiceTypeModel();
            MockLogicManager.Expect(m => m.GenerateEditViewModel(User, 1)).Return(expected);

            var result = Target.Edit(1) as PartialViewResult;

            result.AssertGetViewModel(expected);
        }
 public void InitializeTest()
 {
     Target = new ServiceTypeModel();
 }
 public ServiceTypeModel GenerateCreateViewModel(EducationSecurityPrincipal user)
 {
     if (user == null)
     {
         throw new ArgumentNullException("user");
     }
     ServiceTypeModel model = new ServiceTypeModel();
     PopulateViewModel(user, model);
     return model;
 }
        public void GivenNewServiceTypeState_WhenCreatePosted_ThenLogicManagerCreatesServiceType()
        {
            ServiceTypeModel expected = new ServiceTypeModel();

            Target.Create(expected);

            MockLogicManager.AssertWasCalled(m => m.Create(expected));
        }
        public void GivenValidServiceTypeId_WhenICallDelete_ThenAPartialViewResultIsReturned()
        {
            ServiceTypeModel expected = new ServiceTypeModel();
            MockLogicManager.Expect(m => m.GenerateDeleteViewModel(1)).Return(expected);

            var result = Target.Delete(1) as PartialViewResult;

            result.AssertGetViewModel(expected);
        }
        public void GivenValidationExceptionThrown_WhenDeleteIsClicked_ThenAPartialViewResultIsCreated_AndExpectedViewModelGenerated()
        {
            ServiceTypeModel expected = new ServiceTypeModel();
            MockLogicManager.Expect(m => m.Delete(1)).Throw(new ValidationException());
            MockLogicManager.Expect(m => m.GenerateDeleteViewModel(1)).Return(expected);

            PartialViewResult result = Target.DeleteConfirmed(1) as PartialViewResult;

            result.AssertGetViewModel(expected);
        }
 public void PopulateViewModel(EducationSecurityPrincipal user, ServiceTypeModel viewModel)
 {
     if (viewModel == null)
     {
         throw new ArgumentNullException("viewModel");
     }
     viewModel.IsAdministrator = user.IsInRole(SecurityRoles.DataAdmin);
     viewModel.Categories = new MultiSelectList(CategoryRepository.Items, "Id", "Name", viewModel.SelectedCategories);
     viewModel.Programs = new MultiSelectList(ProgramRepository.Items.Where(p => p.IsActive), "Id", "Name", viewModel.SelectedPrograms);
 }
 public ServiceTypeModel GenerateEditViewModel(EducationSecurityPrincipal user, int typeId)
 {
     if (user == null)
     {
         throw new ArgumentNullException("user");
     }
     var serviceType = ServiceTypeRepository.Items.Include(s => s.Categories).Include("ServiceOfferings.Program").SingleOrDefault(s => s.Id == typeId && s.IsActive);
     if (serviceType == null)
     {
         throw new EntityNotFoundException("Specified service type does not exist");
     }
     ServiceTypeModel viewModel = new ServiceTypeModel();
     viewModel.CopyFrom(serviceType);
     viewModel.Categories = new MultiSelectList(CategoryRepository.Items, "Id", "Name", serviceType.Categories.Select(c => c.Id));
     viewModel.Programs = new MultiSelectList(ProgramRepository.Items.Where(p => p.IsActive), "Id", "Name", serviceType.ServiceOfferings.Where(so => so.IsActive && so.Program.IsActive).Select(s => s.ProgramId).Distinct());
     viewModel.IsAdministrator = user.IsInRole(SecurityRoles.DataAdmin);
     return viewModel;
 }
        public void GivenViewModelHasDuplicateName_WhenCreatePosted_ThenModelStateHasErrors()
        {
            var model = new ServiceTypeModel { Name = "Mentoring" };
            MockLogicManager.Expect(m => m.ValidateForDuplicate(model)).Throw(new ValidationException(new ValidationResult("Error!", new[] { "Name" }), null, model));

            PartialViewResult result = Target.Create(model) as PartialViewResult;

            Assert.IsTrue(Target.ModelState["Name"].Errors.Count > 0);
        }
 public ServiceTypeModel GenerateDeleteViewModel(int typeId)
 {
     var model = ServiceTypeRepository.Items.SingleOrDefault(s => s.Id == typeId);
     if (model == null)
     {
         throw new EntityNotFoundException("Specified service type does not exist");
     }
     ServiceTypeModel viewModel = new ServiceTypeModel();
     viewModel.CopyFrom(model);
     return viewModel;
 }
        public void GivenViewModelHasInvalidState_WhenCreatePosted_ThenViewResultContainsValidationErrorMessage()
        {
            Target.ModelState.AddModelError("Name", new ValidationException());
            var model = new ServiceTypeModel();

            PartialViewResult result = Target.Create(model) as PartialViewResult;

            result.AssertGetViewModel(model);
        }
        public void GivenViewModelHasInvalidState_WhenCreatePosted_ThenViewResultWithViewModelReturned_AndViewModelPopulatedLists()
        {
            var expected = new ServiceTypeModel();
            Target.ModelState.AddModelError("Name", new ValidationException());

            PartialViewResult result = Target.Create(expected) as PartialViewResult;

            MockLogicManager.AssertWasCalled(m => m.PopulateViewModel(User, expected));
            result.AssertGetViewModel(expected);
        }
 public void Edit(ServiceTypeModel viewModel)
 {
     var updatedServiceType = ServiceTypeRepository.Items.Include("ServiceOfferings.Program.Schools").Include(s => s.Categories).Include("ServiceOfferings.Program").SingleOrDefault(s => s.Id == viewModel.Id);
     if (updatedServiceType == null)
     {
         throw new EntityNotFoundException("Service Type not found.");
     }
     viewModel.CopyTo(updatedServiceType);
     ServiceTypeRepository.Update(updatedServiceType);
     UpdateTypeCategories(viewModel.SelectedCategories, updatedServiceType);
     UpdateServiceTypePrograms(viewModel.SelectedPrograms, updatedServiceType);
     RepositoryContainer.Save();
 }