跳转至

费用分摊功能

功能描述

  • 分摊单据子表选中销售入库单
  • 将分摊单据子表中订单产品明细填入产品分摊子表

代码示例

销售分摊表单前端代码

  • 监听分摊单据子表的关联表单控件销售出库单的值变化
  • 当分摊单据子表的关联表单控件销售出库单值变化时，通过销售出库单的 Id 读取销售出库单的出库产品明细子表数据
  • 将第二步中读取到的数据填充到销售分摊的分摊单据子表
  • 此处演示选中数据新增的情况，不考虑数据删除等其他情况 
/* 控件接口说明：
 * 1. 读取控件: this.***,*号输入控件编码;
 * 2. 读取控件的值： this.***.GetValue();
 * 3. 设置控件的值： this.***.SetValue(???);
 * 4. 绑定控件值变化事件： this.***.BindChange(key,function(){})，key是定义唯一的方法名;
 * 5. 解除控件值变化事件： this.***.UnbindChange(key);
 * 6. CheckboxList、DropDownList、RadioButtonList: $.***.AddItem(value,text),$.***.ClearItems();
 */
/* 公共接口：
 * 1. ajax：$.SmartForm.PostForm(actionName,data,callBack,errorBack,async),
 *          actionName:提交的ActionName;data:提交后台的数据;callback:回调函数;errorBack:错误回调函数;async:是否异步;
 * 2. 打开表单：$.IShowForm(schemaCode, objectId, checkIsChange)，
 *          schemaCode:表单编码;objectId;表单数据Id;checkIsChange:关闭时，是否感知变化;
 * 3. 定位接口：$.ILocation();
 */

// 表单插件代码
$.extend($.JForm,{
    // 加载事件
    OnLoad:function(){
        var parent = this;
       /* 费用分摊步骤
        *1.监听分摊单据子表的变化，判断分摊单据是否变化
        *2.读取分摊ObjectId读取出库产品明细
        *3.更新或添加出库产品明细
        */
        //获取费用分摊子表的控件管理器，D287672OutboundDetail为费用分摊子表编码
        var outboundDetailControlManager = parent.D287672OutboundDetail;
        //加载完成时删除子表的默认空行
        deleteDefaultRows();
        // 监听子表的字段值变化
        this.D287672SalesAllocationDocument.BindChange("salesAllocationDocumentChanged", function(data){
            var responseData = data[0];
            if(!responseData || !responseData.DataField){
                return;
            }
            if(responseData.DataField == "D287672SalesAllocationDocument.SalesOutboundId"){
                var currentRowId = responseData.ObjectId;   //获取行ID 
                var salesOutboundId =  this.GetCellManager(currentRowId, "D287672SalesAllocationDocument.SalesOutboundId").GetValue(); //获取分摊单据Id
                queryOutboundAndFillData(salesOutboundId);
            }

        });

        //通过销售出库单Id查询出库明细数据并填充到分摊单据子表
        function queryOutboundAndFillData(salesOutboundId){
            if(!salesOutboundId){
                return;
            }
            var params = {"SalesOutboundId": salesOutboundId };
            // 通过后端服务请求数据
            $.SmartForm.PostForm("QuerySaleOutbound", params, function(data){
                //判断后端的返回值
                if(!data || !data.ReturnData || !data.ReturnData.SalesOutbound){
                    //返回值为空
                    return;
                }
                var saleOutbound = data.ReturnData.SalesOutbound;
                fillOneOutbound(saleOutbound);
            },
            function(error){

            },false);
        }

        //填充数据
        function fillOneOutbound(saleOutbound){
            for(var index in saleOutbound.SalesProductDetails){
                var saleOutboundDetial = saleOutbound.SalesProductDetails[index];
                //前端赋值关联表单值会触发关联填充规则
                outboundDetailControlManager.AddRow($.IGuid(),
                    {
                    "D287672OutboundDetail.OutboundSubTableId":saleOutboundDetial.ObjectId
                });
            }
        }
        //删除默认空行
        function deleteDefaultRows(){
            const outboundDetails = outboundDetailControlManager.GetValue();
            if(!outboundDetails){
                return;
            }
            if(outboundDetails.length != 1){
                return;
            }
            var isDefault = false;
            for(var index in outboundDetails){
                var detailItem = outboundDetails[index];
                if(!detailItem.OutboundSubTableId || detailItem.OutboundSubTableId == ""){
                    outboundDetailControlManager.ClearRows();
                }
            }
        }
    },

    // 按钮事件
    OnLoadActions:function(actions){
    },

    // 提交校验
    OnValidate:function(actionControl){
        return true;
    },

    // 提交前事件
    BeforeSubmit:function(action, postValue){
    },

    // 提交后事件
    AfterSubmit:function(action, responseValue){
    }
});

销售分摊表单后端代码

  • 定义QueryUtility类封装查询数据方法
  • 定义销售出库单常量类SalesOutboundConstants，字段编码与表单编码通过该类获取
  • 查询数据统一转换为实体OutboundItem，序列化到前端时转换为Dictionary<string, object>格式

```javascript

using System; using System.Collections.Generic; using System.Text; using H3;

public class D287672CostSharing: H3.SmartForm.SmartFormController { public D287672CostSharing(H3.SmartForm.SmartFormRequest request): base(request) { }

protected override void OnLoad(H3.SmartForm.LoadSmartFormResponse response)
{
    base.OnLoad(response);
}

protected override void OnSubmit(string actionName, H3.SmartForm.SmartFormPostValue postValue, H3.SmartForm.SubmitSmartFormResponse response)
{
    if(actionName == "QuerySaleOutbound") 
    {
        //获取前端传递的销售出库单据Id
        string salesOutboundId = this.Request["SalesOutboundId"];
        SaleOutboundQuery query = new SaleOutboundQuery(this.Request.Engine, salesOutboundId);
        //执行查询
        OutboundItem outboundItem = query.Execute();
        if(response.ReturnData == null) 
        {
            response.ReturnData = new Dictionary<string, object>();
        }
        //返回数据给前端使用
        response.ReturnData["SalesOutbound"] = outboundItem.ToDictionary();
        return;
    }
    base.OnSubmit(actionName, postValue, response);
}

}

//销售出库单信息查询 public class SaleOutboundQuery { private readonly IEngine _engine; private readonly string _saleOutboundId;

//一次查询一个销售出库单据
public SaleOutboundQuery(IEngine engine, string saleOutboundId)
{
    _engine = engine;
    _saleOutboundId = saleOutboundId;
}

private OutboundItem FromVirtualObject(VirtualObject virtualObject)
{
    OutboundItem outboundItem = new OutboundItem();
    outboundItem.ObjectId = virtualObject.ObjectId;
    VirtualObject[] detailVos = virtualObject.GetPropertyValue(SalesOutboundConstants.SchemaCode_OutboundDetails) as VirtualObject[];
    if(detailVos != null)
    {
        foreach(VirtualObject v in detailVos)
        {
            SalesProductDetailItem detailItem = new SalesProductDetailItem();
            detailItem.ObjectId = v.ObjectId;
            outboundItem.SalesProductDetails.Add(detailItem);
        }
    }
    return outboundItem;
}

public OutboundItem Execute()
{
    if(string.IsNullOrEmpty(_saleOutboundId))
    {
        throw new H3Exception("请选择销售出库单!");
    }
    OutboundItem outboundItem = new OutboundItem();
    H3.Data.Filter.Filter filter = new H3.Data.Filter.Filter();
    H3.Data.Filter.And and = new H3.Data.Filter.And();
    and.Add(new ItemMatcher(SalesOutboundConstants.FieldCode_ObjectId, H3.Data.ComparisonOperatorType.Equal, _saleOutboundId));
    filter.Matcher = and;
    VirtualObject[] vos = QueryUtility.GetVirtualObjects(_engine.BizObjectManager, filter, SalesOutboundConstants.SchemaCode);
    if(vos == null || vos.Length == 0)
    {
        return outboundItem;
    }
    VirtualObject virtualObject = vos[0];
    return FromVirtualObject(virtualObject);
}

public List<OutboundItem> ExecuteByIds(string[] ids)
{
    List < OutboundItem > items = new List<OutboundItem>();
    if(ids == null || ids.Length == 0)
    {
        return items;
    }
    H3.Data.Filter.Filter filter = new H3.Data.Filter.Filter();
    H3.Data.Filter.And and = new H3.Data.Filter.And();
    and.Add(new ItemMatcher(SalesOutboundConstants.FieldCode_ObjectId, H3.Data.ComparisonOperatorType.In, ids));
    filter.Matcher = and;
    VirtualObject[] vos = QueryUtility.GetVirtualObjects(_engine.BizObjectManager, filter, SalesOutboundConstants.SchemaCode);
    if(vos == null || vos.Length == 0)
    {
        return items;
    }
    foreach(VirtualObject virtualObject in vos) 
    {
        items.Add(FromVirtualObject(virtualObject));
    }
    return items;
}

}

//销售出库单主表数据结构定义 public class OutboundItem { public OutboundItem() { SalesProductDetails = new List(); OutboundProductDetails = new List(); } public string ObjectId; public string OutboundDate; ///

/// 订单产品明细 /// 

public List<SalesProductDetailItem> SalesProductDetails;
/// <summary>
/// 出库产品明细
/// </summary>

public List<OutboundProductDetailItem> OutboundProductDetails;

public Dictionary<string, object> ToDictionary()
{
   Dictionary < string, object > dict = new Dictionary<string, object>();
    dict.Add("ObjectId", ObjectId);
    dict.Add("OutboundDate", OutboundDate);
    List < Dictionary < string, object >> salesProductDetails = new List<Dictionary<string, object>>();
    foreach(SalesProductDetailItem item in SalesProductDetails)
    {
        salesProductDetails.Add(item.ToDictionary());
    }
    dict.Add("SalesProductDetails", salesProductDetails);

    List < Dictionary < string, object >> outboundProductDetails = new List<Dictionary<string, object>>();
    foreach(OutboundProductDetailItem item in OutboundProductDetails)
    {
        outboundProductDetails.Add(item.ToDictionary());
    }
    dict.Add("OutboundProductDetails", outboundProductDetails);
    return dict;
}

public static List<Dictionary<string, object >> ToDictionaryList(List < OutboundItem > itemlist)

{ List < Dictionary < string, object >> list = new List>(); if(itemlist == null) { return list; } foreach(OutboundItem item in itemlist) { list.Add(item.ToDictionary()); } return list; } }

///

/// 出库产品明细数据结构定义 ///

public class OutboundProductDetailItem { public string ObjectId;

//分仓库存ObjectId
public string SeparateWarehouseObjectId;

public string WarehouseId;

public string ProductId;

public string OrderProductId;

//批次号Id
public string BatchNumberObjectId;

//批次号
public string BatchNumber;

//本次出货数量
public double ActualOutboundAmount;

//自定义代码类不能直接返回前端，需要转换为Dictionary<string, object>格式
public Dictionary<string, object> ToDictionary()
{
    Dictionary < string, object > dict = new Dictionary<string, object>();
    dict.Add("ObjectId", ObjectId);
    dict.Add("SeparateWarehouseObjectId", SeparateWarehouseObjectId);
    dict.Add("WarehouseId", WarehouseId);
    dict.Add("ProductId", ProductId);
    dict.Add("OrderProductId", OrderProductId);
    dict.Add("BatchNumberObjectId", BatchNumberObjectId);
    dict.Add("BatchNumber", BatchNumber);
    dict.Add("ActualOutboundAmount", ActualOutboundAmount);
    return dict;
}

}

//销售出库的字段常量，封装变化部分 public class SalesOutboundConstants { public static readonly string SchemaCode = "D287672SalesoutBound"; //订单产品明细 public static readonly string SchemaCode_OutboundDetails = "D287672OutboundDetails"; //出库产品明细 public static readonly string SchemaCode_OutboundProductDetails = "D287672OutboundProductDetails";

public static readonly string FieldCode_ObjectId = "ObjectId";
//客户
public static readonly string FieldCode_CustomerId = "CustomerId";
//出库时间
public static readonly string FieldCode_Date = "Date";
//对账状态
public static readonly string FieldCode_ReconciliationStatus = "ReconciliationStatus";
//对账方式
public static readonly string FieldCode_ReconciliationMethod = "ReconciliationMethod";
public static readonly string FieldCode_OutboundDetail_DefaultWarehouseId = "F0000001";
//出库订单产品
public static readonly string FieldCode_OutboundDetail_OrderProductId = "OrderProductId";
//产品
public static readonly string FieldCode_OutboundDetail_ProductId = "ProductId";
public static readonly string FieldCode_OutboundDetail_ProductName = "ProductName";
public static readonly string FieldCode_OutboundDetail_ProductUnit = "ProductUnit";
public static readonly string FieldCode_OutboundDetail_OutboundAmount = "OutboundAmount";
public static readonly string FieldCode_OutboundDetail_ActualOutboundQuantity = "ActualOutboundQuantity";
public static readonly string FieldCode_OutboundDetail_TaxUnitPrice = "TaxUnitPrice";
public static readonly string FieldCode_OutboundDetail_ActualOutboundQuantity2 = "ActualOutboundQuantity2";

/// <summary>
/// 出库产品明细-产品
/// </summary>

public static readonly string FieldCode_OutboundProductDetails_ProductId = "ProductId";

}

//查询数据 public class QueryUtility { public static VirtualObject[] GetVirtualObjects(IBizObjectManager bizObjectManager, H3.Data.Filter.Filter filter, string schemaCode) { int count = 0; Dictionary < string, BizObjectHeader > relatedHeaders = null; Dictionary < string, string > unitTable = null; VirtualObject[] vos = bizObjectManager.GetList(H3.Organization.User.SystemUserId, schemaCode, H3.DataModel.GetListScopeType.GlobalAll, filter, out count, false, out relatedHeaders, out unitTable); return vos; }

public static BizObject[] GetBizObjectList(H3.IEngine engine,string schemaCode,H3.Data.Filter.Filter filter)
{
    H3.DataModel.BizObjectSchema schema = engine.BizObjectManager.GetPublishedSchema(schemaCode); 
    H3.DataModel.BizObject[] bizObjects = H3.DataModel.BizObject.GetList(engine, H3.Organization.User.SystemUserId, schema, H3.DataModel.GetListScopeType.GlobalAll, filter); 
    return bizObjects;
}

}