同步数据到外部系统

/// <summary>
/// 推送仓库
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost]
public async Task<bool> WarehseSaveOrUpdateAsync(List<WarehseInput> input)
{
    try
    {
        var warehseCodes = input.Select(x => x.WarehouseCode).Distinct().ToList();
        var datas = _db.Queryable<Tables.ErpWarehse>().Where(x => warehseCodes.Contains(x.WarehouseCode)).ToList();

        if (datas.Count == 0) return true;

        var parameters = datas.Select(s => new WarehouseModel()
        {
            WarehouseCode = s.WarehouseCode,
            WarehouseName = s.Description,
            Inactive = s.Inactive ? 1 : 0
        }).ToList();

        await _ajaxToTengYi.Post<ResponseBase>(this.Company, "WarehouseStandard/WS_Create", new { ParameterList = parameters });

        // 更新同步标记
        var _sysRowIds = datas.Select(s => s.SysRowID).ToList();
        int resutl = _db.Updateable<Tables.ErpWarehseUD>().Where(w => _sysRowIds.Contains(w.ForeignSysRowID))
             .SetColumns(it => new ErpWarehseUD { MesLog_c = true })
             .ExecuteCommand();

        // 校验检查第一次同步
        var dataKeys = datas.Select(s => s.WarehouseCode).ToList();
        await _mesSyncDataBusiness.CreateAsync(this.Company, "erp.warehse", dataKeys, HttpContext.RequestAborted);

        return true;
    }
    catch (Exception ex)
    {
        if (ex is BusErrorException)
            throw;
        else
            throw new BusErrorException($"数据同步腾一时发生错误: {ex.Message}", ex);
    }

}

/// <summary>
/// 推送仓库 删除
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost]
public async Task WarehseDelete(DeleteCommonReq<List<WarehseInput>> input)
{
    try
    {
        var ids = input.Data.Select(s => s.WarehouseCode).ToList();

        // 检查一下，只有同步过的才删除
        if (!input.AlwayDelete)
        {
            var syncData = await _mesSyncDataBusiness.GetSyncDataAsync(this.Company, "erp.warehse", ids, HttpContext.RequestAborted);
            ids = syncData;
        }

        var q_data = _db.Queryable<Tables.ErpWarehse>().Where((a) => a.Company == this.Company && ids.Contains(a.WarehouseCode));
        var data = await q_data.ToListAsync(HttpContext.RequestAborted);

        var partNums = data.Select(s => new { WarehouseCode = s.WarehouseCode }).ToList();

        await _ajaxToTengYi.Post<ResponseBase>(this.Company, "WarehouseStandard/WS_Delete", new { ParameterList = partNums });



        var sysRowIDs = data.Select(s => s.SysRowID).ToList();
        // 更新UD字段
        await _db.Updateable<Tables.ErpWarehseUD>()
            .SetColumns(x => x.MesLog_c == false)
            .Where(x => sysRowIDs.Contains(x.ForeignSysRowID))
            .ExecuteCommandAsync();

        // 删除同步数据
        var dataKeys = data.Select(s => s.WarehouseCode).ToList();
        await _mesSyncDataBusiness.DeleteAsync(this.Company, "erp.rma", dataKeys, HttpContext.RequestAborted);
    }
    catch (Exception ex)
    {
        if (ex is BusErrorException)
            throw;
        else
            throw new BusErrorException($"数据同步腾一时发生错误: {ex.Message}", ex);
    }
}

var validCompanyReult = this.EfxLib.ZAPIServer.ValidCompanyToTengYi();
if(validCompanyReult == false ){
  this.success = true;
  this.message = "当前公司配置为无需同步";  
  return;
}

var paramData = this.keys.Split(',').Select(s=>new {
  warehouseCode= s
}).ToList();

var paramJson = System.Text.Json.JsonSerializer.Serialize(paramData);

var urlPath = $"/api/{this.callContextClient.CurrentCompany}/PushDataToTengYi/WarehseSaveOrUpdate";

var result = this.EfxLib.ZAPIServer.PostEx(urlPath, paramJson);


this.success = result.success;
this.message = result.message;
if(!result.success) 
{
  throw new Ice.Common.BusinessObjectException(new Ice.Common.BusinessObjectMessage(this.message){
            Type=Ice.Common.BusinessObjectMessageType.Error
        });
}

List<string> keys = new List<string>();
List<string> delData = new List<string>();
foreach(var row in ds.Warehse) {
    // 新增，修改 滕一同步标记置为false
    if(row.RowMod =="A" || row.RowMod =="U") {
        row["MesLog_c"] = false;
        keys.Add(row.WarehouseCode);
    }

    if(row.RowMod =="D") {
       delData.Add(row.WarehouseCode);
    }
}
callContextBpmData.Character01 = String.Join(',',keys);

if(delData.Count>0) {
    var resultValid = (Tuple<System.Boolean>)this.InvokeFunction("ZAPIServer","ValidCompanyToTengYi",new Tuple<object>(null));
    // 公司没有配置推送腾一
    if(resultValid.Item1 == false) {
        return;
    }
    string functionLibrary =  "ZAPIServer";
    string function =  "PostEx";

    var paramData =delData.Select(s=>new {
        warehouseCode= s
    }).ToList();

    var jsonBody = new {
        alwayDelete = false,
        data = paramData
    };

    var urlPath = $"/api/{callContextClient.CurrentCompany}/PushDataToTengYi/WarehseDelete";
    string jsonStr = System.Text.Json.JsonSerializer.Serialize(jsonBody);
    try{
        var result = (Tuple<System.Boolean,System.String,System.String>)this.InvokeFunction(functionLibrary,function,Tuple.Create(urlPath,jsonStr));
        bool success = result.Item1;
        string message = result.Item2;
        if(!success) {
            throw new Ice.Common.BusinessObjectException(new Ice.Common.BusinessObjectMessage("调用滕一删除发生错误："+message){
                Type=Ice.Common.BusinessObjectMessageType.Error
            });
        }
    } 
    catch(Ice.Common.BusinessObjectException bex) {
        throw bex;
    }
    catch(Exception ex){
        throw new Ice.Common.BusinessObjectException(new Ice.Common.BusinessObjectMessage("调用滕一删除发生异常："+ex.Message){
            Type=Ice.Common.BusinessObjectMessageType.Error
        });
    }
}

if(String.IsNullOrEmpty(callContextBpmData.Character01)) return;
// PublishInfoMessage(callContextBpmData.Character01, Ice.Common.BusinessObjectMessageType.Information, Ice.Bpm.InfoMessageDisplayMode.Individual, "", "");

var resultValid = (Tuple<System.Boolean>)this.InvokeFunction("ZAPIServer","ValidCompanyToTengYi",new Tuple<object>(null));
// 公司没有配置推送腾一
if(resultValid.Item1 == false) {
	return;
}

string functionLibrary =  "ZAPIServer";
string function =  "PostEx";

var urlPath = $"/api/{callContextClient.CurrentCompany}/PushDataToTengYi/WarehseSaveOrUpdate";
// 仓库代码集合
var warehouseCodes = callContextBpmData.Character01.Split(',');
var paramData = warehouseCodes.Select(s=>new {
    WarehouseCode= s
}).ToList();

string jsonStr = System.Text.Json.JsonSerializer.Serialize(paramData);
try{
    var result = (Tuple<System.Boolean,System.String,System.String>)this.InvokeFunction(functionLibrary,function,Tuple.Create(urlPath,jsonStr));
    if(result.Item1 == false) {
        // throw new Ice.Common.BusinessObjectException(new Ice.Common.BusinessObjectMessage("数据保存成功，但同步腾一发生错误："+result.Item3){
        //     Type=Ice.Common.BusinessObjectMessageType.Error
        // });
        PublishInfoMessage("数据保存成功，但同步腾一发生错误："+result.Item3, Ice.Common.BusinessObjectMessageType.Information, Ice.Bpm.InfoMessageDisplayMode.Individual, "", "");
    } else {
        // 更新主键值，避免前端再次修改保存时提示数据已被修改
        var dataWhseNew = this.Db.Warehse.Where(w=>w.Company == callContextClient.CurrentCompany && warehouseCodes.Contains(w.WarehouseCode)).Select(s=>new {
            s.WarehouseCode,
            s.MesLog_c,
            s.UD_SysRevID
        }).ToList();

        for(int i = 0;i<ds.Warehse.Count;i++) {
            var row = ds.Warehse[0];
            var item = dataWhseNew.Where(w=>w.WarehouseCode == row.WarehouseCode).FirstOrDefault();
            if(item!=null) {
                row["MesLog_c"] = item.MesLog_c;
                row["UD_SysRevID"] = item.UD_SysRevID;
            }
        }
    }
} 
catch(Exception ex){
    // throw new Ice.Common.BusinessObjectException(new Ice.Common.BusinessObjectMessage("同步腾一发生异常："+ex.Message){
    //     Type=Ice.Common.BusinessObjectMessageType.Error
    // });
    PublishInfoMessage("数据保存成功，但同步腾一发生异常："+ex.Message, Ice.Common.BusinessObjectMessageType.Information, Ice.Bpm.InfoMessageDisplayMode.Individual, "", "");
}