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