DEMOMySql/MicroServices/Business/Business.Application/SyncDataManagement/SyncMySQLDataAppService.cs

using Business.Core.MongoDBHelper;
using Business.Core.Utilities;
using Business.Model.MES.IC;
using Business.Model.SRM;
using Business.Model.Tech;
using Business.MongoModel.MES.IC;
using Business.MongoModel.SRM;
using Business.MongoModel.Tech;
using System;
using System.Collections.Generic;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Repositories;

namespace Business.SyncDataManagement
{
    /// <summary>
    /// 同步mysql数据到mongodb
    /// </summary>
    public class SyncMySQLDataAppService : ApplicationService
    {
        #region 服务
        /// <summary>
        /// 物料bom
        /// </summary>
        private readonly IMongoDB<mo_ic_bom> _ic_bom;
        private IRepository<ic_bom, long> _mysql_ic_bom;

        /// <summary>
        /// 物料bom子表
        /// </summary>
        private readonly IMongoDB<mo_ic_bom_child> _ic_bom_child;
        private IRepository<ic_bom_child, long> _mysql_ic_bom_child;

        /// <summary>
        /// 物料
        /// </summary>
        private readonly IMongoDB<mo_ic_item> _ic_item;
        private IRepository<ic_item, long> _mysql_ic_item;

        /// <summary>
        /// 替代群组
        /// </summary>
        private readonly IMongoDB<mo_ic_substitute> _ic_substitute;
        private IRepository<ic_substitute, long> _mysql_ic_substitute;

        /// <summary>
        /// 物料替代多群组
        /// </summary>
        private readonly IMongoDB<mo_ic_substitute_group> _ic_substitute_group;
        private IRepository<ic_substitute_group, long> _mysql_ic_substitute_group;

        /// <summary>
        /// 物料替代多群组明细
        /// </summary>
        private readonly IMongoDB<mo_ic_substitute_group_detail> _ic_substitute_group_detail;
        private IRepository<ic_substitute_group_detail, long> _mysql_ic_substitute_group_detail;

        /// <summary>
        /// 供应商
        /// </summary>
        private readonly IMongoDB<mo_srm_supplier> _srm_supplier;
        private IRepository<srm_supplier, long> _mysql_srm_supplier;

        /// <summary>
        /// 工艺路径
        /// </summary>
        private readonly IMongoDB<mo_mes_technique> _mes_technique;
        private IRepository<mes_technique, long> _mysql_mes_technique;

        /// <summary>
        /// 工序
        /// </summary>
        private readonly IMongoDB<mo_mes_process> _mes_process;
        private IRepository<mes_process, long> _mysql_mes_process;

        /// <summary>
        /// 工艺路径关联工序
        /// </summary>
        private readonly IMongoDB<mo_mes_tech_process> _mes_tech_process;
        private IRepository<mes_tech_process, long> _mysql_mes_tech_process;

        /// <summary>
        /// 物料采购报价单
        /// </summary>
        private readonly IMongoDB<mo_srm_purchase> _srm_purchase;
        private IRepository<srm_purchase, long> _mysql_srm_purchase;

        /// <summary>
        /// 雪花算法
        /// </summary>
        SnowFlake help = new SnowFlake();
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        public SyncMySQLDataAppService(
            IMongoDB<mo_ic_bom> ic_bom,
            IMongoDB<mo_ic_bom_child> ic_bom_child,
            IMongoDB<mo_ic_item> ic_item,
            IMongoDB<mo_ic_substitute> ic_substitute,
            IMongoDB<mo_ic_substitute_group> ic_substitute_group,
            IMongoDB<mo_ic_substitute_group_detail> ic_substitute_group_detail,
            IMongoDB<mo_srm_supplier> srm_supplier,
            IMongoDB<mo_mes_technique> mes_technique,
            IMongoDB<mo_mes_process> mes_process,
            IMongoDB<mo_mes_tech_process> mes_tech_process,
            IMongoDB<mo_srm_purchase> srm_purchase,
            IRepository<ic_bom, long> mysql_ic_bom,
            IRepository<ic_bom_child, long> mysql_ic_bom_child,
            IRepository<ic_item, long> mysql_ic_item,
            IRepository<ic_substitute, long> mysql_ic_substitute,
            IRepository<ic_substitute_group, long> mysql_ic_substitute_group,
            IRepository<ic_substitute_group_detail, long> mysql_ic_substitute_group_detail,
            IRepository<srm_supplier, long> mysql_srm_supplier,
            IRepository<mes_technique, long> mysql_mes_technique,
            IRepository<mes_process, long> mysql_mes_process,
            IRepository<mes_tech_process, long> mysql_mes_tech_process,
            IRepository<srm_purchase, long> mysql_srm_purchase
            )
        {
            _ic_bom= ic_bom;
            _ic_bom_child= ic_bom_child;
            _ic_item= ic_item;
            _ic_substitute= ic_substitute;
            _ic_substitute_group= ic_substitute_group;
            _ic_substitute_group_detail = ic_substitute_group_detail;
            _srm_supplier= srm_supplier;
            _mes_technique = mes_technique;
            _mes_process= mes_process;
            _mes_tech_process = mes_tech_process;
            _srm_purchase = srm_purchase;
            _mysql_ic_bom = mysql_ic_bom;
            _mysql_ic_bom_child= mysql_ic_bom_child;
            _mysql_ic_item= mysql_ic_item;
            _mysql_ic_substitute= mysql_ic_substitute;
            _mysql_ic_substitute_group= mysql_ic_substitute_group;
            _mysql_ic_substitute_group_detail= mysql_ic_substitute_group_detail;
            _mysql_srm_supplier= mysql_srm_supplier;
            _mysql_mes_technique= mysql_mes_technique;
            _mysql_mes_process= mysql_mes_process;
            _mysql_mes_tech_process= mysql_mes_tech_process;
            _mysql_srm_purchase = mysql_srm_purchase;
        }

        /// <summary>
        /// 同步基础数据到mongodb
        /// </summary>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async void SyncBaseDataToMongoDB()
        {
            //同步物料Bom数据
            var icBoms = _mysql_ic_bom.GetListAsync().Result;
            if (icBoms.Count > 0)
            {
                //先清空表数据
                await _ic_bom.Delete(p => p.mysql_id != -1);
                var moIcBoms = ObjectMapper.Map<List<ic_bom>, List<mo_ic_bom>>(icBoms);
                moIcBoms.ForEach(s => s.id = help.NextId());
                //插入数据
                await _ic_bom.InsertMany(moIcBoms);
            }

            //同步物料BOM明细数据
            var icbom_childs = _mysql_ic_bom_child.GetListAsync().Result;
            if (icbom_childs.Count > 0)
            {
                //先清空表数据
                await _ic_bom_child.Delete(p => p.mysql_id != -1);
                var moIcbom_childs = ObjectMapper.Map<List<ic_bom_child>, List<mo_ic_bom_child>>(icbom_childs);
                moIcbom_childs.ForEach(s => s.id = help.NextId());
                //插入数据
                await _ic_bom_child.InsertMany(moIcbom_childs);
            }

            ////工厂物料明细表
            //var ic_factory_details = _mysql_ic_factory_details.GetListAsync().Result;
            //if (ic_factory_details.Count > 0)
            //{
            //    //先清空表数据
            //    await _ic_factory_details.Delete(p => p.mysql_id != -1);
            //    var moIc_factory_details = ObjectMapper.Map<List<ic_factory_details>, List<mo_ic_factory_details>>(ic_factory_details);
            //    moIc_factory_details.ForEach(s => s.id = help.NextId());
            //    await _ic_factory_details.InsertMany(moIc_factory_details);
            //}

            //同步物料数据
            var icItems = _mysql_ic_item.GetListAsync().Result;
            if (icItems.Count > 0)
            {
                //先清空表数据
                await _ic_item.Delete(p => p.mysql_id != -1);
                var moIcItems = ObjectMapper.Map<List<ic_item>, List<mo_ic_item>>(icItems);
                moIcItems.ForEach(s => s.id = help.NextId());
                //插入数据
                await _ic_item.InsertMany(moIcItems);
            }

            //同步替代群组数据
            var subtitutes = _mysql_ic_substitute.GetListAsync().Result;
            if (subtitutes.Count > 0)
            {
                //先清空表数据
                await _ic_substitute.Delete(p => p.mysql_id != -1);
                var moSubtitutes = ObjectMapper.Map<List<ic_substitute>, List<mo_ic_substitute>>(subtitutes);
                moSubtitutes.ForEach(s => s.id = help.NextId());
                //插入数据
                await _ic_substitute.InsertMany(moSubtitutes);
            }

            //同步物料替代多群组数据
            var subAlls = _mysql_ic_substitute_group.GetListAsync().Result;
            if (subAlls.Count > 0)
            {
                //先清空表数据
                await _ic_substitute_group.Delete(p => p.mysql_id != -1);
                var moSubAlls = ObjectMapper.Map<List<ic_substitute_group>, List<mo_ic_substitute_group>>(subAlls);
                moSubAlls.ForEach(s => s.id = help.NextId());
                //插入数据
                await _ic_substitute_group.InsertMany(moSubAlls);
            }

            //同步物料替代多群组明细数据
            var subAllDtls = _mysql_ic_substitute_group_detail.GetListAsync().Result;
            if (subAllDtls.Count > 0)
            {
                //先清空表数据
                await _ic_substitute_group_detail.Delete(p => p.mysql_id != -1);
                var moSubAllDtls = ObjectMapper.Map<List<ic_substitute_group_detail>, List<mo_ic_substitute_group_detail>>(subAllDtls);
                moSubAllDtls.ForEach(s => s.id = help.NextId());
                //插入数据
                await _ic_substitute_group_detail.InsertMany(moSubAllDtls);
            }

            //同步供应商数据
            var suppliers = _mysql_srm_supplier.GetListAsync().Result;
            if (suppliers.Count > 0)
            {
                //先清空表数据
                await _srm_supplier.Delete(p => p.mysql_id != -1);
                var moSuppliers = ObjectMapper.Map<List<srm_supplier>, List<mo_srm_supplier>>(suppliers);
                moSuppliers.ForEach(s => s.id = help.NextId());
                //插入数据
                await _srm_supplier.InsertMany(moSuppliers);
            }

            //同步工艺路径数据
            var techs = _mysql_mes_technique.GetListAsync().Result;
            if (techs.Count > 0)
            {
                //先清空表数据
                await _mes_technique.Delete(p => p.mysql_id != -1);
                var moTechs = ObjectMapper.Map<List<mes_technique>, List<mo_mes_technique>>(techs);
                moTechs.ForEach(s => s.id = help.NextId());
                //插入数据
                await _mes_technique.InsertMany(moTechs);
            }

            //同步工序数据
            var processes = _mysql_mes_process.GetListAsync().Result;
            if (suppliers.Count > 0)
            {
                //先清空表数据
                await _mes_process.Delete(p => p.mysql_id != -1);
                var moProcesses = ObjectMapper.Map<List<mes_process>, List<mo_mes_process>>(processes);
                moProcesses.ForEach(s => s.id = help.NextId());
                //插入数据
                await _mes_process.InsertMany(moProcesses);
            }

            //同步工艺关联工序数据
            var tech_procs = _mysql_mes_tech_process.GetListAsync().Result;
            if (tech_procs.Count > 0)
            {
                //先清空表数据
                await _mes_tech_process.Delete(p => p.mysql_id != -1);
                var moTech_procs = ObjectMapper.Map<List<mes_tech_process>, List<mo_mes_tech_process>>(tech_procs);
                moTech_procs.ForEach(s => s.id = help.NextId());
                //插入数据
                await _mes_tech_process.InsertMany(moTech_procs);
            }


            ////物料采购计划表
            //var ic_plan = _mysql_ic_plan.GetListAsync().Result;
            //if (ic_plan.Count > 0)
            //{
            //    //先清空表数据
            //    await _ic_plan.Delete(p => p.mysql_id != -1);
            //    var moIc_plan = ObjectMapper.Map<List<ic_plan>, List<mo_ic_plan>>(ic_plan);
            //    moIc_plan.ForEach(s => s.id = help.NextId());
            //    await _ic_plan.InsertMany(moIc_plan);
            //}

            //物料采购报价单
            var srm_purchase = _mysql_srm_purchase.GetListAsync().Result;
            if (srm_purchase.Count > 0)
            {
                //先清空表数据
                await _srm_purchase.Delete(p => p.mysql_id != -1);
                var mosrm_purchase = ObjectMapper.Map<List<srm_purchase>, List<mo_srm_purchase>>(srm_purchase);
                mosrm_purchase.ForEach(s => s.id = help.NextId());
                await _srm_purchase.InsertMany(mosrm_purchase);
            }
        }
    }
}