WMS-Api/src/WMS.Web.Api/Controllers/TestController.cs

using ERP;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore.Storage;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.Threading.Tasks;
using WMS.Web.Core.Dto;
using WMS.Web.Core.Internal.Results;
using WMS.Web.Domain.Entitys;
using WMS.Web.Domain.Infrastructure;
using WMS.Web.Domain.IService;
using WMS.Web.Domain.IService.Public;

namespace WMS.Web.Api.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class TestController : ControllerBase
    {
        private readonly IErpService _erpService;
        private IInStockTaskService _inStockTaskService;
        private IBasicsRepositories _transactionRepositories;
        private readonly IOpsService _opsService;
        private readonly IBoxService _boxService;
        private readonly IOutStockTaskRepositories _outStockTaskRepositories;
        private readonly IOutStockTaskService _outStockTaskService;
        private readonly IBoxInventoryRepositories _boxInventoryRepositories;
        private readonly ITakeStockService _takeStockService;
        private readonly ITakeStockRepositories _takeStockRepositories;
        public TestController(IErpService erpService, IInStockTaskService inStockTaskService, IBoxInventoryRepositories boxInventoryRepositories,
            IBasicsRepositories transactionRepositories, IOpsService opsService, IBoxService boxService,
            IOutStockTaskRepositories outStockTaskRepositories, IOutStockTaskService outStockTaskService,
            ITakeStockService takeStockService, ITakeStockRepositories takeStockRepositories)
        {
            _boxInventoryRepositories = boxInventoryRepositories;
            this._erpService = erpService;
            this._inStockTaskService = inStockTaskService;
            this._transactionRepositories = transactionRepositories;
            _opsService = opsService;
            _boxService = boxService;
            _outStockTaskRepositories = outStockTaskRepositories;
            _outStockTaskService = outStockTaskService;
            _takeStockService = takeStockService;
            _takeStockRepositories = takeStockRepositories;
        }

        [HttpGet]
        [Route("hj")]
        public async Task<string> TestHJ()
        {
          var entity=await  _takeStockRepositories.GetEntityList(new List<int>() {2 });
          var r= await _takeStockService.Loss_Profit(entity.First());
            //var list = await GetList();
            //var c = await _erpService.BillQueryForSubStock(null,null);
            //var bc2 = await _erpService.BillQueryForDeliveryNoticeOutStock(new List<string>() { "FHTZD8022232" }, DateTime.Now.AddDays(-10));
            //var bc = await _erpService.BillQueryForTransferOutOutStock(null, DateTime.Now.AddDays(-10));
            //var b=await _erpService.BillQueryForAssembledAppOutStock_Assembly(null, DateTime.Now.AddDays(-1));
            // var b2 = await _erpService.BillQueryForAssembledAppOutStock_Dassembly(null, DateTime.Now.AddDays(-10));
            //var b = await _outStockTaskService.Sync(new List<string>() { "FHTZD8022232" });
            //var result = await this._outStockTaskService.Sync(null);
            //var t=await _outStockTaskRepositories.Get(1);
            // t.Details[0].Remark = "sdf";
            // t.Details[0].ErpDetails[0].SaleBillNo = "sdfsfsbbbb";
            // var s = await _outStockTaskRepositories.Edit(t);
            //await _boxService.Sync(list);
            //var res = await this._erpService.BillQueryForAssembledAppOutStock_Dassembly(null,DateTime.Now.AddDays(-300));
            //var result= await this._erpService.BillQueryForPurchaseInStock();
            //var result = await this._erpService.BillQueryForOrg();
            //var result = await this._erpService.BillQueryForMaterial();
            //if (!result.IsSuccess)
            //    return "";
            //return JsonConvert.SerializeObject(result.Data);
            return "";
        }


        [HttpGet]
        [Route("Refresh")]
        public async Task<string> Refresh()
        {
            var result = await this._outStockTaskService.Sync(null);
            return "";
        }

        [HttpGet]
        [Route("tf")]
        public async Task<string> TestTF()
        {
            ////var result = await this._erpService.BillQueryForOrg();
            //var result = await this._erpService.BillQueryForBillType();
            //if (!result.IsSuccess)
            //    return "";
            //return JsonConvert.SerializeObject(result.Data);

           // var bis = new List<string>() { "CGDD224198", "CGDD224199", "CGDD224200", "CGDD224202", "SUB00006680", "CGDD224203", "SUB000066801", "CGDD224204", "CGDD224205", "CGDD224206", "CGDD224207", "SUB00006681", "CGDD224208", "CGDD224209", "SUB00006682", "CGDD224210", "CGDD224211", "CGDD224212", "CGDD224213", "CGDD224216", "SUB00006683", "CGDD224218", "CGDD224219", "CGDD224220", "CGDD224221", "CGDD224222", "CGDD224223", "CGDD224224", "CGDD224225", "CGDD224226", "CGDD224227", "CGDD224229", "CGDD224230", "CGDD224231", "CGDD224232", "CGDD224233", "SUB00006685", "SUB00006686", "CGDD224234", "CGDD224235", "CGDD224236", "CGDD224237", "CGDD224238", "CGDD224239", "CGDD224240", "CGDD224241", "CGDD224242", "CGDD224243", "CGDD224244", "CGDD224245", "CGDD224246", "CGDD224247", "CGDD224248", "CGDD224249", "CGDD224250", "CGDD224251" };

            var result = await this._erpService.BillQueryForPurchaseInStock();
            //var result1 = await this._erpService.BillQueryForMiscellaneous();
            //var result2 = await this._erpService.BillQueryForTransferDirect();
            //var result3 = await this._erpService.BillQueryForTransferin();

            //var result4= await this._erpService.BillQueryForAssembledApp_Assembly();

            //var result5 = await this._erpService.BillQueryForAssembledApp_Disassembly();

            //var  list= result.Data.ToList();
            //list.AddRange(result2.Data.ToList());

            var tt = JsonConvert.SerializeObject(result);

            //var tttt = new List<string>() {  "ABCD14200999" };
            //var boxInventorys = await _boxInventoryRepositories.Get(142);

            //var data = new List<BoxInventory>();

            //var entity = new BoxInventory();
            //entity.Id = 34;
            //entity.BoxId = 142;
            //entity.OrgCode = "101";
            //entity.StockCode = "CK003";
            //entity.SubStockId = 2949;

            //var det = new BoxInventoryDetails();

            //det.Id = 266;
            //det.Fid = 34;
            //det.MaterialId = 4799560;
            //det.SerialNumbers = new List<string>() { "ABCD143001", "ABCD142002" };
            //det.Qty = 2;
            //entity.Details.Add(det);

            //boxInventorys.Details.ForEach(x=>
            //{
            //    x.SerialNumbers.RemoveAll(t => tttt.Contains(t));
            //    //x.SerialNumbers.AddRange(tttt);
            //    x.Qty = 3;
            //});

            //data.Add(boxInventorys);
            //var result= await _boxInventoryRepositories.UpdateRange(data);
            return tt;


        }
        /// <summary>
        /// 根据物料Id获取物料编码
        /// </summary>
        /// <param name="materialIds"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("GetMaterial")]
        public async Task<List<(int Id, string Number, string name)>> GetMaterial([FromQuery] List<int> materialIds)
        {
            List<(int Id, string Number, string name)> mList = new List<(int Id, string Number, string name)>();
            var materials_result = await _erpService.BillQueryForMaterial();
            var materials = materials_result.Data.ToList();
            foreach (var mid in materialIds)
            {
                var m = materials.FirstOrDefault(f => f.MaterialId == mid);
                mList.Add((m.MaterialId, m.MaterialNumber, m.MaterialName));
            }
            return mList;
        }
        /// <summary>
        /// 根据物料编码获取物料Id
        /// </summary>
        /// <param name="number"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("GetMaterialId/{number}")]
        public async Task<(int Id, string Number, string name)> GetMaterialId([FromRoute] string number)
        {
            List<(int Id, string Number, string name)> mList = new List<(int Id, string Number, string name)>();
            var materials_result = await _erpService.BillQueryForMaterial();
            var materials = materials_result.Data.ToList();

            var m = materials.FirstOrDefault(f => f.MaterialNumber.Contains(number));
            return (m.MaterialId, m.MaterialNumber, m.MaterialName);
        }
        /// <summary>
        /// 自动生成箱信息
        /// </summary>
        /// <param name="str"></param>
        /// <param name="number"></param>
        /// <param name="materialNumbers"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("SCBox/{str}/{number}")]
        public async Task<Result> SCBox([FromRoute] string str, [FromRoute] int number, [FromQuery] List<string> materialNumbers)
        {
            if (materialNumbers == null)
                materialNumbers = new List<string>();
            var list = await GetList(str, number, materialNumbers);
            await _boxService.Sync(list);
            return Result.ReSuccess();
        }
        private async Task<List<OpsBoxResponse>> GetList(string str, int number, List<string> materialNumbers)
        {
            var materials_result = await _erpService.BillQueryForMaterial();
            var materials = materials_result.Data.ToList();

            List<int> mIds = materials.Where(w => materialNumbers.Contains(w.MaterialNumber)).Select(s => s.MaterialId).ToList();
            int jn = 3;
            if (mIds.Count() <= 0)
                mIds= materials.Skip((new Random()).Next(1000, 10000)).Take(4).Select(s => s.MaterialId).ToList();
            jn = mIds.Count() - 1;
            List<OpsBoxResponse> list = new List<OpsBoxResponse>();
            for (int i = 0; i < number; i++)
            {
                List<OpsBoxDetailsResponse> Details = new List<OpsBoxDetailsResponse>();
                for (int j = 0; j <= jn; j++)
                {
                    var ran = (new Random()).Next(5, 10);
                    List<OpsSerialNumbersResponse> SerialNumbers = new List<OpsSerialNumbersResponse>();
                    for (int g = 0; g < ran; g++)
                    {
                        OpsSerialNumbersResponse or = new OpsSerialNumbersResponse()
                        {
                            SerialNumber = await GetStr(),
                            BarCereateUser = "01",
                            BarCreateTime = DateTime.Now
                        };
                        SerialNumbers.Add(or);
                    }
                    var mi = (new Random()).Next(1000, 20000);
                    OpsBoxDetailsResponse d = new OpsBoxDetailsResponse()
                    {
                        MaterialId = mIds[j],
                        Qty = ran,
                        SerialNumbers = SerialNumbers
                    };
                    Details.Add(d);
                }

                OpsBoxResponse response = new OpsBoxResponse()
                {
                    BoxBillNo = str + ((new Random()).Next(500, 2000) + i).ToString(),
                    OpsBoxId = 100 + i,
                    CompleteCartonTime = DateTime.Now,
                    CompleteCartonUser = "02",
                    CreateTime = DateTime.Now,
                    CreateUser = "01",
                    OrgId = 0,
                    SupplierId = 10897,
                    Details = Details
                };
                list.Add(response);
            }
            return list;
        }

        private Task<string> GetStr()
        {
            var characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
            var Charsarr = new char[11];
            var random = new Random();

            for (int i = 0; i < Charsarr.Length; i++)
            {
                Charsarr[i] = characters[random.Next(characters.Length)];
            }

            return Task.FromResult(new String(Charsarr));
        }

        /// <summary>
        /// 测试：同步入库单
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("InStock")]
        public async Task<Result> InStock()
        {
            
            //3.同步数据
            var result = await _inStockTaskService.Sysn();
            return result;

        }
    }
}