001package org.nasdanika.html.flow;
002
003import java.util.Collection;
004import java.util.Collections;
005import java.util.List;
006import java.util.function.BiConsumer;
007import java.util.stream.Collectors;
008
009import org.eclipse.emf.common.util.EList;
010import org.eclipse.emf.ecore.EObject;
011import org.nasdanika.common.Context;
012import org.nasdanika.common.ProgressMonitor;
013import org.nasdanika.flow.Activity;
014import org.nasdanika.flow.Artifact;
015import org.nasdanika.flow.Package;
016import org.nasdanika.flow.Participant;
017import org.nasdanika.flow.Resource;
018import org.nasdanika.html.model.app.Action;
019import org.nasdanika.html.model.app.AppFactory;
020import org.nasdanika.ncore.util.NamedElementComparator;
021
022public class PackageActionBuilder extends PackageElementActionBuilder<org.nasdanika.flow.Package> {
023        
024        public PackageActionBuilder(org.nasdanika.flow.Package value, Context context) {
025                super(value, context);
026        }
027        
028        @Override
029        protected Action buildAction(
030                        Action action,
031                        BiConsumer<EObject,Action> registry, 
032                        java.util.function.Consumer<org.nasdanika.common.Consumer<org.nasdanika.html.emf.EObjectActionResolver.Context>> resolveConsumer, 
033                        ProgressMonitor progressMonitor) throws Exception {
034                action = super.buildAction(action, registry, resolveConsumer, progressMonitor);
035                
036                EList<EObject> children = action.getChildren();
037                children.addAll(createSubPackageActions(registry, resolveConsumer, progressMonitor));
038                children.addAll(createActivityActions(registry, resolveConsumer, progressMonitor));
039                children.addAll(createParticipantActions(registry, resolveConsumer, progressMonitor));
040                children.addAll(createResourceActions(registry, resolveConsumer, progressMonitor));
041                children.addAll(createArtifactActions(registry, resolveConsumer, progressMonitor));
042                
043                return action;
044        }
045        
046        /**
047         * Creates a list of actions for sub-packages. 
048         * @param progressMonitor
049         * @return An empty list if there are no sub-packages. A singleton list containing a grouping action containing sub-package actions otherwise.
050         * @throws Exception 
051         */
052        protected List<Action> createSubPackageActions(
053                        BiConsumer<EObject,Action> registry, 
054                        java.util.function.Consumer<org.nasdanika.common.Consumer<org.nasdanika.html.emf.EObjectActionResolver.Context>> resolveConsumer, 
055                        ProgressMonitor progressMonitor) throws Exception {
056                List<Package> subPackages = getTarget().getSubPackages().values().stream().sorted(NamedElementComparator.INSTANCE).collect(Collectors.toList());
057                if (subPackages.isEmpty()) {
058                        return Collections.emptyList();
059                }
060                Action group = AppFactory.eINSTANCE.createAction();
061                group.setText("Sub-packages");
062                // TODO - icon, ...
063                EList<EObject> children = group.getChildren();
064                for (Package sp: subPackages) {
065                        children.add(createChildAction(sp, registry, resolveConsumer, progressMonitor));
066                }
067                
068                return Collections.singletonList(group);
069        }
070        
071        /**
072         * Creates a list of actions for activities. 
073         * @param progressMonitor
074         * @return An empty list if there are no activities. A singleton list containing a grouping action containing activity actions otherwise.
075         * @throws Exception 
076         */
077        protected List<Action> createActivityActions(
078                        BiConsumer<EObject,Action> registry, 
079                        java.util.function.Consumer<org.nasdanika.common.Consumer<org.nasdanika.html.emf.EObjectActionResolver.Context>> resolveConsumer, 
080                        ProgressMonitor progressMonitor) throws Exception {
081                Collection<Activity<?>> activities = getTarget().getActivities().values().stream().sorted(NamedElementComparator.INSTANCE).collect(Collectors.toList());
082                if (activities.isEmpty()) {
083                        return Collections.emptyList();
084                }
085                Action group = AppFactory.eINSTANCE.createAction();
086                group.setText("Activities");
087                // TODO - icon, ...
088                EList<EObject> children = group.getChildren();
089                for (Activity<?> activity: activities) {
090                        children.add(createChildAction(activity, registry, resolveConsumer, progressMonitor));
091                }
092                
093                return Collections.singletonList(group);
094        }
095        
096        /**
097         * Creates a list of actions for participants. 
098         * @param progressMonitor
099         * @return An empty list if there are no participants. A singleton list containing a grouping action containing participant actions otherwise.
100         * @throws Exception 
101         */
102        protected List<Action> createParticipantActions(
103                        BiConsumer<EObject,Action> registry, 
104                        java.util.function.Consumer<org.nasdanika.common.Consumer<org.nasdanika.html.emf.EObjectActionResolver.Context>> resolveConsumer, 
105                        ProgressMonitor progressMonitor) throws Exception {
106                Collection<Participant> participants = getTarget().getParticipants().values().stream().sorted(NamedElementComparator.INSTANCE).collect(Collectors.toList());
107                if (participants.isEmpty()) {
108                        return Collections.emptyList();
109                }
110                Action group = AppFactory.eINSTANCE.createAction();
111                group.setText("Participants");
112                // TODO - icon, ...
113                EList<EObject> children = group.getChildren();
114                for (Participant participant: participants) {
115                        children.add(createChildAction(participant, registry, resolveConsumer, progressMonitor));
116                }
117                
118                return Collections.singletonList(group);
119        }
120        
121        /**
122         * Creates a list of actions for resources. 
123         * @param progressMonitor
124         * @return An empty list if there are no resources. A singleton list containing a grouping action containing resource actions otherwise.
125         * @throws Exception 
126         */
127        protected List<Action> createResourceActions(
128                        BiConsumer<EObject,Action> registry, 
129                        java.util.function.Consumer<org.nasdanika.common.Consumer<org.nasdanika.html.emf.EObjectActionResolver.Context>> resolveConsumer, 
130                        ProgressMonitor progressMonitor) throws Exception {
131                Collection<Resource> resources = getTarget().getResources().values().stream().sorted(NamedElementComparator.INSTANCE).collect(Collectors.toList());
132                if (resources.isEmpty()) {
133                        return Collections.emptyList();
134                }
135                Action group = AppFactory.eINSTANCE.createAction();
136                group.setText("Resources");
137                // TODO - icon, ...
138                EList<EObject> children = group.getChildren();
139                for (Resource resource: resources) {
140                        children.add(createChildAction(resource, registry, resolveConsumer, progressMonitor));
141                }
142                
143                return Collections.singletonList(group);
144        }
145        
146        /**
147         * Creates a list of actions for activities. 
148         * @param progressMonitor
149         * @return An empty list if there are no activities. A singleton list containing a grouping action containing actvity actions otherwise.
150         * @throws Exception 
151         */
152        protected List<Action> createArtifactActions(
153                        BiConsumer<EObject,Action> registry, 
154                        java.util.function.Consumer<org.nasdanika.common.Consumer<org.nasdanika.html.emf.EObjectActionResolver.Context>> resolveConsumer, 
155                        ProgressMonitor progressMonitor) throws Exception {
156                Collection<Artifact> artifacts = getTarget().getArtifacts().values().stream().sorted(NamedElementComparator.INSTANCE).collect(Collectors.toList());
157                if (artifacts.isEmpty()) {
158                        return Collections.emptyList();
159                }
160                Action group = AppFactory.eINSTANCE.createAction();
161                group.setText("Artifacts");
162                // TODO - icon, ...
163                EList<EObject> children = group.getChildren();
164                for (Artifact artifact: artifacts) {
165                        children.add(createChildAction(artifact, registry, resolveConsumer, progressMonitor));
166                }
167                
168                return Collections.singletonList(group);
169        }
170        
171}