WZC2/be/Modules/BaseData/src/Win_in.Sfs.Basedata.Application/Locations/LocationAppService.cs

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Threading.Tasks;

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Volo.Abp.Caching;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Validation;
using Win_in.Sfs.Basedata.Application.Contracts;
using Win_in.Sfs.Basedata.Domain;
using Win_in.Sfs.Basedata.Domain.Shared;
using Win_in.Sfs.Shared.Domain.Shared;

namespace Win_in.Sfs.Basedata.Application;

[Authorize]
[Route($"{BasedataConsts.RootPath}Location")]

public class LocationAppService
    : SfsBaseDataWithCodeAppServiceBase<Location, LocationDTO, SfsBaseDataRequestInputBase, LocationEditInput, LocationImportInput>
    , ILocationAppService
{

    private readonly ILocationManager _manager;

    private readonly LocationValidator _locationValidator;
    private readonly ILocationGroupAppService _locationGroupAppService;
    private readonly IWorkGroupAppService _workGroupAppService;
    private readonly IAreaAppService _areaAppService;

    public LocationAppService(
        ILocationRepository repository
        , IDistributedCache<LocationDTO> cache
        , LocationValidator locationValidator
        , ILocationManager manager
        , ILocationGroupAppService locationGroupAppService
        , IWorkGroupAppService workGroupAppService
        , IAreaAppService areaAppService
        ) : base(repository, cache)
    {

        //_locationCapacityAppService = locationCapacityAppService;
        _locationValidator = locationValidator;
        _manager = manager;
        base.CreatePolicyName = LocationPermissions.Create;
        base.UpdatePolicyName = LocationPermissions.Update;
        base.DeletePolicyName = LocationPermissions.Delete;
        _areaAppService = areaAppService;
        _locationGroupAppService = locationGroupAppService;
        _workGroupAppService = workGroupAppService;
    }

    [HttpPost("check")]
    //[Authorize(LocationPermissions.Default)]

    public virtual async Task CheckAsync(string code, LocationCheckInput input)
    {
        var result = new AbpValidationResult();
        _locationValidator.CheckFormat(code);
        var dto = await GetByCodeAsync(code).ConfigureAwait(false);
        var entity = ObjectMapper.Map<LocationDTO, Domain.Location>(dto);
        _locationValidator.CheckType(entity, input.Types, result);
        _locationValidator.CheckLocationGroup(entity, input.LocationGroups, result);
        _locationValidator.CheckWorkGroup(entity, input.WorkGroups, result);
        // _locationValidator.CheckLocation(entity, input.Locations, result);
        _locationValidator.CheckWarehouse(entity, input.Warehouses, result);
        _locationValidator.CheckMixItem(entity, input.MixItem, result);
        _locationValidator.CheckMixLot(entity, input.MixLot, result);
        _locationValidator.CheckMixStatus(entity, input.MixStatus, result);
        _locationValidator.CheckNegative(entity, input.Negative, result);
        _locationValidator.CheckKeepZero(entity, input.KeepZero, result);
        _locationValidator.CheckOpportunityCount(entity, input.OpportunityCount, result);
        _locationValidator.CheckPick(entity, input.Pick, result);
        _locationValidator.CheckOverPick(entity, input.OverPick, result);
        _locationValidator.CheckWholeStore(entity, input.WholeStore, result);
        _locationValidator.CheckBreakStore(entity, input.BreakStore, result);
        _locationValidator.CheckShip(entity, input.Ship, result);
        _locationValidator.CheckReceive(entity, input.Receive, result);
        _locationValidator.CheckReturnToSupplier(entity, input.ReturnToSupplier, result);
        _locationValidator.CheckReturnFromCustomer(entity, input.ReturnFromCustomer, result);
        await _locationValidator.CheckItemAsync(entity, input.ItemCode, result).ConfigureAwait(false);
        if (result.Errors.Count > 0)
        {
            throw new AbpValidationException(result.Errors);
        }
    }

    /// <summary>
    /// 筛选可用领料的库位
    /// </summary>
    /// <param name="locationCodes"></param>
    /// <param name="enablePick"></param>
    /// <returns></returns>
    /// <exception cref="NotImplementedException"></exception>
    [HttpGet("list/by-codes-and-enable-pick")]
    public virtual async Task<List<LocationDTO>> GetListByCodesAndEnablePickAsync(List<string> locationCodes, bool enablePick)
    {
        var locations = await _repository.GetListAsync(c => c.EnablePick == enablePick
                                                            && locationCodes.Contains(c.Code)).ConfigureAwait(false);
        var dtos = ObjectMapper.Map<List<Domain.Location>, List<LocationDTO>>(locations);
        return dtos;
    }

    [HttpGet("list/by-enable-picks")]
    public virtual async Task<List<LocationDTO>> GetListByEnablePickAsync(bool enablePick)
    {
        var locations = await _repository.GetListAsync(c => c.EnablePick == enablePick).ConfigureAwait(false);
        var dtos = ObjectMapper.Map<List<Domain.Location>, List<LocationDTO>>(locations);
        return dtos;
    }

    [HttpGet("list/by-groups")]
    public virtual async Task<List<LocationDTO>> GetListByGroupsAsync(List<string> locationGroupCodes)
    {
        var locations = await _repository.GetListAsync(c => locationGroupCodes.Contains(c.LocationGroupCode)).ConfigureAwait(false);
        var dtos = ObjectMapper.Map<List<Domain.Location>, List<LocationDTO>>(locations);

        return dtos;
    }

    [HttpGet("list/by-areas")]
    public virtual async Task<List<LocationDTO>> GetListByAreasAsync(List<string> areas)
    {
        var locations = await _repository.GetListAsync(c => areas.Contains(c.AreaCode)).ConfigureAwait(false);
        var dtos = ObjectMapper.Map<List<Domain.Location>, List<LocationDTO>>(locations);

        return dtos;
    }

    [HttpGet("list/by-codes-and-types")]
    public virtual async Task<List<LocationDTO>> GetListByCodesAndTypesAsync(List<string> locationCodes, List<EnumLocationType> locationTypes)
    {
        var locations = await _repository.GetListAsync(c => locationCodes.Contains(c.Code)
                                                            && locationTypes.Contains(c.Type)).ConfigureAwait(false);
        var dtos = ObjectMapper.Map<List<Domain.Location>, List<LocationDTO>>(locations);

        return dtos;
    }

    [HttpGet("first/by-type")]
    public virtual async Task<LocationDTO> GetFirstByTypeAsync(EnumLocationType type)
    {
        //特殊库位可能有多个 多个溢出 多个锁定
        var location = await _repository.FirstOrDefaultAsync(p => p.Type == type).ConfigureAwait(false);

        var dto = ObjectMapper.Map<Domain.Location, LocationDTO>(location);
        return dto;
    }

    [HttpGet("list/by-types")]
    public virtual async Task<List<LocationDTO>> GetListByTypesAsync(List<EnumLocationType> types)
    {
        var locations = await _repository.GetListAsync(c => types.Contains(c.Type)).ConfigureAwait(false);
        var dtos = ObjectMapper.Map<List<Domain.Location>, List<LocationDTO>>(locations);
        return dtos;
    }

    [HttpGet("list/by-types-and-erp")]
    public virtual async Task<List<LocationDTO>> GetListByTypesAndErpCodeAsync(List<EnumLocationType> types, string erpCode)
    {
        var locations = await _repository.GetListAsync(c => types.Contains(c.Type) && c.ErpLocationCode == erpCode).ConfigureAwait(false);
        var dtos = ObjectMapper.Map<List<Domain.Location>, List<LocationDTO>>(locations);
        return dtos;
    }
    [HttpGet("list/by-types-and-erp-code")]
    public virtual async Task<List<LocationDTO>> GetListByTypesAndErpCodeAsync(List<EnumLocationType> types, string erpCode,string locCode)
    {
        var locations = await _repository.GetListAsync(c => types.Contains(c.Type) && c.ErpLocationCode == erpCode&&c.Code==locCode).ConfigureAwait(false);
        var dtos = ObjectMapper.Map<List<Domain.Location>, List<LocationDTO>>(locations);
        return dtos;
    }



    [HttpGet("list/by-location-group-code-and-location-type")]
    public virtual async Task<List<LocationDTO>> GeListByLocationGroupCodeAndLocationType(List<string> locationGroupCodes, List<EnumLocationType> locationTypes)
    {
        List<Domain.Location> locations = await _repository.GetListAsync(c => locationGroupCodes.Contains(c.LocationGroupCode) && locationTypes.Contains(c.Type)).ConfigureAwait(false);
        var dtos = ObjectMapper.Map<List<Domain.Location>, List<LocationDTO>>(locations);
        //var result = new List<LocationDTO>();
        //foreach (var item in dtos)
        //{
        //    var flag = await _itemStoreRelationRepository.GetListAsync(p => p.StoreValue == item.Code && p.StoreRelationType == EnumStoreRelationType.Location);

        //    if (!flag.Any())
        //    {
        //        result.Add(item);
        //    }
        //}

        return dtos;
    }

    [HttpPost("list/by-many-codes")]
    public virtual async Task<List<LocationDTO>> GetListByManyCodes(List<string> codes)
    {
        var entitys = await _repository.GetListAsync(p => codes.Contains(p.Code)).ConfigureAwait(false);

        var dtos = ObjectMapper.Map<List<Domain.Location>, List<LocationDTO>>(entitys);

        return dtos;
    }

    [HttpGet("get-all")]
    //[Authorize(LocationPermissions.Default)]
    public virtual async Task<List<LocationDTO>> GetAllAsync()
    {
        var list = await _repository.GetListAsync().ConfigureAwait(false);

        return ObjectMapper.Map<List<Domain.Location>, List<LocationDTO>>(list);
    }

    protected override async Task ValidateImportModelAsync(LocationImportInput importInput, List<ValidationResult> validationRresult)
    {
        await base.ValidateImportModelAsync(importInput, validationRresult).ConfigureAwait(false);
        await base.CheckAreaCodeAsync(importInput.AreaCode, validationRresult).ConfigureAwait(false);
        await base.CheckWorkGroupWorkshopCodeAsync(importInput.WorkGroupCode, validationRresult).ConfigureAwait(false);
        await base.CheckLocationGroupCodeAsync(importInput.LocationGroupCode, validationRresult).ConfigureAwait(false);
        await base.CheckWarehouseCodeAsync(importInput.WarehouseCode, validationRresult).ConfigureAwait(false);
    }
}