public async Task <ResourceResult <EmployeeResource> > UpsertAsync(EmployeeResource resource) { var result = new ResourceResult <EmployeeResource>(); // Beautify before validation and make validation more succesfull BeautifyResource(resource); // save beautify effect effect result.Resource = resource; // Apply simple validation on attribute level ValidateAttributes(resource, result.Errors); // Apply complex business rules validation ValidateBusinessRules(resource, result.Errors); // Save is only usefull when error free if (result.Errors.Count == 0) { // Convert resource to entity var entity = mapper.Map <Employee>(resource); // save entity await EntityContext.UpsertAsync(entity); // convert save result back to resource and get database created values like auto incremental field and timestamps. result.Resource = mapper.Map <EmployeeResource>(entity); } return(result); }
private String RemoveSensitiveFields(EmployeeResource resource) { // The dynamic Linq Select(params) works only on an IQueryable list // thats why 1 one item is added to a list var items = new List <EmployeeResource>(new[] { resource }).AsQueryable(); // Find all property names var propertyNames = resource.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance).Select(p => p.Name).ToList(); // Salary only visible to HR department if (!User.HasClaim("Department", "HR")) { propertyNames.Remove(nameof(EmployeeResource.Salary)); } // Dynamic Linq supports dynamic selector var selector = $"new({String.Join(",", propertyNames)})"; // Create dynamic object with authorized fields var reducedResource = items.Select(selector).First(); // Create JSON var result = JsonConvert.SerializeObject(reducedResource, new JsonSerializerSettings() { Formatting = Formatting.Indented }); return(result); }
public async Task <IActionResult> Post([FromBody] EmployeeResource resource) { try { // Create rescource var serviceResult = await ResourceService.InsertAsync(resource); // if return error message if needed if (serviceResult.Errors.Count > 0) { return(BadRequest(serviceResult)); } // On succes return url with id and newly created resource return(CreatedAtAction(nameof(Get), new { id = serviceResult.Resource.Id }, serviceResult.Resource)); } catch (Exception ex) { var result = new ResourceResult <EmployeeResource>(resource); while (ex != null) { result.Exceptions.Add(ex.Message); } return(BadRequest(result)); } }
public async Task <ActionResult <Employee> > UpdateEmployee(Guid id, EmployeeResource resource) { Employee employee = await _context.Employees .Include(e => e.EmployeeSkill).ThenInclude(e => e.Skill) .FirstOrDefaultAsync(e => e.Id == id); if (employee == null) { return(NotFound()); } _mapper.Map(resource, employee); employee.FullName = employee.Name + " " + employee.Surname; employee.UpdateDate = DateTime.Now; employee.Age = DateTime.Today.Year - employee.DateOfBirth.Year; if (employee.EmployeeSkill.Count > 0) { _context.EmployeeSkills.RemoveRange(employee.EmployeeSkill); } if (resource.Skills.Count > 0) { foreach (var skill in resource.Skills) { _context.EmployeeSkills.Add(new EmployeeSkill { EmployeeId = employee.Id, SkillId = skill.Id }); } } await _context.SaveChangesAsync(); return(Ok(employee)); }
public async Task <ActionResult <List <Employee> > > CreateEmployees(EmployeeResource resource) { var newEmployee = _mapper.Map <EmployeeResource, Employee>(resource); newEmployee.Id = Guid.NewGuid(); newEmployee.FullName = newEmployee.Name + " " + newEmployee.Surname; newEmployee.CreationDate = DateTime.Now; newEmployee.UpdateDate = DateTime.Now; newEmployee.Age = DateTime.Today.Year - resource.DateOfBirth.Year; if (resource.Skills.Count > 0) { foreach (var skill in resource.Skills) { _context.EmployeeSkills.Add(new EmployeeSkill { EmployeeId = newEmployee.Id, SkillId = skill.Id }); } } await _context.AddAsync(newEmployee); await _context.SaveChangesAsync(); return(Ok(newEmployee)); }
// Werte setzen public void InitialSet() { UpdateFunctionList(); // Wenn keine personelle Ressource ausgewählt: Erstellen if (selectedVEmployeeResource == null) { CreateFieldsEnabled = true; SetFieldsEnabled = false; btnCreateOrSetEmployeeResourceName = "Erstellen"; } else { // Wenn personelle Ressource ausgewählt: Updaten CreateFieldsEnabled = false; SetFieldsEnabled = true; // View Obj in richtiges EmployeeResource umwandeln selectedEmployeeResource = new EmployeeResource(selectedVEmployeeResource.Id, selectedVEmployeeResource.BudgetTime, selectedVEmployeeResource.EffectiveTime, selectedVEmployeeResource.Deviation, selectedVEmployeeResource.FunctionId, selectedVEmployeeResource.ActivityId); txtPlannedTime = selectedEmployeeResource.BudgetTime; txtEffectiveTime = selectedEmployeeResource.EffectiveTime; txtDeviation = selectedEmployeeResource.Deviation; btnCreateOrSetEmployeeResourceName = "Setzen"; } }
public async Task <EmployeeResource> ReplaceAsync(int id, EmployeeResource resource) { Employee entity = await FindAsync(id); Mapper.Map(resource, entity); await _db.SaveChangesAsync(); return(ToResource(entity)); }
public async Task <EmployeeResource> AddAsync(EmployeeResource resource) { Employee entity = ToEntity(resource); _db.Employees.Add(entity); await _db.SaveChangesAsync(); return(ToResource(entity)); }
public EmployeeResource Create() { var result = new EmployeeResource() { Id = Guid.NewGuid() }; return(result); }
public async Task <IHttpActionResult> PostEmployee(EmployeeResource resoure) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } EmployeeResource result = await _employeesService.AddAsync(resoure); return(CreatedAtRoute("DefaultApi", new { id = result.Id }, result)); }
/// <summary> /// Perform basic validation /// </summary> /// <param name="resource"></param> /// <param name="errors"></param> protected void ValidateAttributes(EmployeeResource resource, IList <ValidationError> errors) { var validationContext = new System.ComponentModel.DataAnnotations.ValidationContext(resource); var validationResults = new List <ValidationResult>();; Validator.TryValidateObject(resource, validationContext, validationResults, true); foreach (var item in validationResults) { errors.Add(new ValidationError(item.ErrorMessage, item.MemberNames?.FirstOrDefault() ?? "")); } }
public async Task <ResourceResult <EmployeeResource> > InsertAsync(EmployeeResource resource) { // Fields are set by persistance service resource.CreatedBy = null; resource.ModifiedAt = null; resource.ModifiedBy = null; resource.RowVersion = null; return(await UpsertAsync(resource)); }
public async Task <IHttpActionResult> PutEmployee(int id, EmployeeResource resource) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } resource.Id = id; await _employeesService.ReplaceAsync(id, resource); return(StatusCode(HttpStatusCode.NoContent)); }
public async Task <IHttpActionResult> GetEmployee(int id) { try { EmployeeResource resource = await _employeesService.SingleAsync(id); return(Ok(resource)); } catch (KeyNotFoundException) { return(NotFound()); } }
public async Task <IActionResult> CreateEmployee([FromBody] EmployeeResource employeeResource) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var employee = mapper.Map <EmployeeResource, Employee>(employeeResource); context.Employees.Add(employee); await context.SaveChangesAsync(); return(Ok(employee)); }
public async Task <IActionResult> Edit(int id, [FromForm] EmployeeResource employeeResource) { if (!ModelState.IsValid) { return(View(employeeResource)); } var response = await _service.Put(id, employeeResource, _appSetings.RestApiUrl); if (!response.Success) { ModelState.AddModelError("Email", response.Message); return(View(employeeResource)); } return(RedirectToAction("Index")); }
public async Task <IActionResult> UpdateEmployee(int id, [FromBody] EmployeeResource employeeResource) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var employee = await context.Employees.FindAsync(id); if (employee == null) { return(NotFound()); } mapper.Map <EmployeeResource, Employee>(employeeResource, employee); await context.SaveChangesAsync(); return(Ok(employee)); }
public void CreateEmployee(UserResource createdUser) { var siteId = GetSiteID(); var siteAssignments = CreateEmployeeSiteAssignmentCollection(createdUser, StartDate, siteId); var jobAssignments = CreateEmployeeJobAssignments(createdUser, StartDate, siteId); var employeeStatuses = CreateEmployeeStatusCollection(createdUser, siteId, StartDate); var scheduleConstraints = CreateEmployeeScheduleConstraintsList(createdUser, siteId); var employee = new EmployeeResource { SeniorityDate = StartDate, MinorStatus = "NotMinor", PunchValidationCode = "NoScheduleValidation", GenerateException = true, EmployeeSiteAssignmentCollection = siteAssignments, IsManagement = false, EmployeeJobAssignments = jobAssignments, ManagerInSchedule = false, ID = createdUser.ID, BadgeNumber = createdUser.ID.ToString(), SchoolDistrictID = null, SchedulingTypeCode = "Manual", IgnoreBiometricValidation = false, PayGroupID = null, CanWorkUnassignedJobs = false, PayrollSystemNumber = null, ManagerPassword = null, GenerateAlerts = false, BirthDate = "1992-09-02T00:00:00", EmployeeStatuses = employeeStatuses, EmployeeScheduleConstraints = scheduleConstraints, HireDate = StartDate }; try { _Client.Create(HttpMethod.Post, EmployeeApi, employee).Wait(); Console.WriteLine("Employee " + createdUser.Name.FirstName + " " + createdUser.Name.LastName + " was created"); } catch (AggregateException aggregateException) { aggregateException.Handle(HandleCreationException); } }
public async Task <IActionResult> AddEmployee([FromBody] EmployeeResource empResource) { if (!ModelState.IsValid) { return(BadRequest(ModelState.GetErrorMessages())); } var isEmailUsed = await _service.FindEmployeeByEmail(empResource.Email); if (isEmailUsed.Success) { return(Conflict("Esse email já foi utilizado.")); } var employee = _converter.ConvertToModel(empResource); var result = await _service.AddEmployee(employee); if (!result.Success) { return(BadRequest(result.Message)); } return(Ok(result.Employee)); }
public async Task <IActionResult> Put([FromBody] EmployeeResource resource) { try { var currentResource = await ResourceService.FindAsync(resource.Id); if (currentResource == null) { return(NotFound()); } var serviceResult = await ResourceService.UpdateAsync(resource); if (serviceResult.Errors.Count > 0) { return(BadRequest(serviceResult)); } return(Ok(serviceResult.Resource)); } catch (Exception ex) { var result = new ResourceResult <EmployeeResource>(resource); while (ex != null) { result.Exceptions.Add(ex.Message); if (ex is ConcurrencyException) { return(StatusCode(HttpStatusCode.Conflict.ToInt32(), result)); } ex = ex.InnerException; } return(BadRequest(result)); } }
protected virtual void ValidateDelete(EmployeeResource resource, IList <ValidationError> errors) { }
public async Task <IEnumerable <EmployeeResource> > GetEmployee(EmployeeResource employeeResource) { var employee = await context.Employees.ToListAsync(); return(mapper.Map <IEnumerable <Employee>, IEnumerable <EmployeeResource> >(employee)); }
public async Task <ResourceResult <EmployeeResource> > UpdateAsync(EmployeeResource resource) { return(await UpsertAsync(resource)); }
protected virtual void BeautifyResource(EmployeeResource resource) { }
protected virtual void ValidateBusinessRules(EmployeeResource resource, IList <ValidationError> errors) { }
private static Employee ToEntity(EmployeeResource resource) { return(Mapper.Map <Employee>(resource)); }
public void RunBeforeTests() { _resource = new EmployeeResource(_token); }