コード例 #1
0
  private void setIndexMatrix(HSSFWorkbook workbook, HSSFSheet sheet, ERTable table) {
    CellLocation logicalIndexCellLocation = POIUtils.findCell(sheet, KEYWORD_LOGICAL_INDEX_MATRIX);

    if (logicalIndexCellLocation != null) {
      if (this.logicalIndexMatrixCellStyle == null) {
        this.logicalIndexMatrixCellStyle =
            this.createMatrixCellStyle(workbook, sheet, logicalIndexCellLocation);
      }
      setIndexMatrix(
          workbook, sheet, table, logicalIndexCellLocation, this.logicalIndexMatrixCellStyle, true);
    }

    CellLocation physicalIndexCellLocation =
        POIUtils.findCell(sheet, KEYWORD_PHYSICAL_INDEX_MATRIX);

    if (physicalIndexCellLocation != null) {
      if (this.physicalIndexMatrixCellStyle == null) {
        this.physicalIndexMatrixCellStyle =
            this.createMatrixCellStyle(workbook, sheet, physicalIndexCellLocation);
      }
      setIndexMatrix(
          workbook,
          sheet,
          table,
          physicalIndexCellLocation,
          this.physicalIndexMatrixCellStyle,
          false);
    }
  }
コード例 #2
0
  private void setComplexUniqueKeyMatrix(HSSFWorkbook workbook, HSSFSheet sheet, ERTable table) {
    CellLocation logicalCellLocation =
        POIUtils.findCell(sheet, KEYWORD_LOGICAL_COMPLEX_UNIQUE_KEY_MATRIX);

    if (logicalCellLocation != null) {
      if (this.logicalComplexUniqueKeyMatrixCellStyle == null) {
        this.logicalComplexUniqueKeyMatrixCellStyle =
            this.createMatrixCellStyle(workbook, sheet, logicalCellLocation);
      }
      setComplexUniqueKeyMatrix(
          workbook,
          sheet,
          table,
          logicalCellLocation,
          this.logicalComplexUniqueKeyMatrixCellStyle,
          true);
    }

    CellLocation physicalCellLocation =
        POIUtils.findCell(sheet, KEYWORD_PHYSICAL_COMPLEX_UNIQUE_KEY_MATRIX);

    if (physicalCellLocation != null) {
      if (this.physicalComplexUniqueKeyMatrixCellStyle == null) {
        this.physicalComplexUniqueKeyMatrixCellStyle =
            this.createMatrixCellStyle(workbook, sheet, physicalCellLocation);
      }

      this.setComplexUniqueKeyMatrix(
          workbook,
          sheet,
          table,
          physicalCellLocation,
          this.physicalComplexUniqueKeyMatrixCellStyle,
          false);
    }
  }
コード例 #3
0
  private HSSFCellStyle createMatrixCellStyle(
      HSSFWorkbook workbook,
      HSSFCellStyle matrixHeaderTemplateCellStyle,
      boolean top,
      boolean right,
      boolean bottom,
      boolean left) {
    HSSFCellStyle cellStyle = POIUtils.copyCellStyle(workbook, matrixHeaderTemplateCellStyle);

    if (top) {
      cellStyle.setBorderTop(HSSFCellStyle.BORDER_THIN);
    }
    if (right) {
      cellStyle.setBorderRight(HSSFCellStyle.BORDER_THIN);
    }
    if (bottom) {
      cellStyle.setBorderBottom(HSSFCellStyle.BORDER_THIN);
    }
    if (left) {
      cellStyle.setBorderLeft(HSSFCellStyle.BORDER_THIN);
    }

    return cellStyle;
  }
コード例 #4
0
  private void setComplexUniqueKeyMatrix(
      HSSFWorkbook workbook,
      HSSFSheet sheet,
      ERTable table,
      CellLocation cellLocation,
      MatrixCellStyle matrixCellStyle,
      boolean isLogical) {

    int rowNum = cellLocation.r;
    int columnNum = cellLocation.c;

    HSSFRow headerTemplateRow = sheet.getRow(rowNum);
    HSSFCell headerTemplateCell = headerTemplateRow.getCell(columnNum);

    int num = table.getComplexUniqueKeyList().size();

    if (num == 0) {
      headerTemplateRow.removeCell(headerTemplateCell);

      HSSFRow row = sheet.getRow(rowNum - 1);
      if (row != null) {
        HSSFCell cell = row.getCell(columnNum);
        if (cell != null) {
          cell.getCellStyle().setBorderBottom(headerTemplateCell.getCellStyle().getBorderBottom());
        }
      }
      return;
    }

    HSSFRow headerRow = sheet.createRow(rowNum++);

    for (int i = 0; i < num + 1; i++) {
      HSSFCell cell = headerRow.createCell(columnNum + i);

      if (i == 0) {
        cell.setCellStyle(matrixCellStyle.style11);

      } else {
        ComplexUniqueKey complexUniqueKey = table.getComplexUniqueKeyList().get(i - 1);
        HSSFRichTextString text =
            new HSSFRichTextString(Format.null2blank(complexUniqueKey.getUniqueKeyName()));
        cell.setCellValue(text);

        if (i != num) {
          cell.setCellStyle(matrixCellStyle.style12);
        } else {
          cell.setCellStyle(matrixCellStyle.style13);
        }
      }
    }

    int columnSize = table.getExpandedColumns().size();
    for (int j = 0; j < columnSize; j++) {
      NormalColumn normalColumn = table.getExpandedColumns().get(j);

      HSSFRow row = POIUtils.insertRow(sheet, rowNum++);

      for (int i = 0; i < num + 1; i++) {
        HSSFCell cell = row.createCell(columnNum + i);

        if (i == 0) {
          String columnName = null;
          if (isLogical) {
            columnName = normalColumn.getLogicalName();
          } else {
            columnName = normalColumn.getPhysicalName();
          }

          HSSFRichTextString text = new HSSFRichTextString(columnName);
          cell.setCellValue(text);
          cell.setCellStyle(headerTemplateCell.getCellStyle());

          if (j != columnSize - 1) {
            cell.setCellStyle(matrixCellStyle.style21);
          } else {
            cell.setCellStyle(matrixCellStyle.style31);
          }

        } else {
          ComplexUniqueKey complexUniqueKey = table.getComplexUniqueKeyList().get(i - 1);
          List<NormalColumn> targetColumnList = complexUniqueKey.getColumnList();

          int indexNo = targetColumnList.indexOf(normalColumn);
          if (indexNo != -1) {
            cell.setCellValue(indexNo + 1);
          }

          if (i != num) {
            if (j != columnSize - 1) {
              cell.setCellStyle(matrixCellStyle.style22);
            } else {
              cell.setCellStyle(matrixCellStyle.style32);
            }

          } else {
            if (j != columnSize - 1) {
              cell.setCellStyle(matrixCellStyle.style23);
            } else {
              cell.setCellStyle(matrixCellStyle.style33);
            }
          }
        }
      }
    }
  }
コード例 #5
0
  public void setTableData(HSSFWorkbook workbook, HSSFSheet sheet, ERTable table) {
    POIUtils.replace(
        sheet,
        KEYWORD_LOGICAL_TABLE_NAME,
        this.getValue(this.keywordsValueMap, KEYWORD_LOGICAL_TABLE_NAME, table.getLogicalName()));

    POIUtils.replace(
        sheet,
        KEYWORD_PHYSICAL_TABLE_NAME,
        this.getValue(this.keywordsValueMap, KEYWORD_PHYSICAL_TABLE_NAME, table.getPhysicalName()));

    POIUtils.replace(
        sheet,
        KEYWORD_TABLE_DESCRIPTION,
        this.getValue(this.keywordsValueMap, KEYWORD_TABLE_DESCRIPTION, table.getDescription()));

    POIUtils.replace(
        sheet,
        KEYWORD_TABLE_CONSTRAINT,
        this.getValue(this.keywordsValueMap, KEYWORD_TABLE_CONSTRAINT, table.getConstraint()));

    CellLocation cellLocation = POIUtils.findCell(sheet, FIND_KEYWORDS_OF_COLUMN);

    if (cellLocation != null) {
      int rowNum = cellLocation.r;
      HSSFRow templateRow = sheet.getRow(rowNum);

      if (this.columnTemplate == null) {
        this.columnTemplate = this.loadColumnTemplate(workbook, sheet, cellLocation);
      }

      int order = 1;

      for (NormalColumn normalColumn : table.getExpandedColumns()) {
        HSSFRow row = POIUtils.insertRow(sheet, rowNum++);
        this.setColumnData(this.keywordsValueMap, columnTemplate, row, normalColumn, table, order);
        order++;
      }

      this.setCellStyle(
          columnTemplate,
          sheet,
          cellLocation.r,
          rowNum - cellLocation.r,
          templateRow.getFirstCellNum());
    }

    CellLocation fkCellLocation = POIUtils.findCell(sheet, FIND_KEYWORDS_OF_FK_COLUMN);

    if (fkCellLocation != null) {
      int rowNum = fkCellLocation.r;
      HSSFRow templateRow = sheet.getRow(rowNum);

      if (this.fkColumnTemplate == null) {
        this.fkColumnTemplate = this.loadColumnTemplate(workbook, sheet, fkCellLocation);
      }

      int order = 1;

      for (NormalColumn normalColumn : table.getExpandedColumns()) {
        if (normalColumn.isForeignKey()) {
          HSSFRow row = POIUtils.insertRow(sheet, rowNum++);
          this.setColumnData(
              this.keywordsValueMap, this.fkColumnTemplate, row, normalColumn, table, order);
          order++;
        }
      }

      this.setCellStyle(
          this.fkColumnTemplate,
          sheet,
          fkCellLocation.r,
          rowNum - fkCellLocation.r,
          templateRow.getFirstCellNum());
    }

    this.setIndexMatrix(workbook, sheet, table);
    this.setComplexUniqueKeyMatrix(workbook, sheet, table);
  }