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