com.innovenso.townplanner.io.concepts.WorksheetIO.scala Maven / Gradle / Ivy

Go to download
package com.innovenso.townplanner.io.concepts

import com.innovenso.townplanner.model.{EnterpriseArchitecture, TownPlan}
import org.apache.poi.ss.usermodel.{Cell, Row, Sheet}
import org.apache.poi.xssf.usermodel.XSSFWorkbook

import scala.collection.immutable.Seq
import scala.jdk.CollectionConverters.IteratorHasAsScala
import scala.util.{Failure, Success, Try}

trait WorksheetIO {
  def worksheet(townPlan: TownPlan, workbook: XSSFWorkbook): Option[Sheet]

  def prepareSheet(workbook: XSSFWorkbook, name: String): Option[Sheet] =
    Option(workbook.getSheet(name)).orElse(Some(workbook.createSheet(name)))

  def prepareHeader(sheet: Sheet, columns: String*): Option[Row] =
    prepareHeader(sheet, columns.toList)

  def prepareHeader(sheet: Sheet, columns: List[String]): Option[Row] =
    Option(sheet.getRow(0))
      .orElse(Some(sheet.createRow(0)).map(r => prepareHeaderCells(r, columns)))

  def prepareHeaderCells(row: Row, columns: Seq[String]): Row = {
    columns.zipWithIndex.foreach(tuple =>
      prepareHeaderCell(row, tuple._2, tuple._1)
    )
    row
  }

  def prepareHeaderCell(row: Row, index: Int, name: String): Option[Cell] =
    Option(row.getCell(index))
      .orElse(Try {
        row.createCell(index)
      }.toOption)
      .map(cell => {
        cell.setCellValue(name)
        cell
      })

  def cell(row: Row, index: Int, value: String): Option[Cell] =
    Option(row.getCell(index))
      .orElse(Some(row.createCell(index)))
      .map(c => {
        c.setCellValue(value)
        c
      })

  def columnIndex(worksheet: Option[Sheet], header: String): Option[Int] =
    getRow(worksheet, 0).flatMap(row =>
      listOfCells(row)
        .find(c => isCellValue(c, header))
        .map(c => c.getColumnIndex)
    )

  def isCellValue(cell: Cell, value: String): Boolean = Try {
    cell.getStringCellValue == value
  } match {
    case Success(value) => value
    case Failure(exception) => {
      exception.printStackTrace()
      false
    }
  }

  def getCellValue(
      worksheet: Option[Sheet],
      row: Option[Row],
      index: Option[Int]
  ): Option[String] =
    for {
      r <- row
      i <- index
      value <- Try { r.getCell(i).getStringCellValue.trim }
        .orElse(Try { String.valueOf(r.getCell(i).getNumericCellValue) })
        .orElse(Try { r.getCell(i).getLocalDateTimeCellValue.toString })
        .toOption
    } yield value

  def getRow(worksheet: Option[Sheet], number: Int): Option[Row] =
    worksheet.flatMap(sheet => Option(sheet.getRow(number)))

  def listOfCells(row: Row): List[Cell] =
    row.cellIterator().asScala.toList

  def listOfRows(worksheet: Option[Sheet]): List[Row] =
    worksheet
      .map(sheet =>
        sheet.rowIterator().asScala.toList match {
          case head :: tail => tail
          case _            => Nil
        }
      )
      .getOrElse(Nil)

  def read(
      enterpriseArchitecture: EnterpriseArchitecture,
      workbook: XSSFWorkbook
  ): Unit
}