com.hengyi.japp.execution.domain.Task.java Source code

Introduction

Here is the source code for com.hengyi.japp.execution.domain.Task.java

Source

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.hengyi.japp.execution.domain;

import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.hengyi.japp.execution.data.TaskSmsReactionType;
import com.hengyi.japp.execution.data.TaskStatus;
import com.hengyi.japp.execution.data.TaskType;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.persistence.Transient;
import javax.validation.constraints.NotNull;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlRootElement;
import org.hibernate.validator.constraints.NotBlank;
import org.joda.time.LocalDate;

/**
 *
 * @author jzb
 */
@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
@Entity
@Table(name = "T_TASK")
@NamedQueries({
        @NamedQuery(name = "Task.findByRelateSort", query = "SELECT o FROM Task o WHERE o.relateSort=:relateSort"),
        @NamedQuery(name = "Task.findByRelateSorts", query = "SELECT o FROM Task o WHERE o.relateSort IN :relateSorts") })
public class Task extends AbstractEntity implements Comparable<Task> {

    private static final long serialVersionUID = 1L;
    @NotNull
    @ManyToOne
    @JoinColumn(nullable = false)
    private Customer customer;
    @NotNull
    private TaskType type = TaskType.PERSONAL;
    @NotNull
    private TaskStatus status = TaskStatus.INIT;
    @NotBlank
    private String content;
    private String imageContent;
    @NotNull
    @Temporal(TemporalType.DATE)
    private Date startDate = new Date();
    @NotNull
    @Temporal(TemporalType.DATE)
    private Date endDate;
    @NotNull
    @ManyToOne
    @JoinColumn(nullable = false)
    private Operator charger;
    @ManyToMany(fetch = FetchType.EAGER, cascade = CascadeType.ALL)
    @JoinTable(name = "T_TASK_T_EXECUTOR")
    private List<Operator> executors;
    @ManyToMany(fetch = FetchType.EAGER, cascade = CascadeType.ALL)
    @JoinTable(name = "T_TASK_T_FOLLOWER")
    private List<Operator> followers;
    @ManyToMany(cascade = CascadeType.ALL)
    @JoinTable(name = "T_TASK_T_EXPERIENCE")
    private List<Experience> experiences;
    @OneToMany(mappedBy = "task", fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval = true)
    private List<TaskSms> taskSmses;
    private LogInfo logInfo = new LogInfo();
    //??
    @Column(length = 36)
    private String relateSort;

    public Task() {
        super();
    }

    public Task(Customer customer) {
        this();
        this.customer = customer;
    }

    public boolean isPersonal() {
        return TaskType.PERSONAL.equals(type);
    }

    public boolean isTeam() {
        return TaskType.TEAM.equals(type);
    }

    public boolean isNeedNotice() {
        return !TaskType.NONE.equals(type);
    }

    public boolean isOverTime() {
        return LocalDate.now().isAfter(LocalDate.fromDateFields(getEndDate()));
    }

    public boolean isInit() {
        return TaskStatus.INIT.equals(status);
    }

    public boolean isRun() {
        return TaskStatus.RUN.equals(status);
    }

    public boolean isFinish() {
        return TaskStatus.FINISH.equals(status);
    }

    public boolean isClose() {
        return TaskStatus.CLOSE.equals(status);
    }

    public boolean isStop() {
        return isFinish() || isClose();
    }

    public boolean isAlreadyFinish() {
        if (!isNeedNotice()) {
            return isOverTime();
        }
        for (TaskSms taskSms : getTaskSmses()) {
            if (isPersonal() && !taskSms.isSended()) {
                return false;
            }

            for (Operator executor : executors) {
                if (!TaskSmsReactionType.YES.equals(taskSms.getTaskSmsReactionType(executor))) {
                    return false;
                }
            }
        }
        return true;
    }

    public Customer getCustomer() {
        return customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }

    public TaskType getType() {
        return type;
    }

    public void setType(TaskType type) {
        this.type = type;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String getImageContent() {
        return imageContent;
    }

    public void setImageContent(String imageContent) {
        this.imageContent = imageContent;
    }

    public Date getStartDate() {
        return startDate;
    }

    public void setStartDate(Date startDate) {
        this.startDate = startDate;
    }

    public Date getEndDate() {
        return endDate;
    }

    public void setEndDate(Date endDate) {
        this.endDate = endDate;
    }

    public Operator getCharger() {
        return charger;
    }

    public void setCharger(Operator charger) {
        this.charger = charger;
    }

    public List<Operator> getFollowers() {
        return followers;
    }

    public void setFollowers(List<Operator> followers) {
        this.followers = followers;
    }

    public List<Operator> getExecutors() {
        return executors;
    }

    public List<Experience> getExperiences() {
        return experiences;
    }

    public void setExperiences(List<Experience> experiences) {
        this.experiences = experiences;
    }

    public void setExecutors(List<Operator> executors) {
        this.executors = executors;
    }

    public TaskStatus getStatus() {
        return status;
    }

    public void setStatus(TaskStatus status) {
        this.status = status;
    }

    @Transient
    private boolean _taskSmsesSorted;

    public List<TaskSms> getTaskSmses() {
        if (!_taskSmsesSorted) {
            if (taskSmses != null) {
                Collections.sort(taskSmses);
            }
            _taskSmsesSorted = true;
        }
        return taskSmses;
    }

    public void setTaskSmses(List<TaskSms> taskSmses) {
        this.taskSmses = taskSmses;
    }

    public LogInfo getLogInfo() {
        return logInfo;
    }

    public void setLogInfo(LogInfo logInfo) {
        this.logInfo = logInfo;
    }

    public String getRelateSort() {
        return relateSort;
    }

    public void setRelateSort(String relateSort) {
        this.relateSort = relateSort;
    }

    @Override
    public String toString() {
        return getContent();
    }

    @Override
    public int compareTo(Task o) {
        if (this.getStartDate() == null || o.getStartDate() == null) {
            return 0;
        }
        return this.getStartDate().compareTo(o.getStartDate());
    }

    public void add(TaskSms taskSms) {
        if (taskSmses == null) {
            taskSmses = Lists.newArrayList(taskSms);
        } else if (!taskSmses.contains(taskSms)) {
            taskSmses.add(taskSms);
            Collections.sort(taskSmses);
        }
    }

    public void remove(TaskSms taskSms) {
        if (taskSms == null || taskSmses == null || taskSmses.isEmpty()) {
            return;
        }
        // ?taskSms
        taskSmses.removeAll(getAllSubTaskSms(taskSms));
        taskSmses.remove(taskSms);
    }

    public Collection<TaskSms> getAllSubTaskSms(TaskSms taskSms) {
        if (taskSms == null || taskSmses == null) {
            return null;
        }

        Collection<TaskSms> result = Sets.newHashSet();
        for (TaskSms _taskSms : taskSmses) {
            if (taskSms.equals(_taskSms.getDependTaskSms())) {
                result.addAll(getAllSubTaskSms(_taskSms));
                result.add(_taskSms);
            }
        }
        return result;
    }

}