Example #1
0
        /// <summary>
        /// 获取“员工”数据
        /// </summary>
        /// <param name="queryParams"></param>
        /// <returns></returns>
        public async Task <IEnumerable <Employee> > GetEmployeesAsync(EmployeeQueryDto queryParams)
        {
            if (queryParams == null)
            {
                throw new ArgumentNullException(nameof(queryParams));
            }
            var queryExpression = _context.Employees as IQueryable <Employee>;

            if (!string.IsNullOrWhiteSpace(queryParams.Name))
            {
                queryParams.Name = queryParams.Name.Trim();
                queryExpression  = queryExpression.Where(x => x.Name == queryParams.Name);
            }
            if (!string.IsNullOrWhiteSpace(queryParams.EmployeeNo))
            {
                queryParams.EmployeeNo = queryParams.EmployeeNo.Trim();
                queryExpression        = queryExpression.Where(x => x.EmployeeNo == queryParams.EmployeeNo);
            }
            if (!string.IsNullOrWhiteSpace(queryParams.SearchTerm))
            {
                queryParams.SearchTerm = queryParams.SearchTerm.Trim();
                queryExpression        = queryExpression.Where(x => x.Name.Contains(queryParams.SearchTerm) ||
                                                               x.EmployeeNo.Contains(queryParams.SearchTerm));
            }

            var mappingDictionary = _propertyMappingService.GetPropertyMapping <EmployeeDto, Employee>();

            queryExpression = queryExpression.ApplySort(queryParams.OrderBy, mappingDictionary);

            return(await PagedList <Employee> .CreateAsync(queryExpression, queryParams.PageNumber, queryParams.PageSize));
        }
        public async Task <ActionResult <IEnumerable <EmployeeDto> > > GetEmployees([FromQuery] EmployeeQueryDto parameters)
        {
            var employees = await _employeeRepository.GetEmployeesAsync(parameters);

            var employeeDtos = _mapper.Map <IEnumerable <EmployeeDto> >(employees);

            return(Ok(employeeDtos));
        }
        public async Task <IEnumerable <EmployeeDto> > GetEmployeesAsync(EmployeeQueryDto query)
        {
            string queryString = null;

            if (query != null)
            {
                queryString = query.QueryStringFormat();
            }
            var relativeUri = queryString == null ? $"/api/employees" : $"/api/employees?{queryString}";
            var jsonAsync   = await _httpClient.GetStringAsync(relativeUri);

            return(JsonSerializer.Deserialize <IEnumerable <EmployeeDto> >(jsonAsync,
                                                                           new JsonSerializerOptions {
                PropertyNameCaseInsensitive = true,
            }));
        }
        public async Task <IEnumerable <Employee> > GetEmployeesAsync(int companyId, EmployeeQueryDto queryDto)
        {
            var query = _dbContext.Employees.Where(e => e.CompanyId == companyId);

            if (!string.IsNullOrWhiteSpace(queryDto?.Name))
            {
                queryDto.Name = queryDto.Name.Trim();

                query = query.Where(e => e.Name.Contains(queryDto.Name));
            }

            if (!string.IsNullOrWhiteSpace(queryDto?.Gender))
            {
                var gender = Enum.Parse <Gender>(queryDto.Gender.Trim(), true);
                query = query.Where(e => e.Gender == gender);
            }

            return(await query.ToListAsync());
        }
        //注意,queryDto为复杂参数,ApiController默认其绑定源为body
        public async Task <ActionResult <IEnumerable <EmployeeDto> > > GetEmpoyees(int companyId, [FromQuery] EmployeeQueryDto queryDto)
        {
            var employees = await _companyService.GetEmployeesAsync(companyId, queryDto);

            var result = _mapper.Map <IEnumerable <EmployeeDto> >(employees);

            return(Ok(result));
        }