/// <summary>
/// Deletes the specified id.
/// </summary>
/// <param name="id">The id.</param>
/// <returns>if success return true else false</returns>
public bool Delete(int id)
{
var employee = new EmployeeDto { EmployeeID = id };
var entity = enityadapter.Transform<EmployeeDto, Employee>(employee);
this.ebo.AttachEmployee(entity);
return this.ebo.DelEmployee(entity);
}
public void Promote(EmployeeDto promtedDto, int newBoss)
{
//in the real world, go to service then update the cache
//update the cache with the emploee,
_employees.AddOrUpdate(new EmployeeDto(promtedDto.Id,promtedDto.Name,newBoss));
}
public void TestGetEntiyByPK(Int32 pkid)
{
var _EmployeeBO = new EmployeeBO(new FakeEmployeeConverter());
var dtoEntity=new EmployeeDto(){EmployeeID=pkid};
var dbResult = _EmployeeBO.GetEntiyByPK(dtoEntity);
Assert.NotNull(dbResult);
}
public void TestGeEmployeeDto(EmployeeDto employeeDto)
{
var controller = new EmployeeController(new EmployeeBO(new EmployeeConverter()));
var result=controller.Get(employeeDto);
Assert.NotNull(result);
}
public void Promote(EmployeeDto promtedDto, int newBoss)
{
//simulate going to a service
//update the cache with the emploee,
_employees.AddOrUpdate(new EmployeeDto(promtedDto.Id,promtedDto.Name,newBoss));
}
public void SourceObjectWithNullReference()
{
var employeeDto = new EmployeeDto
{
Title = "Man"
};
var employee = new Employee
{
ManagerID = 2,
ContactID = 3,
Title = "Developer",
BirthDate = new DateTime(1965, 1, 1, 0, 0, 0),
HireDate = DateTime.Now,
Gender = "M",
MaritalStatus = "M",
ModifiedDate = DateTime.Now,
NationalIDNumber = "2",
rowguid = new Guid(),
CurrentFlag = true,
VacationHours = 2,
SickLeaveHours = 3,
SalariedFlag = false,
LoginID = "adventure-works\\peter"
};
ITypeAdapter typeAdapter = new TypeAdapter();
employee = typeAdapter.Transform(employeeDto, employee);
Assert.NotNull(employee.Gender);
Assert.Equal(employee.Title, employeeDto.Title);
}
// Add POST: Employee/Post
public async Task<bool> Post(EmployeeDto value)
{
if (ModelState.IsValid)
{
return await ClientInvokeHttpPOST<EmployeeDto>(value);
}
return false;
}
public void TestFindEnties(EmployeeDto _EmployeeDto)
{
var _EmployeeBO = new EmployeeBO(new EmployeeConverter());
bool hasAdded = _EmployeeBO.CreateEntiy(_EmployeeDto);
var dbResult=_EmployeeBO.FindEnties(new PagedList<EmployeeDto> {_EmployeeDto});
Assert.NotNull(dbResult);
Assert.True(dbResult.Total>0);
}
public void Add(EmployeeDto employee)
{
Log.Debug(System.Reflection.MethodBase.GetCurrentMethod().Name +
"() traced. Added employee: " +
employee.FirstName + " " +
employee.LastName);
_repo.InsertEmployee(employee);
}
//Update PUT: Employee/Put/
public async Task<bool> Put(EmployeeDto value)
{
if (ModelState.IsValid)
{
return await ClientHTTPPut<EmployeeDto>(value);
}
return false;
}
/// <summary>
/// Converts the dto to entities.
/// </summary>
/// <param name="_EmployeeDto">The Employee dto</param>
/// <param name="efEmployee">已存在的Employee EF model</param>
/// <returns>Employee</returns>
public Employee ConvertDtoToEntities(EmployeeDto _EmployeeDto, Employee efEmployee)
{
if (_EmployeeDto==null && efEmployee==null)
{
throw new ArgumentNullException("models should not be null");
}
ConvertObject(_EmployeeDto, efEmployee);
return efEmployee;
}
/// <summary>
/// Converts the dto to entities.
/// </summary>
/// <param name="_ EmployeeDto">The Employee dto.</param>
/// <param name="ef Employee">已存的EntityFramework实体 ef Employee</param>
/// <param name="skipNullPropertyValue">if set to <c>true</c> [skip null property value].</param>
/// <returns>Employee</returns>
public Employee ConvertDtoToEntities(EmployeeDto _EmployeeDto, Employee efEmployee, bool skipNullPropertyValue)
{
if (_EmployeeDto==null && efEmployee==null)
{
throw new ArgumentNullException("models should not be null");
}
ConvertObjectWithCheckNull(_EmployeeDto, skipNullPropertyValue, efEmployee);
return efEmployee;
}
// GET: Employee/Find/?pageindex=1&pagesize=10&....
public async Task<JsonResult> Find(EmployeeDto _EmployeeDto,int pageIndex=1,int pageSize=10)
{
string pageQueryString = string.Empty;
//for EASYUI datagrid
if (Request["page"] != null)
{
pageIndex = Convert.ToInt32(Request["page"].ToString());
}
pageQueryString = string.Format("&pageIndex={0}&pageSize={1}", pageIndex, pageSize);
return Json(await ClientHTTPGetList<EasyuiDatagridData<EmployeeDto>, EmployeeDto>(_EmployeeDto, pageQueryString));
}
public async Task Edit(EmployeeDto employeeDto)
{
var employee = employeeRepository.All().Where(e => e.Id == employeeDto.Id).FirstOrDefault();
if (employeeDto.Id != 0 && employee != null)
{
if (employeeDto.IsActive == true)
{
await SetAllNonActive();
}
employee.FullName = employeeDto.FullName;
employee.IsActive = employeeDto.IsActive;
employeeRepository.Update(employee);
await employeeRepository.SaveChangesAsync();
}
}
/// <summary>
/// 社員データを登録する
/// </summary>
/// <param name="data">登録社員データ</param>
/// <returns>登録件数</returns>
public int ExecUpdate(EmployeeDto data)
{
if ( data == null )
throw new ArgumentNullException("data");
if ( data.Id.HasValue )
{
EmployeeDto e1 = _dao.GetData(data.Id.Value);
if ( e1 != null )
return ( _dao.UpdateData(data) );
else
return ( _dao.InsertData(data) );
}
else
{
return ( _dao.InsertData(data) );
}
}
/// <summary>Удаление сторудника из списка.</summary>
/// <param name="employee">Данные удаляемого сотрудника.
/// Должны полностью совпадать с имеющимся в списке.</param>
public void RemoveEmployee(EmployeeDto employee)
{
if (!employeesDict.TryGetValue(employee.Id, out EmployeeDto empl))
{
throw new ArgumentException("Сотрудника с таким ID нет.", nameof(employee));
}
if (empl.Name != employee.Name || empl.Position != employee.Position || empl.DateOfBirth != employee.DateOfBirth)
{
throw new ArgumentException("Несовпадают данные о сутруднике", nameof(employee));
}
// Удаление работника из приватного словаря.
employeesDict.Remove(employee.Id);
// Создание события, уведомляющего об удалении элемента из коллекции.
RaiseActionEmployees(ActionListEnum.Removed, empl);
}
// DataTableをEmployeeDtoに変換
private List <EmployeeDto> SetEmployeeDto(DataTable dt)
{
var list = new List <EmployeeDto>();
foreach (DataRow dr in dt.Rows)
{
EmployeeDto dto = new EmployeeDto
{
Code = int.Parse(dr["code"].ToString()),
Name = dr["name"].ToString(),
DepartmentCode = int.Parse(dr["departmentCode"].ToString()),
Password = dr["password"].ToString(),
AdminFlug = int.Parse(dr["adminFlug"].ToString())
};
list.Add(dto);
}
return(list);
}
public void Sack(EmployeeDto sackEmp)
{
_employees.BatchUpdate(updater =>
{
//assign new boss to the workers of the sacked employee
var workersWithNewBoss = updater.Items
.Where(emp => emp.BossId == sackEmp.Id)
.Select(dto => new EmployeeDto(dto.Id, dto.Name, sackEmp.BossId))
.ToArray();
updater.AddOrUpdate(workersWithNewBoss);
//get rid of the existing person
updater.Remove(sackEmp.Id);
});
}
public async Task <IActionResult> PostEmployee([FromBody] EmployeeDto employeeDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
await _employeesService.PostAsync(employeeDto, User);
}
catch (DbUpdateException e)
{
return(BadRequest(e.Message));
}
return(Ok());
}
public void ContractTypeIsShoterThen4ErrorExpected()
{
var employee = new EmployeeDto()
{
Id = 1,
Surname = "Duck",
Name = "Donald",
BirthDay = "1984-11-13",
StartDate = "2018-01-25",
ContractType = "PRM"
};
var addEmployeeValidator = new AddEmployeeValidator();
var result = addEmployeeValidator.Validate(employee);
Assert.AreEqual(result.Errors.Count, 1);
}
public void UpdateAParentNode()
{
_sourceCache.AddOrUpdate(CreateEmployees());
var changed = new EmployeeDto(1)
{
BossId = 0,
Name = "Employee 1 (with name change)"
};
_sourceCache.AddOrUpdate(changed);
_result.Count.Should().Be(2);
var firstNode = _result.Items.First();
firstNode.Children.Count.Should().Be(3);
firstNode.Item.Name.Should().Be(changed.Name);
}
public void Execute(string[] data)
{
if (data.Length != 1)
{
throw new ArgumentException("Invalid Command!");
}
int employeeId = int.Parse(data[0]);
EmployeeDto employee = this.employeeService.GetEmployeeInfo(employeeId);
if (employee == null)
{
throw new InvalidOperationException($"Employee with id {employeeId} not found!");
}
Console.WriteLine(employee.ToString());
}
/// <summary>
/// Add New Employee Details
/// </summary>
/// <param name="ImageFile"></param>
/// <param name="EmployeeDto"></param>
/// <returns></returns>
public bool AddEmployees(HttpPostedFileBase ImageFile, EmployeeDto EmployeeDto)
{
bool IsAdded = default(bool);
IsAdded = iEmployeeRepository.AddEmployees(ImageFile, new Employee
{
Name = EmployeeDto.Name,
DateOfBirth = EmployeeDto.DateOfBirth,
DateOfJoining = EmployeeDto.DateOfJoining,
Photo = EmployeeDto.Photo,
DepartmentId = EmployeeDto.DepartmentId,
MobileNumber = EmployeeDto.MobileNumber,
Address = EmployeeDto.Address,
Age = EmployeeDto.Age
});
return(IsAdded);
}
public async Task <EmployeeDto> UpdateEmployee()
{
int id = 28;
string responseBody = await this._clientService.GetResponse(localhostApi + "api/EmployeeApi/" + id, "", validJwt);
EmployeeDto employeeSearch = JsonConvert.DeserializeObject <EmployeeDto>(responseBody);
Employees employee = new Employees()
{
Surname = "Salfishn",
Name = "José",
Surname2 = "",
IdCard = "3333333333Z"
};
string responseBody2 = this._clientService.PutResponse(localhostApi + "api/EmployeeApi/" + id, JsonConvert.SerializeObject(employee), validJwt).GetAwaiter().GetResult();
EmployeeDto EmployeeDto = JsonConvert.DeserializeObject <EmployeeDto>(responseBody);
return(EmployeeDto);
}
public void UpdateAParentNode()
{
_sourceCache.AddOrUpdate(CreateEmployees());
var changed = new EmployeeDto(1)
{
BossId = 0,
Name = "Employee 1 (with name change)"
};
_sourceCache.AddOrUpdate(changed);
Assert.AreEqual(2, _result.Count);
var firstNode = _result.Items.First();
Assert.AreEqual(3, firstNode.Children.Count);
Assert.AreEqual(changed.Name, firstNode.Item.Name);
}
public void UpdateEmployee(int id, EmployeeDto employeeDto)
{
if (!ModelState.IsValid)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
var employeeInDb = _context.Employees.SingleOrDefault(c => c.Id == id);
if (employeeInDb == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
Mapper.Map(employeeDto, employeeInDb);
_context.SaveChanges();
}
public EmployeeDto ConvertToDto()
{
var result = new EmployeeDto();
result.Id = this.doctroId;
result.SiteId = this.hospId;
result.DeptId = this.deptId;
result.EmCode = this.doctroId;
result.EmName = this.doctorName;
result.IDNumber = this.idCard;
result.Phone = this.telphone;
result.TitleId = this.profTitle;
result.TitleName = this.GetTitleName();
result.Password = this.password;
result.Desc = this.type;
result.Disabled = this.hasFlag == "0";
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="employee"></param>
/// <returns></returns>
internal IDbQuery UpsertEmployee(EmployeeDto employee)
{
return(DbFluent.Upsert(Table <DbEmployee>())
.WithQueries(
DbFluent.UpdateQuery(Table <DbEmployee>())
.WithFields(q => new[]
{
DbFluent.FieldAsParameter(nameof(DbEmployee.Code), q.UseParameter("code", DataValueTypes.Text)),
DbFluent.FieldAsParameter(nameof(DbEmployee.ByteArrayField), q.UseParameter("ByteArrayField", DataValueTypes.Text)),
DbFluent.FieldAsParameter(nameof(DbEmployee.DoubleField), q.UseParameter("DoubleField", DataValueTypes.Text)),
DbFluent.FieldAsParameter(nameof(DbEmployee.DoubleField), q.UseParameter("DoubleField", DataValueTypes.Text)),
DbFluent.FieldAsParameter(nameof(DbEmployee.DateTimeField), q.UseParameter("DateTimeField", DataValueTypes.Text)),
DbFluent.FieldAsParameter(nameof(DbEmployee.LongField), q.UseParameter("LongField", DataValueTypes.Date))
}),
DbFluent.InsertQuery(Table <DbEmployee>())
.WithFields(q => new[]
{
DbFluent.FieldAsParameter(nameof(DbEmployee.Code), q.UseParameter("code", DataValueTypes.Text)),
DbFluent.FieldAsParameter(nameof(DbEmployee.ByteArrayField), q.UseParameter("ByteArrayField", DataValueTypes.Text)),
DbFluent.FieldAsParameter(nameof(DbEmployee.DoubleField), q.UseParameter("DoubleField", DataValueTypes.Text)),
DbFluent.FieldAsParameter(nameof(DbEmployee.DateTimeField), q.UseParameter("DateTimeField", DataValueTypes.Text)),
DbFluent.FieldAsParameter(nameof(DbEmployee.LongField), q.UseParameter("LongField", DataValueTypes.Date))
})
.WithParameters(
ElementFactory.CreateScalar("code", employee.Code),
ElementFactory.CreateScalar("ByteArrayField", employee.ByteArrayField),
ElementFactory.CreateScalar("DoubleField", employee.DoubleField),
ElementFactory.CreateScalar("DateTimeField", employee.DateTimeField),
ElementFactory.CreateScalar("LongField", employee.LongField)))
.WithCTE(
DbFluent.TableAsQuery(
DbFluent.SelectQuery(null)
.WithFields(q => new[]
{
DbFluent.FieldAsParameter(nameof(DbEmployee.Code), q.UseParameter("code", DataValueTypes.Text))
}))
.WithAlias("T"))
.WithParameters(
ElementFactory.CreateScalar("code", employee.Code),
ElementFactory.CreateScalar("ByteArrayField", employee.ByteArrayField),
ElementFactory.CreateScalar("DoubleField", employee.DoubleField),
ElementFactory.CreateScalar("DateTimeField", employee.DateTimeField),
ElementFactory.CreateScalar("LongField", employee.LongField)));
}
public EmployeeDto GetEmployee(int employeeId)
{
using (HeadSpringDb db = new HeadSpringDb())
{
EmployeeDto employeeDto = new EmployeeDto();
Employee employee = db.Employees.SingleOrDefault(x => x.EmployeeId == employeeId);
if (employee != null)
{
employeeDto = (from e in db.Employees
where e.EmployeeId == employeeId
select new EmployeeDto
{
EmployeeId = e.EmployeeId,
Name = e.Name,
LastName = e.LastName,
MotherLastName = e.MotherLastName,
Location = e.Location,
JobTitle = e.JobTitle,
Phone = e.Phone,
Email = e.Email,
Active = e.Active,
RequiresUser = false,
}).SingleOrDefault();
//Check if employee has a user
if (!string.IsNullOrEmpty(employee.UserId))
{
ApplicationDbContext context = new ApplicationDbContext();
var UserManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(context));
ApplicationUser user = UserManager.FindById(employee.UserId);
string roleId = user.Roles.SingleOrDefault().RoleId;
employeeDto.UserId = employee.UserId;
employeeDto.RoleName = (from r in db.AspNetRoles
where r.Id == roleId
select r).SingleOrDefault().Name;
employeeDto.RequiresUser = true;
}
}
return(employeeDto);
}
}
public Employees_tests()
{
_employeeController = new EmployeeController(_IEmployeeRepository.Object);
_employeeDto = new EmployeeDto()
{
Name = "Gvidas",
Surname = "Nor",
Address = "Sauletekio ave. 18., Vilnius",
BirthDate = DateTime.Now,
Email = "*****@*****.**",
Password = "******",
PersonalCode = "3888888878",
Phone = "8655547558",
EmploymentDate = DateTime.Now.ToString(),
Id = 2,
};
_employeeCreate = new EmployeeCreate()
{
Name = "Gvidas",
Surname = "Nor",
Address = "Sauletekio ave. 18., Vilnius",
BirthDate = DateTime.Now,
Email = "*****@*****.**",
Password = "******",
PersonalCode = "3888888878",
Phone = "8655547558",
EmploymentDate = DateTime.Now.ToString()
};
_employeeUpdate = new EmployeeUpdate()
{
Name = "Gvidas",
Surname = "Nor",
Address = "Sauletekio ave. 18., Vilnius",
BirthDate = DateTime.Now,
Email = "*****@*****.**",
Password = "******",
PersonalCode = "3888888878",
Phone = "8655547558",
EmploymentDate = DateTime.Now.ToString()
};
}
private async Task <EmployeViewModel> GetEmployeeViewModelAsync(EmployeeDto employee)
{
var employeeViewModel = new EmployeViewModel
{
Id = employee.Id,
FirstName = employee.FirstName,
LastName = employee.LastName,
ExperienceEmployee = employee.ExperienceEmployeeId,
VacationDays = employee.VacationDays,
Salary = employee.Salary,
CompanyName = employee.CompanyName,
OfficeId = employee.OfficeId,
CompanyId = employee.CompanyId,
CountryId = employee.CompanyId,
CityId = employee.CompanyId,
AllCompanies = (await this.companyService.GetAllAsync()).Select(company => new CompanyViewModel
{
Id = company.Id,
Name = company.Name,
CreationDate = company.CreationDate
}),
AllCountries = (await this.countryService.GetAllAsync()).Select(country => new CountryViewModel
{
Id = country.Id,
Name = country.Name,
}),
CitiesByCountry = employee.CountryId == 0 ?
Enumerable.Empty <CityViewModel>() :
(await this.cityService.GetAllByCountryIdAsync(employee.CountryId))
.Select(country => new CityViewModel
{
Id = country.Id,
Name = country.Name,
}),
AllOfficies = (await this.officeService.GetAllAsync()).Select(office => new OfficeViewModel
{
Id = office.Id,
Street = office.Street,
StreetNumber = office.StreetNumber
}),
};
return(employeeViewModel);
}
public async Task <ActionResult <Employee> > Update(int id, [FromBody] EmployeeDto employeeDto)
{
var existingEmp = await _repo.GetByIdAsync(id);
if (existingEmp == null)
{
return(NotFound());
}
_mapper.Map(employeeDto, existingEmp);
_repo.Update(existingEmp);
bool result = _repo.Save();
if (!result)
{
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
return(Ok(_mapper.Map <EmployeeDto>(existingEmp)));
}
public async Task SuccesfullDeleteEmployee()
{
var service = new ServiceCollection();
var kindOfIdService = new ServiceCollection();
service.ConfigurePersons(new DbSettings
{
ConnectionString = "Server = DESKTOP-QHO5U57\\MYSQLFORBLAZOR; Database=PersonsContactInfo;Trusted_Connection=True;"
});
kindOfIdService.ConfigureKindOfIdentification(new DbSettings
{
ConnectionString = "Server = DESKTOP-QHO5U57\\MYSQLFORBLAZOR; Database=PersonsContactInfo;Trusted_Connection=True;"
});
var provider = service.BuildServiceProvider();
var providerkindOfId = kindOfIdService.BuildServiceProvider();
var employeeService = provider.GetRequiredService <IEmployeeService>();
var KindOfIdService = providerkindOfId.GetRequiredService <IKindOfIdentificationService>();
var kindOfId = "Cedula";
var KindOfIdEntity = await KindOfIdService.GetOne(new KindOfIdentificationDto { IdentificationName = kindOfId });
var AddedEmployee = new EmployeeDto
{
EmployeeCode = Guid.NewGuid(),
KindOfPerson = "Natural",
AreaId = Guid.NewGuid(),
KindOfIdentificationId = KindOfIdEntity.KindOfIdentificationId,
DateOfBirth = DateTimeOffset.Now,
SignUpDate = DateTimeOffset.Now,
IdNumber = 5418498,
IdEmployee = Guid.NewGuid()
};
await employeeService.InsertEmployee(AddedEmployee);
var response = await employeeService.DeleteEmployee(AddedEmployee).ConfigureAwait(false);
Assert.True(response);
}
public async Task <HttpResponseMessage> Delete(int id)
{
EmployeeDto empdto = await employeeService.GetAsync(id);
if (empdto != null)
{
bool isDeleted = await employeeService.Delete(id);
if (isDeleted)
{
return(new HttpResponseMessage(HttpStatusCode.OK));
}
else
{
return(new HttpResponseMessage(HttpStatusCode.NotFound));
}
}
return(new HttpResponseMessage(HttpStatusCode.NotFound));
}
private static void ConvertObject(EmployeeDto _EmployeeDto, Employee efEmployee)
{
efEmployee.EmployeeID = _EmployeeDto.EmployeeID;
efEmployee.NationalIDNumber = _EmployeeDto.NationalIDNumber;
efEmployee.ContactID = _EmployeeDto.ContactID;
efEmployee.LoginID = _EmployeeDto.LoginID;
efEmployee.ManagerID = _EmployeeDto.ManagerID;
efEmployee.Title = _EmployeeDto.Title;
efEmployee.BirthDate = _EmployeeDto.BirthDate;
efEmployee.MaritalStatus = _EmployeeDto.MaritalStatus;
efEmployee.Gender = _EmployeeDto.Gender;
efEmployee.HireDate = _EmployeeDto.HireDate;
efEmployee.SalariedFlag = _EmployeeDto.SalariedFlag;
efEmployee.VacationHours = _EmployeeDto.VacationHours;
efEmployee.SickLeaveHours = _EmployeeDto.SickLeaveHours;
efEmployee.CurrentFlag = _EmployeeDto.CurrentFlag;
efEmployee.rowguid = _EmployeeDto.rowguid;
efEmployee.ModifiedDate = _EmployeeDto.ModifiedDate;
}
public async Task <bool> DeleteEmployee(EmployeeDto employee)
{
var EmployeeToDelete = await _employeeRepo.GetOne <EmployeeEntity>(x => x.IdEmployee == employee.IdEmployee).ConfigureAwait(false);
if (EmployeeToDelete != null)
{
try
{
await _employeeRepo.Delete(EmployeeToDelete);
return(true);
}
catch
{
return(false);
}
}
throw new NoExistingEmployee("El empleado que intenta eliminar no se encuentra registrado");
}
public IActionResult Update(int id, [FromBody] EmployeeDto employeeDto)
{
// map dto to entity and set id
var employee = _mapper.Map <Employee>(employeeDto);
employee.EmployeeId = id;
try
{
// save
_employeeRepository.UpdateEmployee(employee, employeeDto.Password);
return(Ok());
}
catch (Exception ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
public void UpdateChildNode()
{
_sourceCache.AddOrUpdate(CreateEmployees());
var changed = new EmployeeDto(2)
{
BossId = 1,
Name = "Employee 2 (with name change)"
};
_sourceCache.AddOrUpdate(changed);
_result.Count.Should().Be(2);
var changedNode = _result.Items.First().Children.Items.First();
changedNode.Parent.Value.Item.Id.Should().Be(1);
changedNode.Children.Count.Should().Be(1);
changed.Name.Should().Be(changed.Name);
}
/// <summary>
/// Updates an employee's information
/// </summary>
/// <param name="employee">The employee's new information</param>
/// <returns></returns>
public async Task UpdateEmployeeAsync(EmployeeDto employee)
{
using (var connection = _connectionProvider())
{
await connection.ExecuteAsync(
EmployeesQueries.UpdateEmployee,
new
{
employee.Matricule,
employee.FirstName,
employee.LastName,
employee.BirthDate,
employee.Email,
employee.Password
},
commandType : CommandType.StoredProcedure
).ConfigureAwait(false);
}
}
public async Task <IActionResult> Post([FromBody] EmployeeDto newEmployee)
{
if (ModelState.IsValid)
{
var newEmployeeForRepo = _mapper.Map <Employee>(newEmployee);
await _unitOfWork.Employees.Add(newEmployeeForRepo);
if (await _unitOfWork.Complete())
{
return(Created($"api/employees/{newEmployeeForRepo.Id}", _mapper.Map <EmployeeDto>(newEmployeeForRepo)));
}
else
{
return(BadRequest("Failed to save changes"));
}
}
return(BadRequest("Bad Data"));
}
public void TestMethodCreate()
{
OptionInstance.ConfigAutomapper();
EmployeeRepo repo = new EmployeeRepo(@"Persist Security Info=False;Integrated Security=true;Initial Catalog=RJD.Test;Server=localhost");
var createDto = new EmployeeDto
{
Id = Guid.NewGuid(),
Name = "Иван",
Surname = "Иванов"
};
repo.Create(createDto);
var readDto = repo.Read(createDto.Id);
Assert.AreEqual(readDto, createDto);
}
public async Task <IActionResult> AddEmployee(EmployeeDto data)
{
var emp = await _repo.GetEmployee(data.Nik, "");
if (emp != null)
{
return(BadRequest("NIK sudah terdaftar a.n. " + emp.ELEMNA));
}
var ehal = _mapper.Map <EHAL>(data);
_repo.Add <EHAL>(ehal);
if (await _repo.SaveAll())
{
return(Ok());
}
throw new Exception("Gagal menyimpan data");
}
public async Task <CustomResponse> Delete(Guid id)
{
EmployeeDto appDeviceDto = _unitOfWork.EmployeeRepository.Find(id);
if (appDeviceDto == null)
{
return(_responsMessages.EmployeeNotFound);
}
// should check if emplyee have some realted records in some other tables
// like this example
//if (_unitOfWork.VisitsRepository.Where(x => x.EmployeeId == appDeviceDto.Id).Count() > 0)
// return _responsMessages.EmployeeHasRelatedRecords; // badRequest
_unitOfWork.EmployeeRepository.Remove(appDeviceDto);
await _unitOfWork.SaveChangesAsync();
return(_responsMessages.EmployeeDeletedSuccessfully);
}
private EmployeeDto EmployeeDtoFactory(Pessoa pessoa, bool isActive = true)
{
EmployeeDto employeeDto = new EmployeeDto();
employeeDto.Id = pessoa.Id;
employeeDto.Name = pessoa.Nome;
employeeDto.Mail = pessoa.Email;
employeeDto.Address = new AddressDto();
employeeDto.Address.Neighborhood = pessoa.Bairro;
employeeDto.Address.Cep = pessoa.CEP;
employeeDto.Address.Street = pessoa.Logradouro;
employeeDto.Address.Number = pessoa.Numero;
employeeDto.Address.Additional = pessoa.Complemento;
employeeDto.Phone = new PhoneDto {
Ddd = pessoa.DDD, Number = pessoa.Telefone
};
employeeDto.isActive = isActive;
return(employeeDto);
}
public bool UpdateEmployee(EmployeeDto employee)
{
Employee emp = new Employee();
emp.FirstName = employee.FirstName;
emp.LastName = employee.LastName;
emp.RegistrationNo = employee.RegistrationNo;
emp.Gender = employee.Gender;
emp.Address = employee.Address;
emp.ContactInfo = employee.ContactInfo;
emp.Birthdate = employee.Birthdate;
emp.ImgUrl = employee.ImgUrl;
emp.CreatedOn = employee.CreatedOn;
emp.PoistionId = Int32.Parse(employee.PositionId);
emp.EmployeeId = Int32.Parse(employee.EmployeeId);
_PayRollManagmentContext.Update(emp);
return(Save());
}
/// <summary>
/// Creates the dto.
/// </summary>
/// <returns></returns>
private EmployeeDto CreateDTO()
{
var employee = new EmployeeDto
{
ManagerID = 2,
ContactID = 3,
Title = "Developer",
BirthDate = new DateTime(1965, 1, 1, 0, 0, 0),
HireDate = DateTime.Now,
Gender = "M",
MaritalStatus = "M",
ModifiedDate = DateTime.Now,
NationalIDNumber = DateTime.Now.ToString("hhmmddss"),
rowguid = Guid.NewGuid(),
CurrentFlag = true,
VacationHours = 2,
SickLeaveHours = 3,
SalariedFlag = false,
LoginID = "peter"+DateTime.Now.Ticks.ToString()
};
return employee;
}
public void TestEditService()
{
Include(PATH);
IEmployeeEditService service = (IEmployeeEditService) GetComponent(typeof (IEmployeeEditService));
Assert.IsNotNull(service, "NotNull");
EmployeeDto data = service.GetData(3);
Assert.AreEqual(3, data.Id.Value, "Id");
Assert.AreEqual("佐藤愛子", data.Name, "Name");
Assert.AreEqual("010003", data.Code, "Code");
Assert.AreEqual(2, data.Gender, "Gender");
Assert.AreEqual(new DateTime(2001, 4, 1, 0, 0, 0),
data.EntryDay.Value, "Entry");
Assert.AreEqual(1, data.DeptNo.Value, "DeptNo");
Assert.AreEqual(1, data.Department.Id.Value, "Dept.No");
Assert.AreEqual("営業部", data.Department.Name, "Dept.Name");
Assert.AreEqual("0001", data.Department.Code, "Dept.Code");
Assert.AreEqual("営業部", data.DeptName, "DeptName");
// 挿入のテスト
data = new EmployeeDto();
data.Code = "060006";
data.Name = "後藤六郎";
data.EntryDay = new DateTime(2006, 4, 1, 0, 0, 0);
data.Gender = 1;
data.DeptNo = 1;
Assert.AreEqual(1, service.ExecUpdate(data), "Insert");
// 更新のテスト
data = new EmployeeDto();
data.Id = 2;
data.Code = "999999";
data.Name = "鈴木二郎";
data.EntryDay = new DateTime(1999, 5, 1, 0, 0, 0);
data.Gender = 1;
data.DeptNo = 2;
Assert.AreEqual(1, service.ExecUpdate(data), "Update");
data = service.GetData(2);
Assert.AreEqual(2, data.Id.Value, "Id");
Assert.AreEqual("鈴木二郎", data.Name, "Name");
Assert.AreEqual("999999", data.Code, "Code");
Assert.AreEqual(1, data.Gender, "Gender");
Assert.AreEqual(new DateTime(1999, 5, 1, 0, 0, 0),
data.EntryDay.Value, "Entry");
Assert.AreEqual(2, data.DeptNo.Value, "DeptNo");
Assert.AreEqual(2, data.Department.Id.Value, "Dept.No");
Assert.AreEqual("技術部", data.Department.Name, "Dept.Name");
Assert.AreEqual("0002", data.Department.Code, "Dept.Code");
Assert.AreEqual("技術部", data.DeptName, "DeptName");
}
public void TestInsertOfDao()
{
Include(PATH);
IEmployeeDao dao = (IEmployeeDao) GetComponent(typeof (IEmployeeDao));
Assert.IsNotNull(dao, "NotNull");
// 挿入のテスト
EmployeeDto data = new EmployeeDto();
data.Code = "060006";
data.Name = "後藤六郎";
data.EntryDay = new DateTime(2006, 4, 1, 0, 0, 0);
data.Gender = 1;
data.DeptNo = 1;
Assert.AreEqual(1, dao.InsertData(data), "Insert");
// 更新のテスト
int id = dao.GetId("060006");
data.Id = id;
data.Code = "060006";
data.Name = "五島六郎";
data.EntryDay = new DateTime(2006, 4, 1, 0, 0, 0);
data.Gender = 1;
data.DeptNo = 2;
Assert.AreEqual(1, dao.UpdateData(data), "Update");
data = dao.GetData(id);
Assert.AreEqual(id, data.Id.Value, "Id");
Assert.AreEqual("五島六郎", data.Name, "Name");
Assert.AreEqual("060006", data.Code, "Code");
Assert.AreEqual(1, data.Gender, "Gender2");
Assert.AreEqual(new DateTime(2006, 4, 1, 0, 0, 0),
data.EntryDay.Value, "Entry");
Assert.AreEqual(2, data.DeptNo.Value, "DeptNo");
Assert.AreEqual(2, data.Department.Id.Value, "Dept.No2");
Assert.AreEqual("技術部", data.Department.Name, "Dept.Name2");
Assert.AreEqual("0002", data.Department.Code, "Dept.Code2");
// 削除のテスト
data = new EmployeeDto();
data.Id = id;
Assert.AreEqual(1, dao.DeleteData(data), "Delete");
IList<EmployeeDto> list = dao.GetAll();
Assert.AreEqual(5, list.Count, "Count");
}
public void Post(EmployeeDto value)
{
_EmployeeBO.CreateEntiy(value);
}
/// <summary>
/// 社員データを削除する
/// </summary>
/// <param name="id">削除社員ID</param>
/// <returns>削除件数</returns>
public int ExecDelete(int id)
{
EmployeeDto data = new EmployeeDto();
data.Id = id;
return ( _dao.DeleteData(data) );
}
public bool Post(EmployeeDto value)
{
return _EmployeeBO.CreateEntiy(value);
}
/// <summary>
/// Gets the specified identifier.
/// </summary>
/// <param name="id">The identifier.</param>
/// <example><code>GET: api/Employee/5</code></example>
/// <returns>EmployeeDto</returns>
public EmployeeDto Get(Int32 id)
{
var dtoEntity = new EmployeeDto() { EmployeeID=id};
return _EmployeeBO.GetEntiyByPK(dtoEntity);
}
// DELETE: api/Employee/5
public bool Delete(int id)
{
var entity = new EmployeeDto() { EmployeeID = id };
return _EmployeeBO.DeleteWithAttachEntiy(entity);
}
public bool Put(EmployeeDto value)
{
return _EmployeeBO.UpdateWithAttachEntiy(value);
}
/// <summary>
/// Updates the with attach entiy asynchronous.
/// </summary>
/// <param name="tDTo">The t d to.</param>
/// <returns></returns>
public async Task<int> UpdateWithAttachEntiyAsync(EmployeeDto tDTo)
{
var dbentity = typeAdapter.ConvertDtoToEntities(tDTo);
if (StateHelpers.GetEquivalentEntityState(dbentity.State) == StateHelpers.GetEquivalentEntityState(State.Detached))
{
entiesrepository.Attach(dbentity);
}
dbentity.State = State.Modified;
context.ChangeObjectState<Employee>(dbentity, StateHelpers.GetEquivalentEntityState(dbentity.State));
return await uow.SaveAsync();
}
public void Put(EmployeeDto value)
{
_EmployeeBO.UpdateWithAttachEntiy(value);
}
public void TransformDTOToEmployee()
{
var adapter = new EmployeeAdapter();
var employee = new EmployeeDto()
{
EmployeeID = 1,
LoginID = "petter"
,ContactID = 12
,
EmployeePayHistoriess = new List<EmployeePayHistoryDto>()
{
new EmployeePayHistoryDto()
{
EmployeeID = 1,
ModifiedDate = DateTime.Now
}
}.ToArray()
};
var dto = adapter.Transform<EmployeeDto, Employee>(employee);
Assert.Equal(employee.EmployeeID, dto.EmployeeID);
Assert.Equal(employee.LoginID, dto.LoginID);
}
// DELETE: api/Employee/5
public void Delete(int id)
{
var entity = new EmployeeDto() { EmployeeID = id };
_EmployeeBO.DeleteWithAttachEntiy(entity);
}
/// <summary>
/// Updates the entiy with get asynchronous.
/// </summary>
/// <param name="entity">The entity.</param>
/// <returns></returns>
public async Task<int> UpdateEntiyWithGetAsync(EmployeeDto entity)
{
var dbEntity = entiesrepository.Repository.Single(e => e.EmployeeID == entity.EmployeeID);
dbEntity = typeAdapter.ConvertDtoToEntities(entity, dbEntity, skipNullPropertyValue: true);
return await uow.SaveAsync();
}
/// <summary>
/// Creates the DTO.
/// </summary>
/// <returns>EmployeeDto</returns>
private EmployeeDto CreateDTO()
{
var employee = new EmployeeDto
{
ManagerID = 2,
ContactID = 3,
Title = "Developer",
BirthDate = new DateTime(1965, 1, 1, 0, 0, 0),
HireDate = DateTime.Now,
Gender = "M",
MaritalStatus = "M",
ModifiedDate = DateTime.Now,
NationalIDNumber = "2",
rowguid = new Guid(),
CurrentFlag = true,
VacationHours = 2,
SickLeaveHours = 3,
SalariedFlag = false,
LoginID = "adventure-works\\peter"
};
return employee;
}
