P15GEN2\59518
2025-10-10 9f6890646993d16260d4201d613c092132856127
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
package foundation.system;
 
import java.util.ArrayList;
import java.util.List;
 
import foundation.dao.DataPackage;
import foundation.dao.DataReader;
import foundation.dao.DataWriter;
import foundation.data.entity.Entity;
import foundation.data.entity.EntitySet;
import foundation.data.entity.Filter;
import foundation.data.object.DataObject;
import foundation.org.LeaderHierarchy;
import foundation.org.LeaderHierarchys;
import foundation.org.Position;
import foundation.org.PositionHierarchys;
import foundation.state.approve.IHierarchyStepsCreator;
import foundation.state.approve.Step;
import foundation.state.approve.StepType;
import foundation.token.IOnlineUser;
import foundation.user.OnlineUser;
import foundation.util.Util;
import foundation.workflow.WorkStep;
 
 
public class HierarchyStepsCreator implements IHierarchyStepsCreator {
 
    private static HierarchyStepsCreator instance;
    
    
    private HierarchyStepsCreator() {
 
    }
    
    public static synchronized HierarchyStepsCreator getInstance() {
        if (instance == null) {
            instance = new HierarchyStepsCreator();
        }
        
        return instance;
    }
    
    @Override
    public List<Step> createSteps(StepType type, Step template, IOnlineUser user, WorkStep step) throws Exception {
        DataWriter dataWriter = step.getDataWriter();
        List<Step> result = new ArrayList<Step>();
        Position position;
        
        DataPackage dataPackage = step.getDataPackage();
        if (dataPackage == null) {
            DataReader dataReader = step.getDataReader();
            dataPackage = dataReader.getDataPackage();
        }
        
        if(dataPackage == null) {
            //1. 过去申请用户的当前岗位(默认审批提交操作等动作必须选定一个当前岗位)
            position  = ((OnlineUser)user).getCurrentPosition();
        }
        else {
            Entity master = dataPackage.getMasterEntity();
            position = getDocumentPosition(master);
            
            if (position == null) {
                position = getAccountPosition(dataPackage.getName(), master);
            }
        }
        
        //2. 获取岗位领导关系架构
        Filter filter = null;
        
        if (isBusiness(type)) {
            filter = new Filter();
            filter.add("duty", type.name());
        }
        else {
            if (position == null) {
                position = ((OnlineUser)user).getCurrentPosition();
            }
            
            if (position == null) {
                dataWriter.reportOneError("createHierarchySteps", "没有获取到当前用户的岗位,无法创建审批步骤");
                step.terminateTask();
            }
            
            filter = new Filter();
            filter.add("md_position.id", position.getId());
        }
        
        LeaderHierarchys hierarchys = LeaderHierarchys.getInstance(type, filter);
        
        int i = template.getIndexNo() - 1;
        
        for (PositionHierarchys hierarchy: hierarchys) {
            String id = type.name() + "-" + i;
            Step flowStep = null;
            
            if (!template.isCopy()) {
                flowStep = new Step(id, hierarchy.getPositionTitle() + "审批");
                flowStep.setIndexNo(i);
                i = i + 1;
            }
            else {
                flowStep = new Step(id, "通知" + hierarchy.getPositionTitle());
                flowStep.setIndexNo(i);
                flowStep.setCopy(template.isCopy());
            }
            
            for (LeaderHierarchy positionHierarchy : hierarchy.getPositinEmoployees()) {
                flowStep.addOneUser(positionHierarchy.getUserId(), positionHierarchy.getEmployeeName());
            }
            
            result.add(flowStep);
        }
        
        return result;
    }
 
    private Position getDocumentPosition(Entity entity) throws Exception {
        String positionId = entity.getString("position_id");
        
        if (Util.isEmpty(positionId)) {
            positionId = entity.getString("sale_position_id");
        }
        
        if (Util.isEmpty(positionId)) {
            return null;
        }
        
        return Position.loadPosition(positionId);
    }
 
    public static boolean isBusiness(StepType type) {
        return (StepType.BusinessOperator == type) || (StepType.BusinessDirector == type ||
                (StepType.BusinessOperationAssistant == type) || (StepType.CEO == type) 
                || (StepType.CFO == type) || (StepType.IT == type) || (StepType.DocumentController == type));
    }
 
    private Position getAccountPosition(String dataname, Entity entity) throws Exception {
        String accountId = entity.getString("account_id");
        
        if (dataname.equals("md_org_account") || dataname.equals("md_org_account_initial")) {
            accountId = entity.getId();
        }
        
        if (Util.isEmpty(accountId)) {
            accountId = entity.getString("customer_id");;
        }
        
        DataObject dataObject = DataObject.getInstance("md_org_account_position");
        Filter filter = new Filter();
        filter.add("parent_id", accountId);
        EntitySet positionEntitySet = dataObject.getTableEntitySet(filter);
        
        if (positionEntitySet.size() == 0 ) {
            return null;
        }
        
        boolean isExistsMainApprover = false;
        for (Entity position: positionEntitySet) {
            if(position.getBoolean("is_main_approver") && (!isExistsMainApprover)) {
                return Position.loadPosition(position.getString("position_id"));
            }
        }
        
        Entity position  =  positionEntitySet.getEntity(0);
        return Position.loadPosition(position.getString("position_id"));
    }
}