workservice.java

来自「一个很好的开源项目管理系统源代码」· Java 代码 · 共 459 行 · 第 1/2 页

package net.java.workeffort.service;

import java.util.ArrayList;
import java.util.List;

import net.java.workeffort.infrastructure.sequence.SequenceManager;
import net.java.workeffort.service.dao.IRowCallback;
import net.java.workeffort.service.domain.PageResult;
import net.java.workeffort.service.domain.Work;
import net.java.workeffort.service.domain.WorkAssociation;
import net.java.workeffort.service.domain.WorkDeliverableProduced;
import net.java.workeffort.service.domain.WorkFixedAssetAssignment;
import net.java.workeffort.service.domain.WorkInventoryAssignment;
import net.java.workeffort.service.domain.WorkPartyAssignment;
import net.java.workeffort.service.domain.WorkProductProduced;
import net.java.workeffort.service.domain.WorkQuery;
import net.java.workeffort.service.domain.WorkRequirement;
import net.java.workeffort.service.support.ChildRowExistsFkException;
import net.java.workeffort.service.support.IllegalHierarchyException;
import net.java.workeffort.service.support.InvalidHierarchyException;
import net.java.workeffort.service.support.NoParentRowFkException;
import net.java.workeffort.service.support.OptimisticLockingException;
import net.java.workeffort.service.support.UniqueConstraintException;

/**
 * Service for Work.
 * <p>
 * This is fronted by a spring proxy which implements transaction management,
 * security etc. The clients always interact with the proxy and <b>not </b> with
 * this, the target object.
 * </p>
 * @author Antony Joseph
 */
public class WorkService extends BaseService implements IWorkService {
    // This is to avoid infinite recursion if for some reason we have
    // circular parent/child relationship for work associations
    private static int MAX_DEPTH = 10;

    public Work getWork(Long pk) {
        return (Work) dao.queryForObject("Work.getWork", pk);
    }

    public PageResult getPageResultWork(WorkQuery query) {
        return dao.getPageResult(dbPrefix + "Work.getPageResultWork", query);
    }

    public void insertWork(Work work) {
        work.setWorkId(SequenceManager.getSequence("work").getNextId());
        dao.insert("Work.insertWork", work);
    }

    public void updateWork(Work work) throws OptimisticLockingException {
        dao.update("Work.updateWork", work);
    }

    public void deleteWork(Work work) throws OptimisticLockingException,
            ChildRowExistsFkException {
        dao.delete("Work.deleteWork", work);
    }

    public Work getWorkWithDeliverableProduced(Long pk) {
        Work work = (Work) dao.queryForObject("Work.getWork", pk);
        if (work != null) {
            List workDeliverableProduced = dao.queryForList(
                    "Work.getListWorkDeliverableProduced", pk);
            work.setWorkDeliverableProduced(workDeliverableProduced);
        }
        return work;
    }

    public void saveWorkWithDeliverableProduced(Work work)
            throws OptimisticLockingException, UniqueConstraintException {
        dao.processRows(work, "workDeliverableProduced",
                new DeliverableProducedRowCallback());
    }

    public Work getWorkWithFixedAssetAssignment(Long pk) {
        Work work = (Work) dao.queryForObject("Work.getWork", pk);
        if (work != null) {
            List workFixedAssetAssignments = dao.queryForList(
                    "Work.getListWorkFixedAssetAssignment", pk);
            work.setWorkFixedAssetAssignment(workFixedAssetAssignments);
        }
        return work;
    }

    public void saveWorkWithFixedAssetAssignment(Work work)
            throws OptimisticLockingException, UniqueConstraintException {
        dao.processRows(work, "workFixedAssetAssignment",
                new FixedAssetAssignmentRowCallback());
    }

    public Work getWorkWithInventoryAssignment(Long pk) {
        Work work = (Work) dao.queryForObject("Work.getWork", pk);
        if (work != null) {
            List workInventoryAssignments = dao.queryForList(
                    "Work.getListWorkInventoryAssignment", pk);
            work.setWorkInventoryAssignment(workInventoryAssignments);
        }
        return work;
    }

    public void saveWorkWithInventoryAssignment(Work work)
            throws OptimisticLockingException, UniqueConstraintException {
        dao.processRows(work, "workInventoryAssignment",
                new InventoryAssignmentRowCallback());
    }

    public Work getWorkWithProductProduced(Long pk) {
        Work work = (Work) dao.queryForObject("Work.getWork", pk);
        if (work != null) {
            List workProductProduced = dao.queryForList(
                    "Work.getListWorkProductProduced", pk);
            work.setWorkProductProduced(workProductProduced);
        }
        return work;
    }

    public void saveWorkWithProductProduced(Work work)
            throws OptimisticLockingException, UniqueConstraintException {
        dao.processRows(work, "workProductProduced",
                new ProductProducedRowCallback());

    }

    public Work getWorkWithRequirement(Long pk) {
        Work work = (Work) dao.queryForObject("Work.getWork", pk);
        if (work != null) {
            List workRequirement = dao.queryForList(
                    "Work.getListWorkRequirement", pk);
            work.setWorkRequirement(workRequirement);
        }
        return work;
    }

    public void saveWorkWithRequirement(Work work)
            throws OptimisticLockingException, UniqueConstraintException {
        dao.processRows(work, "workRequirement", new RequirementRowCallback());

    }

    public Work getWorkWithPartyAssignment(Long pk) {
        Work work = (Work) dao.queryForObject("Work.getWork", pk);
        if (work != null) {
            List workPartyAssignment = dao.queryForList(
                    "Work.getListWorkPartyAssignment", pk);
            work.setWorkPartyAssignment(workPartyAssignment);
        }
        return work;
    }

    public void saveWorkWithPartyAssignment(Work work)
            throws OptimisticLockingException, UniqueConstraintException {
        dao.processRows(work, "workPartyAssignment",
                new PartyAssignmentRowCallback());
    }

    public Work getWorkWithAssociation(Long pk) {
        Work work = (Work) dao.queryForObject("Work.getWork", pk);
        if (work != null) {
            List workAssociation = dao.queryForList("Work.getListWorkChildren",
                    pk);
            work.setWorkAssociation(workAssociation);
        }
        return work;
    }

    public void saveWorkWithAssociation(Work work)
            throws OptimisticLockingException, InvalidHierarchyException,
            UniqueConstraintException {
        dao.processRows(work, "workAssociation", new AssociationRowCallback());

    }

    public List getListWorkAssociationHierarchy(Long pk) {
        List hierarchy = new ArrayList();
        //A work could have multiple parents.
        List parents = new ArrayList();
        getTopLevelParents(parents, pk, 0);
        //System.out.println("parents = " + parents);
        for (int i = 0; i < parents.size(); i++) {
            Work parent = (Work) dao.queryForObject("Work.getWork", parents
                    .get(i));
            WorkAssociation workAssociation = new WorkAssociation();
            workAssociation.setWorkId(parent.getWorkId());
            workAssociation.setName(parent.getName());
            workAssociation.setLevel(new Integer(0));
            hierarchy.add(workAssociation);
            List children = new ArrayList();
            // getWorkIdChildren() gets all the children
            // going down the hierarchy.
            getWorkIdChildren(children, (Long) parents.get(i), 1);

            for (int j = 0; j < children.size(); j++) {
                hierarchy.add(children.get(j));
            }
            //System.out.println("children=" + children);
            //System.out.println("hierarchy = " + hierarchy);
        }
        return hierarchy;
    }

    private void getWorkIdChildren(List children, Long workId, int level) {
        if (level > MAX_DEPTH)
            throw new IllegalStateException("Level=" + level
                    + " went beyond max depth " + MAX_DEPTH);

        List list = dao.queryForList("Work.getListWorkChildren", workId);
        for (int i = 0; i < list.size(); i++) {
            ((WorkAssociation) list.get(i)).setLevel(new Integer(level));
            children.add(list.get(i));
            getWorkIdChildren(children, ((WorkAssociation) list.get(i))
                    .getWorkId(), level + 1);
        }
    }

    private void getTopLevelParents(List parents, Long workId, int level) {
        if (level > MAX_DEPTH)
            throw new IllegalStateException("Level=" + level
                    + " went beyond max depth " + MAX_DEPTH);

        List list = dao.queryForList("Work.getListWorkParent", workId);
        if (list == null || list.size() == 0) {
            // need the found flag to avoid duplicate top level parents.
            boolean found = false;
            for (int i = 0; i < parents.size(); i++) {
                if (workId.intValue() == ((Long) parents.get(i)).intValue()) {
                    found = true;
                    break;
                }