peis/src/Shentun.Peis.Application/Units/UnitAppService.cs

using AutoMapper.Internal.Mappers;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Shentun.Peis.HelperDto;
using Shentun.Peis.Models;
using Shentun.Peis.Units;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Identity;
using Volo.Abp.Users;

namespace Shentun.Peis.Units
{

    /// <summary>
    /// 计量单位
    /// </summary>
    [ApiExplorerSettings(GroupName = "Work")]
    [Authorize]
    public class UnitAppService : CrudAppService<
            Unit, //The Book entity
            UnitDto, //Used to show books
            Guid, //Primary key of the book entity
            PagedAndSortedResultRequestDto, //Used for paging/sorting
            CreateUnitDto,
            UpdateUnitDto>
    {
        private readonly IRepository<IdentityUser, Guid> _userRepository;
        private readonly UnitManager _manager;
        private readonly CacheService _cacheService;

        public UnitAppService(
            IRepository<Unit, Guid> repository,
            IRepository<IdentityUser, Guid> userRepository,
            UnitManager manager,
            CacheService cacheService)
            : base(repository)
        {
            _userRepository = userRepository;
            _manager = manager;
            _cacheService = cacheService;
        }
        /// <summary>
        /// 获取通过主键
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public override async Task<UnitDto> GetAsync(Guid id)
        {
            var userList = await _userRepository.GetListAsync();
            var entityDto = await base.GetAsync(id);
            entityDto.CreatorName = EntityHelper.GetSurnameNoSql(userList, entityDto.CreatorId);
            entityDto.LastModifierName = EntityHelper.GetSurnameNoSql(userList, entityDto.LastModifierId);

            return entityDto;
        }
        /// <summary>
        /// 获取列表  单位  遗弃
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [RemoteService(false)]
        public override async Task<PagedResultDto<UnitDto>> GetListAsync(PagedAndSortedResultRequestDto input)
        {
            return await base.GetListAsync(input);
        }


        /// <summary>
        /// 获取列表  单位  带搜索
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<List<UnitDto>> GetListInFilterAsync(GetListInFilterDto input)
        {
            var entlist = await Repository.GetQueryableAsync();

            if (!string.IsNullOrEmpty(input.Filter))
                entlist = entlist.Where(m => m.DisplayName.Contains(input.Filter));

            var entdto = entlist.Select(s => new UnitDto
            {
                CreationTime = s.CreationTime,
                CreatorId = s.CreatorId,
                DisplayName = s.DisplayName,
                DisplayOrder = s.DisplayOrder,
                Id = s.Id,
                LastModificationTime = s.LastModificationTime,
                LastModifierId = s.LastModifierId,
                SimpleCode = s.SimpleCode,
                CreatorName = _cacheService.GetSurnameAsync(s.CreatorId).GetAwaiter().GetResult(),
                LastModifierName = _cacheService.GetSurnameAsync(s.LastModifierId).GetAwaiter().GetResult()
            }).OrderBy(o => o.DisplayOrder).ToList();

            return entdto;

           
        }

        /// <summary>
        /// 创建
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public override async Task<UnitDto> CreateAsync(CreateUnitDto input)
        {
            var createEntity = ObjectMapper.Map<CreateUnitDto, Unit>(input);
            var entity = await _manager.CreateAsync(createEntity);
            entity = await Repository.InsertAsync(entity);
            var dto = ObjectMapper.Map<Unit, UnitDto>(entity);
            return dto;
        }
        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="id"></param>
        /// <param name="input"></param>
        /// <returns></returns>
        public override async Task<UnitDto> UpdateAsync(Guid id, UpdateUnitDto input)
        {
            var entity = await Repository.GetAsync(id);
            var sourceEntity = ObjectMapper.Map<UpdateUnitDto, Unit>(input);
            await _manager.UpdateAsync(sourceEntity, entity);
            entity = await Repository.UpdateAsync(entity);
            return ObjectMapper.Map<Unit, UnitDto>(entity);
        }
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public override async Task DeleteAsync(Guid id)
        {
           await _manager.CheckAndDeleteAsync(id);
        }

        

        /// <summary>
        /// 修改排序  置顶，置底
        /// </summary>
        /// <param name="id">需要修改的ID</param>
        /// <param name="SortType">修改方式：1 置顶   2 置底</param>
        /// <returns></returns>
        [HttpPut("api/app/unit/updatemanysort")]
        public async Task UpdateManySortAsync(Guid id, int SortType)
        {
            await _manager.UpdateManySortAsync(id, SortType);
        }

        /// <summary>
        ///  修改排序  拖拽
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPut("api/app/unit/updatesortmany")]
        public async Task UpdateSortManyAsync(UpdateSortManyDto input)
        {
            await _manager.UpdateSortManyAsync(input);
        }
    }
}