public async Task <bool> RemoveCoownerAsync(long ownerId, long restaurantId, long coownerId) { EmployersRestaurants currentConnection = await CheckEmployerRestaurantAsync(ownerId, restaurantId); Employers employerToRemove = await CheckEmployerExistenceAsync(coownerId); long count = await EmployerRestaurantRepo.GetNumbetOfEmployers(restaurantId); if (count == 1) { throw new Exception("There's ony one owner to the restaurant. Use Close restaurant instead"); } if (currentConnection.TheEmployer.Id == employerToRemove.Id) { throw new Exception("The owner cannot remove itself. Use Transfer ownership instead"); } EmployersRestaurants data = await EmployerRestaurantRepo.GetByRestaurantIdAndEmployerId(restaurantId, coownerId); if (data == null) { throw new Exception(String.Format("The given owner with id:{0} can't be removed beacause is not an owner", coownerId)); } await EmployerRestaurantRepo.RemoveAsync(data); return(true); }
public async Task <bool> TransferOwnershipAsync(long ownerId, long restaurantId, long newOwnerId) { EmployersRestaurants currentConnection = await CheckEmployerRestaurantAsync(ownerId, restaurantId); Employers newEmployer = await CheckEmployerExistenceAsync(newOwnerId); EmployersRestaurants oldData = await EmployerRestaurantRepo.GetByRestaurantIdAndEmployerId(restaurantId, ownerId); if (oldData == null) { throw new Exception(String.Format("The given owner with id:{0} is not an owner.", ownerId)); } EmployersRestaurants newData = await EmployerRestaurantRepo.GetByRestaurantIdAndEmployerId(restaurantId, newOwnerId); if (newData != null) { throw new Exception(String.Format("The given new owner with id:{0} is already an owner.", newOwnerId)); } await EmployerRestaurantRepo.AddAsync ( new EmployersRestaurants { RestaurantId = restaurantId, EmployerId = newOwnerId }, ModifierId ); await EmployerRestaurantRepo.RemoveAsync(oldData); return(true); }
public async Task <LocationContact> AddContactAddressAsync(long ownerId, long restaurantId, int floor, string steetNumber, string route, string locality, string country, int zipCode, float latitude, float longitude, [Optional] string administrativeAreaLevel1, [Optional] string administrativeAreaLevel2, [Optional] string googleLink) { EmployersRestaurants connection = await CheckEmployerRestaurantAsync(ownerId, restaurantId); CheckTheLoggedInPerson(); LocationPoints point = new LocationPoints { Latitude = latitude, Longitude = longitude }; await PointRepo.AddAsync(point, ModifierId); LocationContact contact = new LocationContact() { LocationPointId = point.Id, RestaurantId = connection.TheRestaurant.Id }; contact.FillOrUpdateFields(floor, steetNumber, route, locality, country, zipCode, administrativeAreaLevel1, administrativeAreaLevel2, googleLink); try { await LocationRepo.AddAsync(contact, ModifierId); } catch (Exception ex) { if (contact.Id <= 0) { contact = null; await PointRepo.RemoveAsync(point); } throw ex; } return(contact); }
public async Task <Employees> TransferEmployeeToAnotherRestaurantAsync(long ownerId, long restaurantId, long employeeId, long newRestaurantId) { this.CheckTheLoggedInPerson(); EmployersRestaurants currentEmployerRestaurant = await CheckEmployerRestaurantAsync(ownerId, restaurantId); EmployersRestaurants newEmployerRestaurant = await CheckEmployerRestaurantAsync(ownerId, newRestaurantId); Employees employee = await CheckEmployeesExistenceAsync(employeeId); if (!employee.RestaurantId.HasValue) { throw new Exception("Cannot transfer non-employed employee."); } if (employee.RestaurantId.Value != restaurantId) { throw new Exception("Employee not employed in the given restaurant."); } employee.RestaurantId = newRestaurantId; await EmployeesRepo.UpdateAsync(employee, ModifierId); return(employee); }
public async Task <List <AssignedEmployeeTypes> > AssignResponsibilitiesForEmployeeAsync(long ownerId, long restaurantId, long employeeId, List <EmployeeTypeEnum> responsibilities) { this.CheckTheLoggedInPerson(); EmployersRestaurants employersRestaurants = await CheckEmployerRestaurantAsync(ownerId, restaurantId); Employees employee = await CheckEmployeesExistenceAsync(employeeId); List <AssignedEmployeeTypes> assigned = await AssignedTypeRepo.GetTypesForEmployee(employee.Id); foreach (var item in assigned) { if (responsibilities.Where(x => (long)x == item.Id).LongCount() == 0) { await AssignedTypeRepo.RemoveAsync(item); } } foreach (var item in responsibilities) { if (assigned.Where(x => x.Id == (long)item).LongCount() == 0) { AssignedEmployeeTypes newItem = new AssignedEmployeeTypes { EmployeeId = employee.Id, TypeId = (long)item }; await AssignedTypeRepo.AddAsync(newItem, this.ModifierId); } } return(await AssignedTypeRepo.GetTypesForEmployee(employee.Id)); }
public async Task <bool> RemoveMenuCategoryAsync(long ownerId, long restaurantId, long menuCategoryId) { CheckTheLoggedInPerson(); EmployersRestaurants connection = await CheckEmployerRestaurantAsync(ownerId, restaurantId); MenuCategories menuCategory = await CheckMenuCategoryExistance(menuCategoryId); return(await RemoveMenuCategoryByIdAsync(menuCategory.Id)); }
public async Task <bool> RemoveMenuItemAsync(long ownerId, long restaurantId, long menuItemId) { CheckTheLoggedInPerson(); EmployersRestaurants connection = await CheckEmployerRestaurantAsync(ownerId, restaurantId); MenuItems menuItem = await CheckMenuItemExistance(menuItemId); return(await RemoveMenuItemById(menuItem.Id)); }
public async Task <bool> RemoveMenuLanguageAsync(long ownerId, long restaurantId, long menuLanguageId) { CheckTheLoggedInPerson(); EmployersRestaurants connection = await CheckEmployerRestaurantAsync(ownerId, restaurantId); MenuLanguages menuLanguage = await CheckMenuLanguageExistence(menuLanguageId); return(await RemoveMenuLanguageByIdAsync(menuLanguage.Id)); }
protected async Task <EmployersRestaurants> CheckEmployerRestaurantAsync(long employerId, long restaurantId) { EmployersRestaurants emplRest = await EmployerRestaurantRepo.GetByRestaurantIdAndEmployerId(restaurantId, employerId); if (emplRest == null) { throw new Exception(String.Format("The restaurant with {0} does not have owner with id {1}", restaurantId, employerId)); } return(emplRest); }
public async Task <bool> RemoveContactNumberAsync(long ownerId, long restaurantId, long contactId) { EmployersRestaurants connection = await CheckEmployerRestaurantAsync(ownerId, restaurantId); PhoneContacts phone = await CheckPhoneExistenceAsync(contactId); CheckTheLoggedInPerson(); await PhoneRepo.RemoveAsync(phone); return(true); }
public async Task <bool> RemoveOutOfScheduleIntervalAsync(long employerId, long restaurantId, long scheduleId) { EmployersRestaurants connection = await CheckEmployerRestaurantAsync(employerId, restaurantId); CheckTheLoggedInPerson(); OutOfSchedulePeriods current = await CheckOutPeriodExistanceAsync(scheduleId); await OutOfScheduleRepo.RemoveAsync(current); return(true); }
public async Task <bool> RemoveWorkingIntervalAsync(long employerId, long restaurantId, long scheduleId) { EmployersRestaurants connection = await CheckEmployerRestaurantAsync(employerId, restaurantId); CheckTheLoggedInPerson(); OpenHoursSchedule current = await CheckScheduleExistanceAsync(scheduleId); await ScheduleRepo.RemoveAsync(current); return(true); }
public async Task <PhoneContacts> UpdateContactNumberAsync(long ownerId, long restaurantId, long contactId, string phoneNumber, string phoneDescription) { EmployersRestaurants connection = await CheckEmployerRestaurantAsync(ownerId, restaurantId); PhoneContacts phone = await CheckPhoneExistenceAsync(contactId); CheckTheLoggedInPerson(); phone.PhoneNumber = phoneNumber; phone.PhoneDescription = phoneDescription; await PhoneRepo.UpdateAsync(phone, ModifierId); return(phone); }
public async Task <bool> CloseRestaurantAsync(long ownerId, long restaurantId) { EmployersRestaurants currentConnection = await CheckEmployerRestaurantAsync(ownerId, restaurantId); List <EmployersRestaurants> dataToRemove = await EmployerRestaurantRepo.GetByRestaurantId(restaurantId); foreach (var data in dataToRemove) { await EmployerRestaurantRepo.RemoveAsync(data); } return(true); }
public async Task <MenuCategories> UpdateMenuCategoryAsync(long ownerId, long restaurantId, long menuCategoryId, Dictionary <long, string> categoryName, Dictionary <long, string> categoryDescription) { CheckTheLoggedInPerson(); EmployersRestaurants connection = await CheckEmployerRestaurantAsync(ownerId, restaurantId); Menus currentMenu = await CheckMenuExistanceAsync(restaurantId); List <MenuLanguages> menuLanguages = await MenuLanguagesRepo.GetItemsByMenuId(currentMenu.Id); MenuCategories menuCategory = await CheckMenuCategoryExistance(menuCategoryId); List <Categories> categories = await CategoriesRepo.GetByMenuCategoryId(menuCategory.Id); foreach (var menuLang in menuLanguages) { bool checkName = categoryName.TryGetValue(menuLang.Id, out string name); categoryDescription.TryGetValue(menuLang.Id, out string description); if (!checkName) { name = "<< no name >>"; } Categories cat = categories.Where(x => x.MenuLanguageId == menuLang.Id).SingleOrDefault(); if (cat == null) { cat = new Categories { CategoryName = name, CategoryDescription = description, MenuCategoryId = menuCategory.Id, MenuLanguageId = menuLang.Id }; categories.Add(cat); await CategoriesRepo.AddAsync(cat, this.ModifierId); } else { cat.CategoryName = name; cat.CategoryDescription = description; await CategoriesRepo.UpdateAsync(cat, this.ModifierId); } } return(menuCategory); }
public async Task <RestaurantObjects> UpdateRestaurantAsync(long ownerId, long restaurantId, string restaurantName, string restaurantDescription) { EmployersRestaurants currentConnection = await CheckEmployerRestaurantAsync(ownerId, restaurantId); RestaurantObjects currentRestaurant = currentConnection.TheRestaurant; currentRestaurant.Name = restaurantName; currentRestaurant.Description = restaurantDescription; CheckTheLoggedInPerson(); await RestaurantRepo.UpdateAsync(currentRestaurant, ModifierId); return(currentRestaurant); }
public async Task <bool> RemoveContactAddressAsync(long ownerId, long restaurantId, long contactId) { EmployersRestaurants connection = await CheckEmployerRestaurantAsync(ownerId, restaurantId); LocationContact loc = await CheckLocationExistenceAsync(contactId); LocationPoints point = await CheckLocationPointExistenceAsync(loc.LocationPointId); CheckTheLoggedInPerson(); await PointRepo.RemoveAsync(point); await LocationRepo.RemoveAsync(loc); return(true); }
public async Task <MenuCurrencies> UpdateMenuCurrenciesAsync(long ownerId, long restaurantId, long menuCurrencyId, long newCurrencyId) { CheckTheLoggedInPerson(); EmployersRestaurants connection = await CheckEmployerRestaurantAsync(ownerId, restaurantId); MenuCurrencies menuCurrency = await CheckMenuCurrencyExistence(menuCurrencyId); Currencies newCurrency = await CheckCurrencyExistance(newCurrencyId); menuCurrency.CurrencyId = newCurrency.Id; menuCurrency.TheCurrency = newCurrency; await MenuCurrencyRepo.UpdateAsync(menuCurrency, this.ModifierId); return(menuCurrency); }
public async Task <MenuLanguages> UpdateMenuLanguageAsync(long ownerId, long restaurantId, long menuLanguageId, long newLanguageId) { CheckTheLoggedInPerson(); EmployersRestaurants connection = await CheckEmployerRestaurantAsync(ownerId, restaurantId); MenuLanguages menuLanguage = await CheckMenuLanguageExistence(menuLanguageId); Languages newLanguage = await CheckLanguageExistance(newLanguageId); menuLanguage.LanguageId = newLanguage.Id; menuLanguage.TheLanguage = newLanguage; await MenuLanguagesRepo.UpdateAsync(menuLanguage, this.ModifierId); return(menuLanguage); }
public async Task <PhoneContacts> AddContactNumberAsync(long ownerId, long restaurantId, string phoneNumber, string phoneDescription) { EmployersRestaurants connection = await CheckEmployerRestaurantAsync(ownerId, restaurantId); PhoneContacts phone = new PhoneContacts { PhoneNumber = phoneNumber, PhoneDescription = phoneDescription, RestaurantId = connection.RestaurantId }; CheckTheLoggedInPerson(); await PhoneRepo.AddAsync(phone, ModifierId); return(phone); }
public async Task <OutOfSchedulePeriods> AddOutOfScheduleIntervalAsync(long employerId, long restaurantId, long openScheduleId, DateTimeOffset startOn, DateTimeOffset endsOn, string description) { EmployersRestaurants connection = await CheckEmployerRestaurantAsync(employerId, restaurantId); OpenHoursSchedule work = await CheckScheduleExistanceAsync(openScheduleId); if (restaurantId != work.RestaurantId) { throw new Exception("Operation not permitted. Cannot add schedule for other restaurants."); } CheckTheLoggedInPerson(); if (startOn.CompareTo(endsOn) >= 0) { throw new Exception(String.Format("Invalid period range. The period range can not start on: {0} and ends on {1}.", startOn.ToString("s"), endsOn.ToString("S"))); } DateTimeOffset current = DateTimeOffset.UtcNow; if (endsOn.CompareTo(current) <= 0) { throw new Exception(String.Format("The interval ({0} - {1}) is before current time {2}, and can not be added.", startOn.ToString("s"), endsOn.ToString("s"), current.ToString("s"))); } DateTimeOffset real = startOn.CompareTo(current) <= 0 ? current : startOn; OutOfSchedulePeriods outSchedule = new OutOfSchedulePeriods { OutOfSchedulePeriodStarts = real, OutOfSchedulePeriodEnds = endsOn, Description = description, OpenHoursScheduleId = openScheduleId }; List <OutOfSchedulePeriods> existingSchedules = await OutOfScheduleRepo.GetAllInPeriod(openScheduleId, real, endsOn); if (existingSchedules.Count == 0) { await OutOfScheduleRepo.AddAsync(outSchedule, this.ModifierId); return(outSchedule); } throw new Exception("There are overlapping periods"); }
public async Task <MenuCurrencies> AddMenuCurrencyAsync(long ownerId, long restaurantId, long currencyId) { CheckTheLoggedInPerson(); EmployersRestaurants connection = await CheckEmployerRestaurantAsync(ownerId, restaurantId); Menus currentMenu = await CheckMenuExistanceAsync(restaurantId); Currencies currencyToAdd = await CheckCurrencyExistance(currencyId); MenuCurrencies item = new MenuCurrencies { MenuId = currentMenu.Id, CurrencyId = currencyToAdd.Id }; await MenuCurrencyRepo.AddAsync(item, this.ModifierId); return(item); }
public async Task <MenuLanguages> AddMenuLanguageAsync(long ownerId, long restaurantId, long languageId) { CheckTheLoggedInPerson(); EmployersRestaurants connection = await CheckEmployerRestaurantAsync(ownerId, restaurantId); Menus currentMenu = await CheckMenuExistanceAsync(restaurantId); Languages languageToAdd = await CheckLanguageExistance(languageId); MenuLanguages item = new MenuLanguages { MenuId = currentMenu.Id, LanguageId = languageToAdd.Id }; await MenuLanguagesRepo.AddAsync(item, this.ModifierId); return(item); }
public async Task <Employees> AddEmployeeToRestaurantAsync(long ownerId, long restaurantId, long employeeId) { this.CheckTheLoggedInPerson(); EmployersRestaurants employersRestaurants = await CheckEmployerRestaurantAsync(ownerId, restaurantId); Employees employee = await CheckEmployeesExistenceAsync(employeeId); if (employee.RestaurantId.HasValue) { throw new Exception("Employee already employed! Use transfer to another restaurant instead."); } employee.RestaurantId = restaurantId; await EmployeesRepo.UpdateAsync(employee, ModifierId); return(employee); }
public async Task <EmployersRestaurants> AddCoownerAsync(long ownerId, long restaurantId, long coownerId) { CheckTheLoggedInPerson(); EmployersRestaurants currentConnection = await CheckEmployerRestaurantAsync(ownerId, restaurantId); Employers newEmployer = await CheckEmployerExistenceAsync(coownerId); EmployersRestaurants item = new EmployersRestaurants { EmployerId = newEmployer.Id, RestaurantId = currentConnection.TheRestaurant.Id }; await EmployerRestaurantRepo.AddAsync(item, ModifierId); return(item); }
public async Task <Employees> FireEmployeeOutAsync(long ownerId, long restaurantId, long employeeId) { this.CheckTheLoggedInPerson(); EmployersRestaurants employersRestaurants = await CheckEmployerRestaurantAsync(ownerId, restaurantId); Employees employee = await CheckEmployeesExistenceAsync(employeeId); if (!employee.RestaurantId.HasValue) { throw new Exception("Can't fire non-employed employee."); } employee.RestaurantId = null; await EmployeesRepo.UpdateAsync(employee, ModifierId); return(employee); }
public async Task <LocationContact> UpdateContactAddressAsync(long ownerId, long restaurantId, long contactId, int floor, string steetNumber, string route, string locality, string country, int zipCode, float latitude, float longitude, [Optional] string administrativeAreaLevel1, [Optional] string administrativeAreaLevel2, [Optional] string googleLink) { EmployersRestaurants connection = await CheckEmployerRestaurantAsync(ownerId, restaurantId); LocationContact contact = await CheckLocationExistenceAsync(contactId); LocationPoints point = await CheckLocationPointExistenceAsync(contact.LocationPointId); point.Latitude = latitude; point.Longitude = longitude; CheckTheLoggedInPerson(); await PointRepo.UpdateAsync(point, ModifierId); contact.FillOrUpdateFields(floor, steetNumber, route, locality, country, zipCode, administrativeAreaLevel1, administrativeAreaLevel2, googleLink); await LocationRepo.UpdateAsync(contact, ModifierId); return(contact); }
public async Task <OpenHoursSchedule> UpdateWokingIntervalAsync(long employerId, long restaurantId, long scheduleId, DayOfWeek startDay, TimeSpan startTime, DayOfWeek endDay, TimeSpan endTime) { EmployersRestaurants connection = await CheckEmployerRestaurantAsync(employerId, restaurantId); CheckTheLoggedInPerson(); List <OpenHoursSchedule> currentSchedules = await ScheduleRepo.FindByRestaurantId(restaurantId); OpenHoursSchedule existing = currentSchedules.Where(x => x.Id == scheduleId).Single(); existing.StartDay = startDay; existing.StartTime = startTime; existing.EndDay = endDay; existing.EndTime = endTime; List <OpenHoursSchedule> overlappingSchedules = GetOverlappedSchedule(existing, currentSchedules); if (overlappingSchedules.Count == 0) { await ScheduleRepo.UpdateAsync(existing, this.ModifierId); return(existing); } OpenHoursSchedule newSchedule = SolveOverlappedSchedules(existing, overlappingSchedules); existing.StartDay = newSchedule.StartDay; existing.StartTime = newSchedule.StartTime; existing.EndDay = newSchedule.EndDay; existing.EndTime = newSchedule.EndTime; await ScheduleRepo.UpdateAsync(existing, this.ModifierId); foreach (var sch in overlappingSchedules) { await ScheduleRepo.RemoveAsync(sch); } return(existing); }
public async Task <OpenHoursSchedule> AddWorkingIntervalAsync(long employerId, long restaurantId, DayOfWeek startDay, TimeSpan startTime, DayOfWeek endDay, TimeSpan endTime) { EmployersRestaurants connection = await CheckEmployerRestaurantAsync(employerId, restaurantId); CheckTheLoggedInPerson(); OpenHoursSchedule schedule = new OpenHoursSchedule { StartDay = startDay, StartTime = startTime, EndDay = endDay, EndTime = endTime, RestaurantId = restaurantId, }; List <OpenHoursSchedule> currentSchedules = await ScheduleRepo.FindByRestaurantId(restaurantId); List <OpenHoursSchedule> overlappingShedules = GetOverlappedSchedule(schedule, currentSchedules); if (overlappingShedules.Count == 0) { await ScheduleRepo.AddAsync(schedule, this.ModifierId); return(schedule); } OpenHoursSchedule newSchedule = SolveOverlappedSchedules(schedule, overlappingShedules); newSchedule.RestaurantId = restaurantId; await ScheduleRepo.AddAsync(newSchedule, this.ModifierId); foreach (var sch in overlappingShedules) { await ScheduleRepo.RemoveAsync(sch); } return(newSchedule); }
public async Task <MenuCategories> AddMenuCategoryAsync(long ownerId, long restaurantId, Dictionary <long, string> categoryName, Dictionary <long, string> categoryDescription) { CheckTheLoggedInPerson(); EmployersRestaurants connection = await CheckEmployerRestaurantAsync(ownerId, restaurantId); Menus currentMenu = await CheckMenuExistanceAsync(restaurantId); List <MenuLanguages> menuLanguages = await MenuLanguagesRepo.GetItemsByMenuId(currentMenu.Id); MenuCategories menuCat = new MenuCategories(); await MenuCategoriesRepo.AddAsync(menuCat, this.ModifierId); foreach (var menuLang in menuLanguages) { bool checkName = categoryName.TryGetValue(menuLang.Id, out string name); categoryDescription.TryGetValue(menuLang.Id, out string description); if (!checkName) { name = "<< no name >>"; } Categories cat = new Categories { CategoryName = name, CategoryDescription = description, MenuLanguageId = menuLang.Id, MenuCategoryId = menuCat.Id }; await CategoriesRepo.AddAsync(cat, this.ModifierId); } return(menuCat); }