public WorkerDto Update(int id, [FromBody] WorkerDto workerDto)
{
Worker worker = workerDtoToWorkerMapping.Map(workerDto);
Worker actualWorker = alohaContext.Workers
.Include(f => f.User)
.Include(w => w.Workstation)
.ThenInclude(w => w.Floor)
.Include(f => f.Photo)
.SingleOrDefault(f => f.Id == id);
if (workerDto.PhotoUrl != null && workerDto.PhotoUrl != string.Empty)
{
if (actualWorker.Photo != null)
{
alohaContext.Remove(actualWorker.Photo);
}
actualWorker.Photo = FileHelper.GetFileFromBase64(workerDto.PhotoUrl);
}
workerUpdater.Update(actualWorker, worker);
alohaContext.SaveChanges();
return(workerToWorkerDtoMapping.Map(actualWorker));
}
private void BtnSave_Click(object sender, RoutedEventArgs e)
{
try
{
WorkerDto workerDto = new WorkerDto();
workerDto.idDivision = int.Parse(tbDivisionID.Text);
//workerDto.idWorker = int.Parse(tbID.Text);
workerDto.Name = tbName.Text;
IWorkerProcess workerProcess = ProcessFactory.GetWorkerProcess();
if (_id == 0)
{
workerProcess.Add(workerDto);
}
else
{
workerDto.idDivision = _id;
workerProcess.Update(workerDto);
}
this.Close();
} catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public ActionResult <WorkerDto> Add([FromBody] WorkerDto workerDto)
{
if (workerDto.UserName == null)
{
return(BadRequest(new { Password = "******" }));
}
if (workerDto.Password == null)
{
return(BadRequest(new { Password = "******" }));
}
Worker worker = workerDtoToWorkerMapping.Map(workerDto);
User user = new User()
{
UserName = workerDto.UserName,
Worker = worker,
PasswordHash = securityService.HashPassword(workerDto.Password)
};
alohaContext.Users.Add(user);
alohaContext.SaveChanges();
return(workerToWorkerDtoMapping.Map(worker));
}
//Cập nhật Brand
public async Task <bool> Update(WorkerDto model)
{
var Line = _mapper.Map <Worker>(model);
_repoWorker.Update(Line);
return(await _repoWorker.SaveAll());
}
public void Create(WorkerDto worker)
{
var model = _autoMapper.Map <Worker>(worker);
_context.Workers.Add(model);
_context.SaveChanges();
}
public async Task <IActionResult> PutWorker(int id, WorkerDto workerDto)
{
var worker = _mapper.Map <Worker>(workerDto);
if (id != worker.WorkerId)
{
return(BadRequest());
}
_context.Entry(worker).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkerExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> EditWorker(string id, [FromBody] WorkerDto worker)
{
try
{
var updateWorkerDataCommand = new UpdateWorkerDataCommand
{
Id = id,
FirstName = worker.FirstName,
LastName = worker.LastName
};
var result = await _mediator.Send(updateWorkerDataCommand);
var updateScheduleCommand = new UpdateScheduleCommand
{
Id = id,
Schedule = worker.Schedule
};
result = await _mediator.Send(updateScheduleCommand);
var uploadImageCommand = new UploadImageCommand
{
Id = id,
ImageSource = worker.ImageSource
};
result = await _mediator.Send(uploadImageCommand);
await _userService.UpdateUserAsync(id, worker.UserEmail, worker.UserPhoneNumber);
return(Ok());
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public async Task <IActionResult> Update(WorkerDto update)
{
if (await _workerService.Update(update))
{
return(NoContent());
}
return(BadRequest($"Updating Worker {update.ID} failed on save"));
}
public async Task <IActionResult> PostAsync([FromBody] WorkerDto workerDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Created("", await _workerService.CreateAsync(workerDto)));
}
public void Update(string key, WorkerDto worker)
{
_workers.TryGetValue(key, out var app);
if (app != null)
{
Remove(key);
Add(worker.Name, worker);
}
}
public void Add(string key, WorkerDto worker)
{
_workers.TryGetValue(key, out var app);
if (app == null)
{
_workers.TryAdd(key, worker);
_scheduler.StartAsync(worker, CancellationToken.None);
}
}
public async Task <ActionResult <Worker> > PostWorker(WorkerDto workerDto)
{
var worker = _mapper.Map <Worker>(workerDto);
_context.Workers.Add(worker);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetWorker", new { id = worker.WorkerId }, worker));
}
public async Task <WorkerDto> CreateAsync(WorkerDto dto)
{
WorkerModel model = _mapper.Map <WorkerDto, WorkerModel>(dto);
await _unitOfWork.WorkersRepository.InsertAsync(model);
await _unitOfWork.SaveAsync();
return(dto);
}
public ActionResult Update(WorkerDto workerDto)
{
var result = _workerService.Update(workerDto);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
public async Task <IActionResult> GetAsync(int id)
{
WorkerDto worker = await _workerService.GetByIdAsync(id);
if (worker == null)
{
return(NotFound(id));
}
return(Json(worker));
}
public static BusinessLayer.Worker FromDto(WorkerDto worker)
{
return new BusinessLayer.Worker()
{
Id = worker.Id,
Name = worker.Name,
Surname = worker.Surname,
Number = worker.Number,
Pin = worker.Pin
};
}
public Response <WorkerDto> UpdateWorkerData(WorkerDto data, string token)
{
Response <WorkerDto> obj = null;
var hCliente = _global.rspClient("Worker/ActualizarDataTrabajador", data, token);
if (hCliente.IsSuccessStatusCode)
{
obj = new JavaScriptSerializer().Deserialize <Response <WorkerDto> >(hCliente.Content.ReadAsStringAsync().Result);
}
return(obj);
}
public static BusinessLayer.Worker FromDto(WorkerDto worker)
{
return(new BusinessLayer.Worker()
{
Id = worker.Id,
Name = worker.Name,
Surname = worker.Surname,
Number = worker.Number,
Pin = worker.Pin
});
}
public void WorkerWillBeStarted(WorkerDto worker)
{
// Если эта джоба была запущена не нами, то подписаться на ее эвенты
// ...
Thread.Sleep(6000);
var context = new InstanceContext(new JobManagerServiceCallback());
var client = new JobManagerServiceClient(context);
client.SetClientContextToWorker(worker.Id);
}
public async Task <WorkerDto> UpdateAsync(int id, WorkerDto dto)
{
dto.Character = null;
dto.Group = null;
dto.GroupRank = null;
WorkerModel model = await _unitOfWork.WorkersRepository.JoinAndGetAsync(id);
_mapper.Map(dto, model);
await _unitOfWork.SaveAsync();
return(dto);
}
public IActionResult Delete(WorkerDto workerDto)
{
// using MyWebApiContext db = new MyWebApiContext(DbContextOptions);
var worker = new Worker {
Id = workerDto.Id
};
db.Workers.Attach(worker);
db.Workers.Remove(worker);
db.SaveChanges();
return(RedirectPermanent("/"));
}
public static Worker Convert(WorkerDto workerDto)
{
if (workerDto == null)
{
return(null);
}
Worker worker = new Worker();
worker.idWorker = workerDto.idWorker;
worker.idDivision = workerDto.idDivision;
worker.Name = workerDto.Name;
return(worker);
}
public static Worker Convert(WorkerDto workerDto)
{
if (workerDto == null)
{
return(null);
}
Worker worker = new Worker();
worker.Adress = workerDto.Adress;
worker.ID = workerDto.ID;
worker.Name = workerDto.Name;
worker.Phone = workerDto.Phone;
return(worker);
}
public async Task <IActionResult> Create(WorkerDto create)
{
if (_workerService.GetById(create.ID) != null)
{
return(BadRequest("Worker ID already exists!"));
}
//create.CreatedDate = DateTime.Now;
if (await _workerService.Add(create))
{
return(NoContent());
}
throw new Exception("Creating the part failed on save");
}
private void BtnEdit_Click(object sender, RoutedEventArgs e)
{
switch (currentTable)
{
case "Worker":
WorkerDto workerDto = (WorkerDto)dgMain.SelectedItem;
if (workerDto != null)
{
WorkerWindow workerWindow = new WorkerWindow();
workerWindow.Load(workerDto);
workerWindow.ShowDialog();
MenuItem_Click(sender, e); //update table
}
break;
case "Division":
DivisionDto divisionDto = (DivisionDto)dgMain.SelectedItem;
if (divisionDto != null)
{
DivisionWindow divisionWindow = new DivisionWindow();
divisionWindow.Load(divisionDto);
divisionWindow.ShowDialog();
MenuItem_Click_1(sender, e);
}
break;
case "ExpenseByWorker":
ExpenseDto expenseDto = (ExpenseDto)dgMain.SelectedItem;
if (expenseDto != null)
{
ExpenseWindow expenseWindow = new ExpenseWindow();
expenseWindow.Load(expenseDto);
expenseWindow.ShowDialog();
MenuItem_Click_3(sender, e);
}
break;
case "TypeExpense":
TypeExpenseDto typeExpenseDto = (TypeExpenseDto)dgMain.SelectedItem;
if (typeExpenseDto != null)
{
TypeExpenseWindow typeExpenseWindow = new TypeExpenseWindow();
typeExpenseWindow.Load(typeExpenseDto);
typeExpenseWindow.ShowDialog();
MenuItem_Click_4(sender, e);
}
break;
}
}
public IResult Update(WorkerDto workerDto)
{
var workerMapper = _mapper.Map <Worker>(workerDto);
_workerDepartmentTypeService.DeleteAllDepartmentByWorkerID(workerDto.WorkerID);
foreach (var departmentType in workerDto.DepartmentTypes)
{
WorkerDepartmentType workerDepartmentType = new WorkerDepartmentType {
DepartmentTypeID = departmentType.DepartmentTypeID, WorkerID = workerMapper.WorkerID
};
_workerDepartmentTypeService.Add(workerDepartmentType);
}
_workerDal.Update(workerMapper);
return(new SuccessResult(Messages.WorkerUpdated));
}
public async Task <IActionResult> PutAsync([FromRoute] int id, [FromBody] WorkerDto workerDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(workerDto));
}
WorkerDto worker = await _workerService.UpdateAsync(id, workerDto);
if (worker == null)
{
return(NotFound(id));
}
return(Json(worker));
}
public JsonResult UpdateWorkerData(WorkerDto data)
{
#region TOKEN
var sessione = (SessionModel)Session[Resources.Constante.SessionUsuario];
LoginDto oLoginDto = new LoginDto();
oLoginDto.v_UserName = sessione.UserName;
oLoginDto.v_Password = sessione.Pass;
var validated = _securityBL.ValidateAccess(oLoginDto);
if (validated == null)
{
return(Json("", "application/json", Encoding.UTF8, JsonRequestBehavior.AllowGet));
}
#endregion
var response = _workerBL.UpdateWorkerData(data, validated.Token);
return(Json(response, "application/json", Encoding.UTF8, JsonRequestBehavior.AllowGet));
}
public void AddWorkerByUserModel(RegistrationModel registrationModel)
{
var company = _companyService.GetCompanyByName(registrationModel.CompanyName);
var workerDto = new WorkerDto
{
FirstName = registrationModel.FirstName,
LastName = registrationModel.LastName,
Email = registrationModel.Email,
UserId = registrationModel.UserId,
CompanyId = company.Id
};
var createdWorker = _workerService.AddWorker(workerDto);
AssignWorkersToRoles(createdWorker.Id, registrationModel.Role);
}
private async Task <List <WorkerDto> > SetBusinessWorkersToWorkersDto(IReadOnlyList <BusinessWorker> businessWorkers)
{
List <WorkerDto> workers = new List <WorkerDto>();
foreach (BusinessWorker worker in businessWorkers)
{
WorkerDto businessWorker = _mapper.Map <BusinessWorker, WorkerDto>(worker);
User user = await _userManager.FindByIdAsync(worker.WorkerId);
businessWorker.FirstName = user.FirstName;
businessWorker.LastName = user.LastName;
workers.Add(businessWorker);
}
return(workers);
}
public void Update(WorkerDto worker)
{
var workerToUpdate = _context.Workers.FirstOrDefault(x => x.Id.Equals(worker.Id));
if (workerToUpdate == null)
{
return;
}
workerToUpdate.Name = worker.Name;
workerToUpdate.Post = worker.Post;
workerToUpdate.DateOfEdit = worker.DateOfEdit;
workerToUpdate.DateOfEmployement = worker.DateOfEmployement;
workerToUpdate.DepartmentId = worker.DepartmentId;
_context.Workers.Update(workerToUpdate);
_context.SaveChanges();
}
