public DiscountDTO GetDiscountById(int discountId)
{
using (UnitOfWorkProvider.Create())
{
var discount = discountRepository.GetById(discountId);
return(discount != null?Mapper.Map <DiscountDTO>(discount) : null);
}
}
public async Task CreateJobOffer(JobOfferCreateDto jobOfferCreate)
{
using (var unitOfWork = UnitOfWorkProvider.Create())
{
jobOfferService.Create(jobOfferCreate);
await unitOfWork.Commit();
}
}
public void CreateNotification(NotificationDTO notification)
{
using (var unitOfWork = UnitOfWorkProvider.Create())
{
Repository.Insert(Mapper.Map <Notification>(notification));
unitOfWork.Commit();
}
}
public SongListDTO GetSonglist(int songlistId)
{
using (UnitOfWorkProvider.Create())
{
var songlist = _songlistRepository.GetById(songlistId);
return(songlist != null?Mapper.Map <SongListDTO>(songlist) : null);
}
}
public void DeleteVehicle(int vehicleId)
{
using (var uow = UnitOfWorkProvider.Create())
{
vehicleRepository.Delete(vehicleId);
uow.Commit();
}
}
public async Task Delete(int menuItemId)
{
using (UnitOfWorkProvider.Create())
{
_menuItemService.DeleteProduct(menuItemId);
await UnitOfWorkProvider.GetUnitOfWorkInstance().Commit();
}
}
/// <summary>
/// Deletes specified account badge
/// </summary>
/// <param name="accountBadgeId"></param>
public void DeleteAccountBadge(Guid accountBadgeId)
{
using (var unitOfWork = UnitOfWorkProvider.Create())
{
Delete(accountBadgeId);
unitOfWork.Commit();
}
}
public TRelationshipDTO GetDetail(TKey id)
{
using (UnitOfWorkProvider.Create())
{
var entity = Repository.GetById(id);
if (entity == null)
{
return(default);
public async Task Delete(int id)
{
using (var unitOfWork = UnitOfWorkProvider.Create())
{
employerService.Delete(id);
await unitOfWork.Commit();
}
}
public async Task Create(EmployeeDto employee)
{
using (UnitOfWorkProvider.Create())
{
_employeeService.Create(employee);
await UnitOfWorkProvider.GetUnitOfWorkInstance().Commit();
}
}
public async Task Delete(int employeeId)
{
using (UnitOfWorkProvider.Create())
{
_employeeService.DeleteProduct(employeeId);
await UnitOfWorkProvider.GetUnitOfWorkInstance().Commit();
}
}
public EventDTO GetEvent(int eventId)
{
using (UnitOfWorkProvider.Create())
{
var e = _eventRepository.GetById(eventId);
return(e != null?Mapper.Map <EventDTO>(e) : null);
}
}
public void DeleteEvent(int eventId)
{
using (var uow = UnitOfWorkProvider.Create())
{
_eventRepository.Delete(eventId);
uow.Commit();
}
}
public async Task CreateSkill(SkillTagDto skill)
{
using (var unitOfWork = UnitOfWorkProvider.Create())
{
skillService.Create(skill);
await unitOfWork.Commit();
}
}
public AlbumReviewDTO GetAlbumReview(int albumReviewId)
{
using (UnitOfWorkProvider.Create())
{
var albumReview = _albumReviewRepository.GetById(albumReviewId);
return(albumReview != null?Mapper.Map <AlbumReviewDTO>(albumReview) : null);
}
}
public async Task <QueryResultDto <EmployerDto, EmployerFilterDto> > GetEmployerForFilter(
EmployerFilterDto employerFilterDto)
{
using (UnitOfWorkProvider.Create())
{
return(await employerService.GetFiltered(employerFilterDto));
}
}
public async Task Create(MenuItemDto menuItem)
{
using (UnitOfWorkProvider.Create())
{
_menuItemService.Create(menuItem);
await UnitOfWorkProvider.GetUnitOfWorkInstance().Commit();
}
}
/// <summary>
/// Creates new account
/// </summary>
/// <param name="account"></param>
public void CreateAccount(Account account)
{
using (var unitOfWork = UnitOfWorkProvider.Create())
{
Save(account);
unitOfWork.Commit();
}
}
/// <summary>
/// Updates existing account badge
/// </summary>
/// <param name="updatedAccountBadge"></param>
public void UpdateAccountBadge(AccountBadge updatedAccountBadge)
{
using (var unitOfWork = UnitOfWorkProvider.Create())
{
Save(updatedAccountBadge);
unitOfWork.Commit();
}
}
/// <summary>
/// Deletes cost info specified by cost info
/// </summary>
/// <param name="costInfoId"></param>
public void DeleteCostInfo(Guid costInfoId)
{
using (var unitOfWork = UnitOfWorkProvider.Create())
{
Delete(costInfoId);
unitOfWork.Commit();
}
}
public void DeleteSonglist(int songlistId)
{
using (var uow = UnitOfWorkProvider.Create())
{
_songlistRepository.Delete(songlistId);
uow.Commit();
}
}
/// <summary>
/// Updates existing cost info
/// </summary>
/// <param name="updatedCostInfo">updated cost info</param>
public void UpdateCostInfo(CostInfo updatedCostInfo)
{
using (var unitOfWork = UnitOfWorkProvider.Create())
{
Save(updatedCostInfo);
unitOfWork.Commit();
}
}
public IEnumerable <SongListDTO> ListSonglists(SongListFilter filter)
{
using (UnitOfWorkProvider.Create())
{
_songlistListQuery.Filter = filter;
return(_songlistListQuery.Execute() ?? new List <SongListDTO>());
}
}
public VillageDTO GetVillage(int villageID)
{
using (var uow = UnitOfWorkProvider.Create())
{
var village = villageRepository.GetById(villageID);
return(village != null?Mapper.Map <VillageDTO>(village) : null);
}
}
public IEnumerable <SonglistDTO> ListAllSonglists()
{
using (UnitOfWorkProvider.Create())
{
songlistListQuery.Filter = null;
return(songlistListQuery.Execute() ?? new List <SonglistDTO>());
}
}
public SongDTO GetSong(int songId)
{
using (UnitOfWorkProvider.Create())
{
var song = _songRepository.GetById(songId);
return(song != null?Mapper.Map <SongDTO>(song) : null);
}
}
protected void InUnitOfWork(Action action)
{
using (var uow = UnitOfWorkProvider.BeginUnitOfWork())
{
action();
uow.Commit();
}
}
public void DeleteAlbumReview(int albumReviewId)
{
using (var uow = UnitOfWorkProvider.Create())
{
_albumReviewRepository.Delete(albumReviewId);
uow.Commit();
}
}
public void UpdateNotification(NotificationDTO notification)
{
using (var unitOfWork = UnitOfWorkProvider.Create())
{
Repository.Update(Mapper.Map(notification, Repository.GetById(notification.Id)));
unitOfWork.Commit();
}
}
public void DeleteDiscount(int discountId)
{
using (var uow = UnitOfWorkProvider.Create())
{
discountRepository.Delete(discountId);
uow.Commit();
}
}
