com.webbfontaine.valuewebb.irms.impl.assignment.action.AssignmentRuleActions.java Source code

Introduction

Here is the source code for com.webbfontaine.valuewebb.irms.impl.assignment.action.AssignmentRuleActions.java

Source

/*
 * Copyrights 2002-2011 Webb Fontaine
 * Developer: Sargis Harutyunyan
 * Date: 28 nov. 2011
 * This software is the proprietary information of Webb Fontaine.
 * Its use is subject to License terms.
 */
package com.webbfontaine.valuewebb.irms.impl.assignment.action;

import com.google.common.base.Optional;
import com.google.common.base.Predicates;
import com.google.common.base.Supplier;
import com.google.common.collect.Sets;
import com.webbfontaine.twm.urmcore.utils.Preconditions;
import com.webbfontaine.valuewebb.irms.repo.AssignmentEventRepository;
import com.webbfontaine.valuewebb.irms.repo.AssignmentRepository;
import com.webbfontaine.valuewebb.model.Pd;
import com.webbfontaine.valuewebb.model.TtGen;
import com.webbfontaine.valuewebb.model.assignment.Assignment;
import com.webbfontaine.valuewebb.model.assignment.PDAssignment;
import com.webbfontaine.valuewebb.model.assignment.TTAssignment;
import com.webbfontaine.valuewebb.model.util.Utils;
import org.jboss.seam.ScopeType;
import org.jboss.seam.annotations.In;
import org.jboss.seam.annotations.Name;
import org.jboss.seam.annotations.Scope;
import org.jboss.seam.annotations.Transactional;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import java.util.Date;
import java.util.List;
import java.util.Set;

import static com.google.common.collect.FluentIterable.from;

@Name("assignmentRuleActions")
@Scope(ScopeType.APPLICATION)
public class AssignmentRuleActions {

    private static final Logger LOGGER = LoggerFactory.getLogger(AssignmentRuleActions.class);

    public static final String IRMS_SYSTEM = "irms system";

    private final EntityManagerFactory entityManagerFactory = Utils.getEntityManagerFactory();

    private AutomaticAssignmentManager automaticAssignmentManager;

    private AssignmentRepository assignmentRepository;

    private AssignmentEventRepository assignmentEventRepository;

    @Transactional
    public void assignTTanalyst(TtGen ttGen, String username) {
        String lastAssignee = Optional
                .fromNullable(assignmentEventRepository.getLastAssigneeByTtId(ttGen.getId(), ttGen.getStatus()))
                .or(username);

        LOGGER.debug("Resolved last assignee: {} for TT with id: {} and fallback user: {}",
                new Object[] { lastAssignee, ttGen.getId(), username });

        assignTTanalystForce(ttGen, lastAssignee);
    }

    @Transactional
    public void assignTTanalystForce(TtGen ttGen, String username) {
        TTAssignment assignment = createTTAssignment(ttGen, username);

        insertIfNotExists(new AssignmentData<>(assignment.getTtId(), assignment, "checkTtAssignmentExistence"));
    }

    @Transactional
    public void assignPDanalyst(Pd pd, String username) {
        PDAssignment assignment = createPDAssignment(pd, username);

        insertIfNotExists(new AssignmentData<>(assignment.getPdId(), assignment, "checkPdAssignmentExistence"));
    }

    public void assignAutomatic(final TtGen ttGen, final List<String> newAssignees) {
        Preconditions.checkArgument(!newAssignees.isEmpty());

        final Set<String> candidates = Sets.newHashSet(newAssignees);

        List<String> previousAssignees = assignmentEventRepository.getAssigneesByTtId(ttGen.getId());
        LOGGER.debug(
                "Found previous distinct assignees: {} for TT with id: {} and will check for presence 'automatic' assignees list: {}",
                new Object[] { previousAssignees, ttGen.getId(), newAssignees });

        String assignee = from(previousAssignees).firstMatch(Predicates.in(candidates)).or(new Supplier<String>() {
            @Override
            public String get() {
                return automaticAssignmentManager.resolveAssignee(newAssignees);
            }
        });

        Preconditions.checkNotNull(assignee,
                "We should have resolved assignee at least from automatic assignees list");
        assignTTanalystForce(ttGen, assignee);
    }

    private <T extends Assignment> boolean insertIfNotExists(AssignmentData<T> assignmentData) {
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        T assignment = assignmentData.getAssignment();

        try {
            boolean newAssignment = assignmentNotFound(entityManager, assignmentData);
            if (newAssignment) {
                assignmentRepository.persist(assignment);
            } else {
                assignmentRepository.logAssignmentDuplication(assignmentData);
            }

            return newAssignment;
        } finally {
            entityManager.close();
        }
    }

    private static boolean assignmentNotFound(EntityManager entityManager, AssignmentData assignmentData) {
        return entityManager.createNamedQuery(assignmentData.getQueryName())
                .setParameter("id", assignmentData.getKey()).getResultList().isEmpty();
    }

    private static PDAssignment createPDAssignment(Pd pd, String username) {
        PDAssignment assignment = new PDAssignment();
        assignment.setTtId(pd.getTtGen().getId());
        assignment.setPdId(pd.getId());
        assignment.setAssigner(IRMS_SYSTEM);
        assignment.setAssignee(username);
        assignment.setDateCreated(now());

        return assignment;
    }

    private static TTAssignment createTTAssignment(TtGen ttGen, String username) {
        TTAssignment assignment = new TTAssignment();
        assignment.setTtId(ttGen.getId());
        assignment.setAssigner(IRMS_SYSTEM);
        assignment.setAssignee(username);
        assignment.setDateCreated(now());

        return assignment;
    }

    private static Date now() {
        return new Date();
    }

    @In(create = true)
    public void setAutomaticAssignmentManager(AutomaticAssignmentManager automaticAssignmentManager) {
        this.automaticAssignmentManager = automaticAssignmentManager;
    }

    @In(create = true)
    public void setAssignmentRepository(AssignmentRepository assignmentRepository) {
        this.assignmentRepository = assignmentRepository;
    }

    @In(value = "assignmentEventRepository", create = true)
    public void setAssignmentEventRepository(AssignmentEventRepository assignmentEventRepository) {
        this.assignmentEventRepository = assignmentEventRepository;
    }

    private static class AssignmentData<T extends Assignment> {

        private final Object key;
        private final T assignment;
        private final String queryName;

        private AssignmentData(Object key, T assignment, String queryName) {
            this.key = key;
            this.assignment = assignment;
            this.queryName = queryName;
        }

        public Object getKey() {
            return key;
        }

        public T getAssignment() {
            return assignment;
        }

        private String getQueryName() {
            return queryName;
        }

        @Override
        public String toString() {
            return "AssignmentCreation{" + "key=" + key + ", assignment=" + assignment + ", queryName='" + queryName
                    + '\'' + '}';
        }
    }
}