1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.codelibs.fess.app.web.admin.reqheader;
17
18 import java.util.ArrayList;
19 import java.util.HashMap;
20 import java.util.List;
21 import java.util.Map;
22
23 import javax.annotation.Resource;
24
25 import org.codelibs.fess.Constants;
26 import org.codelibs.fess.annotation.Secured;
27 import org.codelibs.fess.app.pager.ReqHeaderPager;
28 import org.codelibs.fess.app.service.RequestHeaderService;
29 import org.codelibs.fess.app.service.WebConfigService;
30 import org.codelibs.fess.app.web.CrudMode;
31 import org.codelibs.fess.app.web.base.FessAdminAction;
32 import org.codelibs.fess.es.config.exentity.RequestHeader;
33 import org.codelibs.fess.es.config.exentity.WebConfig;
34 import org.codelibs.fess.helper.SystemHelper;
35 import org.codelibs.fess.util.ComponentUtil;
36 import org.codelibs.fess.util.RenderDataUtil;
37 import org.dbflute.optional.OptionalEntity;
38 import org.dbflute.optional.OptionalThing;
39 import org.lastaflute.web.Execute;
40 import org.lastaflute.web.response.HtmlResponse;
41 import org.lastaflute.web.response.render.RenderData;
42 import org.lastaflute.web.ruts.process.ActionRuntime;
43
44
45
46
47
48
49 public class AdminReqheaderAction extends FessAdminAction {
50
51 public static final String ROLE = "admin-reqheader";
52
53
54
55
56 @Resource
57 private RequestHeaderService requestHeaderService;
58 @Resource
59 private ReqHeaderPager reqHeaderPager;
60 @Resource
61 protected WebConfigService webConfigService;
62
63
64
65
66 @Override
67 protected void setupHtmlData(final ActionRuntime runtime) {
68 super.setupHtmlData(runtime);
69 runtime.registerData("helpLink", systemHelper.getHelpLink(fessConfig.getOnlineHelpNameReqheader()));
70 }
71
72 @Override
73 protected String getActionRole() {
74 return ROLE;
75 }
76
77
78
79
80 @Execute
81 @Secured({ ROLE, ROLE + VIEW })
82 public HtmlResponse index(final SearchForm form) {
83 return asListHtml();
84 }
85
86 @Execute
87 @Secured({ ROLE, ROLE + VIEW })
88 public HtmlResponse list(final OptionalThing<Integer> pageNumber, final SearchForm form) {
89 pageNumber.ifPresent(num -> {
90 reqHeaderPager.setCurrentPageNumber(pageNumber.get());
91 }).orElse(() -> {
92 reqHeaderPager.setCurrentPageNumber(0);
93 });
94 return asHtml(path_AdminReqheader_AdminReqheaderJsp).renderWith(data -> {
95 searchPaging(data, form);
96 });
97 }
98
99 @Execute
100 @Secured({ ROLE, ROLE + VIEW })
101 public HtmlResponse search(final SearchForm form) {
102 copyBeanToBean(form, reqHeaderPager, op -> op.exclude(Constants.PAGER_CONVERSION_RULE));
103 return asHtml(path_AdminReqheader_AdminReqheaderJsp).renderWith(data -> {
104 searchPaging(data, form);
105 });
106 }
107
108 @Execute
109 @Secured({ ROLE, ROLE + VIEW })
110 public HtmlResponse reset(final SearchForm form) {
111 reqHeaderPager.clear();
112 return asHtml(path_AdminReqheader_AdminReqheaderJsp).renderWith(data -> {
113 searchPaging(data, form);
114 });
115 }
116
117 protected void searchPaging(final RenderData data, final SearchForm form) {
118 RenderDataUtil.register(data, "requestHeaderItems", requestHeaderService.getRequestHeaderList(reqHeaderPager));
119 RenderDataUtil.register(data, "displayCreateLink", !crawlingConfigHelper.getAllWebConfigList(false, false, false, null).isEmpty());
120
121
122 copyBeanToBean(reqHeaderPager, form, op -> op.include("id"));
123 }
124
125
126
127
128
129
130
131 @Execute
132 @Secured({ ROLE })
133 public HtmlResponse createnew() {
134 saveToken();
135 return asHtml(path_AdminReqheader_AdminReqheaderEditJsp).useForm(CreateForm.class, op -> {
136 op.setup(form -> {
137 form.initialize();
138 form.crudMode = CrudMode.CREATE;
139 });
140 }).renderWith(data -> {
141 registerWebConfigItems(data);
142 });
143 }
144
145 @Execute
146 @Secured({ ROLE })
147 public HtmlResponse edit(final EditForm form) {
148 validate(form, messages -> {}, this::asListHtml);
149 final String id = form.id;
150 requestHeaderService.getRequestHeader(id).ifPresent(entity -> {
151 copyBeanToBean(entity, form, op -> {});
152 }).orElse(() -> {
153 throwValidationError(messages -> messages.addErrorsCrudCouldNotFindCrudTable(GLOBAL, id), this::asListHtml);
154 });
155 saveToken();
156 if (form.crudMode.intValue() == CrudMode.EDIT) {
157
158 form.crudMode = CrudMode.DETAILS;
159 return asDetailsHtml();
160 }
161 form.crudMode = CrudMode.EDIT;
162 return asEditHtml();
163 }
164
165
166
167
168 @Execute
169 @Secured({ ROLE, ROLE + VIEW })
170 public HtmlResponse details(final int crudMode, final String id) {
171 verifyCrudMode(crudMode, CrudMode.DETAILS);
172 saveToken();
173 return asDetailsHtml().useForm(EditForm.class, op -> {
174 op.setup(form -> {
175 requestHeaderService.getRequestHeader(id).ifPresent(entity -> {
176 copyBeanToBean(entity, form, copyOp -> {
177 copyOp.excludeNull();
178 });
179 form.crudMode = crudMode;
180 }).orElse(() -> {
181 throwValidationError(messages -> messages.addErrorsCrudCouldNotFindCrudTable(GLOBAL, id), this::asListHtml);
182 });
183 });
184 });
185 }
186
187
188
189
190 @Execute
191 @Secured({ ROLE })
192 public HtmlResponse create(final CreateForm form) {
193 verifyCrudMode(form.crudMode, CrudMode.CREATE);
194 validate(form, messages -> {}, this::asEditHtml);
195 verifyToken(this::asEditHtml);
196 getRequestHeader(form).ifPresent(entity -> {
197 try {
198 requestHeaderService.store(entity);
199 saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
200 } catch (final Exception e) {
201 throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),
202 this::asEditHtml);
203 }
204 }).orElse(() -> {
205 throwValidationError(messages -> messages.addErrorsCrudFailedToCreateInstance(GLOBAL), this::asEditHtml);
206 });
207 return redirect(getClass());
208 }
209
210 @Execute
211 @Secured({ ROLE })
212 public HtmlResponse update(final EditForm form) {
213 verifyCrudMode(form.crudMode, CrudMode.EDIT);
214 validate(form, messages -> {}, this::asEditHtml);
215 verifyToken(this::asEditHtml);
216 getRequestHeader(form).ifPresent(entity -> {
217 try {
218 requestHeaderService.store(entity);
219 saveInfo(messages -> messages.addSuccessCrudUpdateCrudTable(GLOBAL));
220 } catch (final Exception e) {
221 throwValidationError(messages -> messages.addErrorsCrudFailedToUpdateCrudTable(GLOBAL, buildThrowableMessage(e)),
222 this::asEditHtml);
223 }
224 }).orElse(() -> {
225 throwValidationError(messages -> messages.addErrorsCrudCouldNotFindCrudTable(GLOBAL, form.id), this::asEditHtml);
226 });
227 return redirect(getClass());
228 }
229
230 @Execute
231 @Secured({ ROLE })
232 public HtmlResponse delete(final EditForm form) {
233 verifyCrudMode(form.crudMode, CrudMode.DETAILS);
234 validate(form, messages -> {}, this::asDetailsHtml);
235 verifyToken(this::asDetailsHtml);
236 final String id = form.id;
237 requestHeaderService.getRequestHeader(id).ifPresent(entity -> {
238 try {
239 requestHeaderService.delete(entity);
240 saveInfo(messages -> messages.addSuccessCrudDeleteCrudTable(GLOBAL));
241 } catch (final Exception e) {
242 throwValidationError(messages -> messages.addErrorsCrudFailedToDeleteCrudTable(GLOBAL, buildThrowableMessage(e)),
243 this::asEditHtml);
244 }
245 }).orElse(() -> {
246 throwValidationError(messages -> messages.addErrorsCrudCouldNotFindCrudTable(GLOBAL, id), this::asDetailsHtml);
247 });
248 return redirect(getClass());
249 }
250
251
252
253
254 public static OptionalEntity<RequestHeader> getEntity(final CreateForm form, final String username, final long currentTime) {
255 switch (form.crudMode) {
256 case CrudMode.CREATE:
257 return OptionalEntity.of(new RequestHeader()).map(entity -> {
258 entity.setCreatedBy(username);
259 entity.setCreatedTime(currentTime);
260 return entity;
261 });
262 case CrudMode.EDIT:
263 if (form instanceof EditForm) {
264 return ComponentUtil.getComponent(RequestHeaderService.class).getRequestHeader(((EditForm) form).id);
265 }
266 break;
267 default:
268 break;
269 }
270 return OptionalEntity.empty();
271 }
272
273 public static OptionalEntity<RequestHeader> getRequestHeader(final CreateForm form) {
274 final SystemHelper systemHelper = ComponentUtil.getSystemHelper();
275 final String username = systemHelper.getUsername();
276 final long currentTime = systemHelper.getCurrentTimeAsLong();
277 return getEntity(form, username, currentTime).map(entity -> {
278 entity.setUpdatedBy(username);
279 entity.setUpdatedTime(currentTime);
280 copyBeanToBean(form, entity, op -> op.exclude(Constants.COMMON_CONVERSION_RULE));
281 return entity;
282 });
283 }
284
285 protected void registerWebConfigItems(final RenderData data) {
286 final List<Map<String, String>> itemList = new ArrayList<>();
287 final List<WebConfig> webConfigList = crawlingConfigHelper.getAllWebConfigList(false, false, false, null);
288 for (final WebConfig webConfig : webConfigList) {
289 itemList.add(createItem(webConfig.getName(), webConfig.getId().toString()));
290 }
291 RenderDataUtil.register(data, "webConfigItems", itemList);
292 }
293
294 protected Map<String, String> createItem(final String label, final String value) {
295 final Map<String, String> map = new HashMap<>(2);
296 map.put(Constants.ITEM_LABEL, label);
297 map.put(Constants.ITEM_VALUE, value);
298 return map;
299 }
300
301
302
303
304 protected void verifyCrudMode(final int crudMode, final int expectedMode) {
305 if (crudMode != expectedMode) {
306 throwValidationError(messages -> {
307 messages.addErrorsCrudInvalidMode(GLOBAL, String.valueOf(expectedMode), String.valueOf(crudMode));
308 }, this::asListHtml);
309 }
310 }
311
312
313
314
315
316 private HtmlResponse asListHtml() {
317 return asHtml(path_AdminReqheader_AdminReqheaderJsp).renderWith(data -> {
318 RenderDataUtil.register(data, "requestHeaderItems", requestHeaderService.getRequestHeaderList(reqHeaderPager));
319 RenderDataUtil.register(data, "displayCreateLink",
320 !crawlingConfigHelper.getAllWebConfigList(false, false, false, null).isEmpty());
321 }).useForm(SearchForm.class, setup -> {
322 setup.setup(form -> {
323 copyBeanToBean(reqHeaderPager, form, op -> op.include("id"));
324 });
325 });
326 }
327
328 private HtmlResponse asEditHtml() {
329 return asHtml(path_AdminReqheader_AdminReqheaderEditJsp).renderWith(data -> {
330 registerWebConfigItems(data);
331 });
332 }
333
334 private HtmlResponse asDetailsHtml() {
335 return asHtml(path_AdminReqheader_AdminReqheaderDetailsJsp).renderWith(data -> {
336 registerWebConfigItems(data);
337 });
338 }
339 }