From 5f28026d6925e1933c4635e357c3b6bf1ee8ef61 Mon Sep 17 00:00:00 2001 From: xuhaihui <2098865055@qq.com> Date: Tue, 23 Dec 2025 10:38:19 +0800 Subject: [PATCH] =?UTF-8?q?=E6=A0=87=E8=AE=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../report/WarehouseReportQueryPluginExt.java | 894 ++++++++++++++++++ 1 file changed, 894 insertions(+) create mode 100644 code/zcdev/zcgj-zcdev-zcdev-pr/src/main/java/zcgj/zcdev/zcdev/pr/plugin/report/WarehouseReportQueryPluginExt.java diff --git a/code/zcdev/zcgj-zcdev-zcdev-pr/src/main/java/zcgj/zcdev/zcdev/pr/plugin/report/WarehouseReportQueryPluginExt.java b/code/zcdev/zcgj-zcdev-zcdev-pr/src/main/java/zcgj/zcdev/zcdev/pr/plugin/report/WarehouseReportQueryPluginExt.java new file mode 100644 index 0000000..5cd4462 --- /dev/null +++ b/code/zcdev/zcgj-zcdev-zcdev-pr/src/main/java/zcgj/zcdev/zcdev/pr/plugin/report/WarehouseReportQueryPluginExt.java @@ -0,0 +1,894 @@ +// +// Source code recreated from a .class file by IntelliJ IDEA +// (powered by FernFlower decompiler) +// + +package zcgj.zcdev.zcdev.pr.plugin.report; + +import java.util.ArrayList; +import java.util.Calendar; +import java.util.Date; +import java.util.Iterator; +import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import kd.bos.algo.DataSet; +import kd.bos.algo.GroupbyDataSet; +import kd.bos.algo.JoinType; +import kd.bos.dataentity.entity.DataEntityBase; +import kd.bos.dataentity.entity.DynamicObject; +import kd.bos.dataentity.entity.DynamicObjectCollection; +import kd.bos.dataentity.resource.ResManager; +import kd.bos.dataentity.utils.StringUtils; +import kd.bos.entity.report.AbstractReportColumn; +import kd.bos.entity.report.AbstractReportListDataPlugin; +import kd.bos.entity.report.FilterInfo; +import kd.bos.entity.report.ReportQueryParam; +import kd.bos.orm.query.QFilter; +import kd.bos.servicehelper.QueryServiceHelper; +import kd.bos.servicehelper.org.OrgUnitServiceHelper; +import kd.ec.basedata.common.utils.CurrencyHelper; +import org.jetbrains.annotations.NotNull; + +public class WarehouseReportQueryPluginExt extends AbstractReportListDataPlugin { + private static final String[] sumFieldArr = new String[]{"initqty", "initamtoftax", "initamtofnotax", "inqty", "inamtofnotax", "inamtoftax", "outqty", "outamtoftax", "outamtofnotax", "stockqty", "stockamtoftax", "stockamtofnotax"}; + private static final List commonSelectFieldList = (List) Stream.of("materialnumber", " modelnum", "calculateunit", "lotnum", "initqty", "initamtoftax", "initamtofnotax", "inqty", "inamtofnotax", "inamtoftax", "outqty", "outamtoftax", "outamtofnotax", "stockqty", "stockamtoftax", "stockamtofnotax", "project", "unitproject", "warehouse").collect(Collectors.toList()); + private static final String baseQueryString = "billno,project,warehouse,entryentity.material.resource.name as resourcename,entryentity.material.resource as resource,entryentity.material as materialnumber,entryentity.modelnum as modelnum,entryentity.measureunit as calculateunit,entryentity.lot as lotnum,"; + private static final int BILLTYPE_WAREHOUSE_INIT = 0; + private static final int BILLTYPE_MATERIAL_IN = 1; + private static final int BILLTYPE_MATERIAL_OUT = 2; + private static final int BILLTYPE_ALLOCATION_IN = 3; + private static final int BILLTYPE_ALLOCATION_OUT = 4; + + public WarehouseReportQueryPluginExt() { + } + + public DataSet query(ReportQueryParam param, Object arg1) throws Throwable { + DataSet initDataSet = this.getInitDataSet(param); + DataSet inOutDataSet = this.getInOutDataSet(param); + DataSet stockDataSet = this.getStockDataSet(param); + DataSet orderDataSet = this.handleDataSet(param, initDataSet, inOutDataSet, stockDataSet); + return orderDataSet; + } + + public List getColumns(List columns) throws Throwable { + ReportQueryParam queryParam = this.getQueryParam(); + FilterInfo filterInfo = queryParam.getFilter(); + boolean enableproject = filterInfo.getBoolean("enableproject"); + boolean enableunitproject = filterInfo.getBoolean("enableunitproject"); + boolean enablewarehouse = filterInfo.getBoolean("enablewarehouse"); + if (!enablewarehouse) { + columns.remove(4); + } + + if (!enableunitproject) { + columns.remove(3); + } + + if (!enableproject) { + columns.remove(2); + } + + return super.getColumns(columns); + } + + protected DataSet handleDataSet(ReportQueryParam param, DataSet initDataSet, DataSet inOutDataSet, DataSet stockDataSet) { + String commonFieldString = "project,unitproject,warehouse,materialnumber,resourcename,resource,modelnum,calculateunit,lotnum"; + DataSet materialDataSet = initDataSet.select(commonFieldString).union(inOutDataSet.select(commonFieldString)).union(stockDataSet.select(commonFieldString)).groupBy(commonFieldString.split(",")).finish(); + DataSet newInitDataSet = this.leftJoinInitDataSet(materialDataSet, initDataSet); + DataSet initInOutDataSet = this.leftJoinInOutDataSet(newInitDataSet, inOutDataSet); + DataSet resultSet = this.leftJoinStockDataSet(initInOutDataSet, stockDataSet); + DataSet addLineTypeDataSet = this.addLineTypeToCommonDataSet(resultSet); + DataSet initSumByGroupDataSet = this.sumDataSetByGroup(new String[]{"resource", "resourcename"}, resultSet, sumFieldArr); + DataSet initTotalSumByGroupDataSet = this.sumDataSetByGroup(new String[0], initSumByGroupDataSet, sumFieldArr); + DataSet totalSumResultSet = this.addLineTypeToTotalSumDataSet(initTotalSumByGroupDataSet); + DataSet groupSumDataSet = this.addLineTypeToSummaryDataSet(initSumByGroupDataSet); + DataSet afterLeftJoinSet = this.leftJoinByGroupSet(groupSumDataSet); + DataSet recursionByGroupDataSet = this.summaryAndFilterNullLine(afterLeftJoinSet); + DataSet newRecursionByGroupDataSet = this.summaryLeafAndSelfDataSet(recursionByGroupDataSet); + DataSet unionSet = addLineTypeDataSet.union(newRecursionByGroupDataSet); + DataSet orderDataSet = this.orderByAndAddTotalLineDataSet(param, unionSet, totalSumResultSet); + FilterInfo filterInfo = param.getFilter(); + DynamicObject org = filterInfo.getDynamicObject("org"); + DynamicObject currency = CurrencyHelper.getCurrency((Long) org.getPkValue()); + orderDataSet = orderDataSet.addField(String.valueOf(currency.getPkValue()), "currency"); + return orderDataSet; + } + + @NotNull + protected QFilter getSubordinateOrgFilter(DynamicObject org) { + List orgIds = new ArrayList(); + orgIds.add(org.getLong("id")); + List subordinateOrgIds = OrgUnitServiceHelper.getAllSubordinateOrgs(Long.parseLong("15"), orgIds, true); + return new QFilter("org", "in", subordinateOrgIds); + } + + private DataSet summaryLeafAndSelfDataSet(DataSet recursionByGroupDataSet) { + List fieldList = new ArrayList(); + fieldList.add("1 as linetype"); + fieldList.add(String.format(ResManager.loadKDString("'汇总行'%s", "WarehouseReportQueryPlugin_3", "ec-ecma-report", new Object[0]), " as sumresource")); + fieldList.add("resource"); + fieldList.addAll(commonSelectFieldList); + DataSet newRecursionByGroupDataSet = this.sumDataSetByGroup(new String[]{"resource"}, recursionByGroupDataSet, sumFieldArr).addNullField(new String[]{"project", "unitproject", "warehouse", "materialnumber", "modelnum", "calculateunit", "lotnum"}).select((String[]) fieldList.toArray(new String[fieldList.size()])); + return newRecursionByGroupDataSet; + } + + private DataSet summaryAndFilterNullLine(DataSet afterLeftJoinSet) { + List fieldList = new ArrayList(); + int maxLevel = this.getMaxLevelByMaterialGroup(); + fieldList.clear(); + fieldList.add("1 as linetype"); + fieldList.add(String.format(ResManager.loadKDString("'汇总行'%s", "WarehouseReportQueryPlugin_3", "ec-ecma-report", new Object[0]), " as sumresource")); + fieldList.add("resource"); + fieldList.addAll(commonSelectFieldList); + DataSet recursionByGroupDataSet = this.groupParentToSumDataSet(afterLeftJoinSet, maxLevel).filter("level > 0 and (initqty !=null or inqty != null or outqty !=null or stockqty !=null)").select((String[]) fieldList.toArray(new String[fieldList.size()])); + return recursionByGroupDataSet; + } + + private DataSet orderByAndAddTotalLineDataSet(ReportQueryParam param, DataSet sourceDataSet, DataSet totalSumResultSet) { + sourceDataSet.print(true); + List fieldList1 = new ArrayList(); + fieldList1.add("longnumber"); + fieldList1.add("linetype"); + fieldList1.add("sumresource"); + fieldList1.add("resource"); + fieldList1.addAll(commonSelectFieldList); + DataSet materGroupDataSet = this.getMaterialGroupDataSet(); + DataSet neworderDataSet = sourceDataSet.join(materGroupDataSet, JoinType.LEFT).on("resource", "id").select("project,unitproject,warehouse,linetype, sumresource, resource, materialnumber, modelnum, calculateunit, lotnum, initqty, initamtoftax, initamtofnotax, inqty, inamtofnotax, inamtoftax, outqty, outamtoftax, outamtofnotax, stockqty, stockamtoftax, stockamtofnotax".split(","), new String[]{"longnumber"}).finish().select((String[]) fieldList1.toArray(new String[fieldList1.size()])); + List fieldList2 = new ArrayList(); + fieldList2.add("number"); + fieldList2.add("longnumber"); + fieldList2.add("linetype"); + fieldList2.add("sumresource"); + fieldList2.add("resource"); + fieldList2.addAll(commonSelectFieldList); + DataSet materialDataSet = this.getMaterialDataSet(); + neworderDataSet = neworderDataSet.join(materialDataSet, JoinType.LEFT).on("materialnumber", "id").select("project,unitproject,warehouse,longnumber,linetype, sumresource, resource, materialnumber, modelnum, calculateunit, lotnum, initqty, initamtoftax, initamtofnotax, inqty, inamtofnotax, inamtoftax, outqty, outamtoftax, outamtofnotax, stockqty, stockamtoftax, stockamtofnotax".split(","), new String[]{"number"}).finish().select((String[]) fieldList2.toArray(new String[fieldList2.size()])); + List fieldList3 = new ArrayList(); + fieldList3.add("parentname"); + fieldList3.add("number"); + fieldList3.add("longnumber"); + fieldList3.add("linetype"); + fieldList3.add("sumresource"); + fieldList3.add("resource"); + fieldList3.addAll(commonSelectFieldList); + DataSet materialGroupDataSet = this.getMaterialGroupDataSet(); + neworderDataSet = neworderDataSet.join(materialGroupDataSet, JoinType.LEFT).on("resource", "id").select("project,unitproject,warehouse,number,longnumber,linetype, sumresource, resource, materialnumber, modelnum, calculateunit, lotnum, initqty, initamtoftax, initamtofnotax, inqty, inamtofnotax, inamtoftax, outqty, outamtoftax, outamtofnotax, stockqty, stockamtoftax, stockamtofnotax".split(","), new String[]{"parentname"}).finish().select((String[]) fieldList3.toArray(new String[fieldList3.size()])); + List calSelectFieldList = (List) Stream.of("materialnumber", " modelnum", "calculateunit", "lotnum", "initqty", "initamtoftax", "initamtofnotax", "initamtoftax-initamtofnotax as inittotaltaxamt", "inqty", "inamtofnotax", "inamtoftax", "inamtoftax-inamtofnotax as intotaltaxamt", "outqty", "outamtofnotax", "stockqty", "stockamtofnotax").collect(Collectors.toList()); + List groupByFields = (List) Stream.of("parentname", "number", "longnumber", "linetype", "sumresource", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum").collect(Collectors.toList()); + FilterInfo filterInfo = param.getFilter(); + boolean enableproject = filterInfo.getBoolean("enableproject"); + boolean enableunitproject = filterInfo.getBoolean("enableunitproject"); + boolean enablewarehouse = filterInfo.getBoolean("enablewarehouse"); + if (enableproject) { + calSelectFieldList.add("project"); + groupByFields.add("project"); + } else { + totalSumResultSet = totalSumResultSet.removeFields(new String[]{"project"}); + } + + if (enableunitproject) { + calSelectFieldList.add("unitproject"); + groupByFields.add("unitproject"); + } else { + totalSumResultSet = totalSumResultSet.removeFields(new String[]{"unitproject"}); + } + + if (enablewarehouse) { + calSelectFieldList.add("warehouse"); + groupByFields.add("warehouse"); + } else { + totalSumResultSet = totalSumResultSet.removeFields(new String[]{"warehouse"}); + } + + List fieldList = new ArrayList(); + fieldList.add("case when linetype!=2 then parentname else null end as parentname"); + fieldList.add("number"); + fieldList.add("longnumber"); + fieldList.add("linetype"); + fieldList.add("case when linetype!=2 then sumresource else null end as sumresource"); + fieldList.add("resource"); + fieldList.addAll(calSelectFieldList); + DataSet select1 = totalSumResultSet.select((String[]) fieldList.toArray(new String[fieldList.size()])); + DataSet finish = neworderDataSet.groupBy((String[]) groupByFields.toArray(new String[groupByFields.size()])).sum("initqty").sum("initamtoftax").sum("initamtofnotax").sum("inqty").sum("inamtofnotax").sum("inamtoftax").sum("outqty").sum("outamtofnotax").sum("stockqty").sum("stockamtofnotax").finish(); + DataSet select = finish.orderBy(new String[]{"longnumber", "linetype", "number", "modelnum", "lotnum"}).select((String[]) fieldList.toArray(new String[fieldList.size()])).union(select1); + return select; + } + + private DataSet getMaterialDataSet() { + DataSet materialDataSet = QueryServiceHelper.queryDataSet(this.getClass().getName(), "ecbd_resourceitem", "id,number", new QFilter[0], "number"); + return materialDataSet; + } + + private DataSet addLineTypeToCommonDataSet(DataSet commonDataSet) { + List fieldList = new ArrayList(); + fieldList.add("2 as linetype"); + fieldList.add("resourcename as sumresource"); + fieldList.add("resource"); + fieldList.addAll(commonSelectFieldList); + DataSet addLineTypeDataSet = commonDataSet.select((String[]) fieldList.toArray(new String[fieldList.size()])); + return addLineTypeDataSet; + } + + private DataSet addLineTypeToTotalSumDataSet(DataSet initTotalSumByGroupDataSet) { + List fieldList = new ArrayList(); + fieldList.add(String.format(ResManager.loadKDString("'总合计行'%s", "WarehouseReportQueryPlugin_4", "ec-ecma-report", new Object[0]), " as parentname")); + fieldList.add("'' as number"); + fieldList.add("'' as longnumber"); + fieldList.add("3 as linetype"); + fieldList.add(String.format(ResManager.loadKDString("'合计行'%s", "WarehouseReportQueryPlugin_5", "ec-ecma-report", new Object[0]), " as sumresource")); + fieldList.add("resource"); + fieldList.addAll(commonSelectFieldList); + DataSet totalSumResultSet = initTotalSumByGroupDataSet.addNullField(new String[]{"project", "unitproject", "warehouse", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum"}).select((String[]) fieldList.toArray(new String[fieldList.size()])); + return totalSumResultSet; + } + + private DataSet addLineTypeToSummaryDataSet(DataSet SummaryDataSet) { + List fieldList = new ArrayList(); + fieldList.add("1 as linetype"); + fieldList.add("resourcename as sumresource"); + fieldList.add("resource"); + fieldList.addAll(commonSelectFieldList); + DataSet groupSumDataSet = SummaryDataSet.addNullField(new String[]{"project", "unitproject", "warehouse", "materialnumber", "modelnum", "calculateunit", "lotnum"}).select((String[]) fieldList.toArray(new String[fieldList.size()])); + return groupSumDataSet; + } + + private DataSet getMaterialGroupDataSet() { + QFilter resourceTypeFilter = new QFilter("resourcetype", "=", "03"); + QFilter enableFilter = new QFilter("enable", "=", "1"); + DataSet materialGroupDataSet = QueryServiceHelper.queryDataSet(this.getClass().getName(), "ecbd_resource", "id,level,parent,parent.name as parentname,longnumber", new QFilter[]{resourceTypeFilter, enableFilter}, "level"); + return materialGroupDataSet; + } + + private DataSet leftJoinByGroupSet(DataSet groupSumDataSet) { + DataSet materialGroupSet = this.getMaterialGroupDataSet(); + List fieldList = new ArrayList(); + fieldList.add("3 as linetype"); + fieldList.add(String.format(ResManager.loadKDString("'合计行'%s", "WarehouseReportQueryPlugin_5", "ec-ecma-report", new Object[0]), " as sumresource")); + fieldList.add("resource"); + fieldList.addAll(commonSelectFieldList); + DataSet afterJoinDataSet = materialGroupSet.join(groupSumDataSet, JoinType.LEFT).on("id", "resource").select(new String[]{"id", "parent", "level"}, (String[]) fieldList.toArray(new String[fieldList.size()])).finish(); + return afterJoinDataSet; + } + + private DataSet leftJoinByGroupSetNoLevel(DataSet groupSumDataSet) { + DataSet materialGroupSet = this.getMaterialGroupDataSet(); + List fieldList = new ArrayList(); + fieldList.add("level"); + fieldList.add("1 as linetype"); + fieldList.add(String.format(ResManager.loadKDString("'汇总行'%s", "WarehouseReportQueryPlugin_3", "ec-ecma-report", new Object[0]), " as sumresource")); + fieldList.add("resource"); + fieldList.addAll(commonSelectFieldList); + DataSet afterJoinDataSet = materialGroupSet.join(groupSumDataSet, JoinType.LEFT).on("id", "resource").select(new String[]{"id", "parent"}, (String[]) fieldList.toArray(new String[fieldList.size()])).finish(); + return afterJoinDataSet; + } + + private DataSet groupParentToSumDataSet(DataSet groupSumDataSet, int maxLevel) { + if (maxLevel > 1) { + DataSet tempGroupSumDataSet = groupSumDataSet.copy().filter((new QFilter("level", "=", maxLevel)).toString()); + GroupbyDataSet maxLevelGroupByParentDataSet = tempGroupSumDataSet.groupBy(new String[]{"parent", "level"}); + DataSet sumMaxLevelGroupByParentDataSet = this.sumColumn(maxLevelGroupByParentDataSet, sumFieldArr).finish(); + List fieldList = new ArrayList(); + --maxLevel; + fieldList.add("parent as id"); + fieldList.add("parent"); + fieldList.add(maxLevel + " as level"); + fieldList.add("1 as linetype"); + fieldList.add(String.format(ResManager.loadKDString("'汇总行'%s", "WarehouseReportQueryPlugin_3", "ec-ecma-report", new Object[0]), " as sumresource")); + fieldList.add("parent as resource"); + fieldList.addAll(commonSelectFieldList); + DataSet totalSumResultSet = sumMaxLevelGroupByParentDataSet.addNullField(new String[]{"id", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse"}).select((String[]) fieldList.toArray(new String[fieldList.size()])); + DataSet newDataSet = groupSumDataSet.union(totalSumResultSet); + DataSet newnewDataSet = this.leftJoinByGroupSetNoLevel(newDataSet); + return this.groupParentToSumDataSet(newnewDataSet, maxLevel); + } else { + return groupSumDataSet; + } + } + + private int getMaxLevelByMaterialGroup() { + QFilter resourceTypeFilter = new QFilter("resourcetype", "=", "03"); + QFilter enableFilter = new QFilter("enable", "=", "1"); + DynamicObjectCollection levelCol = QueryServiceHelper.query("ecbd_resource", "level", new QFilter[]{resourceTypeFilter, enableFilter}); + int max = 1; + Iterator var5 = levelCol.iterator(); + + while (var5.hasNext()) { + DynamicObject dynamicObject = (DynamicObject) var5.next(); + if (max < dynamicObject.getInt("level")) { + max = dynamicObject.getInt("level"); + } + } + + return max; + } + + private GroupbyDataSet sumColumn(GroupbyDataSet dataSet, String... sumFields) { + String[] var3 = sumFields; + int var4 = sumFields.length; + + for (int var5 = 0; var5 < var4; ++var5) { + String sumField = var3[var5]; + dataSet.sum(sumField); + } + + return dataSet; + } + + private DataSet sumDataSetByGroup(String[] groupByFields, DataSet dataSet, String[] sumField) { + dataSet = this.sumColumn(dataSet.groupBy(groupByFields), sumField).finish(); + return dataSet; + } + + private DataSet leftJoinInitDataSet(DataSet materialDataSet, DataSet initDataSet) { + DataSet afterJoinDataSet = materialDataSet.join(initDataSet, JoinType.LEFT).on("materialnumber", "materialnumber").on("modelnum", "modelnum").on("calculateunit", "calculateunit").on("lotnum", "lotnum").on("project", "project").on("unitproject", "unitproject").on("warehouse", "warehouse").select(new String[]{"project", "unitproject", "warehouse", "materialnumber", "resourcename", "resource", "modelnum", "calculateunit", "lotnum"}, new String[]{"initqty", "initamtoftax", "initamtofnotax"}).finish(); + return afterJoinDataSet; + } + + private DataSet leftJoinInOutDataSet(DataSet initDataSet, DataSet inOutDataSet) { + String selectString = "project,unitproject,warehouse,resourcename,resource,materialnumber,modelnum,calculateunit,lotnum,initqty,initamtoftax,initamtofnotax"; + DataSet afterJoinDataSet = initDataSet.join(inOutDataSet, JoinType.LEFT).on("materialnumber", "materialnumber").on("modelnum", "modelnum").on("calculateunit", "calculateunit").on("lotnum", "lotnum").on("project", "project").on("unitproject", "unitproject").on("warehouse", "warehouse").select(selectString.split(","), new String[]{"inqty", "inamtofnotax", "inamtoftax", "outqty", "outamtoftax", "outamtofnotax"}).finish(); + return afterJoinDataSet; + } + + private DataSet leftJoinStockDataSet(DataSet sourceDataSet, DataSet stockDataSet) { + String selectString = "project,unitproject,warehouse,resourcename,resource,materialnumber,modelnum,calculateunit,lotnum,initqty,initamtoftax,initamtofnotax,inqty,inamtoftax,inamtofnotax,outqty,outamtoftax,outamtofnotax"; + DataSet afterJoinDataSet = sourceDataSet.join(stockDataSet, JoinType.LEFT).on("materialnumber", "materialnumber").on("modelnum", "modelnum").on("calculateunit", "calculateunit").on("lotnum", "lotnum").on("project", "project").on("unitproject", "unitproject").on("warehouse", "warehouse").select(selectString.split(","), new String[]{"stockqty", "stockamtoftax", "stockamtofnotax"}).finish(); + return afterJoinDataSet; + } + + private DataSet getInitDataSet(ReportQueryParam param) { + List initBillFilter = this.getCommonFilterByParam(param, 0, 0); + List inFilter = this.getCommonFilterByParam(param, 0, 1); + List outFilter = this.getCommonFilterByParam(param, 0, 2); + DynamicObject org = param.getFilter().getDynamicObject("org"); + DynamicObject orgCurrency = CurrencyHelper.getCurrency((Long) org.getPkValue()); + DynamicObject exRateTable = CurrencyHelper.getExRateTable((Long) org.getPkValue()); + DataSet warehouseInitDataSet = this.getWareHouseInitDataSet(initBillFilter, orgCurrency, exRateTable); + DataSet materialInDataSet = this.getMaterialInitDataSet(inFilter, orgCurrency, exRateTable); + DataSet materialOutDataSet = this.getMaterialOutInitDataSet(outFilter, orgCurrency, exRateTable); + DataSet allocationInDataSet = this.getAllocationInitDataSet(param, orgCurrency, exRateTable, 3); + DataSet allocationOutDataSet = this.getAllocationInitDataSet(param, orgCurrency, exRateTable, 4); + DataSet compMatOutDataSet = this.getCompMatInitDataSet(param, orgCurrency, exRateTable); + DataSet checkingAdjustInitDataSet = this.getCheckingAdjustInitDataSet(param, orgCurrency, exRateTable); + DataSet unionDataSet = warehouseInitDataSet.union(materialInDataSet).union(materialOutDataSet).union(allocationInDataSet).union(allocationOutDataSet).union(checkingAdjustInitDataSet).union(compMatOutDataSet); + DataSet groupBySet = unionDataSet.groupBy(new String[]{"project", "unitproject", "warehouse", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum"}).sum("initqty").sum("initamtoftax").sum("initamtofnotax").finish(); + return groupBySet; + } + + private DataSet getMaterialOutInitDataSet(List outFilter, DynamicObject orgCurrency, DynamicObject exRateTable) { + String materialOutString = "billno,project,warehouse,entryentity.material.resource.name as resourcename,entryentity.material.resource as resource,entryentity.material as materialnumber,entryentity.modelnum as modelnum,entryentity.measureunit as calculateunit,entryentity.lot as lotnum,case when transtype.type='INCREASE' then entryentity.qty when transtype.type='REDUCE' then 0-entryentity.qty else 0 end as initqty,currency,unitprojectpro as unitproject,case when transtype.type='INCREASE' then entryentity.amount when transtype.type='REDUCE' then 0-entryentity.amount else 0 end as initamtoftax,case when transtype.type='INCREASE' then entryentity.amount when transtype.type='REDUCE' then 0-entryentity.amount else 0 end as initamtofnotax"; + outFilter.add(new QFilter("matbilltype", "=", "materialout")); + outFilter.add(new QFilter("transtype.type", "!=", "UNIMPACT")); + DataSet materialOutDataSet = QueryServiceHelper.queryDataSet(this.getClass().getName(), "ecma_materialoutbill", materialOutString, (QFilter[]) outFilter.toArray(new QFilter[outFilter.size()]), ""); + DataSet groupBySet = materialOutDataSet.groupBy(new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "currency", "project", "unitproject", "warehouse"}).sum("initqty").sum("initamtoftax").sum("initamtofnotax").finish(); + DataSet rateDataSet = CurrencyHelper.getExchangeRateDataSet(orgCurrency, exRateTable, this.getClass().getName()); + String[] materialFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "initqty", "initamtoftax", "initamtofnotax"}; + String[] materialWithRateFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "initqty", "initamtoftax * rate as initamtoftax", "initamtofnotax * rate as initamtofnotax"}; + return groupBySet.copy().join(rateDataSet, JoinType.LEFT).on("currency", "ratecurrency").select(materialFields, new String[]{"rate"}).finish().select((String) Stream.of(materialFields).collect(Collectors.joining(",")) + ",case when rate <= 0 then 1 else rate end as rate").select((String) Stream.of(materialWithRateFields).collect(Collectors.joining(","))); + } + + private DataSet getCompMatInitDataSet(ReportQueryParam param, DynamicObject orgCurrency, DynamicObject exRateTable) { + List outFilter = this.getCompMatFilterByParam(param, 0); + String materialOutString = "billno,entryentity.subentryentity.material.resource.name as resourcename,entryentity.subentryentity.material.resource as resource,entryentity.subentryentity.material as materialnumber,entryentity.subentryentity.modelnum as modelnum,entryentity.subentryentity.measureunit as calculateunit,entryentity.subentryentity.lot as lotnum,0-entryentity.subentryentity.qty as initqty,currency,project,unitproject,0-entryentity.subentryentity.amount as initamtoftax,0-entryentity.subentryentity.amount as initamtofnotax,entryentity.subentryentity.warehouse as warehouse"; + DataSet materialOutDataSet = QueryServiceHelper.queryDataSet(this.getClass().getName(), "ecma_compmatout", materialOutString, (QFilter[]) outFilter.toArray(new QFilter[outFilter.size()]), ""); + DataSet groupBySet = materialOutDataSet.groupBy(new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "currency", "project", "unitproject", "warehouse"}).sum("initqty").sum("initamtoftax").sum("initamtofnotax").finish(); + DataSet rateDataSet = CurrencyHelper.getExchangeRateDataSet(orgCurrency, exRateTable, this.getClass().getName()); + String[] materialFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "initqty", "initamtoftax", "initamtofnotax"}; + String[] materialWithRateFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "initqty", "initamtoftax * rate as initamtoftax", "initamtofnotax * rate as initamtofnotax"}; + return groupBySet.join(rateDataSet, JoinType.LEFT).on("currency", "ratecurrency").select(materialFields, new String[]{"rate"}).finish().select((String) Stream.of(materialFields).collect(Collectors.joining(",")) + ",case when rate <= 0 then 1 else rate end as rate").select((String) Stream.of(materialWithRateFields).collect(Collectors.joining(","))); + } + + private DataSet getMaterialInitDataSet(List inFilter, DynamicObject orgCurrency, DynamicObject exRateTable) { + String materialInString = "billno,project,warehouse,entryentity.material.resource.name as resourcename,entryentity.material.resource as resource,entryentity.material as materialnumber,entryentity.modelnum as modelnum,entryentity.measureunit as calculateunit,entryentity.lot as lotnum,case when transtype.type='INCREASE' then entryentity.qty when transtype.type='REDUCE' then 0-entryentity.qty else 0 end as initqty,case when transtype.type='INCREASE' then entryentity.oftaxamount when transtype.type='REDUCE' then 0-entryentity.oftaxamount else 0 end as initamtoftax,case when transtype.type='INCREASE' then entryentity.notaxamount when transtype.type='REDUCE' then 0-entryentity.notaxamount else 0 end as initamtofnotax,currency,unitprojectpro as unitproject"; + inFilter.add(new QFilter("matbilltype", "=", "materialin")); + inFilter.add(new QFilter("transtype.type", "!=", "UNIMPACT")); + DataSet materialInDataSet = QueryServiceHelper.queryDataSet(this.getClass().getName(), "ecma_materialinbill", materialInString, (QFilter[]) inFilter.toArray(new QFilter[inFilter.size()]), ""); + DataSet groupBySet = materialInDataSet.groupBy(new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "currency", "project", "unitproject", "warehouse"}).sum("initqty").sum("initamtoftax").sum("initamtofnotax").finish(); + DataSet rateDataSet = CurrencyHelper.getExchangeRateDataSet(orgCurrency, exRateTable, this.getClass().getName()); + String[] materialFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "initqty", "initamtoftax", "initamtofnotax"}; + String[] materialWithRateFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "initqty", "initamtoftax * rate as initamtoftax", "initamtofnotax * rate as initamtofnotax"}; + return groupBySet.join(rateDataSet, JoinType.LEFT).on("currency", "ratecurrency").select(materialFields, new String[]{"rate"}).finish().select((String) Stream.of(materialFields).collect(Collectors.joining(",")) + ",case when rate <= 0 then 1 else rate end as rate").select((String) Stream.of(materialWithRateFields).collect(Collectors.joining(","))); + } + + private DataSet getWareHouseInitDataSet(List initBillFilter, DynamicObject orgCurrency, DynamicObject exRateTable) { + String warehouInitString = "billno,project,warehouse,entryentity.material.resource.name as resourcename,entryentity.material.resource as resource,entryentity.material as materialnumber,entryentity.modelnum as modelnum,entryentity.measureunit as calculateunit,entryentity.lot as lotnum,entryentity.qty as initqty,currency,unitproject,entryentity.amount as initamtoftax,entryentity.amount as initamtofnotax"; + DataSet warehouseInitDataSet = QueryServiceHelper.queryDataSet(this.getClass().getName(), "ecma_warehouseinit", warehouInitString, (QFilter[]) initBillFilter.toArray(new QFilter[initBillFilter.size()]), ""); + DataSet groupBySet = warehouseInitDataSet.groupBy(new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "currency", "project", "unitproject", "warehouse"}).sum("initqty").sum("initamtoftax").sum("initamtofnotax").finish(); + DataSet rateDataSet = CurrencyHelper.getExchangeRateDataSet(orgCurrency, exRateTable, this.getClass().getName()); + String[] materialFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "initqty", "initamtoftax", "initamtofnotax"}; + String[] materialWithRateFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "initqty", "initamtoftax * rate as initamtoftax", "initamtofnotax * rate as initamtofnotax"}; + return groupBySet.join(rateDataSet, JoinType.LEFT).on("currency", "ratecurrency").select(materialFields, new String[]{"rate"}).finish().select((String) Stream.of(materialFields).collect(Collectors.joining(",")) + ",case when rate <= 0 then 1 else rate end as rate").select((String) Stream.of(materialWithRateFields).collect(Collectors.joining(","))); + } + + private DataSet getCheckingAdjustInitDataSet(ReportQueryParam param, DynamicObject orgCurrency, DynamicObject exRateTable) { + List checkingAdjustInitFilter = this.getAdjustFilterByParam(param, 0); + String formId = "ecma_checkingadjust"; + String selectCheckingAdjustStr = "billno,adjustdetailentry.material.resource.name as resourcename,adjustdetailentry.material.resource as resource,adjustdetailentry.material as materialnumber,adjustdetailentry.modelnum as modelnum,adjustdetailentry.measureunit as calculateunit,adjustdetailentry.lot as lotnum,adjustdetailentry.amount as initamtoftax,adjustdetailentry.amount as initamtofnotax,adjustdetailentry.qty as initqty,currency,depot.project as project,depot.unitproject as unitproject,depot as warehouse"; + DataSet checkingAdjustDataSet = QueryServiceHelper.queryDataSet(this.getClass().getName(), formId, selectCheckingAdjustStr, (QFilter[]) checkingAdjustInitFilter.toArray(new QFilter[checkingAdjustInitFilter.size()]), ""); + DataSet groupBySet = checkingAdjustDataSet.groupBy(new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "currency", "project", "unitproject", "warehouse"}).sum("initqty").sum("initamtoftax").sum("initamtofnotax").finish(); + DataSet rateDataSet = CurrencyHelper.getExchangeRateDataSet(orgCurrency, exRateTable, this.getClass().getName()); + String[] materialFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "initqty", "initamtoftax", "initamtofnotax"}; + String[] materialWithRateFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "initqty", "initamtoftax * rate as initamtoftax", "initamtofnotax * rate as initamtofnotax"}; + return groupBySet.join(rateDataSet, JoinType.LEFT).on("currency", "ratecurrency").select(materialFields, new String[]{"rate"}).finish().select((String) Stream.of(materialFields).collect(Collectors.joining(",")) + ",case when rate <= 0 then 1 else rate end as rate").select((String) Stream.of(materialWithRateFields).collect(Collectors.joining(","))); + } + + private DataSet getAllocationInitDataSet(ReportQueryParam param, DynamicObject orgCurrency, DynamicObject exRateTable, int billType) { + List allocationInBillFilter = this.getCommonFilterByParam(param, 0, billType); + String selectAllocationStr = ""; + String formId = ""; + if (billType == 3) { + formId = "ecma_allocationin"; + selectAllocationStr = "billno,entryentity.material.resource.name as resourcename,entryentity.material.resource as resource,entryentity.material as materialnumber,entryentity.modelnum as modelnum,entryentity.measureunit as calculateunit,entryentity.lot as lotnum,entryentity.qty as initqty,currency,inproject as project,inunitproject as unitproject,entryentity.oftaxamount as initamtoftax,entryentity.amount as initamtofnotax,inwarehouse as warehouse"; + } else { + formId = "ecma_allocationout"; + selectAllocationStr = "billno,entryentity.material.resource.name as resourcename,entryentity.material.resource as resource,entryentity.material as materialnumber,entryentity.modelnum as modelnum,entryentity.measureunit as calculateunit,entryentity.lot as lotnum,0-entryentity.qty as initqty,currency,outproject as project,outunitproject as unitproject,0-entryentity.oftaxamount as initamtoftax,0-entryentity.amount as initamtofnotax,outwarehouse as warehouse"; + } + + DataSet allocationInDataSet = QueryServiceHelper.queryDataSet(this.getClass().getName(), formId, selectAllocationStr, (QFilter[]) allocationInBillFilter.toArray(new QFilter[allocationInBillFilter.size()]), ""); + DataSet groupBySet = allocationInDataSet.groupBy(new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "currency", "project", "unitproject", "warehouse"}).sum("initqty").sum("initamtoftax").sum("initamtofnotax").finish(); + DataSet rateDataSet = CurrencyHelper.getExchangeRateDataSet(orgCurrency, exRateTable, this.getClass().getName()); + String[] materialFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "initqty", "initamtoftax", "initamtofnotax"}; + String[] materialWithRateFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "initqty", "initamtoftax * rate as initamtoftax", "initamtofnotax * rate as initamtofnotax"}; + return groupBySet.join(rateDataSet, JoinType.LEFT).on("currency", "ratecurrency").select(materialFields, new String[]{"rate"}).finish().select((String) Stream.of(materialFields).collect(Collectors.joining(",")) + ",case when rate <= 0 then 1 else rate end as rate").select((String) Stream.of(materialWithRateFields).collect(Collectors.joining(","))); + } + + private DataSet getCheckingAdjustInOutDataSet(ReportQueryParam param, DynamicObject orgCurrency, DynamicObject exRateTable) { + List checkingAdjustFilter = this.getAdjustFilterByParam(param, 1); + String selectAllocationStr = ""; + String formId = "ecma_checkingadjust"; + selectAllocationStr = "billno,adjustdetailentry.material.resource.name as resourcename,adjustdetailentry.material.resource as resource,adjustdetailentry.material as materialnumber,adjustdetailentry.modelnum as modelnum,adjustdetailentry.measureunit as calculateunit,adjustdetailentry.lot as lotnum,case when adjustdetailentry.qty>0 then adjustdetailentry.qty else 0 end as inqty,case when adjustdetailentry.qty<0 then 0-adjustdetailentry.qty else 0 end as outqty,case when adjustdetailentry.qty>0 then adjustdetailentry.amount else 0 end as inamtoftax, case when adjustdetailentry.qty<0 then 0 - adjustdetailentry.amount else 0 end as outamtoftax,case when adjustdetailentry.qty>0 then adjustdetailentry.amount else 0 end as inamtofnotax,case when adjustdetailentry.qty<0 then 0 - adjustdetailentry.amount else 0 end as outamtofnotax,currency,depot.project as project,depot.unitproject as unitproject,depot as warehouse"; + DataSet allocationInOutDataSet = QueryServiceHelper.queryDataSet(this.getClass().getName(), formId, selectAllocationStr, (QFilter[]) checkingAdjustFilter.toArray(new QFilter[checkingAdjustFilter.size()]), ""); + DataSet groupBySet = allocationInOutDataSet.groupBy(new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "currency", "project", "unitproject", "warehouse"}).sum("inqty").sum("outqty").sum("inamtoftax").sum("inamtofnotax").sum("outamtoftax").sum("outamtofnotax").finish(); + DataSet rateDataSet = CurrencyHelper.getExchangeRateDataSet(orgCurrency, exRateTable, this.getClass().getName()); + String[] materialFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "inqty", "outqty", "inamtoftax", "outamtoftax", "inamtofnotax", "outamtofnotax"}; + String[] materialWithRateFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "inqty", "outqty", "inamtoftax * rate as inamtoftax", "outamtoftax * rate as outamtoftax", "inamtofnotax * rate as inamtofnotax", "outamtofnotax * rate as outamtofnotax"}; + return groupBySet.join(rateDataSet, JoinType.LEFT).on("currency", "ratecurrency").select(materialFields, new String[]{"rate"}).finish().select((String) Stream.of(materialFields).collect(Collectors.joining(",")) + ",case when rate <= 0 then 1 else rate end as rate").select((String) Stream.of(materialWithRateFields).collect(Collectors.joining(","))); + } + + private DataSet getAllocationInOutDataSet(ReportQueryParam param, DynamicObject orgCurrency, DynamicObject exRateTable, int billType) { + List allocationInBillFilter = this.getCommonFilterByParam(param, 1, billType); + String selectAllocationStr = ""; + String formId = ""; + if (billType == 3) { + formId = "ecma_allocationin"; + selectAllocationStr = "billno,entryentity.material.resource.name as resourcename,entryentity.material.resource as resource,entryentity.material as materialnumber,entryentity.modelnum as modelnum,entryentity.measureunit as calculateunit,entryentity.lot as lotnum,entryentity.qty as inqty,0 as outqty,currency,inproject as project,entryentity.oftrantaxamount as inamtoftax, 0 as outamtoftax,entryentity.oftranamount as inamtofnotax,0 as outamtofnotax,inunitproject as unitproject,inwarehouse as warehouse"; + } else { + formId = "ecma_allocationout"; + selectAllocationStr = "billno,entryentity.material.resource.name as resourcename,entryentity.material.resource as resource,entryentity.material as materialnumber,entryentity.modelnum as modelnum,entryentity.measureunit as calculateunit,entryentity.lot as lotnum,0 as inqty,entryentity.qty as outqty,currency,outproject as project,entryentity.oftaxamount as outamtoftax,0 as inamtofnotax,entryentity.amount as outamtofnotax,0 as inamtoftax,outunitproject as unitproject,outwarehouse as warehouse"; + } + + DataSet allocationInOutDataSet = QueryServiceHelper.queryDataSet(this.getClass().getName(), formId, selectAllocationStr, (QFilter[]) allocationInBillFilter.toArray(new QFilter[allocationInBillFilter.size()]), ""); + DataSet groupBySet = allocationInOutDataSet.groupBy(new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "currency", "project", "unitproject", "warehouse"}).sum("inqty").sum("outqty").sum("inamtoftax").sum("inamtofnotax").sum("outamtoftax").sum("outamtofnotax").finish(); + DataSet rateDataSet = CurrencyHelper.getExchangeRateDataSet(orgCurrency, exRateTable, this.getClass().getName()); + String[] materialFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "inqty", "outqty", "inamtoftax", "outamtoftax", "inamtofnotax", "outamtofnotax"}; + String[] materialWithRateFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "inqty", "outqty", "inamtoftax * rate as inamtoftax", "outamtoftax * rate as outamtoftax", "inamtofnotax * rate as inamtofnotax", "outamtofnotax * rate as outamtofnotax"}; + return groupBySet.join(rateDataSet, JoinType.LEFT).on("currency", "ratecurrency").select(materialFields, new String[]{"rate"}).finish().select((String) Stream.of(materialFields).collect(Collectors.joining(",")) + ",case when rate <= 0 then 1 else rate end as rate").select((String) Stream.of(materialWithRateFields).collect(Collectors.joining(","))); + } + + private DataSet getInOutDataSet(ReportQueryParam param) { + List initBillFilter = this.getCommonFilterByParam(param, 1, 0); + List inFilter = this.getCommonFilterByParam(param, 1, 1); + List outFilter = this.getCommonFilterByParam(param, 1, 2); + DynamicObject org = param.getFilter().getDynamicObject("org"); + DynamicObject orgCurrency = CurrencyHelper.getCurrency((Long) org.getPkValue()); + DynamicObject exRateTable = CurrencyHelper.getExRateTable((Long) org.getPkValue()); + DataSet warehouseInitDataSet = this.getWareHouseInOutDataSet(initBillFilter, orgCurrency, exRateTable); + DataSet materialInDataSet = this.getMaterialInInOutDataSet(inFilter, orgCurrency, exRateTable); + DataSet materialOutDataSet = this.getMaterialOutInOutDataSet(outFilter, orgCurrency, exRateTable); + DataSet allocationInDataSet = this.getAllocationInOutDataSet(param, orgCurrency, exRateTable, 3); + DataSet allocationOutDataSet = this.getAllocationInOutDataSet(param, orgCurrency, exRateTable, 4); + DataSet compMatOutDataSet = this.getCompMatOutInOutDataSet(param, orgCurrency, exRateTable); + DataSet checkingAdjustInOutDataSet = this.getCheckingAdjustInOutDataSet(param, orgCurrency, exRateTable); + DataSet unionDataSet = warehouseInitDataSet.union(materialInDataSet).union(materialOutDataSet).union(allocationInDataSet).union(allocationOutDataSet).union(checkingAdjustInOutDataSet).union(compMatOutDataSet); + DataSet groupBySet = unionDataSet.groupBy(new String[]{"project", "unitproject", "warehouse", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum"}).sum("inqty").sum("outqty").sum("inamtoftax").sum("outamtoftax").sum("inamtofnotax").sum("outamtofnotax").finish(); + return groupBySet; + } + + private DataSet getMaterialOutInOutDataSet(List outFilter, DynamicObject orgCurrency, DynamicObject exRateTable) { + String materialOutString = "billno,project,warehouse,entryentity.material.resource.name as resourcename,entryentity.material.resource as resource,entryentity.material as materialnumber,entryentity.modelnum as modelnum,entryentity.measureunit as calculateunit,entryentity.lot as lotnum,0 as inqty,case when transtype.type='INCREASE' then 0-entryentity.qty when transtype.type='REDUCE' then entryentity.qty else 0 end as outqty,0 as inamtoftax,0 as inamtofnotax,case when transtype.type='INCREASE' then 0 - entryentity.amount when transtype.type='REDUCE' then entryentity.amount else 0 end as outamtoftax,case when transtype.type='INCREASE' then 0 - entryentity.amount when transtype.type='REDUCE' then entryentity.amount else 0 end as outamtofnotax,currency,unitprojectpro as unitproject"; + outFilter.add(new QFilter("matbilltype", "=", "materialout")); + outFilter.add(new QFilter("transtype.type", "!=", "UNIMPACT")); + DataSet materialOutDataSet = QueryServiceHelper.queryDataSet(this.getClass().getName(), "ecma_materialoutbill", materialOutString, (QFilter[]) outFilter.toArray(new QFilter[outFilter.size()]), ""); + DataSet groupBySet = materialOutDataSet.groupBy(new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "currency", "project", "unitproject", "warehouse"}).sum("inqty").sum("outqty").sum("inamtoftax").sum("inamtofnotax").sum("outamtoftax").sum("outamtofnotax").finish(); + DataSet rateDataSet = CurrencyHelper.getExchangeRateDataSet(orgCurrency, exRateTable, this.getClass().getName()); + String[] materialFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "inqty", "outqty", "inamtoftax", "outamtoftax", "inamtofnotax", "outamtofnotax"}; + String[] materialWithRateFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "inqty", "outqty", "inamtoftax * rate as inamtoftax", "outamtoftax * rate as outamtoftax", "inamtofnotax * rate as inamtofnotax", "outamtofnotax * rate as outamtofnotax"}; + return groupBySet.join(rateDataSet, JoinType.LEFT).on("currency", "ratecurrency").select(materialFields, new String[]{"rate"}).finish().select((String) Stream.of(materialFields).collect(Collectors.joining(",")) + ",case when rate <= 0 then 1 else rate end as rate").select((String) Stream.of(materialWithRateFields).collect(Collectors.joining(","))); + } + + private DataSet getCompMatOutInOutDataSet(ReportQueryParam param, DynamicObject orgCurrency, DynamicObject exRateTable) { + List outFilter = this.getCompMatFilterByParam(param, 1); + String materialOutString = "billno,entryentity.subentryentity.material.resource.name as resourcename,entryentity.subentryentity.material.resource as resource,entryentity.subentryentity.material as materialnumber,entryentity.subentryentity.modelnum as modelnum,entryentity.subentryentity.measureunit as calculateunit,entryentity.subentryentity.lot as lotnum,0 as inqty, entryentity.subentryentity.qty as outqty,0 as inamtoftax,0 as inamtofnotax,entryentity.subentryentity.amount as outamtoftax,entryentity.subentryentity.amount as outamtofnotax,currency,project,unitproject,entryentity.subentryentity.warehouse as warehouse"; + DataSet materialOutDataSet = QueryServiceHelper.queryDataSet(this.getClass().getName(), "ecma_compmatout", materialOutString, (QFilter[]) outFilter.toArray(new QFilter[outFilter.size()]), ""); + DataSet groupBySet = materialOutDataSet.groupBy(new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "currency", "project", "unitproject", "warehouse"}).sum("inqty").sum("outqty").sum("inamtoftax").sum("inamtofnotax").sum("outamtoftax").sum("outamtofnotax").finish(); + DataSet rateDataSet = CurrencyHelper.getExchangeRateDataSet(orgCurrency, exRateTable, this.getClass().getName()); + String[] materialFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "inqty", "outqty", "inamtoftax", "outamtoftax", "inamtofnotax", "outamtofnotax"}; + String[] materialWithRateFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "inqty", "outqty", "inamtoftax * rate as inamtoftax", "outamtoftax * rate as outamtoftax", "inamtofnotax * rate as inamtofnotax", "outamtofnotax * rate as outamtofnotax"}; + return groupBySet.join(rateDataSet, JoinType.LEFT).on("currency", "ratecurrency").select(materialFields, new String[]{"rate"}).finish().select((String) Stream.of(materialFields).collect(Collectors.joining(",")) + ",case when rate <= 0 then 1 else rate end as rate").select((String) Stream.of(materialWithRateFields).collect(Collectors.joining(","))); + } + + private DataSet getMaterialInInOutDataSet(List inFilter, DynamicObject orgCurrency, DynamicObject exRateTable) { + String materialInString = "billno,project,warehouse,entryentity.material.resource.name as resourcename,entryentity.material.resource as resource,entryentity.material as materialnumber,entryentity.modelnum as modelnum,entryentity.measureunit as calculateunit,entryentity.lot as lotnum,case when transtype.type='INCREASE' then entryentity.qty when transtype.type='REDUCE' then 0-entryentity.qty else 0 end as inqty,0 as outqty,case when transtype.type='INCREASE' then entryentity.oftaxamount when transtype.type='REDUCE' then 0-entryentity.oftaxamount else 0 end as inamtoftax,case when transtype.type='INCREASE' then entryentity.notaxamount when transtype.type='REDUCE' then 0-entryentity.notaxamount else 0 end as inamtofnotax,0 as outamtoftax,0 as outamtofnotax,currency,unitprojectpro as unitproject"; + inFilter.add(new QFilter("matbilltype", "=", "materialin")); + inFilter.add(new QFilter("transtype.type", "!=", "UNIMPACT")); + DataSet materialInDataSet = QueryServiceHelper.queryDataSet(this.getClass().getName(), "ecma_materialinbill", materialInString, (QFilter[]) inFilter.toArray(new QFilter[inFilter.size()]), ""); + DataSet groupBySet = materialInDataSet.groupBy(new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "currency", "project", "unitproject", "warehouse"}).sum("inqty").sum("outqty").sum("inamtoftax").sum("inamtofnotax").sum("outamtoftax").sum("outamtofnotax").finish(); + DataSet rateDataSet = CurrencyHelper.getExchangeRateDataSet(orgCurrency, exRateTable, this.getClass().getName()); + String[] materialFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "inqty", "outqty", "inamtoftax", "outamtoftax", "inamtofnotax", "outamtofnotax"}; + String[] materialWithRateFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "inqty", "outqty", "inamtoftax * rate as inamtoftax", "outamtoftax * rate as outamtoftax", "inamtofnotax * rate as inamtofnotax", "outamtofnotax * rate as outamtofnotax"}; + return groupBySet.join(rateDataSet, JoinType.LEFT).on("currency", "ratecurrency").select(materialFields, new String[]{"rate"}).finish().select((String) Stream.of(materialFields).collect(Collectors.joining(",")) + ",case when rate <= 0 then 1 else rate end as rate").select((String) Stream.of(materialWithRateFields).collect(Collectors.joining(","))); + } + + private DataSet getWareHouseInOutDataSet(List initBillFilter, DynamicObject orgCurrency, DynamicObject exRateTable) { + String warehouInitString = "billno,project,warehouse,entryentity.material.resource.name as resourcename,entryentity.material.resource as resource,entryentity.material as materialnumber,entryentity.modelnum as modelnum,entryentity.measureunit as calculateunit,entryentity.lot as lotnum,case when entryentity.qty >0 then entryentity.qty else 0 end as inqty,case when entryentity.qty<0 then -1*entryentity.qty else 0 end as outqty,case when entryentity.inctaxamount>0 then entryentity.inctaxamount else 0 end as inamtoftax,case when entryentity.inctaxamount<0 then -1*entryentity.inctaxamount else 0 end as outamtoftax,case when entryentity.amount>0 then entryentity.amount else 0 end as inamtofnotax,case when entryentity.amount<0 then -1*entryentity.amount else 0 end as outamtofnotax,currency,unitproject"; + DataSet warehouseInitDataSet = QueryServiceHelper.queryDataSet(this.getClass().getName(), "ecma_warehouseinit", warehouInitString, (QFilter[]) initBillFilter.toArray(new QFilter[initBillFilter.size()]), ""); + DataSet groupBySet = warehouseInitDataSet.groupBy(new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "currency", "project", "unitproject", "warehouse"}).sum("inqty").sum("outqty").sum("inamtoftax").sum("inamtofnotax").sum("outamtoftax").sum("outamtofnotax").finish(); + DataSet rateDataSet = CurrencyHelper.getExchangeRateDataSet(orgCurrency, exRateTable, this.getClass().getName()); + String[] materialFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "inqty", "outqty", "inamtoftax", "outamtoftax", "inamtofnotax", "outamtofnotax"}; + String[] materialWithRateFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "inqty", "outqty", "inamtoftax * rate as inamtoftax", "outamtoftax * rate as outamtoftax", "inamtofnotax * rate as inamtofnotax", "outamtofnotax * rate as outamtofnotax"}; + return groupBySet.join(rateDataSet, JoinType.LEFT).on("currency", "ratecurrency").select(materialFields, new String[]{"rate"}).finish().select((String) Stream.of(materialFields).collect(Collectors.joining(",")) + ",case when rate <= 0 then 1 else rate end as rate").select((String) Stream.of(materialWithRateFields).collect(Collectors.joining(","))); + } + + private DataSet getAllocationStockDataSet(ReportQueryParam param, DynamicObject orgCurrency, DynamicObject exRateTable, int billType) { + List allocationBillFilter = this.getCommonFilterByParam(param, 2, billType); + String selectAllocationStr = ""; + String formId = ""; + if (billType == 3) { + formId = "ecma_allocationin"; + selectAllocationStr = "billno,entryentity.material.resource.name as resourcename,entryentity.material.resource as resource,entryentity.material as materialnumber,entryentity.modelnum as modelnum,entryentity.measureunit as calculateunit,entryentity.lot as lotnum,entryentity.qty as stockqty,currency,inproject as project,inunitproject as unitproject,entryentity.oftrantaxamount as stockamtoftax,entryentity.oftranamount as stockamtofnotax,inwarehouse as warehouse"; + } else { + formId = "ecma_allocationout"; + selectAllocationStr = "billno,entryentity.material.resource.name as resourcename,entryentity.material.resource as resource,entryentity.material as materialnumber,entryentity.modelnum as modelnum,entryentity.measureunit as calculateunit,entryentity.lot as lotnum,0-entryentity.qty as stockqty,currency,outproject as project,outunitproject as unitproject,0 - entryentity.oftaxamount as stockamtoftax,0 - entryentity.amount as stockamtofnotax,outwarehouse as warehouse"; + } + + DataSet allocationInOutDataSet = QueryServiceHelper.queryDataSet(this.getClass().getName(), formId, selectAllocationStr, (QFilter[]) allocationBillFilter.toArray(new QFilter[allocationBillFilter.size()]), ""); + DataSet groupBySet = allocationInOutDataSet.groupBy(new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "currency", "project", "unitproject", "warehouse"}).sum("stockqty").sum("stockamtoftax").sum("stockamtofnotax").finish(); + DataSet rateDataSet = CurrencyHelper.getExchangeRateDataSet(orgCurrency, exRateTable, this.getClass().getName()); + String[] materialFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "stockqty", "stockamtoftax", "stockamtofnotax"}; + String[] materialWithRateFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "stockqty", "stockamtoftax * rate as stockamtoftax", "stockamtofnotax * rate as stockamtofnotax"}; + return groupBySet.join(rateDataSet, JoinType.LEFT).on("currency", "ratecurrency").select(materialFields, new String[]{"rate"}).finish().select((String) Stream.of(materialFields).collect(Collectors.joining(",")) + ",case when rate <= 0 then 1 else rate end as rate").select((String) Stream.of(materialWithRateFields).collect(Collectors.joining(","))); + } + + private DataSet getStockDataSet(ReportQueryParam param) { + List initBillFilter = this.getCommonFilterByParam(param, 2, 0); + List inFilter = this.getCommonFilterByParam(param, 2, 1); + List outFilter = this.getCommonFilterByParam(param, 2, 2); + DynamicObject org = param.getFilter().getDynamicObject("org"); + DynamicObject orgCurrency = CurrencyHelper.getCurrency((Long) org.getPkValue()); + DynamicObject exRateTable = CurrencyHelper.getExRateTable((Long) org.getPkValue()); + DataSet warehouseInitDataSet = this.getWareHouseStockDataSet(initBillFilter, orgCurrency, exRateTable); + DataSet materialInDataSet = this.getMaterialInStockDataSet(inFilter, orgCurrency, exRateTable); + DataSet materialOutDataSet = this.getMaterialOutStockDataSet(outFilter, orgCurrency, exRateTable); + DataSet allocationInStockDataSet = this.getAllocationStockDataSet(param, orgCurrency, exRateTable, 3); + DataSet allocationOutStockDataSet = this.getAllocationStockDataSet(param, orgCurrency, exRateTable, 4); + DataSet checkingAdjustStockDataSet = this.getCheckingAdjustStockDataSet(param, orgCurrency, exRateTable); + DataSet compMatOutDataSet = this.getCompMatOutStockDataSet(param, orgCurrency, exRateTable); + DataSet unionDataSet = warehouseInitDataSet.union(materialInDataSet).union(materialOutDataSet).union(allocationInStockDataSet).union(allocationOutStockDataSet).union(checkingAdjustStockDataSet).union(compMatOutDataSet); + DataSet groupBySet = unionDataSet.groupBy(new String[]{"project", "unitproject", "warehouse", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum"}).sum("stockqty").sum("stockamtoftax").sum("stockamtofnotax").finish(); + return groupBySet; + } + + private DataSet getWareHouseStockDataSet(List initBillFilter, DynamicObject orgCurrency, DynamicObject exRateTable) { + String warehouInitString = "billno,project,warehouse,entryentity.material.resource.name as resourcename,entryentity.material.resource as resource,entryentity.material as materialnumber,entryentity.modelnum as modelnum,entryentity.measureunit as calculateunit,entryentity.lot as lotnum,entryentity.qty as stockqty,currency,unitproject,entryentity.amount as stockamtoftax,entryentity.amount as stockamtofnotax"; + DataSet warehouseInitDataSet = QueryServiceHelper.queryDataSet(this.getClass().getName(), "ecma_warehouseinit", warehouInitString, (QFilter[]) initBillFilter.toArray(new QFilter[initBillFilter.size()]), ""); + DataSet groupBySet = warehouseInitDataSet.groupBy(new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "currency", "project", "unitproject", "warehouse"}).sum("stockqty").sum("stockamtoftax").sum("stockamtofnotax").finish(); + DataSet rateDataSet = CurrencyHelper.getExchangeRateDataSet(orgCurrency, exRateTable, this.getClass().getName()); + String[] materialFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "stockqty", "stockamtoftax", "stockamtofnotax"}; + String[] materialWithRateFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "stockqty", "stockamtoftax * rate as stockamtoftax", "stockamtofnotax * rate as stockamtofnotax"}; + return groupBySet.join(rateDataSet, JoinType.LEFT).on("currency", "ratecurrency").select(materialFields, new String[]{"rate"}).finish().select((String) Stream.of(materialFields).collect(Collectors.joining(",")) + ",case when rate <= 0 then 1 else rate end as rate").select((String) Stream.of(materialWithRateFields).collect(Collectors.joining(","))); + } + + private DataSet getMaterialInStockDataSet(List inFilter, DynamicObject orgCurrency, DynamicObject exRateTable) { + String materialInString = "billno,project,warehouse,entryentity.material.resource.name as resourcename,entryentity.material.resource as resource,entryentity.material as materialnumber,entryentity.modelnum as modelnum,entryentity.measureunit as calculateunit,entryentity.lot as lotnum,case when transtype.type='INCREASE' then entryentity.qty when transtype.type='REDUCE' then 0-entryentity.qty else 0 end as stockqty,case when transtype.type='INCREASE' then entryentity.oftaxamount when transtype.type='REDUCE' then 0-entryentity.oftaxamount else 0 end as stockamtoftax,case when transtype.type='INCREASE' then entryentity.notaxamount when transtype.type='REDUCE' then 0-entryentity.notaxamount else 0 end as stockamtofnotax,currency,unitprojectpro as unitproject"; + inFilter.add(new QFilter("matbilltype", "=", "materialin")); + inFilter.add(new QFilter("transtype.type", "!=", "UNIMPACT")); + DataSet materialInDataSet = QueryServiceHelper.queryDataSet(this.getClass().getName(), "ecma_materialinbill", materialInString, (QFilter[]) inFilter.toArray(new QFilter[inFilter.size()]), ""); + DataSet groupBySet = materialInDataSet.groupBy(new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "currency", "project", "unitproject", "warehouse"}).sum("stockqty").sum("stockamtoftax").sum("stockamtofnotax").finish(); + DataSet rateDataSet = CurrencyHelper.getExchangeRateDataSet(orgCurrency, exRateTable, this.getClass().getName()); + String[] materialFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "stockqty", "stockamtoftax", "stockamtofnotax"}; + String[] materialWithRateFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "stockqty", "stockamtoftax * rate as stockamtoftax", "stockamtofnotax * rate as stockamtofnotax"}; + return groupBySet.join(rateDataSet, JoinType.LEFT).on("currency", "ratecurrency").select(materialFields, new String[]{"rate"}).finish().select((String) Stream.of(materialFields).collect(Collectors.joining(",")) + ",case when rate <= 0 then 1 else rate end as rate").select((String) Stream.of(materialWithRateFields).collect(Collectors.joining(","))); + } + + private DataSet getMaterialOutStockDataSet(List outFilter, DynamicObject orgCurrency, DynamicObject exRateTable) { + String materialOutString = "billno,project,warehouse,entryentity.material.resource.name as resourcename,entryentity.material.resource as resource,entryentity.material as materialnumber,entryentity.modelnum as modelnum,entryentity.measureunit as calculateunit,entryentity.lot as lotnum,case when transtype.type='INCREASE' then entryentity.qty when transtype.type='REDUCE' then 0-entryentity.qty else 0 end as stockqty,currency,case when transtype.type='INCREASE' then entryentity.amount when transtype.type='REDUCE' then 0-entryentity.amount else 0 end as stockamtoftax,case when transtype.type='INCREASE' then entryentity.amount when transtype.type='REDUCE' then 0-entryentity.amount else 0 end as stockamtofnotax,unitprojectpro as unitproject"; + outFilter.add(new QFilter("matbilltype", "=", "materialout")); + outFilter.add(new QFilter("transtype.type", "!=", "UNIMPACT")); + DataSet materialOutDataSet = QueryServiceHelper.queryDataSet(this.getClass().getName(), "ecma_materialoutbill", materialOutString, (QFilter[]) outFilter.toArray(new QFilter[outFilter.size()]), ""); + DataSet groupBySet = materialOutDataSet.groupBy(new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "currency", "project", "unitproject", "warehouse"}).sum("stockqty").sum("stockamtoftax").sum("stockamtofnotax").finish(); + DataSet rateDataSet = CurrencyHelper.getExchangeRateDataSet(orgCurrency, exRateTable, this.getClass().getName()); + String[] materialFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "stockqty", "stockamtoftax", "stockamtofnotax"}; + String[] materialWithRateFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "stockqty", "stockamtoftax * rate as stockamtoftax", "stockamtofnotax * rate as stockamtofnotax"}; + return groupBySet.join(rateDataSet, JoinType.LEFT).on("currency", "ratecurrency").select(materialFields, new String[]{"rate"}).finish().select((String) Stream.of(materialFields).collect(Collectors.joining(",")) + ",case when rate <= 0 then 1 else rate end as rate").select((String) Stream.of(materialWithRateFields).collect(Collectors.joining(","))); + } + + private DataSet getCompMatOutStockDataSet(ReportQueryParam param, DynamicObject orgCurrency, DynamicObject exRateTable) { + List outFilter = this.getCompMatFilterByParam(param, 2); + String materialOutString = "billno,entryentity.subentryentity.material.resource.name as resourcename,entryentity.subentryentity.material.resource as resource,entryentity.subentryentity.material as materialnumber,entryentity.subentryentity.modelnum as modelnum,entryentity.subentryentity.measureunit as calculateunit,entryentity.subentryentity.lot as lotnum,0-entryentity.subentryentity.qty as stockqty,0-entryentity.subentryentity.amount as stockamtoftax,0-entryentity.subentryentity.amount as stockamtofnotax,currency,project,unitproject,entryentity.subentryentity.warehouse as warehouse"; + DataSet materialOutDataSet = QueryServiceHelper.queryDataSet(this.getClass().getName(), "ecma_compmatout", materialOutString, (QFilter[]) outFilter.toArray(new QFilter[outFilter.size()]), ""); + DataSet groupBySet = materialOutDataSet.groupBy(new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "currency", "project", "unitproject", "warehouse"}).sum("stockqty").sum("stockamtoftax").sum("stockamtofnotax").finish(); + DataSet rateDataSet = CurrencyHelper.getExchangeRateDataSet(orgCurrency, exRateTable, this.getClass().getName()); + String[] materialFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "stockqty", "stockamtoftax", "stockamtofnotax"}; + String[] materialWithRateFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "stockqty", "stockamtoftax * rate as stockamtoftax", "stockamtofnotax * rate as stockamtofnotax"}; + return groupBySet.join(rateDataSet, JoinType.LEFT).on("currency", "ratecurrency").select(materialFields, new String[]{"rate"}).finish().select((String) Stream.of(materialFields).collect(Collectors.joining(",")) + ",case when rate <= 0 then 1 else rate end as rate").select((String) Stream.of(materialWithRateFields).collect(Collectors.joining(","))); + } + + private DataSet getCheckingAdjustStockDataSet(ReportQueryParam param, DynamicObject orgCurrency, DynamicObject exRateTable) { + List checkingAdjustInitFilter = this.getAdjustFilterByParam(param, 2); + String formId = "ecma_checkingadjust"; + String selectCheckingAdjustStr = "billno,adjustdetailentry.material.resource.name as resourcename,adjustdetailentry.material.resource as resource,adjustdetailentry.material as materialnumber,adjustdetailentry.modelnum as modelnum,adjustdetailentry.measureunit as calculateunit,adjustdetailentry.lot as lotnum,adjustdetailentry.qty as stockqty,adjustdetailentry.amount as stockamtoftax,adjustdetailentry.amount as stockamtofnotax,currency,depot.project as project,depot.unitproject as unitproject,depot as warehouse"; + DataSet checkingAdjustDataSet = QueryServiceHelper.queryDataSet(this.getClass().getName(), formId, selectCheckingAdjustStr, (QFilter[]) checkingAdjustInitFilter.toArray(new QFilter[checkingAdjustInitFilter.size()]), ""); + DataSet groupBySet = checkingAdjustDataSet.groupBy(new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "currency", "project", "unitproject", "warehouse"}).sum("stockqty").sum("stockamtoftax").sum("stockamtofnotax").finish(); + DataSet rateDataSet = CurrencyHelper.getExchangeRateDataSet(orgCurrency, exRateTable, this.getClass().getName()); + String[] materialFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "stockqty", "stockamtoftax", "stockamtofnotax"}; + String[] materialWithRateFields = new String[]{"billno", "resourcename", "resource", "materialnumber", "modelnum", "calculateunit", "lotnum", "project", "unitproject", "warehouse", "stockqty", "stockamtoftax * rate as stockamtoftax", "stockamtofnotax * rate as stockamtofnotax"}; + return groupBySet.join(rateDataSet, JoinType.LEFT).on("currency", "ratecurrency").select(materialFields, new String[]{"rate"}).finish().select((String) Stream.of(materialFields).collect(Collectors.joining(",")) + ",case when rate <= 0 then 1 else rate end as rate").select((String) Stream.of(materialWithRateFields).collect(Collectors.joining(","))); + } + + private List getAdjustFilterByParam(ReportQueryParam param, int beforeDate) { + FilterInfo filterInfo = param.getFilter(); + List filters = new ArrayList(); + this.addCommonFilter(beforeDate, filterInfo, filters); + DynamicObjectCollection projects = filterInfo.getDynamicObjectCollection("projects"); + DynamicObjectCollection materialGroups; + if (projects != null) { + Set projectIdSet = (Set) projects.stream().map((obj) -> { + return obj.getPkValue(); + }).collect(Collectors.toSet()); + materialGroups = filterInfo.getDynamicObjectCollection("unitprojects"); + this.setProjectAndUnitFilter(filters, projectIdSet, materialGroups, "depot.project", "depot.unitproject"); + } + + DynamicObjectCollection warehouses = filterInfo.getDynamicObjectCollection("warehouses"); + if (warehouses != null) { + Set warehouseIdSet = (Set) warehouses.stream().map((obj) -> { + return obj.getPkValue(); + }).collect(Collectors.toSet()); + QFilter warehouseFilter = new QFilter("depot", "in", warehouseIdSet); + filters.add(warehouseFilter); + } + + materialGroups = filterInfo.getDynamicObjectCollection("materialgroups"); + if (materialGroups != null) { + Set materialGroupIdSet = (Set) materialGroups.stream().map((obj) -> { + return obj.getPkValue(); + }).collect(Collectors.toSet()); + QFilter warehouseFilter = new QFilter("adjustdetailentry.material.resource", "in", materialGroupIdSet); + filters.add(warehouseFilter); + } + + DynamicObjectCollection materials = filterInfo.getDynamicObjectCollection("materials"); + QFilter materialFilter; + if (materials != null) { + Set materialIdSet = (Set) materials.stream().map((obj) -> { + return obj.getPkValue(); + }).collect(Collectors.toSet()); + materialFilter = new QFilter("adjustdetailentry.material", "in", materialIdSet); + filters.add(materialFilter); + } + + String materialsname = filterInfo.getString("materialsname"); + if (StringUtils.isNotBlank(materialsname)) { + materialFilter = new QFilter("adjustdetailentry.material.name", "like", "%" + materialsname + "%"); + filters.add(materialFilter); + } + + String modelnums = filterInfo.getString("modelnums"); + if (StringUtils.isNotBlank(modelnums)) { + String[] modelNumArr = modelnums.split(","); + QFilter modelNumFilter = new QFilter("adjustdetailentry.modelnum", "in", modelNumArr); + filters.add(modelNumFilter); + } + + DynamicObjectCollection lotnums = filterInfo.getDynamicObjectCollection("lotnums"); + if (lotnums != null) { + Set lotnumSet = (Set) lotnums.stream().map((obj) -> { + return obj.get("number"); + }).collect(Collectors.toSet()); + QFilter lotnumFilter = new QFilter("adjustdetailentry.lot", "in", lotnumSet); + filters.add(lotnumFilter); + } + + return filters; + } + + private List getCompMatFilterByParam(ReportQueryParam param, int beforeDate) { + FilterInfo filterInfo = param.getFilter(); + List filters = new ArrayList(); + this.addCommonFilter(beforeDate, filterInfo, filters); + DynamicObjectCollection projects = filterInfo.getDynamicObjectCollection("projects"); + DynamicObjectCollection materialGroups; + if (projects != null) { + Set projectIdSet = (Set) projects.stream().map((obj) -> { + return obj.getPkValue(); + }).collect(Collectors.toSet()); + materialGroups = filterInfo.getDynamicObjectCollection("unitprojects"); + this.setProjectAndUnitFilter(filters, projectIdSet, materialGroups, "project", "unitproject"); + } + + DynamicObjectCollection warehouses = filterInfo.getDynamicObjectCollection("warehouses"); + if (warehouses != null) { + Set warehouseIdSet = (Set) warehouses.stream().map((obj) -> { + return obj.getPkValue(); + }).collect(Collectors.toSet()); + QFilter warehouseFilter = new QFilter("entryentity.subentryentity.warehouse", "in", warehouseIdSet); + filters.add(warehouseFilter); + } + + materialGroups = filterInfo.getDynamicObjectCollection("materialgroups"); + if (materialGroups != null) { + Set materialGroupIdSet = (Set) materialGroups.stream().map((obj) -> { + return obj.getPkValue(); + }).collect(Collectors.toSet()); + QFilter warehouseFilter = new QFilter("entryentity.subentryentity.material.resource", "in", materialGroupIdSet); + filters.add(warehouseFilter); + } + + DynamicObjectCollection materials = filterInfo.getDynamicObjectCollection("materials"); + QFilter materialFilter; + if (materials != null) { + Set materialIdSet = (Set) materials.stream().map((obj) -> { + return obj.getPkValue(); + }).collect(Collectors.toSet()); + materialFilter = new QFilter("entryentity.subentryentity.material", "in", materialIdSet); + filters.add(materialFilter); + } + + String materialsname = filterInfo.getString("materialsname"); + if (StringUtils.isNotBlank(materialsname)) { + materialFilter = new QFilter("entryentity.subentryentity.material.name", "like", "%" + materialsname + "%"); + filters.add(materialFilter); + } + + String modelnums = filterInfo.getString("modelnums"); + if (StringUtils.isNotBlank(modelnums)) { + String[] modelNumArr = modelnums.split(","); + QFilter modelNumFilter = new QFilter("entryentity.subentryentity.modelnum", "in", modelNumArr); + filters.add(modelNumFilter); + } + + DynamicObjectCollection lotnums = filterInfo.getDynamicObjectCollection("lotnums"); + if (lotnums != null) { + Set lotnumSet = (Set) lotnums.stream().map((obj) -> { + return obj.get("number"); + }).collect(Collectors.toSet()); + QFilter lotnumFilter = new QFilter("entryentity.subentryentity.lot", "in", lotnumSet); + filters.add(lotnumFilter); + } + + return filters; + } + + protected void addCommonFilter(int beforeDate, FilterInfo filterInfo, List filters) { + DynamicObject org = filterInfo.getDynamicObject("org"); + if (org != null) { + filters.add(this.getSubordinateOrgFilter(org)); + } + + Date bizDate_StartDate = filterInfo.getDate("bizdate_startdate"); + Date bizDate_EndDate = filterInfo.getDate("bizdate_enddate"); + Calendar c = Calendar.getInstance(); + c.setTime(bizDate_EndDate); + c.set(11, 23); + c.set(12, 59); + c.set(13, 59); + bizDate_EndDate = c.getTime(); + QFilter bizDateFilter; + if (bizDate_StartDate != null && bizDate_EndDate != null) { + if (beforeDate == 0) { + bizDateFilter = new QFilter("bizdate", "<", bizDate_StartDate); + filters.add(bizDateFilter); + } else if (beforeDate == 1) { + bizDateFilter = new QFilter("bizdate", ">=", bizDate_StartDate); + bizDateFilter.and(new QFilter("bizdate", "<=", bizDate_EndDate)); + filters.add(bizDateFilter); + } else if (beforeDate == 2) { + bizDateFilter = new QFilter("bizdate", "<", bizDate_EndDate); + filters.add(bizDateFilter); + } + } + + bizDateFilter = new QFilter("billstatus", "=", "C"); + filters.add(bizDateFilter); + } + + private List getCommonFilterByParam(ReportQueryParam param, int beforeDate, int billType) { + FilterInfo filterInfo = param.getFilter(); + List filters = new ArrayList(); + this.addCommonFilter(beforeDate, filterInfo, filters); + DynamicObjectCollection projects = filterInfo.getDynamicObjectCollection("projects"); + DynamicObjectCollection unitprojects; + if (projects != null) { + Set projectIdSet = (Set) projects.stream().map((obj) -> { + return obj.getPkValue(); + }).collect(Collectors.toSet()); + unitprojects = filterInfo.getDynamicObjectCollection("unitprojects"); + if (billType == 1) { + this.setProjectAndUnitFilter(filters, projectIdSet, unitprojects, "project", "unitprojectpro"); + } else if (billType == 2) { + this.setProjectAndUnitFilter(filters, projectIdSet, unitprojects, "project", "unitprojectpro"); + } else if (billType == 0) { + this.setProjectAndUnitFilter(filters, projectIdSet, unitprojects, "warehouse.project", "warehouse.unitproject"); + } else if (billType == 3) { + this.setProjectAndUnitFilter(filters, projectIdSet, unitprojects, "inproject", "inunitproject"); + } else if (billType == 4) { + this.setProjectAndUnitFilter(filters, projectIdSet, unitprojects, "outproject", "outunitproject"); + } + } + + DynamicObjectCollection warehouses = filterInfo.getDynamicObjectCollection("warehouses"); + if (warehouses != null) { + Set warehouseIdSet = (Set) warehouses.stream().map((obj) -> { + return obj.getPkValue(); + }).collect(Collectors.toSet()); + QFilter warehouseFilter = null; + if (billType == 3) { + warehouseFilter = new QFilter("inwarehouse", "in", warehouseIdSet); + } else if (billType == 4) { + warehouseFilter = new QFilter("outwarehouse", "in", warehouseIdSet); + } else if (billType == 0 || billType == 1 | billType == 2) { + warehouseFilter = new QFilter("warehouse", "in", warehouseIdSet); + } + + filters.add(warehouseFilter); + } + + unitprojects = filterInfo.getDynamicObjectCollection("materialgroups"); + if (unitprojects != null) { + Set materialGroupIdSet = (Set) unitprojects.stream().map((obj) -> { + return obj.getPkValue(); + }).collect(Collectors.toSet()); + QFilter warehouseFilter = new QFilter("entryentity.material.resource", "in", materialGroupIdSet); + filters.add(warehouseFilter); + } + + DynamicObjectCollection materials = filterInfo.getDynamicObjectCollection("materials"); + QFilter materialFilter; + if (materials != null) { + Set materialIdSet = (Set) materials.stream().map((obj) -> { + return obj.getPkValue(); + }).collect(Collectors.toSet()); + materialFilter = new QFilter("entryentity.material", "in", materialIdSet); + filters.add(materialFilter); + } + + String materialsname = filterInfo.getString("materialsname"); + if (StringUtils.isNotBlank(materialsname)) { + materialFilter = new QFilter("entryentity.material.name", "like", "%" + materialsname + "%"); + filters.add(materialFilter); + } + + String modelnums = filterInfo.getString("modelnums"); + if (StringUtils.isNotBlank(modelnums)) { + String[] modelNumArr = modelnums.split(","); + QFilter modelNumFilter = new QFilter("entryentity.modelnum", "in", modelNumArr); + filters.add(modelNumFilter); + } + + DynamicObjectCollection lotnums = filterInfo.getDynamicObjectCollection("lotnums"); + if (lotnums != null) { + Set lotnumSet = (Set) lotnums.stream().map((obj) -> { + return obj.get("number"); + }).collect(Collectors.toSet()); + QFilter lotnumFilter = new QFilter("entryentity.lot", "in", lotnumSet); + filters.add(lotnumFilter); + } + + return filters; + } + + protected void setProjectAndUnitFilter(List filterList, Set projectIdSet, DynamicObjectCollection unitprojects, String projectName, String unitprojectName) { + if (unitprojects != null) { + Set unitprojectIds = (Set) unitprojects.stream().map(DataEntityBase::getPkValue).collect(Collectors.toSet()); + QFilter editonpro = (new QFilter(projectName, "in", projectIdSet)).and(new QFilter(projectName + ".boqmode", "=", "project")); + QFilter editonunit = (new QFilter(projectName, "in", projectIdSet)).and(new QFilter(projectName + ".boqmode", "=", "unitproject")).and(new QFilter(unitprojectName, "in", unitprojectIds)); + filterList.add(editonpro.or(editonunit)); + } else { + filterList.add(new QFilter(projectName, "in", projectIdSet)); + } + + } +}