stockmanagementdata.java~719~

java经销存管理系统

      //创建商品调出单
      stockManagementData.createStockLedgerAndSub(ledgerDate, orderOutLedger, stockSubLedger);
      //根据商品调出用户名字取得商品调出单
      String[][] orderOutLedgers = stockManagementData.
          getStockLedgerByStringField(ledgerDate, "submitUser", orderInLedger[3], 2);
      //取得商品调出单标识，最后一条记录便是新创建的商品调出单
      String orderOutId = orderOutLedgers[orderOutLedgers.length -1][0];
      //更新商品调入单数组的标识和关联标识
      orderInLedger[0] = orderInId;
      orderInLedger[2] = orderOutId;
      //根据标识重新取得商品调入单明细数组
      orderInSubLedger = stockManagementData.getStockSubLedgerByOrderId(
          ledgerDate, orderInLedger[0]);
      //更新商品调入单,将调出单的关联标识写入调入单
      stockManagementData.updateStockLedgerAndSub(ledgerDate, orderInLedger, orderInSubLedger);
      result = 1;
    }catch(Exception ex){
      ex.printStackTrace();
    }
    return result;
  }
  //更新商品调拔单的方法
  public int updateTransferOrder(String ledgerDate, String[] stockLedger,
                                     String[][] stockSubLedger){
    int result = 0;
    try{
      //创建商品调出单数组
      String[] orderOutLedger = stockLedger;
      //更新商品调出单
      stockManagementData.updateStockLedgerAndSub(ledgerDate, orderOutLedger, stockSubLedger);
      //创建商品调入单数组
      String[] orderInLedger = new String[stockLedger.length];
      System.arraycopy(stockLedger, 0, orderInLedger, 0, stockLedger.length);
      //更新商品调入单数组，3表示商品调入单
      orderInLedger[0] = stockLedger[2];
      orderInLedger[1] = "3";
      orderInLedger[2] = stockLedger[0];     //调出单的关联标识
      orderInLedger[4] = stockLedger[8];     //调出仓库
      //将调出单的仓库字段放入调入单
      orderInLedger[8] = stockLedger[4];     //调入仓库
      //取得商品调入单明细数组
      String[][] orderInSubLedger = stockManagementData.
          getStockSubLedgerByOrderId(ledgerDate, orderInLedger[0]);
      //更新商品调入单明细数组
      for(int i = 0; i < orderInSubLedger.length; i++){
        orderInSubLedger[i][2] = stockSubLedger[i][2];
        orderInSubLedger[i][3] = stockSubLedger[i][3];
        //将商品数量更改为正数
        orderInSubLedger[i][4] = String.valueOf(-Integer.parseInt(stockSubLedger[i][4]));
        orderInSubLedger[i][5] = stockSubLedger[i][5];
      }
      //更新商品调入单
      stockManagementData.updateStockLedgerAndSub(ledgerDate, orderInLedger, orderInSubLedger);
      result = 1;
    }catch(Exception ex){
      ex.printStackTrace();
    }
    return result;
  }
  //撤消或者恢复商品调拔单的方法
  public int cancelOrRestoreTransferOrder(String ledgerDate, String inOrderId,
                                  String outOrderId, int onProcess, String remark){
    int result = 0;
    try{
      if(onProcess == 0){
        //恢复调入单
        stockManagementData.restoreStockLedgerAndSub(ledgerDate, inOrderId, remark);
        //恢复调出单
        stockManagementData.restoreStockLedgerAndSub(ledgerDate, outOrderId, remark);
      }else{
        //取消调入单
        stockManagementData.cancelStockLedgerAndSub(ledgerDate, inOrderId, remark);
        //取消调出单
        stockManagementData.cancelStockLedgerAndSub(ledgerDate, outOrderId, remark);
      }
      result = 1;
    }catch(Exception ex){
      ex.printStackTrace();
    }
    return result;
  }
  //库存账套数据表电子签名和更新完成状态的方法
  public int signStockLedgerAndSubForFinish(String ledgerDate, String fieldName,
                                            String userName, String orderId,
                                            int onProcess, String remark) {
    int result = 0;
    try{
      result = stockManagementData.signStockLedgerAndSubForFinish(ledgerDate,
          fieldName, userName, orderId, onProcess, remark);
    }catch(Exception ex){
      ex.printStackTrace();
    }
    return result;
  }
  //创建商品分拆单的方法
  public int createRearrangeOrder(String ledgerDate, String[] stockLedger,
                                  String[][] stockSubLedgerOut, String[][] stockSubLedgerIn){
    int result = 0;
    try{
      //创建商品分拆调入单数组
     String[] orderInLedger = new String[stockLedger.length];
     System.arraycopy(stockLedger, 0, orderInLedger, 0, stockLedger.length);
      //创建商品分拆调入单
      stockManagementData.createStockLedgerAndSub(ledgerDate, orderInLedger, stockSubLedgerIn);
      //根据商品组合管理用户名字取得商品分拆调入单,10表示商品分拆调入单
      String[][] orderInLedgers = stockManagementData.
          getStockLedgerByStringField(ledgerDate, "submitUser", stockLedger[3], 10);
      //取得商品分拆调入单标识，最后一条记录便是新创建的商品分拆调入单
      String orderInId = orderInLedgers[orderInLedgers.length -1][0];
      //创建商品分拆调出单数组
      String[] orderOutLedger = new String[stockLedger.length];
      System.arraycopy(stockLedger, 0, orderOutLedger, 0, stockLedger.length);
      //更新商品分拆调出单数组，将商品调入单标识放在供应商字段，9表示商品分拆调出单
      orderOutLedger[2] = orderInId;
      orderOutLedger[1] = "9";
      orderOutLedger[4] = stockLedger[8];         //调入仓库
      orderOutLedger[8] = stockLedger[4];         //调出仓库
      //创建商品分拆调出单
      stockManagementData.createStockLedgerAndSub(ledgerDate, orderOutLedger, stockSubLedgerOut);
      //根据商品组合管理用户名字取得商品分拆调出单
      String[][] orderOutLedgers = stockManagementData.
          getStockLedgerByStringField(ledgerDate, "submitUser", orderOutLedger[3], 9);
      //取得商品分拆调出单标识，最后一条记录便是新创建的商品分拆调出单
      String orderOutId = orderOutLedgers[orderOutLedgers.length -1][0];
      //更新商品分拆调入单数组的标识和关联标识
      orderInLedger[0] = orderInId;
      orderInLedger[2] = orderOutId;
      //根据标识重新取得商品分拆调入单明细数组
      String[][] orderInSubLedger = stockManagementData.getStockSubLedgerByOrderId(
          ledgerDate, orderInLedger[0]);
      //更新商品分拆调入单,将调出单的关联标识写入调入单
      stockManagementData.updateStockLedgerAndSub(ledgerDate, orderInLedger, orderInSubLedger);
      result = 1;
    }catch(Exception ex){
      ex.printStackTrace();
    }
    return result;
  }
  //更新商品分拆单的方法
  public int updateRearrangeOrder(String ledgerDate, String[] stockLedger,
                                  String[][] stockSubLedgerOut, String[][] stockSubLedgerIn){
    int result = 0;
    try{
      //更新商品分拆调入单
      stockManagementData.updateStockLedgerAndSub(ledgerDate, stockLedger, stockSubLedgerIn);
      //创建商品分拆调出单数组
      String[] orderOutLedger = new String[stockLedger.length];
      System.arraycopy(stockLedger, 0, orderOutLedger, 0, stockLedger.length);
      //更新商品分拆调出单数组，9表示调出单
      orderOutLedger[0] = stockLedger[2];
      orderOutLedger[1] = "9";
      orderOutLedger[2] = stockLedger[0];     //调出单的关联标识
      orderOutLedger[4] = stockLedger[8];     //调入仓库
      orderOutLedger[8] = stockLedger[4];     //调出仓库
      //更新商品分拆调出单
      stockManagementData.updateStockLedgerAndSub(ledgerDate, orderOutLedger, stockSubLedgerOut);
      result = 1;
    }catch(Exception ex){
      ex.printStackTrace();
    }
    return result;
  }
  //撤消或者恢复商品分拆或者组合单的方法
  public int cancelOrRestoreRearrangeOrder(String ledgerDate, String inOrderId,
                                           String outOrderId, String userName,
                                           int onProcess, String remark) {
    int result = 0;
    try{
      if(onProcess == 2){
        //恢复调入单
        stockManagementData.signStockLedgerAndSubForFinish(ledgerDate,
            "submitUser", userName, inOrderId, 2, remark);
        //恢复调出单
        stockManagementData.signStockLedgerAndSubForFinish(ledgerDate,
            "submitUser", userName, outOrderId, 2, remark);
      }else{
        //取消调入单
        stockManagementData.cancelStockLedgerAndSub(ledgerDate, inOrderId, remark);
        //取消调出单
        stockManagementData.cancelStockLedgerAndSub(ledgerDate, outOrderId, remark);
      }
      result = 1;
    }catch(Exception ex){
      ex.printStackTrace();
    }
    return result;
  }
  //创建商品组合单的方法
  public int createCombineOrder(String ledgerDate, String[] stockLedger,
                                  String[][] stockSubLedgerOut, String[][] stockSubLedgerIn){
    int result = 0;
    try{
      //创建商品组合调入单数组
     String[] orderInLedger = new String[stockLedger.length];
     System.arraycopy(stockLedger, 0, orderInLedger, 0, stockLedger.length);
      //创建商品组合调入单
      stockManagementData.createStockLedgerAndSub(ledgerDate,
                                                  orderInLedger, stockSubLedgerIn);
      //根据商品组合管理用户名字取得商品组合调入单,12表示商品组合调入单
      String[][] orderInLedgers = stockManagementData.
          getStockLedgerByStringField(ledgerDate, "submitUser", stockLedger[3], 12);
      //取得商品组合调入单标识，最后一条记录便是新创建的商品组合调入单
      String orderInId = orderInLedgers[orderInLedgers.length -1][0];
      //创建商品组合调出单数组
      String[] orderOutLedger = new String[stockLedger.length];
      System.arraycopy(stockLedger, 0, orderOutLedger, 0, stockLedger.length);
      //更新商品组合调出单数组，将商品调入单标识放在供货商字段，11表示商品组合调出单
      orderOutLedger[2] = orderInId;
      orderOutLedger[1] = "11";
      orderOutLedger[4] = stockLedger[8];         //调入仓库
      orderOutLedger[8] = stockLedger[4];         //调出仓库
      //创建商品组合调出单
      stockManagementData.createStockLedgerAndSub(ledgerDate,
                                                  orderOutLedger, stockSubLedgerOut);
      //根据商品组合管理用户名字取得商品组合调出单
      String[][] orderOutLedgers = stockManagementData.
          getStockLedgerByStringField(ledgerDate, "submitUser", orderOutLedger[3], 11);
      //取得商品组合调出单标识，最后一条记录便是新创建的商品组合调出单
      String orderOutId = orderOutLedgers[orderOutLedgers.length -1][0];
      //更新商品组合调入单数组的标识和关联标识
      orderInLedger[0] = orderInId;
      orderInLedger[2] = orderOutId;
      //根据标识重新取得商品组合调入单明细数组
      String[][] orderInSubLedger = stockManagementData.getStockSubLedgerByOrderId(
          ledgerDate, orderInLedger[0]);
      //更新商品组合调入单,将调出单的关联标识写入调入单
      stockManagementData.updateStockLedgerAndSub(ledgerDate,
                                                  orderInLedger, orderInSubLedger);
      result = 1;
    }catch(Exception ex){
      ex.printStackTrace();
    }
    return result;
  }
  //更新商品组合单的方法
  public int updateCombineOrder(String ledgerDate, String[] stockLedger,
                                  String[][] stockSubLedgerOut, String[][] stockSubLedgerIn){
    int result = 0;
    try{
      //更新商品组合调入单
      stockManagementData.updateStockLedgerAndSub(ledgerDate,
                                                  stockLedger, stockSubLedgerIn);
      //创建商品组合调出单数组
      String[] orderOutLedger = new String[stockLedger.length];
      System.arraycopy(stockLedger, 0, orderOutLedger, 0, stockLedger.length);
      //更新商品组合调出单数组，11表示调出单
      orderOutLedger[0] = stockLedger[2];
      orderOutLedger[1] = "11";
      orderOutLedger[2] = stockLedger[0];     //调出单的关联标识
      orderOutLedger[4] = stockLedger[8];     //调入仓库
      orderOutLedger[8] = stockLedger[4];     //调出仓库
      //更新商品组合调出单
      stockManagementData.updateStockLedgerAndSub(ledgerDate,
                                                  orderOutLedger, stockSubLedgerOut);
      result = 1;
    }catch(Exception ex){
      ex.printStackTrace();
    }
    return result;
  }
  //根据仓库名字取得盘点数据的方法
  public String[][] getStocktakeQuantityByWarehouse(String ledgerDate, String warehouse, int onProcess) {
    String[][] data = new String[0][2];
    try {
      data = stockManagementData.getStocktakeQuantityByWarehouse(ledgerDate,
          warehouse, onProcess);
    }
    catch (Exception ex) {
      ex.printStackTrace();
    }
    return data;
  }
  //根据仓库名字汇总显示商品数量和金额的方法
  public String[][] getStockByWarehouse(String ledgerDate, String warehouse, int onProcess) {
    String[][] data = new String[0][5];
    try {
      data = stockManagementData.getStockByWarehouse(ledgerDate, warehouse, onProcess);
    }
    catch (Exception ex) {
      ex.printStackTrace();
    }
    return data;
  }
  //根据商品条形码汇总显示商品在各个仓库的数量和金额的方法
  public String[][] getStockByGoodsBarcode(String ledgerDate, String goodsBarcode, int onProcess) {
    String[][] data = new String[0][5];
    try {
      data = stockManagementData.getStockByGoodsBarcode(ledgerDate, goodsBarcode, onProcess);
    }
    catch (Exception ex) {
      ex.printStackTrace();
    }
    return data;
  }
  //查询过期商品的方法
  public String[][] getStockByUsefulLife(String ledgerDate, String usefulLife, int onProcess) {
    String[][] data = new String[0][6];
    try {
      data = stockManagementData.getStockByUsefulLife(ledgerDate, usefulLife, onProcess);
    }
    catch (Exception ex) {
      ex.printStackTrace();
    }
    return data;
  }
  //创建销售账套数据表和销售账套明细数据表记录的方法
  public int createSaleLedgerAndSub(String ledgerDate, String[] saleLedger,
                                    String[][] saleSubLedger) {
    int result = 0;
    try{
      result = stockManagementData.createSaleLedgerAndSub(ledgerDate,
          saleLedger, saleSubLedger);
    }catch(Exception ex){
      ex.printStackTrace();
    }
    return result;
  }
  //更新销售账套数据表和销售账套明细数据表记录的方法
  public int updateSaleLedgerAndSub(String ledgerDate, String[] saleLedger,
                                    String[][] saleSubLedger) {
    int result = 0;
    try{
      result = stockManagementData.updateSaleLedgerAndSub(ledgerDate,
          saleLedger, saleSubLedger);
    }catch(Exception ex){
      ex.printStackTrace();
    }
    return result;
  }
  //销售账套数据表电子签名和更新完成状态的方法
  public int signSaleLedgerAndSub(String ledgerDate, String fieldName,
                                  String userName, String saleId, int onProcess,
                                  String remark) {
    int result = 0;
    try{
      result = stockManagementData.signSaleLedgerAndSub(ledgerDate, fieldName,
          userName, saleId, onProcess, remark);
    }catch(Exception ex){
      ex.printStackTrace();
    }
    return result;
  }
  //根据单据编号取得销售账套明细数据表的记录
  public String[][] getSaleSubLedgerBySaleId(String ledgerDate, String saleId) {