View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.apache.syncope.client.console.commons;
20  
21  import java.util.ArrayList;
22  import java.util.Collections;
23  import java.util.List;
24  import java.util.stream.Collectors;
25  import org.apache.syncope.client.console.SyncopeConsoleSession;
26  import org.apache.syncope.client.console.init.ClassPathScanImplementationLookup;
27  import org.apache.syncope.client.console.rest.ImplementationRestClient;
28  import org.apache.syncope.common.lib.policy.AccountRuleConf;
29  import org.apache.syncope.common.lib.policy.PasswordRuleConf;
30  import org.apache.syncope.common.lib.report.ReportConf;
31  import org.apache.syncope.common.lib.to.ImplementationTO;
32  import org.apache.syncope.common.lib.types.IdRepoImplementationType;
33  import org.apache.syncope.common.lib.types.ImplementationEngine;
34  import org.apache.wicket.model.IModel;
35  import org.apache.wicket.model.LoadableDetachableModel;
36  
37  public class IdRepoImplementationInfoProvider implements ImplementationInfoProvider {
38  
39      private static final long serialVersionUID = -6620368595630782392L;
40  
41      protected final ClassPathScanImplementationLookup lookup;
42  
43      protected final ImplementationRestClient implementationRestClient;
44  
45      public IdRepoImplementationInfoProvider(
46              final ClassPathScanImplementationLookup lookup,
47              final ImplementationRestClient implementationRestClient) {
48  
49          this.lookup = lookup;
50          this.implementationRestClient = implementationRestClient;
51      }
52  
53      @Override
54      public ViewMode getViewMode(final ImplementationTO implementation) {
55          return implementation.getEngine() == ImplementationEngine.GROOVY
56                  ? ViewMode.GROOVY_BODY
57                  : IdRepoImplementationType.REPORT_DELEGATE.equals(implementation.getType())
58                  || IdRepoImplementationType.ACCOUNT_RULE.equals(implementation.getType())
59                  || IdRepoImplementationType.PASSWORD_RULE.equals(implementation.getType())
60                  ? ViewMode.JSON_BODY
61                  : ViewMode.JAVA_CLASS;
62      }
63  
64      @Override
65      public List<String> getClasses(final ImplementationTO implementation, final ViewMode viewMode) {
66          List<String> classes = List.of();
67          if (viewMode == ViewMode.JAVA_CLASS) {
68              classes = SyncopeConsoleSession.get().getPlatformInfo().getJavaImplInfo(implementation.getType()).
69                      map(javaImplInfo -> new ArrayList<>(javaImplInfo.getClasses())).orElseGet(ArrayList::new);
70          } else if (viewMode == ViewMode.JSON_BODY) {
71              switch (implementation.getType()) {
72                  case IdRepoImplementationType.REPORT_DELEGATE:
73                      classes = lookup.getClasses(ReportConf.class).stream().
74                              map(Class::getName).collect(Collectors.toList());
75                      break;
76  
77                  case IdRepoImplementationType.ACCOUNT_RULE:
78                      classes = lookup.getClasses(AccountRuleConf.class).stream().
79                              map(Class::getName).collect(Collectors.toList());
80                      break;
81  
82                  case IdRepoImplementationType.PASSWORD_RULE:
83                      classes = lookup.getClasses(PasswordRuleConf.class).stream().
84                              map(Class::getName).collect(Collectors.toList());
85                      break;
86  
87                  default:
88              }
89          }
90          if (!classes.isEmpty()) {
91              Collections.sort(classes);
92          }
93  
94          return classes;
95      }
96  
97      @Override
98      public String getGroovyTemplateClassName(final String implementationType) {
99          String templateClassName = null;
100 
101         switch (implementationType) {
102             case IdRepoImplementationType.ACCOUNT_RULE:
103                 templateClassName = "MyAccountRule";
104                 break;
105 
106             case IdRepoImplementationType.PASSWORD_RULE:
107                 templateClassName = "MyPasswordRule";
108                 break;
109 
110             case IdRepoImplementationType.TASKJOB_DELEGATE:
111                 templateClassName = "MySchedTaskJobDelegate";
112                 break;
113 
114             case IdRepoImplementationType.REPORT_DELEGATE:
115                 templateClassName = "MyReportJobDelegate";
116                 break;
117 
118             case IdRepoImplementationType.LOGIC_ACTIONS:
119                 templateClassName = "MyLogicActions";
120                 break;
121 
122             case IdRepoImplementationType.VALIDATOR:
123                 templateClassName = "MyValidator";
124                 break;
125 
126             case IdRepoImplementationType.RECIPIENTS_PROVIDER:
127                 templateClassName = "MyRecipientsProvider";
128                 break;
129 
130             case IdRepoImplementationType.ITEM_TRANSFORMER:
131                 templateClassName = "MyItemTransformer";
132                 break;
133 
134             case IdRepoImplementationType.COMMAND:
135                 templateClassName = "MyCommand";
136                 break;
137 
138             default:
139         }
140 
141         return templateClassName;
142     }
143 
144     @Override
145     public Class<?> getClass(final String implementationType, final String name) {
146         Class<?> clazz = null;
147         switch (implementationType) {
148             case IdRepoImplementationType.REPORT_DELEGATE:
149                 clazz = lookup.getClasses(ReportConf.class).stream().
150                         filter(c -> c.getName().equals(name)).findFirst().orElse(null);
151                 break;
152 
153             case IdRepoImplementationType.ACCOUNT_RULE:
154                 clazz = lookup.getClasses(AccountRuleConf.class).stream().
155                         filter(c -> c.getName().equals(name)).findFirst().orElse(null);
156                 break;
157 
158             case IdRepoImplementationType.PASSWORD_RULE:
159                 clazz = lookup.getClasses(PasswordRuleConf.class).stream().
160                         filter(c -> c.getName().equals(name)).findFirst().orElse(null);
161                 break;
162 
163             default:
164         }
165 
166         return clazz;
167     }
168 
169     @Override
170     public IModel<List<String>> getTaskJobDelegates() {
171         return new LoadableDetachableModel<>() {
172 
173             private static final long serialVersionUID = 5275935387613157437L;
174 
175             @Override
176             protected List<String> load() {
177                 return implementationRestClient.list(IdRepoImplementationType.TASKJOB_DELEGATE).stream().
178                         map(ImplementationTO::getKey).sorted().collect(Collectors.toList());
179             }
180         };
181     }
182 
183     @Override
184     public IModel<List<String>> getReportJobDelegates() {
185         return new LoadableDetachableModel<>() {
186 
187             private static final long serialVersionUID = 5275935387613157437L;
188 
189             @Override
190             protected List<String> load() {
191                 return implementationRestClient.list(IdRepoImplementationType.REPORT_DELEGATE).stream().
192                         map(ImplementationTO::getKey).sorted().collect(Collectors.toList());
193             }
194         };
195     }
196 
197     @Override
198     public IModel<List<String>> getReconFilterBuilders() {
199         return new LoadableDetachableModel<>() {
200 
201             private static final long serialVersionUID = 5275935387613157437L;
202 
203             @Override
204             protected List<String> load() {
205                 return List.of();
206             }
207         };
208     }
209 
210     @Override
211     public IModel<List<String>> getPullActions() {
212         return new LoadableDetachableModel<>() {
213 
214             private static final long serialVersionUID = 5275935387613157437L;
215 
216             @Override
217             protected List<String> load() {
218                 return List.of();
219             }
220         };
221     }
222 
223     @Override
224     public IModel<List<String>> getPushActions() {
225         return new LoadableDetachableModel<>() {
226 
227             private static final long serialVersionUID = 5275935387613157437L;
228 
229             @Override
230             protected List<String> load() {
231                 return List.of();
232             }
233         };
234     }
235 }