public void GetUserDetailsCreatedBeforeToday() { List <EmployeeModel> employeeList = new List <EmployeeModel>(); Function function = new Function(); QueryBuilderRequest employeeRequest = new QueryBuilderRequest { CompanyId = 6, UserId = 111, Payload = new QueryBuilderRequest { ColumnList = DefaultColumnsList, Fields = employeeList, EntityName = "Employee", AppType = Constants.QUERY_BUILDER } }; EmployeeModel employeeModel1 = new EmployeeModel { Name = Constants.USER_CREATED_DATE, Value = "04/22/2019", Operator = "<" }; employeeList.Add(employeeModel1); EmployeeResponse usersResponse = function.GetEmployeesQueryBuilder(employeeRequest, null); List <EmployeeQueryModel> userResponse = usersResponse.Employees; Assert.AreNotEqual(0, userResponse.Count); }
public void GetUsersWithSpecificRole() { List <EmployeeModel> employeeList = new List <EmployeeModel>(); Function function = new Function(); QueryBuilderRequest employeeRequest = new QueryBuilderRequest { CompanyId = 6, UserId = 111, Payload = new QueryBuilderRequest { ColumnList = DefaultColumnsList, Fields = employeeList, EntityName = "Employee", AppType = Constants.QUERY_BUILDER } }; EmployeeModel employeeModel1 = new EmployeeModel { Name = Constants.ROLE, Value = Constants.SUPERVISOR, Operator = "=" }; employeeList.Add(employeeModel1); EmployeeResponse usersResponse = function.GetEmployeesQueryBuilder(employeeRequest, null); List <EmployeeQueryModel> userResponse = usersResponse.Employees; Assert.AreNotEqual(0, userResponse.Count); Assert.IsTrue(userResponse[0].Role.ToUpper() == Constants.SUPERVISOR); }
public void RetrieveEmployeeMetricsFail() { var testEmail = "*****@*****.**"; var empService = new Mock <IEmployeeService>(); EmployeeResponse mockRes = null; // Return a null response from service call empService.Setup(serv => serv.RetrieveEmployeeMetrics(It.IsAny <string>())).Returns(mockRes); var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[] { new Claim(ClaimTypes.Name, "test"), new Claim(ClaimTypes.NameIdentifier, "1"), new Claim("email", testEmail), }, "mock")); var controller = new EmployeeController(empService.Object); controller.ControllerContext = new ControllerContext() { HttpContext = new DefaultHttpContext() { User = user } }; var result = controller.GetEmployeeMetrics().Result; var notFoundResult = result as NotFoundResult; Assert.NotNull(notFoundResult); Assert.Equal(404, notFoundResult.StatusCode); empService.Verify(x => x.RetrieveEmployeeMetrics(It.IsAny <string>()), Times.Once); }
//[HttpGet] public async Task <IEnumerable <EmployeeResponse> > Gettblemployee() { List <EmployeeResponse> EmployeeResponseList = new List <EmployeeResponse>(); List <Employee> list = new List <Employee>(); var o = _context.tblemployee; list = _context.tblemployee.ToList <Employee>(); for (int i = 0; i < list.Count; i++) { try { var document = await _context.document.FirstOrDefaultAsync(x => x.IDEmployee == list[i].ID); EmployeeResponse obj = new EmployeeResponse(); obj.employee = list[i]; obj.fileToUpload = document; EmployeeResponseList.Add(obj); } catch (Exception ex) { System.Console.WriteLine(ex.ToString()); } } return(EmployeeResponseList); }
public async Task <bool> UpdateEmployeeAsync(EmployeeResponse employeeViewModel, CancellationToken ct = default) { var employee = await _employeeRepository.GetByIdAsync(employeeViewModel.EmployeeId, ct); if (employee == null) { return(false); } employee.EmployeeId = employeeViewModel.EmployeeId; employee.LastName = employeeViewModel.LastName; employee.FirstName = employeeViewModel.FirstName; employee.Title = employeeViewModel.Title; employee.ReportsTo = employeeViewModel.ReportsTo; employee.BirthDate = employeeViewModel.BirthDate; employee.HireDate = employeeViewModel.HireDate; employee.Address = employeeViewModel.Address; employee.City = employeeViewModel.City; employee.State = employeeViewModel.State; employee.Country = employeeViewModel.Country; employee.PostalCode = employeeViewModel.PostalCode; employee.Phone = employeeViewModel.Phone; employee.Fax = employeeViewModel.Fax; employee.Email = employeeViewModel.Email; return(await _employeeRepository.UpdateAsync(employee, ct)); }
public async Task <EmployeeResponse> AddEmployeeAsync(EmployeeResponse newEmployeeViewModel, CancellationToken ct = default) { var employee = new Employee { LastName = newEmployeeViewModel.LastName, FirstName = newEmployeeViewModel.FirstName, Title = newEmployeeViewModel.Title, ReportsTo = newEmployeeViewModel.ReportsTo, BirthDate = newEmployeeViewModel.BirthDate, HireDate = newEmployeeViewModel.HireDate, Address = newEmployeeViewModel.Address, City = newEmployeeViewModel.City, State = newEmployeeViewModel.State, Country = newEmployeeViewModel.Country, PostalCode = newEmployeeViewModel.PostalCode, Phone = newEmployeeViewModel.Phone, Fax = newEmployeeViewModel.Fax, Email = newEmployeeViewModel.Email }; employee = await _employeeRepository.AddAsync(employee, ct); newEmployeeViewModel.EmployeeId = employee.EmployeeId; return(newEmployeeViewModel); }
public async Task <ActionResult <EmployeeResponse> > Put(int id, [FromBody] EmployeeResponse input, CancellationToken ct = default) { try { if (input == null) { return(BadRequest()); } if (await _chinookSupervisor.GetEmployeeByIdAsync(id, ct) == null) { return(NotFound()); } var errors = JsonConvert.SerializeObject(ModelState.Values .SelectMany(state => state.Errors) .Select(error => error.ErrorMessage)); Debug.WriteLine(errors); if (await _chinookSupervisor.UpdateEmployeeAsync(input, ct)) { return(Ok(input)); } return(StatusCode(500)); } catch (Exception ex) { return(StatusCode(500, ex)); } }
public void SmartParamCombinationTest() { List <EmployeeModel> employeeList = new List <EmployeeModel>(); Function function = new Function(); QueryBuilderRequest employeeRequest = new QueryBuilderRequest { CompanyId = 6, UserId = 111, Payload = new QueryBuilderRequest { ColumnList = DefaultColumnsList, Fields = employeeList, EntityName = "Employee", AppType = Constants.QUERY_BUILDER } }; EmployeeModel employeeModel1 = new EmployeeModel { Name = Constants.DEPARTMENT, Value = Constants.YES, Operator = "=" }; employeeList.Add(employeeModel1); EmployeeResponse usersResponse = function.GetEmployeesQueryBuilder(employeeRequest, null); List <EmployeeQueryModel> userResponse = usersResponse.Employees; Assert.AreNotEqual(0, userResponse.Count); }
public void RetrieveEmployeeMetricsSuccess() { System.DateTime dt = new System.DateTime(); List <EmployeeMetrics> dbRetVal = new List <EmployeeMetrics>() { new EmployeeMetrics("lol1", "lol2", "lol3", 1.0, 2.0, 3.0, 4.0, 5.0, dt), new EmployeeMetrics("lul", "lul", "lul", 2.0, 2.0, 2.0, 2.0, 2.0, dt) }; MockServiceProvider serviceProvider = new MockServiceProvider() .AddMockDBConnection(); serviceProvider.MockDBConnection .Setup(_ => _.ExecuteQuery <EmployeeMetrics>(QueryGenerator.GetEmployeeMetricsHeader() + QueryGenerator.WhereEmail("*****@*****.**"))) .Returns(dbRetVal); EmployeeService employeeService = new EmployeeService(serviceProvider.Build()); EmployeeResponse response = employeeService.RetrieveEmployeeMetrics("*****@*****.**"); Assert.Equal("lol1", response.EmployeeId); Assert.Equal(3.0, response.Billable.CurrentHours); Assert.Equal(2.0, response.Billable.CurrentTarget); Assert.Equal(1.0, response.Billable.TotalTarget); Assert.Equal(-1.0, response.Growth.HoursRemaining); Assert.Equal(5.0, response.Growth.HoursUsed); Assert.Equal(4.0, response.Growth.TotalGrowth); }
public override async Task <EmployeeResponse> Save(EmployeeRequest request, ServerCallContext context) { try { var metadata = context.RequestHeaders; foreach (var pair in metadata) { _logger.LogInformation($"{pair.Key}: {pair.Value}"); } InMemoryData.Employees.Add(request.Employee); var response = new EmployeeResponse { Employee = InMemoryData.Employees.SingleOrDefault(x => x.No == request.Employee.No) }; Console.WriteLine("Employees:"); foreach (var employee in InMemoryData.Employees) { Console.WriteLine(employee); } return(await Task.FromResult(response)); } catch (RpcException re) { throw; } catch (Exception e) { _logger.LogError(e.Message); throw new RpcException(Status.DefaultCancelled, e.Message); } }
public IEnumerable <EmployeeResponse> GetEmployees( int departmentId, bool includeDepartment) => this .repository .GetEmployees(departmentId, includeDepartment) .Select(x => EmployeeResponse.FromEmployee(x, includeDepartment)) .ToArray();
/// <summary> /// [QueryBuilder] Function to get list of employee(s) filtered with some condition(s) /// </summary> /// <param name="queryBuilderRequest"></param> /// <param name="context"></param> /// <returns>EmployeeResponse</returns> public EmployeeResponse GetEmployeesQueryBuilder(QueryBuilderRequest queryBuilderRequest, ILambdaContext context = null) { EmployeeRepository employeeRepository = new EmployeeRepository(); EmployeeResponse employeeResponse = new EmployeeResponse(); Authorizer authorizer = new Authorizer(); try { //Validating the student details string studentDetails = queryBuilderRequest.Payload.Fields.Where(x => x.Name.ToUpper() == Constants.STUDENT_DETAILS).Select(x => x.Value).FirstOrDefault(); if (authorizer.ValidateUser(queryBuilderRequest.UserId, queryBuilderRequest.CompanyId, queryBuilderRequest.Payload.AppType, studentDetails)) { return(employeeRepository.GetEmployeeDetails(queryBuilderRequest)); } else { employeeResponse.Error = ResponseBuilder.Forbidden(); return(employeeResponse); } } catch (Exception getEmployeesException) { LambdaLogger.Log(getEmployeesException.ToString()); employeeResponse.Error = ResponseBuilder.InternalError(); return(employeeResponse); } }
public async Task <ActionResult <EmployeeResponse> > GetEmployeeByIdAsync(Guid id) { var employee = await _employeeRepository.GetByIdAsync(id); if (employee == null) { return(NotFound()); } var employeeModel = new EmployeeResponse() { Id = employee.Id, Email = employee.Email, Role = new RoleItemResponse() { Id = employee.Id, Name = employee.Role.Name, Description = employee.Role.Description }, FullName = employee.FullName, AppliedPromocodesCount = employee.AppliedPromocodesCount }; return(employeeModel); }
/// <summary> /// 一元操作演示 —— 根据id获取员工数据 /// </summary> /// <param name="request"></param> /// <param name="context"></param> /// <returns></returns> public override async Task <EmployeeResponse> GetEmployeeById(GetEmployeeByIdRequest request, ServerCallContext context) { //读取请求头中的元数据(应用层自定义的 key-value 对) var metaDataIdHeaders = context.RequestHeaders; foreach (var data in metaDataIdHeaders) { Console.WriteLine($"{data.Key} => {data.Value}"); } //根据请求的Id找到员工信息 var employee = EmployeeRepository.Emloyees.SingleOrDefault(emp => emp.Id == request.Id); if (employee == null) { throw new RpcException(Status.DefaultSuccess , $"Employee of {request.Id} is not found"); } var response = new EmployeeResponse { Employee = employee }; return(await Task.FromResult(response)); }
public void RequestWithoutColumnsList() { List <EmployeeModel> employeeList = new List <EmployeeModel>(); Function function = new Function(); QueryBuilderRequest employeeRequest = new QueryBuilderRequest { CompanyId = 6, UserId = 6, Payload = new QueryBuilderRequest { Fields = employeeList, EntityName = "Employee", AppType = Constants.QUERY_BUILDER } }; EmployeeModel employeeModel1 = new EmployeeModel { Name = Constants.USERID, Value = "7", Operator = ">=" }; employeeList.Add(employeeModel1); EmployeeResponse usersResponse = function.GetEmployeesQueryBuilder(employeeRequest, null); ErrorResponse userResponse = usersResponse.Error; Assert.AreEqual(500, userResponse.Status); Assert.AreEqual(33, userResponse.Code); StringAssert.Contains(userResponse.Message, TestConstants.SYSTEM_ERROR); }
public EmployeeResponse Create(EmployeeAttachmentViewModel attachment) { EmployeeResponse response = new EmployeeResponse(); using (SqliteConnection db = new SqliteConnection("Filename=SirmiumERPGFC.db")) { db.Open(); SqliteCommand insertCommand = db.CreateCommand(); insertCommand.CommandText = SqlCommandInsertPart; try { insertCommand = AddCreateParameters(insertCommand, attachment); insertCommand.ExecuteNonQuery(); } catch (SqliteException error) { MainWindow.ErrorMessage = error.Message; response.Success = false; response.Message = error.Message; return(response); } db.Close(); response.Success = true; return(response); } }
internal void InsertEmployeeTest() { RestClient restClient = new RestClient("http://localhost:14547/api/"); EmployeeRequest employeeRequest = new EmployeeRequest() { EmployeeDto = new EmployeeDto() { EmployeeId = 0, LastName = "Engin", FirstName = "Türenç", Title = "Türenç Engin", TitleOfCourtesy = "TE", BirthDate = new DateTime(1986, 07, 14), HireDate = new DateTime(2018, 01, 15), Address = "Sanayi Mahallesi, Teknopark Bulvarı 1/3C Kurtköy - Pendik", City = "İstanbul", Region = "Anadolu", PostalCode = "34906", Country = "Türkiye", HomePhone = "+90 216 664 20 00", Extension = "", Photo = null, Notes = "Developer", ReportsTo = null, PhotoPath = "" } }; EmployeeResponse employeeResponse = restClient.Consume <EmployeeResponse>("Employee/InsertEmpoloyee", employeeRequest);; Console.WriteLine($"EmployeeId: {employeeResponse.EmployeeId}"); }
public ActionResult Create(EmployeeModel model) { try { if (ModelState.IsValid) { EmployeeResponse employeeResponse = _empClient.AddEditRecord(model); return(RedirectToAction("Index")); } var deptList = _DptClient.GetDepartmentList(new DepartmentRequest()); List <SelectListItem> ObjList = new List <SelectListItem>(); foreach (var item in deptList.Items) { var value = new SelectListItem { Text = item.Name, Value = item.Id.ToString() }; ObjList.Add(value); } ; ViewBag.DepartmentList = ObjList; return(View(model)); } catch { return(View(model)); } }
public async Task <object> Get(EmployeeRequest req) { try { var result = new EmployeeResponse() { Id = Guid.Empty.ToString() }; var employee = await _employeeRepository.GetEmployee(req.Id); if (employee != null) { result = new EmployeeResponse() { Id = employee.Record.Id, Name = employee.Record.Name, Department = employee.Record.Department, Address = employee.Record.Address, City = employee.Record.City, Country = employee.Record.Country }; } return(result); } catch (Exception ex) { return(this.ErrorResult(new string[] { ex.Message })); } }
public async Task <IActionResult> Create([FromBody] CreateEmployeeRequest createEmployeeRequest) { var employee = new Employee { FirstName = createEmployeeRequest.FirstName, LastName = createEmployeeRequest.LastName, PersonalIdentity = createEmployeeRequest.PersonalIdentity, ManagerId = createEmployeeRequest.ManagerId }; var createdEmployee = await _repo.CreateEmployeeAsync(employee); if (!createdEmployee) { return(BadRequest(new { Error = "There was an error creating a new Employee" })); } var response = new EmployeeResponse { Id = employee.Id, FirstName = employee.FirstName, LastName = employee.LastName, PersonalIdentity = employee.PersonalIdentity, ManagerId = employee.ManagerId }; return(Created("", response)); }
public async Task <IActionResult> Create([FromBody] CreateEmployeeRequest request) { List <Employee> allEmployees = await _employeeService.GetAllEmployeesAsync(); for (int i = 0; i < allEmployees.Count; i++) { if (allEmployees[i].Email == request.Email) { return(StatusCode(StatusCodes.Status406NotAcceptable, "This Email is already in use, please choose a different Email!")); } } Employee employee = new Employee { FirstName = request.FirstName, LastName = request.LastName, Email = request.Email }; await _employeeService.CreateEmployeeAsync(employee); string baseUrl = HttpContext.Request.Scheme + "//" + HttpContext.Request.Host.ToUriComponent(); string locationUri = baseUrl + "/" + ApiRoutes.Employees.Get.Replace("{employeeId}", employee.Id.ToString()); EmployeeResponse response = new EmployeeResponse { Id = employee.Id }; return(Created(locationUri, response)); }
public async Task <IActionResult> Get(int id) { var response = new EmployeeResponse() { Result = null }; try { var result = await _employeeService.GetEmployeesById(id); if (result == null) { response.Messages = ResponseMessages.NotFound(); return(NotFound(response)); } response.Messages = ResponseMessages.Success(); response.Result = result; return(Ok(response)); } catch (Exception exception) { response.Messages = ResponseMessages.InternalServerError(exception.ToString()); return(StatusCode(500, response)); } }
public override Task <EmployeeResponse> GetEmployeeByEmpID(EmployeeRequest request, ServerCallContext context) { var response = new EmployeeResponse { StatusCode = EmployeeResponse.Types.Status.Notfound, Message = EnumStatus.NotFound.ToString() }; if (request.EmployeeID > 0) { var result = Task.FromResult(new EmployeeResponse() { StatusCode = EmployeeResponse.Types.Status.Success, Message = "Data found", }).Result; result.Data.Add(new EmployeeDTO { EmployeeID = 1, NIK = "10000000", Name = "Farid Permana", Occupation = "Sofware Enginer", Address = "South Jakarta City, Indonesia" }); } return(Task.FromResult(response)); }
public override Task <EmployeeResponse> GetEmployee(EmployeeRequest request, ServerCallContext context) { var response = new EmployeeResponse { StatusCode = EmployeeResponse.Types.Status.Notfound, Message = EnumStatus.NotFound.ToString() }; if (request.MemberID > 0) { var result = new EmployeeResponse() { StatusCode = EmployeeResponse.Types.Status.Success, Message = "Data found", }; var manager = new EmployeeManager(); var query = (from emp in manager.Reader.Value.GetEmployees() select new EmployeeDTO { EmployeeID = emp.EmployeeId, NIK = emp.Nik, Name = emp.Name, Address = emp.Address, Occupation = emp.Occupation }).AsQueryable(); result.Data.AddRange(query.ToArray()); return(Task.FromResult(result)); } return(Task.FromResult(response)); }
public ActionResult CreateOrEditEmployee() { EmployeeResponse _response = new EmployeeResponse(); if (Request.QueryString["id"] != null) { var request = new EmployeeRequest { Data = new EmployeeModel { Id = long.Parse(Request.QueryString["id"].ToString()) } }; EmployeeResponse resp = new EmployeeHandler(_unitOfWork).GetDetail(request); EmployeeModel _model = resp.Entity; ViewBag.Response = _response; ViewBag.EmpTypes = BindDropDownEmployementType(); ViewBag.EmplStatus = BindDropDownEmployeeStatus(); ViewBag.EmpActive = BindDropDownEmployeeReff(); ViewBag.ActionType = ClinicEnums.Action.Edit; return(View(_model)); } else { ViewBag.ActionType = ClinicEnums.Action.Add; ViewBag.Response = _response; ViewBag.EmpTypes = BindDropDownEmployementType(); ViewBag.EmplStatus = BindDropDownEmployeeStatus(); ViewBag.EmpActive = BindDropDownEmployeeReff(); return(View()); } }
public async Task <EmployeeResponse> DeleteAsync(int id, CancellationToken token) { var response = new EmployeeResponse("Init"); if (id > 0) { var dbEmp = await _context.Employees .Where(w => w.Id == id) .FirstOrDefaultAsync(cancellationToken: token) .ConfigureAwait(true); if (dbEmp == null) { response = new EmployeeResponse("Employee Not Found"); } else { _context.Employees.Remove(dbEmp); await _context.SaveChangesAsync(token) .ConfigureAwait(true); return(new EmployeeResponse(new EmployeeModel())); } } else { return(new EmployeeResponse("Invalid Employee Id for delete")); } return(response); }
/// <summary> /// Búsqueda de empleado /// </summary> /// <param name="numberEmployee">Número de empleado</param> /// <param name="name">Nombre del empleado</param> /// <param name="codigoTienda">Codigo de tienda</param> /// <returns>Lista de empleados</returns> public EmployeeResponse[] SearchEmployee(int numberEmployee, string name, int codigoTienda) { List <EmployeeResponse> list = new List <EmployeeResponse>(); var parameters = new Dictionary <string, object>(); parameters.Add("@CodigoEmpleado", numberEmployee); parameters.Add("@Nombre", name); parameters.Add("@CodigoTienda", codigoTienda); foreach (var r in data.GetDataReader("sp_vanti_EmpleadosBusqueda", parameters)) { EmployeeResponse employee = new EmployeeResponse(); employee.Code = Convert.ToInt32(r.GetValue(0)); employee.UserName = r.GetValue(1).ToString(); employee.Paternal = r.GetValue(2).ToString(); employee.Maternal = r.GetValue(3).ToString(); employee.Name = r.GetValue(4).ToString(); employee.Position = r.GetValue(5).ToString(); employee.RoleCode = Convert.ToInt32(r.GetValue(6)); employee.InitialDate = Convert.ToDateTime(r.GetValue(7)).ToShortDateString(); employee.Sex = r.GetValue(8).ToString(); employee.Status = r.GetValue(9).ToString(); employee.Store = Convert.ToInt32(r.GetValue(10)); list.Add(employee); } return(list.ToArray()); }
// Mappers // Note: doesn't expose behavior public static PetResponse FromPetDTO(PetDTO item) => new PetResponse() { Id = item.Id, Animal = AnimalResponse.FromAnimalDTO(item.Animal), Name = item.Name, Owner = EmployeeResponse.FromEmployeeDTO(item.Employee) };
private EmployeeResponse InitializeResponse(EmployeeRequest req) { EmployeeResponse res = new EmployeeResponse(); res.RequestId = req.RequestId; return(res); }
public EmployeeResponse SaveEmployee(EmployeeRequest employeeRequest) { EmployeeResponse employeeResponse = new EmployeeResponse(); #region Database activity #endregion return(employeeResponse); }