stockmanagementdata.java

一个使用java 写的进销存代码 使用了ejb 等技术 是学习j2ee的好

  //验收员进行库存账套数据表电子签名的方法
  public int checkUserSignStockLedgerAndSub(String ledgerDate, String userName,
                                            String supplierName, String orderId,
                                            String remark) {
    int result = 0;
    try {
      result = stockManagementData.checkUserSignStockLedgerAndSub(ledgerDate, userName,
          supplierName, orderId, remark);
    }catch (Exception ex) {
      ex.printStackTrace();
    }
    return result;
  }
  //根据相关联票据标识取得往来账套数据表的记录
  public String[] getCurrentAccountLedgerBylinkId(String ledgerDate, String linkId){
    String[] data = new String[11];
    try {
      data = stockManagementData.getCurrentAccountLedgerBylinkId(ledgerDate, linkId);
    }catch (Exception ex) {
      ex.printStackTrace();
    }
    return data;
  }
  //根据票据编号、开票据的用户名、供应商名字取得往来账套数据表记录的方法
  public String[][] getCurrentAccountLedgerByStringField(String ledgerDate,
      String fieldName, String fieldValue, int documentType) {
    String[][] data = new String[0][11];
    try {
      data = stockManagementData.getCurrentAccountLedgerByStringField(
          ledgerDate, fieldName, fieldValue, documentType);
    }
    catch (Exception ex) {
      ex.printStackTrace();
    }
    return data;
  }
  //根据完成状态取得往来账套数据表记录的方法
  public String[][] getCurrentAccountLedgerByOnProcess(String ledgerDate,
      int documentType, int onProcess) {
    String[][] data = new String[0][11];
    try {
      data = stockManagementData.getCurrentAccountLedgerByOnProcess(
          ledgerDate, documentType, onProcess);
    }
    catch (Exception ex) {
      ex.printStackTrace();
    }
    return data;
  }
  //根据开票据日期取得往来账套数据表记录的方法
  public String[][] getCurrentAccountLedgerByFillDate(String ledgerDate,
      java.sql.Timestamp startDate, java.sql.Timestamp endDate,
      int documentType) {
    String[][] data = new String[0][11];
    try {
      data = stockManagementData.getCurrentAccountLedgerByFillDate(ledgerDate,
          startDate, endDate, documentType);
    }
    catch (Exception ex) {
      ex.printStackTrace();
    }
    return data;
  }
  //现金管理员进行电子签名的方法
  public int cashUserSignAccountPayable(String ledgerDate, String userName, String[] currentAccountLedger) {
    int result = 0;
    try{
      result = stockManagementData.cashUserSignAccountPayable(ledgerDate,
          userName, currentAccountLedger);
    }catch(Exception ex){
      ex.printStackTrace();
    }
    return result;
  }
  //根据关联票据标识、记账用户取得现金账套数据表记录的方法
  public String[][] getCashLedgerByStringField(String ledgerDate,
                                               String fieldName,
                                               String fieldValue) {
    String[][] data = new String[0][6];
    try {
      data = stockManagementData.getCashLedgerByStringField(ledgerDate,
          fieldName, fieldValue);
    }catch (Exception ex) {
      ex.printStackTrace();
    }
    return data;
  }
  //根据发生日期取得现金账套数据表记录的方法
  public String[][] getCashLedgerByFillDate(String ledgerDate,
                                            java.sql.Timestamp startDate,
                                            java.sql.Timestamp endDate) {
    String[][] data = new String[0][6];
    try {
      data = stockManagementData.getCashLedgerByFillDate(ledgerDate, startDate,
          endDate);
    }catch (Exception ex) {
      ex.printStackTrace();
    }
    return data;
  }
  //现金管理员收取退款进行电子签名的方法
  public int cashUserSignStockLedgerForStockReturn(String ledgerDate,
      String userName, String supplierName, String orderId, String remark,
      boolean isPay) {
    int result = 0;
    try {
      result = stockManagementData.cashUserSignStockLedgerForStockReturn(
          ledgerDate, userName, supplierName, orderId, remark, isPay);
    }catch (Exception ex) {
      ex.printStackTrace();
    }
    return result;
  }
  //根据会计分录账套数据表的序号取得会计分录明细数据表的记录
  public String[][] getAccountEntrySubLedgerByLinkSerialId(String ledgerDate, int linkSerialId) {
    String[][] data = new String[0][5];
    try {
      data = stockManagementData.getAccountEntrySubLedgerByLinkSerialId(
          ledgerDate, linkSerialId);
    }
    catch (Exception ex) {
      ex.printStackTrace();
    }
    return data;
  }
  //根据会计科目、关联的票据标识、记账用户、审核用户取得会计分录账套数据表记录的方法
  public String[][] getAccountEntryLedgerByStringField(String ledgerDate,
      String accountName, String fieldName, String fieldValue) {
    String[][] data = new String[0][8];
    try {
      data = stockManagementData.getAccountEntryLedgerByStringField(ledgerDate,
          accountName, fieldName, fieldValue);
    }
    catch (Exception ex) {
      ex.printStackTrace();
    }
    return data;
  }
  //根据会计科目、完成状态取得会计分录账套数据表记录的方法
  public String[][] getAccountEntryLedgerByOnProcess(String ledgerDate,
      String accountName, int onProcess) {
    String[][] data = new String[0][8];
    try {
      data = stockManagementData.getAccountEntryLedgerByOnProcess(ledgerDate,
          accountName, onProcess);
    }
    catch (Exception ex) {
      ex.printStackTrace();
    }
    return data;
  }
  //根据会计科目、记账日期取得会计分录账套数据表记录的方法
  public String[][] getAccountEntryLedgerByFillDate(String ledgerDate,
      java.sql.Timestamp startDate, java.sql.Timestamp endDate,
      String accountName) {
    String[][] data = new String[0][8];
    try {
      data = stockManagementData.getAccountEntryLedgerByFillDate(ledgerDate,
          startDate, endDate, accountName);
    }
    catch (Exception ex) {
      ex.printStackTrace();
    }
    return data;
  }
  //撤消和恢复会计分录账套数据表完成状态的方法
  public int cancelOrRestoreAccountEntryLedger(String ledgerDate, int serialId,
                                               int onProcess, String remark) {
    int result = 0;
    try{
      result = stockManagementData.cancelOrRestoreAccountEntryLedger(ledgerDate,
          serialId, onProcess, remark);
    }catch(Exception ex){
      ex.printStackTrace();
    }
    return result;
  }
  //审核用户对会计分录进行电子签名的方法
  public int signAccountEntryLedger(String ledgerDate, String fieldName,
                                    String userName, int serialId,
                                    int onProcess, String remark) {
    int result = 0;
    try{
      result = stockManagementData.signAccountEntryLedger(ledgerDate, fieldName,
          userName, serialId, onProcess, remark);
    }catch(Exception ex){
      ex.printStackTrace();
    }
    return result;
  }
  //创建会计分录的方法
  public int createAccountEntry(String ledgerDate, String[] accountEntryLedger,
                                String[][] accountEntrySubLedger) {
    int result = 0;
    try{
      result = stockManagementData.createAccountEntry(ledgerDate,
          accountEntryLedger, accountEntrySubLedger, false, null);
    }catch(Exception ex){
      ex.printStackTrace();
    }
    return result;
  }
  //更新会计分录的方法
  public int updateAccountEntry(String ledgerDate, String[] accountEntryLedger,
                                String[][] accountEntrySubLedger) {
    int result = 0;
    try{
      result = stockManagementData.updateAccountEntry(ledgerDate,
          accountEntryLedger, accountEntrySubLedger);
    }catch(Exception ex){
      ex.printStackTrace();
    }
    return result;
  }
  //创建商品调拔单的方法
  public int createTransferOrder(String ledgerDate, String[] stockLedger,
                                     String[][] stockSubLedger){
    int result = 0;
    try{
      //创建商品调入单数组
      String[] orderInLedger = new String[stockLedger.length];
      //创建商品调入单明细数组
      String[][] orderInSubLedger = new String[stockSubLedger.length][stockSubLedger[0].length];
      //更新商品调入单明细数组
      for(int i = 0; i < orderInSubLedger.length; i++){
        orderInSubLedger[i][0] = stockSubLedger[i][0];
        orderInSubLedger[i][1] = stockSubLedger[i][1];
        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];
      }
      System.arraycopy(stockLedger, 0, orderInLedger, 0, stockLedger.length);
      //更新商品调入单数组，3表示商品调入单
      orderInLedger[1] = "3";
      orderInLedger[4] = stockLedger[8];         //调出仓库
      orderInLedger[8] = stockLedger[4];         //调入仓库
      //创建商品调入单
      stockManagementData.createStockLedgerAndSub(ledgerDate, orderInLedger, orderInSubLedger);
      //根据商品调出用户名字取得商品调入单
      String[][] orderInLedgers = stockManagementData.
          getStockLedgerByStringField(ledgerDate, "submitUser", orderInLedger[3], 3);
      //取得商品调入单标识，最后一条记录便是新创建的商品调入单
      String orderInId = orderInLedgers[orderInLedgers.length -1][0];
      //创建商品调出单数组
      String[] orderOutLedger = stockLedger;
      //将商品调入单标识放在供应商字段
      orderOutLedger[2] = orderInId;
      //创建商品调出单
      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);