package com.engine.kq.biz.chain.cominfo;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

/**
 */
public class ShiftInfoCominfoBean implements Serializable {


    private static final long serialVersionUID = -1735765502081116461L;

  /**
     * 当前班次如果是作为前一个班次存在，跨到次日的工作时段
     */
    private List<String[]> preWorkTime;

    /**
     * 当前班次作为当前班次存在，在0-24小时内的工作时段
     */
    private List<String[]> workTime;

    /**
     * 当前班次作为当前班次存在，如果存在跨天的话，包含跨天的工作时段，显示成0-24小时的
     */
    private List<String[]> workAcrossTime;


    /**
     * 当前班次如果是作为前一个班次存在，跨到次日的工作时段
     */
    private List<int[]> preWorkTimeIndex;

    /**
     * 当前班次作为当前班次存在，在0-24小时内的工作时段
     */
    private List<int[]> workTimeIndex;

  /**
   * 当前班次作为当前班次存在，在0-48小时内的工作时段下标
   */
  private List<int[]> workLongTimeIndex;

  /**
   * 当前班次作为当前班次存在，在0-48小时内的工作时段下标
   */
  private List<int[]> restLongTimeIndex;

  /**
   * 存储所有的工作时间 48小时制休息时段
   */
  private List<String> allLongWorkTime;

    /**
     * 当前班次作为当前班次存在，如果存在跨天的话，包含跨天的工作时段，显示成0-24小时的
     */
    private List<int[]> workAcrossTimeIndex;

    /**
     * 考勤报表用的 48小时制工作时段
     */
    private List<Map<String,String>> workAcrossLongTime;

    /**
     * 当天打卡时段时间：多少分钟可以开始签到签退的
     */
    private List<String[][]> workPunchMins;

    /**
     * 当前班次如果是作为前一个班次存在，跨到次日的休息时段
     */
    private List<String[]> preRestTime;

    /**
     * 当前班次作为当前班次存在，在0-24小时内的休息时段
     */
    private List<String[]> restTime;

    /**
     * 当前班次作为当前班次存在，如果存在跨r天的话，包含跨天的休息时段，显示成0-24小时的
     */
    private List<String[]> restAcrossTime;
  /**
   * 当前班次如果是作为前一个班次存在，跨到次日的休息时段
   */
  private List<int[]> preRestTimeIndex;

  /**
   * 当前班次作为当前班次存在，在0-24小时内的休息时段
   */
  private List<int[]> restTimeIndex;

  /**
   * 当前班次作为当前班次存在，如果存在跨r天的话，包含跨天的休息时段，显示成0-24小时的
   */
  private List<int[]> restAcrossTimeIndex;

    /**
     * 考勤报表用的 48小时制休息时段
     */
    private List<Map<String,String>> restAcrossLongTime;

    /**
     * 要返回的半天规则时间区间对应的数组下标
     * 这里有值的话是三个，最早的开始时间 中间时间 最晚的下班时间
     */
    private List<String> halfWorkTime;

  /**
   * 要返回的半天规则时间区间对应的数组下标
   * 这里有值的话是三个，最早的开始时间 中间时间 最晚的下班时间
   */
  private List<int[]> halfWorkIndex;

  /**
   * 存储所有的工作时间
   */
  private List<String> allWorkTime;

  /**
   * 存储所有的跨天时间
   */
  private List<String> allAcrossWorkTime;
  /**
   * 存储所有的休息时间
   */
  private List<String> allRestTime;

  /**
   * 存储所有的休息时间
   */
  private List<String> allAcrossRestTime;

  /**
   * 存储每一段工作时段内的工作时长
   */
  private List<Integer> eachWorkMins;

    /**
     * 工作时长
     */
    private int workmins;

    /**
     * 当前日期的班次
     */
    private String serialid;

  /**
   * 判断当前班次是否存在跨天
   */
  private String isAcross;

  /**
   * 半天计算规则
   */
  private String halfcalrule;

  /**
   * 自定义 半天计算规则 时间点
   */
  private String halfcalpoint;

  private String halfcalpoint2cross;

  private List<Object> timelineList;

  /**
   * 允许签到签退的时段范围
   */
  private List<Map<String,String>> signWorkTime;

  /**
   * 存储所有的工作时间是否跨天 和allWorkTime对应
   */
  private List<String> allWorkTimeisAcross;

  private String uuid = "";

  public ShiftInfoCominfoBean() {

    this.preWorkTime = new ArrayList<>();
    this.workTime = new ArrayList<>();
    this.workAcrossTime = new ArrayList<>();
    this.preWorkTimeIndex = new ArrayList<>();
    this.workTimeIndex = new ArrayList<>();
    this.workAcrossTimeIndex = new ArrayList<>();
    this.workAcrossLongTime = new ArrayList<>();
    this.workPunchMins = new ArrayList<>();
    this.preRestTime = new ArrayList<>();
    this.restTime = new ArrayList<>();
    this.restAcrossTime = new ArrayList<>();
    this.preRestTimeIndex = new ArrayList<>();
    this.restTimeIndex = new ArrayList<>();
    this.restAcrossTimeIndex = new ArrayList<>();
    this.restAcrossLongTime = new ArrayList<>();
    this.halfWorkTime = new ArrayList<>();
    this.allWorkTime = new ArrayList<>();
    this.allAcrossWorkTime = new ArrayList<>();
    this.allRestTime = new ArrayList<>();
    this.allAcrossRestTime = new ArrayList<>();
    this.eachWorkMins = new ArrayList<>();
    this.workmins = 0;
    this.serialid = "";
    this.isAcross = "0";
    this.halfcalrule = "0";
    this.halfWorkIndex = new ArrayList<>();

    this.timelineList = new ArrayList<>();

    this.workLongTimeIndex = new ArrayList<>();
    this.restLongTimeIndex = new ArrayList<>();
    this.allLongWorkTime = new ArrayList<>();
    this.signWorkTime = new ArrayList<>();
    this.allWorkTimeisAcross = new ArrayList<>();
    this.uuid = UUID.randomUUID().toString();
    this.halfcalpoint = "0";
    this.halfcalpoint2cross = "0";
  }

    public List<String[]> getPreWorkTime() {
      return preWorkTime;
    }

    public void setPreWorkTime(List<String[]> preWorkTime) {
      this.preWorkTime = preWorkTime;
    }

    public List<String[]> getWorkTime() {
      return workTime;
    }

    public void setWorkTime(List<String[]> workTime) {
      this.workTime = workTime;
    }

    public List<String[]> getWorkAcrossTime() {
      return workAcrossTime;
    }

    public void setWorkAcrossTime(List<String[]> workAcrossTime) {
      this.workAcrossTime = workAcrossTime;
    }

    public List<Map<String, String>> getWorkAcrossLongTime() {
      return workAcrossLongTime;
    }

    public void setWorkAcrossLongTime(
        List<Map<String, String>> workAcrossLongTime) {
      this.workAcrossLongTime = workAcrossLongTime;
    }

  public List<String[][]> getWorkPunchMins() {
      return workPunchMins;
    }

    public void setWorkPunchMins(List<String[][]> workPunchMins) {
      this.workPunchMins = workPunchMins;
    }

    public List<String> getHalfWorkTime() {
      return halfWorkTime;
    }

    public void setHalfWorkTime(List<String> halfWorkTime) {
      this.halfWorkTime = halfWorkTime;
    }

    public int getWorkmins() {
      return workmins;
    }

    public void setWorkmins(int workmins) {
      this.workmins = workmins;
    }

    public String getSerialid() {
      return serialid;
    }

    public void setSerialid(String serialid) {
      this.serialid = serialid;
    }

    public List<String> getAllWorkTime() {
      return allWorkTime;
    }

    public void setAllWorkTime(List<String> allWorkTime) {
      this.allWorkTime = allWorkTime;
    }

    public List<String> getAllAcrossWorkTime() {
      return allAcrossWorkTime;
    }

    public void setAllAcrossWorkTime(List<String> allAcrossWorkTime) {
      this.allAcrossWorkTime = allAcrossWorkTime;
    }

  public List<String[]> getRestTime() {
    return restTime;
  }

  public void setRestTime(List<String[]> restTime) {
    this.restTime = restTime;
  }

  public String getIsAcross() {
    return isAcross;
  }

  public void setIsAcross(String isAcross) {
    this.isAcross = isAcross;
  }

  public List<String[]> getPreRestTime() {
    return preRestTime;
  }

  public void setPreRestTime(List<String[]> preRestTime) {
    this.preRestTime = preRestTime;
  }

  public List<String[]> getRestAcrossTime() {
    return restAcrossTime;
  }

  public void setRestAcrossTime(List<String[]> restAcrossTime) {
    this.restAcrossTime = restAcrossTime;
  }

  public List<Map<String, String>> getRestAcrossLongTime() {
    return restAcrossLongTime;
  }

  public void setRestAcrossLongTime(
      List<Map<String, String>> restAcrossLongTime) {
    this.restAcrossLongTime = restAcrossLongTime;
  }

  public List<String> getAllRestTime() {
    return allRestTime;
  }

  public void setAllRestTime(List<String> allRestTime) {
    this.allRestTime = allRestTime;
  }

  public List<String> getAllAcrossRestTime() {
    return allAcrossRestTime;
  }

  public void setAllAcrossRestTime(List<String> allAcrossRestTime) {
    this.allAcrossRestTime = allAcrossRestTime;
  }

  public List<Integer> getEachWorkMins() {
    return eachWorkMins;
  }

  public void setEachWorkMins(List<Integer> eachWorkMins) {
    this.eachWorkMins = eachWorkMins;
  }

  public List<int[]> getPreWorkTimeIndex() {
    return preWorkTimeIndex;
  }

  public void setPreWorkTimeIndex(List<int[]> preWorkTimeIndex) {
    this.preWorkTimeIndex = preWorkTimeIndex;
  }

  public List<int[]> getWorkTimeIndex() {
    return workTimeIndex;
  }

  public void setWorkTimeIndex(List<int[]> workTimeIndex) {
    this.workTimeIndex = workTimeIndex;
  }

  public List<int[]> getWorkAcrossTimeIndex() {
    return workAcrossTimeIndex;
  }

  public void setWorkAcrossTimeIndex(List<int[]> workAcrossTimeIndex) {
    this.workAcrossTimeIndex = workAcrossTimeIndex;
  }

  public List<int[]> getPreRestTimeIndex() {
    return preRestTimeIndex;
  }

  public void setPreRestTimeIndex(List<int[]> preRestTimeIndex) {
    this.preRestTimeIndex = preRestTimeIndex;
  }

  public List<int[]> getRestTimeIndex() {
    return restTimeIndex;
  }

  public void setRestTimeIndex(List<int[]> restTimeIndex) {
    this.restTimeIndex = restTimeIndex;
  }

  public List<int[]> getRestAcrossTimeIndex() {
    return restAcrossTimeIndex;
  }

  public void setRestAcrossTimeIndex(List<int[]> restAcrossTimeIndex) {
    this.restAcrossTimeIndex = restAcrossTimeIndex;
  }

  public List<int[]> getHalfWorkIndex() {
    return halfWorkIndex;
  }

  public void setHalfWorkIndex(List<int[]> halfWorkIndex) {
    this.halfWorkIndex = halfWorkIndex;
  }

  public List<Object> getTimelineList() {
    return timelineList;
  }

  public void setTimelineList(List<Object> timelineList) {
    this.timelineList = timelineList;
  }

  public List<int[]> getWorkLongTimeIndex() {
    return workLongTimeIndex;
  }

  public void setWorkLongTimeIndex(List<int[]> workLongTimeIndex) {
    this.workLongTimeIndex = workLongTimeIndex;
  }

  public List<int[]> getRestLongTimeIndex() {
    return restLongTimeIndex;
  }

  public void setRestLongTimeIndex(List<int[]> restLongTimeIndex) {
    this.restLongTimeIndex = restLongTimeIndex;
  }

  public List<String> getAllLongWorkTime() {
    return allLongWorkTime;
  }

  public void setAllLongWorkTime(List<String> allLongWorkTime) {
    this.allLongWorkTime = allLongWorkTime;
  }

  public List<Map<String, String>> getSignWorkTime() {
    return signWorkTime;
  }

  public void setSignWorkTime(
      List<Map<String, String>> signWorkTime) {
    this.signWorkTime = signWorkTime;
  }

  public List<String> getAllWorkTimeisAcross() {
    return allWorkTimeisAcross;
  }

  public void setAllWorkTimeisAcross(List<String> allWorkTimeisAcross) {
    this.allWorkTimeisAcross = allWorkTimeisAcross;
  }

  public String getHalfcalrule() {
    return halfcalrule;
  }

  public void setHalfcalrule(String halfcalrule) {
    this.halfcalrule = halfcalrule;
  }

  public String getUuid() {
    return uuid;
  }

  public void setUuid(String uuid) {
    this.uuid = uuid;
  }

  public String getHalfcalpoint() {
    return halfcalpoint;
  }

  public void setHalfcalpoint(String halfcalpoint) {
    this.halfcalpoint = halfcalpoint;
  }

  public String getHalfcalpoint2cross() {
    return halfcalpoint2cross;
  }

  public void setHalfcalpoint2cross(String halfcalpoint2cross) {
    this.halfcalpoint2cross = halfcalpoint2cross;
  }
}

