public async Task <ExamProgram> Create(ExamProgram examProgram) { if (!await ExamProgramValidator.Create(examProgram)) { return(examProgram); } using (UOW.Begin()) { try { examProgram.Id = Guid.NewGuid(); examProgram = await GetSemesterId(examProgram); await UOW.ExamProgramRepository.Create(examProgram); await UOW.Commit(); return(examProgram); } catch (Exception e) { await UOW.Rollback(); examProgram.AddError(nameof(ExamProgramService), nameof(Create), CommonEnum.ErrorCode.SystemError); return(examProgram); } } }
public async Task <OrderContent> Create(OrderContent OrderContent) { if (!await OrderContentValidator.Create(OrderContent)) { return(OrderContent); } try { await UOW.Begin(); await UOW.OrderContentRepository.Create(OrderContent); await UOW.Commit(); await Logging.CreateAuditLog(OrderContent, new { }, nameof(OrderContentService)); return(await UOW.OrderContentRepository.Get(OrderContent.Id)); } catch (Exception ex) { await UOW.Rollback(); await Logging.CreateSystemLog(ex.InnerException, nameof(OrderContentService)); if (ex.InnerException == null) { throw new MessageException(ex); } else { throw new MessageException(ex.InnerException); } } }
public async Task <Category> Create(Category Category) { if (!await CategoryValidator.Create(Category)) { return(Category); } try { await UOW.Begin(); await UOW.CategoryRepository.Create(Category); await UOW.Commit(); await UOW.AuditLogRepository.Create(Category, "", nameof(CategoryService)); return(await UOW.CategoryRepository.Get(Category.Id)); } catch (Exception ex) { await UOW.Rollback(); await UOW.SystemLogRepository.Create(ex, nameof(CategoryService)); throw new MessageException(ex); } }
public async Task <District> Create(District District) { if (!await DistrictValidator.Create(District)) { return(District); } try { await UOW.Begin(); await UOW.DistrictRepository.Create(District); await UOW.Commit(); await UOW.AuditLogRepository.Create(District, "", nameof(DistrictService)); return(await UOW.DistrictRepository.Get(District.Id)); } catch (Exception ex) { await UOW.Rollback(); await UOW.SystemLogRepository.Create(ex, nameof(DistrictService)); throw new MessageException(ex); } }
public async Task <FoodGrouping> Create(FoodGrouping FoodGrouping) { if (!await FoodGroupingValidator.Create(FoodGrouping)) { return(FoodGrouping); } try { await UOW.Begin(); await UOW.FoodGroupingRepository.Create(FoodGrouping); await UOW.Commit(); await Logging.CreateAuditLog(FoodGrouping, new { }, nameof(FoodGroupingService)); return(await UOW.FoodGroupingRepository.Get(FoodGrouping.Id)); } catch (Exception ex) { await UOW.Rollback(); await Logging.CreateSystemLog(ex.InnerException, nameof(FoodGroupingService)); if (ex.InnerException == null) { throw new MessageException(ex); } else { throw new MessageException(ex.InnerException); } } }
public async Task <Variation> Create(Variation Variation) { if (!await VariationValidator.Create(Variation)) { return(Variation); } try { await UOW.Begin(); await UOW.VariationRepository.Create(Variation); await UOW.Commit(); await UOW.AuditLogRepository.Create(Variation, "", nameof(VariationService)); return(await UOW.VariationRepository.Get(Variation.Id)); } catch (Exception ex) { await UOW.Rollback(); await UOW.SystemLogRepository.Create(ex, nameof(VariationService)); throw new MessageException(ex); } }
public async Task <Administrator> Create(Administrator Administrator) { if (!await AdministratorValidator.Create(Administrator)) { return(Administrator); } try { await UOW.Begin(); await UOW.AdministratorRepository.Create(Administrator); await UOW.Commit(); await UOW.AuditLogRepository.Create(Administrator, "", nameof(AdministratorService)); return(await UOW.AdministratorRepository.Get(Administrator.Id)); } catch (Exception ex) { await UOW.Rollback(); await UOW.SystemLogRepository.Create(ex, nameof(AdministratorService)); throw new MessageException(ex); } }
public async Task <Item> Create(Item Item) { if (!await ItemValidator.Create(Item)) { return(Item); } try { await UOW.Begin(); await UOW.ItemRepository.Create(Item); await UOW.Commit(); await UOW.AuditLogRepository.Create(Item, "", nameof(ItemService)); return(await UOW.ItemRepository.Get(Item.Id)); } catch (Exception ex) { await UOW.Rollback(); await UOW.SystemLogRepository.Create(ex, nameof(ItemService)); throw new MessageException(ex); } }
public async Task <University> Create(University university) { university.Id = Guid.NewGuid(); if (!await UniversityValidator.Create(university)) { return(university); } try { await UOW.Begin(); await UOW.UniversityRepository.Create(university); await UOW.Commit(); return(await Get(university.Id)); } catch (Exception ex) { await UOW.Rollback(); throw new MessageException(ex); } }
public async Task <Wallet> Create(Wallet wallet) { wallet.Id = Guid.NewGuid(); if (wallet == null) { return(null); } if (!await WalletValidator.Create(wallet)) { return(wallet); } using (UnitOfWork.Begin()) { try { await UnitOfWork.WalletRepository.Create(wallet); await UnitOfWork.Commit(); } catch (Exception ex) { await UnitOfWork.Rollback(); wallet.AddError(nameof(WalletService), nameof(wallet.Id), CommonEnum.ErrorCode.SystemError); } } return(wallet); }
public async Task <Form> ApproveAccept(Form form) { if (!await FormValidator.Approve(form)) { return(form); } try { await UOW.Begin(); //Chuyển trạng thái từ chờ duyệt sang đã duyệt form.Status = 2; await UOW.FormRepository.Approve(form); await UOW.StudentRepository.UpdateStatus(new Student { Id = form.StudentId, Status = form.Status }); await UOW.Commit(); return(await Get(form.StudentId)); } catch (Exception ex) { await UOW.Rollback(); throw new MessageException(ex); } }
public async Task <PaymentMethod> Create(PaymentMethod PaymentMethod) { if (!await PaymentMethodValidator.Create(PaymentMethod)) { return(PaymentMethod); } try { await UOW.Begin(); await UOW.PaymentMethodRepository.Create(PaymentMethod); await UOW.Commit(); await UOW.AuditLogRepository.Create(PaymentMethod, "", nameof(PaymentMethodService)); return(await UOW.PaymentMethodRepository.Get(PaymentMethod.Id)); } catch (Exception ex) { await UOW.Rollback(); await UOW.SystemLogRepository.Create(ex, nameof(PaymentMethodService)); throw new MessageException(ex); } }
public async Task <Reservation> Create(Reservation Reservation) { if (!await ReservationValidator.Create(Reservation)) { return(Reservation); } try { await UOW.Begin(); await UOW.ReservationRepository.Create(Reservation); await UOW.Commit(); await Logging.CreateAuditLog(Reservation, new { }, nameof(ReservationService)); return(await UOW.ReservationRepository.Get(Reservation.Id)); } catch (Exception ex) { await UOW.Rollback(); await Logging.CreateSystemLog(ex.InnerException, nameof(ReservationService)); if (ex.InnerException == null) { throw new MessageException(ex); } else { throw new MessageException(ex.InnerException); } } }
public async Task <ProductStatus> Create(ProductStatus ProductStatus) { if (!await ProductStatusValidator.Create(ProductStatus)) { return(ProductStatus); } try { await UOW.Begin(); await UOW.ProductStatusRepository.Create(ProductStatus); await UOW.Commit(); await UOW.AuditLogRepository.Create(ProductStatus, "", nameof(ProductStatusService)); return(await UOW.ProductStatusRepository.Get(ProductStatus.Id)); } catch (Exception ex) { await UOW.Rollback(); await UOW.SystemLogRepository.Create(ex, nameof(ProductStatusService)); throw new MessageException(ex); } }
public async Task <ImageFile> Create(ImageFile ImageFile) { if (!await ImageFileValidator.Create(ImageFile)) { return(ImageFile); } try { await UOW.Begin(); await UOW.ImageFileRepository.Create(ImageFile); await UOW.Commit(); await UOW.AuditLogRepository.Create(ImageFile, "", nameof(ImageFileService)); return(await UOW.ImageFileRepository.Get(ImageFile.Id)); } catch (Exception ex) { await UOW.Rollback(); await UOW.SystemLogRepository.Create(ex, nameof(ImageFileService)); throw new MessageException(ex); } }
public async Task <Stock> Create(Stock Stock) { if (!await StockValidator.Create(Stock)) { return(Stock); } try { await UOW.Begin(); await UOW.StockRepository.Create(Stock); await UOW.Commit(); await UOW.AuditLogRepository.Create(Stock, "", nameof(StockService)); return(await UOW.StockRepository.Get(Stock.Id)); } catch (Exception ex) { await UOW.Rollback(); await UOW.SystemLogRepository.Create(ex, nameof(StockService)); throw new MessageException(ex); } }
public async Task <EVoucher> Create(EVoucher EVoucher) { if (!await EVoucherValidator.Create(EVoucher)) { return(EVoucher); } try { await UOW.Begin(); await UOW.EVoucherRepository.Create(EVoucher); await UOW.Commit(); await UOW.AuditLogRepository.Create(EVoucher, "", nameof(EVoucherService)); return(await UOW.EVoucherRepository.Get(EVoucher.Id)); } catch (Exception ex) { await UOW.Rollback(); await UOW.SystemLogRepository.Create(ex, nameof(EVoucherService)); throw new MessageException(ex); } }
public async Task <List <Store> > AddToCustomer(List <Store> Stores) { if (!await StoreValidator.AddToCustomer(Stores)) { return(Stores); } try { await UOW.Begin(); await UOW.StoreRepository.BulkMerge(Stores); await UOW.Commit(); await Logging.CreateAuditLog(Stores, new { }, nameof(StoreService)); return(Stores); } catch (Exception ex) { if (ex.InnerException == null) { await Logging.CreateSystemLog(ex, nameof(StoreService)); throw new MessageException(ex); } else { await Logging.CreateSystemLog(ex.InnerException, nameof(StoreService)); throw new MessageException(ex.InnerException); } } }
public async Task <TicketType> Create(TicketType TicketType) { if (!await TicketTypeValidator.Create(TicketType)) { return(TicketType); } try { await UOW.Begin(); await UOW.TicketTypeRepository.Create(TicketType); await UOW.Commit(); await Logging.CreateAuditLog(TicketType, new { }, nameof(TicketTypeService)); return(await UOW.TicketTypeRepository.Get(TicketType.Id)); } catch (Exception ex) { await UOW.Rollback(); await Logging.CreateSystemLog(ex.InnerException, nameof(TicketTypeService)); if (ex.InnerException == null) { throw new MessageException(ex); } else { throw new MessageException(ex.InnerException); } } }
public async Task <Term> Create(Term term) { if (!await TermValidator.Create(term)) { return(term); } using (UOW.Begin()) { try { term.Id = Guid.NewGuid(); term = await GetSemesterId(term); await UOW.TermRepository.Create(term); await UOW.Commit(); return(term); } catch (Exception e) { await UOW.Rollback(); term.AddError(nameof(TermService), nameof(Create), CommonEnum.ErrorCode.SystemError); return(term); } } }
public async Task <SubjectGroup> Create(SubjectGroup subjectGroup) { subjectGroup.Id = Guid.NewGuid(); if (!await SubjectGroupValidator.Create(subjectGroup)) { return(subjectGroup); } try { await UOW.Begin(); await UOW.SubjectGroupRepository.Create(subjectGroup); await UOW.Commit(); return(await Get(subjectGroup.Id)); } catch (Exception ex) { await UOW.Rollback(); throw new MessageException(ex); } }
public async Task <OrderContent> Create(OrderContent OrderContent) { if (!await OrderContentValidator.Create(OrderContent)) { return(OrderContent); } try { await UOW.Begin(); await UOW.OrderContentRepository.Create(OrderContent); await UOW.Commit(); await UOW.AuditLogRepository.Create(OrderContent, "", nameof(OrderContentService)); return(await UOW.OrderContentRepository.Get(OrderContent.Id)); } catch (Exception ex) { await UOW.Rollback(); await UOW.SystemLogRepository.Create(ex, nameof(OrderContentService)); throw new MessageException(ex); } }
public async Task <WorkflowStep> Create(WorkflowStep WorkflowStep) { if (!await WorkflowStepValidator.Create(WorkflowStep)) { return(WorkflowStep); } try { await UOW.Begin(); await UOW.WorkflowStepRepository.Create(WorkflowStep); await UOW.Commit(); await Logging.CreateAuditLog(WorkflowStep, new { }, nameof(WorkflowStepService)); return(await UOW.WorkflowStepRepository.Get(WorkflowStep.Id)); } catch (Exception ex) { await UOW.Rollback(); await Logging.CreateSystemLog(ex.InnerException, nameof(WorkflowStepService)); if (ex.InnerException == null) { throw new MessageException(ex); } else { throw new MessageException(ex.InnerException); } } }
public async Task <ShippingAddress> Create(ShippingAddress ShippingAddress) { if (!await ShippingAddressValidator.Create(ShippingAddress)) { return(ShippingAddress); } try { await UOW.Begin(); await UOW.ShippingAddressRepository.Create(ShippingAddress); await UOW.Commit(); await UOW.AuditLogRepository.Create(ShippingAddress, "", nameof(ShippingAddressService)); return(await UOW.ShippingAddressRepository.Get(ShippingAddress.Id)); } catch (Exception ex) { await UOW.Rollback(); await UOW.SystemLogRepository.Create(ex, nameof(ShippingAddressService)); throw new MessageException(ex); } }
public async Task <CustomerGrouping> Create(CustomerGrouping CustomerGrouping) { if (!await CustomerGroupingValidator.Create(CustomerGrouping)) { return(CustomerGrouping); } try { await UOW.Begin(); await UOW.CustomerGroupingRepository.Create(CustomerGrouping); await UOW.Commit(); await UOW.AuditLogRepository.Create(CustomerGrouping, "", nameof(CustomerGroupingService)); return(await UOW.CustomerGroupingRepository.Get(CustomerGrouping.Id)); } catch (Exception ex) { await UOW.Rollback(); await UOW.SystemLogRepository.Create(ex, nameof(CustomerGroupingService)); throw new MessageException(ex); } }
public async Task <ScheduleMaster> Create(ScheduleMaster ScheduleMaster) { if (!await ScheduleMasterValidator.Create(ScheduleMaster)) { return(ScheduleMaster); } try { await UOW.Begin(); await UOW.ScheduleMasterRepository.Create(ScheduleMaster); await UOW.Commit(); await Logging.CreateAuditLog(ScheduleMaster, new { }, nameof(ScheduleMasterService)); return(await UOW.ScheduleMasterRepository.Get(ScheduleMaster.Id)); } catch (Exception ex) { await UOW.Rollback(); await Logging.CreateSystemLog(ex.InnerException, nameof(ScheduleMasterService)); if (ex.InnerException == null) { throw new MessageException(ex); } else { throw new MessageException(ex.InnerException); } } }
public async Task <Semester> Create(Semester semester) { if (!await SemesterValidator.Create(semester)) { return(semester); } using (UOW.Begin()) { try { semester.Id = Guid.NewGuid(); await UOW.SemesterRepository.Create(semester); await UOW.Commit(); return(await Get(semester.Id)); } catch (Exception e) { await UOW.Rollback(); semester.AddError(nameof(SemesterService), nameof(Create), CommonEnum.ErrorCode.SystemError); return(semester); } } }
public async Task <University_Majors> Create(University_Majors university_Majors) { if (!await university_MajorsValidator.Create(university_Majors)) { return(university_Majors); } try { university_Majors.Id = Guid.NewGuid(); await UOW.Begin(); await UOW.University_MajorsRepository.Create(university_Majors); await UOW.Commit(); return(await Get(university_Majors.Id)); } catch (Exception ex) { await UOW.Rollback(); throw new MessageException(ex); } }
public async Task <Ward> Create(Ward Ward) { if (!await WardValidator.Create(Ward)) { return(Ward); } try { await UOW.Begin(); await UOW.WardRepository.Create(Ward); await UOW.Commit(); await UOW.AuditLogRepository.Create(Ward, "", nameof(WardService)); return(await UOW.WardRepository.Get(Ward.Id)); } catch (Exception ex) { await UOW.Rollback(); await UOW.SystemLogRepository.Create(ex, nameof(WardService)); throw new MessageException(ex); } }
public async Task <Majors> Create(Majors majors) { majors.Id = Guid.NewGuid(); if (!await MajorsValidator.Create(majors)) { return(majors); } try { await UOW.Begin(); await UOW.MajorsRepository.Create(majors); await UOW.Commit(); return(await Get(majors.Id)); } catch (Exception ex) { await UOW.Rollback(); throw new MessageException(ex); } }