Spark_Max/src/main/scala/com/winhc/bigdata/spark/utils/BaseUtil.scala

package com.winhc.bigdata.spark.utils

import java.text.SimpleDateFormat
import java.util.regex.{Pattern}
import java.util.{Calendar, Date, Locale}
import org.apache.commons.lang3.StringUtils
import org.apache.commons.lang3.time.DateFormatUtils
import org.apache.spark.sql.SparkSession

/**
 * @Author: XuJiakai
 * @Date: 2020/6/3 18:49
 * @Description:
 */
object BaseUtil {
  //去其他符号 去空格
  private val pattern = "[^\\u4e00-\\u9fa50-9a-zA-Z]".r

  //去其他符号 去空格  补全null
  def cleanup(s: String): String = {
    if (StringUtils.isBlank(s))
      ""
    else
      pattern replaceAllIn(s, "")
  }

  def isWindows: Boolean = System.getProperty("os.name").contains("Windows")

  def getPartitions(t: String, @transient spark: SparkSession): Seq[String] = {
    import spark._
    val sql_s = s"show partitions " + t
    sql(sql_s).collect.toList.map(_.getString(0).split("=")(1)).seq
  }


  def getPartion(t: String, @transient spark: SparkSession) = {
    val ps = getPartitions(t, spark)
    if (ps.size > 0) {
      ps.last
    } else {
      ""
    }
  }

  def getFirstPartion(t: String, @transient spark: SparkSession) = {
    val ps = getPartitions(t, spark)
    if (ps.size > 0) {
      ps.head
    } else {
      ""
    }
  }

  def nowDate(pattern: String = "yyyy-MM-dd"): String = {
    new SimpleDateFormat(pattern).format(new Date)
  }

  def atMonthsBefore(n: Int, pattern: String = "yyyy-MM-dd"): String = {
    val c = Calendar.getInstance(Locale.CHINA)
    c.setTimeInMillis(new Date().getTime)
    c.add(Calendar.MONTH, -1 * n)
    DateFormatUtils.format(c.getTime.getTime, pattern)
  }

  def getYesterday(): String = {
    atDaysAfter(-1, nowDate("yyyyMMdd"))
  }

  def getYear(n:Int): String ={
    val cal = Calendar.getInstance(Locale.CHINA)
    cal.add(Calendar.YEAR,1*n)
    cal.get(Calendar.YEAR).toString
  }

  def atDaysAfter(n: Int, time: String, pattern: String = "yyyyMMdd"): String = {
    import java.text.SimpleDateFormat
    val newtime: Date = new SimpleDateFormat("yyyyMMdd").parse(time)
    val c = Calendar.getInstance(Locale.CHINA)
    c.setTimeInMillis(newtime.getTime)
    c.add(Calendar.DATE, 1 * n)
    DateFormatUtils.format(c.getTime.getTime, pattern)
  }

  private val case_no = Pattern.compile(".*([（\\(]\\d{4}[）\\)].*?号).*")

  def caseNo(s: String): String = {
    if (StringUtils.isBlank(s)) return ""
    val s1 = s.replaceAll("(\\r\\n|\\r|\\n|\\n\\r|\\s+)", "")
    val matcher = case_no.matcher(s1)
    if (matcher.find) {
      return matcher.replaceAll("$1").replaceAll("\\(", "（").replaceAll("\\)", "）")
    }
    ""
  }

  private val replace_char = "[^\\u4e00-\\u9fa5a-zA-Z\\(\\)（）]+".r

  def replaceChar(s: String) = {
    if (StringUtils.isNotBlank(s)) {
      val arr =
        s.replaceAll("、", ",")
          .replaceAll(";", ",")
          .replaceAll("，", ",")
          .replaceAll(" ", ",")
          .replaceAll("。", ",")
          .replaceAll("；", ",")
          .replaceAll("：", ",")
          .replaceAll("\\s+", ",").split(",")

      val list = arr.filter(_.length > 1).toList
      if (list.nonEmpty) {
        val sb = new StringBuilder
        for (a <- list) {
          sb.append(a).append(",")
        }
        sb.substring(0, sb.lastIndexOf(",")) toString()
      } else {
        ""
      }
    } else {
      ""
    }
  }

  def BKDRHash(str: String): Long = {
    val seed: Long = 1313131313 // 31 131 1313 13131 131313 etc..
    var hash: Long = 0
    for (i <- 0 to str.length - 1) {
      hash = hash * seed + str.charAt(i)
      hash = hash & 0x7FFFFFFFFFFFFFFFL
    }
    return hash
  }

  def nameJudge(name: String, yg_name: String, bg_name: String): String = {
    if(StringUtils.isNotBlank(name)){
      if(StringUtils.isNotBlank(yg_name)&&yg_name.contains(name)){
        return "y"
      }else if(StringUtils.isNotBlank(bg_name)&&bg_name.contains(name)){
        return "b"
      }
    }
     ""
  }

  def main(args: Array[String]): Unit = {
    println(getYear(-1))
  }

}