Exemple #1
0
        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);
        }
Exemple #2
0
        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);
        }
Exemple #3
0
        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);
        }
Exemple #4
0
        //[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));
            }
        }
Exemple #8
0
        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);
            }
        }
Exemple #11
0
 public IEnumerable <EmployeeResponse> GetEmployees(
     int departmentId, bool includeDepartment) =>
 this
 .repository
 .GetEmployees(departmentId, includeDepartment)
 .Select(x => EmployeeResponse.FromEmployee(x, includeDepartment))
 .ToArray();
Exemple #12
0
        /// <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);
        }
Exemple #14
0
        /// <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));
        }
Exemple #15
0
        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);
            }
        }
Exemple #17
0
        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));
            }
        }
Exemple #19
0
        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 }));
            }
        }
Exemple #20
0
        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());
            }
        }
Exemple #26
0
    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);
    }
Exemple #27
0
        /// <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);
        }