public void CreateDepartment(DepartmentViewModel departmentViewModel) { var department = Mapper.Map <DepartmentViewModel, Department_M>(departmentViewModel); _departmentRepository.Add(department); SaveDepartment(); }
public async Task <ActionResult <Department> > Create(Department Department) { _departmentRepository.Add(Department); await _departmentRepository.SaveChangesAsync(); return(CreatedAtAction(nameof(GetById), new { id = Department.Id }, Department)); }
public int CreateDepartment(string number, string name, string createdBy, int companyId) { using (IUnitOfWork work = UnitOfWork.Begin()) { Department department = DomainObjectFactory.CreateDepartment(); department.Name = name; department.Number = number; department.ModifiedLast = DateTime.Now; department.ModifiedBy = createdBy; department.CompanyId = companyId; department.IsDeleted = false; _departmentRepository.Add(department); work.Commit(); department = _departmentRepository.FindById(department.Id); var departmentLogEntity = new DepartmentEventEntity(department); _logService.CreateLog(CurrentUser.Get().Id, "web", flag, CurrentUser.Get().HostName, CurrentUser.Get().CompanyId, departmentLogEntity.GetCreateMessage()); return(department.Id); } }
public async Task <DepartmentViewModel> AddNewDepartment(DepartmentViewModel model) { var mapped = _mapper.Map <Department>(model); await _departmentRepository.Add(mapped); return(model); }
public ActionResult <Department> Post([FromForm] Department department) { try { if (ModelState.IsValid) { var isAdded = repository.Add(department); if (isAdded) { return(Created("Department", department)); } else { return(StatusCode(StatusCodes.Status500InternalServerError)); } } else { return(BadRequest(ModelState)); } } catch { return(StatusCode(StatusCodes.Status500InternalServerError)); } }
public ActionResult <Department> PostDepartment(Department department) { _departmentRepository.Add(department); _departmentRepository.Save(); return(CreatedAtAction("GetDepartment", new { id = department.Id }, department)); }
public async Task <bool> ImportExcel(string filePath, string user) { using (var package = new ExcelPackage(new FileInfo(filePath))) { ExcelWorksheet workSheet = package.Workbook.Worksheets[0]; for (int i = workSheet.Dimension.Start.Row + 1; i <= workSheet.Dimension.End.Row; i++) { var id = workSheet.Cells[i, 1].Value.ToString(); if (!(await this.CheckDept(id))) { Department department = new Department(); department.Status = "1"; department.Updated_Time = DateTime.Now; department.Updated_By = user; department.ID = workSheet.Cells[i, 1].Value.ToString(); department.Name_ZW = workSheet.Cells[i, 2].Value == null ? "" : workSheet.Cells[i, 2].Value.ToString(); department.Name_LL = workSheet.Cells[i, 3].Value == null ? "" : workSheet.Cells[i, 3].Value.ToString(); department.Name_EN = workSheet.Cells[i, 4].Value == null ? "" : workSheet.Cells[i, 4].Value.ToString(); _repoDepartment.Add(department); } } try { return(await _repoDepartment.SaveAll()); } catch (System.Exception) { return(false); throw; } } }
public override void Add(DepartmentDTO item) { var department = new Department(); department.Name = item.Name; _baseRepository.Add(department); }
public int SaveDepartment(DepartmentModel model) { model.Status = true; var department = Mapper.DynamicMap <lkpDepartment>(model); _departmentRepository.Add(department); return(_departmentRepository.SaveChanges()); }
public Department Add(DepartmentViewModel Vm) { var entity = _mapper.Map <DepartmentViewModel, Department>(Vm); _departmentRepository.Add(entity); SaveChanges(); return(entity); }
public OperationResult Add(AddDepartmentInputInfo inputInfo) { var newDepartment = _mapper.Map <Department>(inputInfo); _departmentRepository.Add(newDepartment); return(new OperationResult(true, Messages.SuccessfullyAddedDepartment)); }
public void AddDepartment(Department department) { DepartmentValidator validator = new DepartmentValidator(); validator.ValidateAndThrow(department); _repository.Add(department); }
public override bool Add(Department department) { if (string.IsNullOrEmpty(department.Name)) { throw new Exception("Department Name is not provided!"); } return(_repository.Add(department)); }
public int AddDepartment(Department dept) { using (TransactionScope tran = new TransactionScope()) { Departments.Add(dept); //Complete(); tran.Complete(); return(dept.Id); } }
public void Create(Department department) { using (var transaction = new TransactionScope()) { _departmentRepository.Add(department); _departmentRepository.SaveChanges(); transaction.Complete(); } }
public async Task <Guid> CreateDepartmentAsync(CreateDepartmentCommand command) { var department = new Department(command.Name, command.IsEnabled, command.ParentId); departmentRepository.Add(department); await unitOfWork.CommitAsync(); return(department.Id); }
public async override Task <AddDepartmentResoponse> AddDepartment(AddDepartmentRequest request, ServerCallContext context) { var department = await _departmentRepository.Add(request.Department); return(new AddDepartmentResoponse() { Department = department }); }
public IActionResult CreatePost(Department model) { if (ModelState.IsValid) { _departmentRepository.Add(model); } return(RedirectToAction("Details", new { detailId = model.DepartmentId })); }
public async Task <dynamic> Post([FromBody] Department obj, long id) { if (id > 0) { return(await _departmentRepository.Update(id, obj)); } else { return(await _departmentRepository.Add(obj)); } }
public override async Task <AddDepartmentResponse> Add(AddDepatmentRequest request, ServerCallContext context) { var departmet = await _departmentRepository.Add(request.Deparment); var result = new AddDepartmentResponse { Deparment = departmet }; return(result); }
public async Task <IActionResult> CreateAsync([FromBody] CreateDepartment request, CancellationToken cancellationToken) { var department = new Department(request.Name, request.ParentId, request.CompanyId); _departmentRepository.Add(department); await _departmentRepository.UnitOfWork.SaveChangesAsync(cancellationToken); var vm = _mapper.Map <ViewDepartment>(department); return(CreatedAtAction(nameof(GetAsync), new { id = vm.Id }, vm)); }
public async Task <DepartmentQueryModel> Handle(CreateDepartmentCommand request, CancellationToken cancellationToken) { Department department = new Department(request.Name, request.SchoolName); var newDepartment = _repo.Add(department); DepartmentQueryModel departmentQ = new DepartmentQueryModel(newDepartment.Id, newDepartment.Name, newDepartment.SchoolName); await _uow.Commit(); return(departmentQ); }
public void Create() { var department = new DepartmentDto() { DepartmentDtoId = 1 }; _departmentService.Create(department); A.CallTo(() => _department.Add(department)).MustHaveHappenedOnceExactly(); }
public ActionResult Create([Bind(Include = "Id,Name,Budget,StartDate,InstructorId")] Department department) { if (ModelState.IsValid) { departmentRepository.Add(department); return(RedirectToAction("Index")); } ListInstructors(department.InstructorId); return(View(department)); }
public string Post([FromBody] Department department) { try { _departmentRepository.Add(department); return("Added Successfully"); } catch (Exception) { return("Failed to Add"); } }
public RedirectToActionResult Create(Department department) { Department newEmployee = new Department { DepName = department.DepName, DepHod = department.DepHod, DepLocation = department.DepLocation, }; _empRepo.Add(newEmployee); return(RedirectToAction("AllDetails")); }
public Department CreateDepartment(CreateDepartment department) { var departmentMap = new Department() { Title = department.Title, Description = department.Description }; _departmentRepository.Add(departmentMap); _departmentRepository.Commit(); return(departmentMap); }
public void AddNewDepartment(Guid id, string name, string code, Guid?parentDepartmentId = null) { Department department = new Department { ID = id, Name = name, Code = code, ParentDepartmentID = parentDepartmentId }; _departmentRepository.Add(department); }
public ActionResult Create(CreateDepartmentViewModel viewModel) { if (ModelState.IsValid) { Department department = new Department(); department = mapper.Map <Department>(viewModel); repository.Add(department); repository.Save(); return(RedirectToAction("index", "Department")); } return(View(viewModel)); }
public async Task <bool> Handle(CreateDepartmentCommand message) { // Add/Update the Buyer AggregateRoot // DDD patterns comment: Add child entities and value-objects through the Order Aggregate-Root // methods and constructor so validations, invariants and business logic // make sure that consistency is preserved across the whole aggregate var group = DepartmentGroup.Create(message.DepartmentGroup.Id, message.DepartmentGroup.Description); var depto = Department.Create(message.Id, group, message.DepartmentType, message.Description, message.ApplyTax, message.Amount, message.Percentage); _deptoRepository.Add(depto); return(await _deptoRepository.UnitOfWork .SaveEntitiesAsync()); }
public void TestTransaction_DifferentContext_AllFail() { _departmentRepository = new DepartmentRepository( Helper.GetEfContext() ); try { using ( TransactionScope scope = new TransactionScope() ) { _employeeRepository.Add( _employee ); throw new Exception(); _departmentRepository.Add( _department ); scope.Complete(); } } catch { _employeeRepository = Ioc.Create<IEmployeeRepository>(); Assert.IsNull( _employeeRepository.Find( _employee.Id ) ); } }
public void TestTransaction_DifferentContext_AllSuccess() { _departmentRepository = new DepartmentRepository( Helper.GetEfContext() ); using ( TransactionScope scope = new TransactionScope() ) { _employeeRepository.Add( _employee ); _departmentRepository.Add( _department ); scope.Complete(); } _employeeRepository = Ioc.Create<IEmployeeRepository>(); Assert.IsNotNull( _employeeRepository.Find( _employee.Id ) ); _departmentRepository = Ioc.Create<IDepartmentRepository>(); Assert.IsNotNull( _departmentRepository.Find( _department.Id ) ); }
public void TestInit() { _department = Department.GetDepartment(); _repository = Ioc.Create<IDepartmentRepository>(); _repository.Clear(); _repository.Add( _department ); }