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);
}
