1 package fr.ifremer.quadrige3.core.config;
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 import com.google.common.base.Charsets;
30 import com.google.common.base.Joiner;
31 import com.google.common.base.Splitter;
32 import com.google.common.collect.ImmutableSet;
33 import com.google.common.collect.Sets;
34 import fr.ifremer.quadrige3.core.dao.technical.Daos;
35 import fr.ifremer.quadrige3.core.dao.technical.hibernate.DateType;
36 import fr.ifremer.quadrige3.core.dao.technical.spring.Springs;
37 import fr.ifremer.quadrige3.core.exception.QuadrigeTechnicalException;
38 import org.apache.commons.lang3.ArrayUtils;
39 import org.apache.commons.lang3.StringUtils;
40 import org.apache.commons.logging.Log;
41 import org.apache.commons.logging.LogFactory;
42 import org.nuiton.config.ApplicationConfig;
43 import org.nuiton.config.ApplicationConfigHelper;
44 import org.nuiton.config.ApplicationConfigProvider;
45 import org.nuiton.config.ArgumentsParserException;
46 import org.nuiton.version.Version;
47 import org.springframework.beans.BeansException;
48 import org.springframework.beans.factory.BeanInitializationException;
49 import org.springframework.beans.factory.InitializingBean;
50 import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;
51 import org.springframework.context.ApplicationContext;
52 import org.springframework.context.ApplicationContextAware;
53 import org.springframework.core.io.Resource;
54 import org.springframework.util.CollectionUtils;
55
56 import java.io.File;
57 import java.io.IOException;
58 import java.io.InputStream;
59 import java.net.MalformedURLException;
60 import java.net.URL;
61 import java.util.*;
62
63 import static org.nuiton.i18n.I18n.t;
64
65
66
67
68
69
70 public class QuadrigeConfiguration extends PropertyPlaceholderConfigurer implements ApplicationContextAware, InitializingBean {
71
72 private static final Log log = LogFactory.getLog(QuadrigeConfiguration.class);
73
74 private static final String DEFAULT_SHARED_CONFIG_FILE = "quadrige3-core-shared.config";
75
76
77
78
79 protected final ApplicationConfig applicationConfig;
80
81 private ApplicationContext appContext = null;
82
83 private boolean isInitialize = false;
84
85 private static QuadrigeConfiguration instance;
86
87
88
89
90
91
92 public static QuadrigeConfiguration getInstance() {
93 return instance;
94 }
95
96
97
98
99
100
101 public static void setInstance(QuadrigeConfiguration instance) {
102 QuadrigeConfiguration.instance = instance;
103 }
104
105 private File configFile;
106
107
108
109
110
111
112 public QuadrigeConfiguration(ApplicationConfig applicationConfig) {
113 super();
114 this.applicationConfig = applicationConfig;
115 }
116
117
118
119
120
121
122
123 public QuadrigeConfiguration(String file, String... args) {
124 super();
125 this.applicationConfig = new ApplicationConfig();
126 this.applicationConfig.setEncoding(Charsets.UTF_8.name());
127 this.applicationConfig.setConfigFileName(file);
128
129
130 Set<ApplicationConfigProvider> providers =
131 ApplicationConfigHelper.getProviders(null,
132 null,
133 null,
134 true);
135
136
137 ApplicationConfigHelper.loadAllDefaultOption(applicationConfig,
138 providers);
139
140
141 for (ApplicationConfigProvider provider : providers) {
142 applicationConfig.loadActions(provider.getActions());
143 }
144
145
146 addAlias(applicationConfig);
147
148
149 overrideExternalModulesDefaultOptions(applicationConfig);
150
151 try {
152 applicationConfig.parse(args);
153
154 } catch (ArgumentsParserException e) {
155 throw new QuadrigeTechnicalException(t("quadrige3.config.parse.error"), e);
156 }
157
158
159 File appBasedir = applicationConfig.getOptionAsFile(
160 QuadrigeConfigurationOption.BASEDIR.getKey());
161
162 if (appBasedir == null) {
163 appBasedir = new File("");
164 }
165 if (!appBasedir.isAbsolute()) {
166 appBasedir = new File(appBasedir.getAbsolutePath());
167 }
168 if (appBasedir.getName().equals("..")) {
169 appBasedir = appBasedir.getParentFile().getParentFile();
170 }
171 if (appBasedir.getName().equals(".")) {
172 appBasedir = appBasedir.getParentFile();
173 }
174 if (log.isInfoEnabled()) {
175 log.info("Application basedir: " + appBasedir);
176 }
177 applicationConfig.setOption(
178 QuadrigeConfigurationOption.BASEDIR.getKey(),
179 appBasedir.getAbsolutePath());
180 }
181
182
183
184
185
186
187
188 protected void addAlias(ApplicationConfig applicationConfig) {
189 applicationConfig.addAlias("-u", "--option", QuadrigeConfigurationOption.JDBC_USERNAME.getKey());
190 applicationConfig.addAlias("--user", "--option", QuadrigeConfigurationOption.JDBC_USERNAME.getKey());
191 applicationConfig.addAlias("-p", "--option", QuadrigeConfigurationOption.JDBC_PASSWORD.getKey());
192 applicationConfig.addAlias("--password", "--option", QuadrigeConfigurationOption.JDBC_PASSWORD.getKey());
193 applicationConfig.addAlias("-db", "--option", QuadrigeConfigurationOption.JDBC_URL.getKey());
194 applicationConfig.addAlias("--database", "--option", QuadrigeConfigurationOption.JDBC_URL.getKey());
195
196 applicationConfig.addAlias("--output", "--option", QuadrigeConfigurationOption.LIQUIBASE_OUTPUT_FILE.getKey());
197 applicationConfig.addAlias("-f", "--option", QuadrigeConfigurationOption.LIQUIBASE_FORCE_OUTPUT_FILE.getKey(), "true");
198
199 applicationConfig.addAlias("--port", "--option", QuadrigeConfigurationOption.SERVER_PORT.getKey());
200 }
201
202
203
204
205
206
207
208 protected void overrideExternalModulesDefaultOptions(ApplicationConfig applicationConfig) {
209
210 QuadrigeConfigurations.remapOptionsToPrefix(applicationConfig,
211 "synchro.persistence",
212 QuadrigeConfigurationOption.values(),
213 "quadrige3.persistence");
214
215
216 QuadrigeConfigurations.remapOptionsToPrefix(applicationConfig,
217 "synchro",
218 QuadrigeConfigurationOption.values(),
219 "quadrige3.synchro");
220
221 applicationConfig.setDefaultOption("synchro.tempQueryParameter.userId.column", "QUSER_ID");
222 }
223
224
225 @Override
226 public void setApplicationContext(ApplicationContext appContext) throws BeansException {
227 this.appContext = appContext;
228 }
229
230
231 @Override
232 public void afterPropertiesSet() throws Exception {
233
234 if (isInitialize) {
235 return;
236 }
237 isInitialize = true;
238
239
240 String[] enumerationFilePaths = getEnumerationFilesPath();
241 if (ArrayUtils.isEmpty(enumerationFilePaths)) {
242 throw new BeanInitializationException(
243 String.format(
244 "No enumeration files path has been set in the configuration. This is required to initialize enumeration values. Please set the option [%s] in configuration file.",
245 QuadrigeConfigurationOption.DB_ENUMERATION_RESOURCE));
246 }
247 if (log.isDebugEnabled()) {
248 log.debug(String.format("Getting enumeration files from path: %s", Arrays.toString(enumerationFilePaths)));
249 }
250
251
252 List<Resource> resources = Springs.getResourcesFromPaths(enumerationFilePaths, appContext, true);
253
254
255 if (CollectionUtils.isEmpty(resources)) {
256 throw new BeanInitializationException(String.format("No enumeration files could be found from path %s",
257 Arrays.toString(enumerationFilePaths)));
258 }
259 if (log.isDebugEnabled()) {
260 log.debug(String.format("%s enumeration files found from path: %s", resources.size(), Arrays.toString(enumerationFilePaths)));
261 }
262
263
264 QuadrigeEnumerationHelper.reload(applicationConfig, resources);
265
266
267 initVersion(applicationConfig);
268
269
270 initTimeZone();
271 }
272
273
274
275
276 protected void initTimeZone() {
277
278 String dbTimeZone = applicationConfig.getOption(QuadrigeConfigurationOption.DB_TIMEZONE.getKey());
279 if (StringUtils.isNotBlank(dbTimeZone)) {
280 if (log.isInfoEnabled()) {
281 log.info(String.format("Using timezone [%s] for database", dbTimeZone));
282 }
283 DateType.setTimeZone(TimeZone.getTimeZone(dbTimeZone));
284 } else if (log.isInfoEnabled()) {
285 log.info(String.format("Using default timezone [%s] for database", System.getProperty("user.timezone")));
286 }
287 }
288
289
290
291
292
293
294
295
296 protected void initVersion(ApplicationConfig applicationConfig) {
297
298 try {
299
300 Properties sharedConfigFile = new Properties();
301 InputStream fis = getClass().getClassLoader().getResourceAsStream(DEFAULT_SHARED_CONFIG_FILE);
302 sharedConfigFile.load(fis);
303 fis.close();
304
305
306 String defaultVersion = applicationConfig.getOption(QuadrigeConfigurationOption.VERSION.getKey());
307 String implementationVersion = sharedConfigFile.getProperty(QuadrigeConfigurationOption.VERSION.getKey());
308 if (StringUtils.isNotBlank(implementationVersion)
309 && StringUtils.isNotBlank(defaultVersion)
310 && !Objects.equals(implementationVersion, defaultVersion)) {
311 if (log.isDebugEnabled()) {
312 log.debug(String.format("Replace default version option value [%s] with implementation value [%s] found in file [%s]",
313 defaultVersion,
314 implementationVersion,
315 DEFAULT_SHARED_CONFIG_FILE));
316 }
317 applicationConfig.setDefaultOption(
318 QuadrigeConfigurationOption.VERSION.getKey(),
319 implementationVersion);
320 }
321 else if (StringUtils.isNotBlank(implementationVersion)) {
322 if (log.isInfoEnabled()) {
323 log.info("Version: " + implementationVersion);
324 }
325 applicationConfig.setDefaultOption(
326 QuadrigeConfigurationOption.VERSION.getKey(),
327 implementationVersion);
328 }
329 else if (StringUtils.isNotBlank(defaultVersion)) {
330 if (log.isInfoEnabled()) {
331 log.info("Version: " + defaultVersion);
332 }
333 }
334 else if (log.isErrorEnabled()) {
335 log.error(String.format("Could init version, from classpath file [%s]", DEFAULT_SHARED_CONFIG_FILE));
336 }
337 } catch (IOException e) {
338 log.warn(String.format("Could not load implementation version from file [%s]", DEFAULT_SHARED_CONFIG_FILE));
339 }
340
341 }
342
343
344
345
346
347
348 public File getConfigFile() {
349 if (configFile == null) {
350 File dir = getBasedir();
351 if (dir == null || !dir.exists()) {
352 dir = new File(applicationConfig.getUserConfigDirectory());
353 }
354 configFile = new File(dir, applicationConfig.getConfigFileName());
355 }
356 return configFile;
357 }
358
359
360
361
362
363
364 public File getBasedir() {
365 return applicationConfig.getOptionAsFile(QuadrigeConfigurationOption.BASEDIR.getKey());
366 }
367
368
369
370
371
372
373 public File getDataDirectory() {
374 return applicationConfig.getOptionAsFile(QuadrigeConfigurationOption.DATA_DIRECTORY.getKey());
375 }
376
377
378
379
380
381
382 public ApplicationConfig getApplicationConfig() {
383 return applicationConfig;
384 }
385
386
387 @Override
388 protected String resolvePlaceholder(String placeholder, Properties props) {
389 if (applicationConfig == null) {
390 throw new QuadrigeTechnicalException(
391 "Configuration.applicationConfig must not be null. Please initialize Configuration instance with a not null applicationConfig BEFORE starting Spring.");
392 }
393
394
395 String optionValue = applicationConfig.getOption(placeholder);
396 if (optionValue != null) {
397 return optionValue;
398 }
399
400
401 return super.resolvePlaceholder(placeholder, props);
402 }
403
404
405
406
407
408
409 public File getTempDirectory() {
410 return applicationConfig.getOptionAsFile(QuadrigeConfigurationOption.TMP_DIRECTORY.getKey());
411 }
412
413
414
415
416
417
418 public File getDbDirectory() {
419 return applicationConfig.getOptionAsFile(QuadrigeConfigurationOption.DB_DIRECTORY.getKey());
420 }
421
422
423
424
425
426
427 public void setDbDirectory(File dbDirectory) {
428 applicationConfig.setOption(QuadrigeConfigurationOption.DB_DIRECTORY.getKey(), dbDirectory.getPath());
429 }
430
431
432
433
434
435
436 public void setJdbcUrl(String jdbcUrl) {
437 applicationConfig.setOption(QuadrigeConfigurationOption.JDBC_URL.getKey(), jdbcUrl);
438 }
439
440
441
442
443
444
445 public TimeZone getDbTimezone() {
446 String tz = applicationConfig.getOption(QuadrigeConfigurationOption.DB_TIMEZONE.getKey());
447 return StringUtils.isNotBlank(tz) ? TimeZone.getTimeZone(tz) : TimeZone.getDefault();
448 }
449
450
451
452
453
454
455 public File getDbAttachmentDirectory() {
456 return applicationConfig.getOptionAsFile(QuadrigeConfigurationOption.DB_ATTACHMENT_DIRECTORY.getKey());
457 }
458
459 public File getDbPhotoDirectory() {
460 return applicationConfig.getOptionAsFile(QuadrigeConfigurationOption.DB_PHOTO_DIRECTORY.getKey());
461 }
462
463
464
465
466
467
468 public File getCacheDirectory() {
469 return applicationConfig.getOptionAsFile(QuadrigeConfigurationOption.DB_CACHE_DIRECTORY.getKey());
470 }
471
472
473
474
475
476
477 public File getDbBackupDirectory() {
478 return applicationConfig.getOptionAsFile(QuadrigeConfigurationOption.DB_BACKUP_DIRECTORY.getKey());
479 }
480
481
482
483
484
485
486 public String getAdminEmail() {
487 return applicationConfig.getOption(QuadrigeConfigurationOption.ADMIN_EMAIL.getKey());
488 }
489
490
491
492
493
494
495
496 public File getSynchroExportDirectoryByUser(int userId) {
497 return new File(
498 getSynchronizationDirectory(),
499 new StringBuilder()
500 .append(userId)
501 .append(File.separator)
502 .append("export")
503 .toString());
504 }
505
506
507
508
509
510
511
512 public File getSynchroImportDirectoryByUser(int userId) {
513 return new File(
514 getSynchronizationDirectory(),
515 new StringBuilder()
516 .append(userId)
517 .append(File.separator)
518 .append("import")
519 .toString());
520 }
521
522
523
524
525
526
527 public boolean useLiquibaseAutoRun() {
528 return applicationConfig.getOptionAsBoolean(QuadrigeConfigurationOption.LIQUIBASE_RUN_AUTO.getKey());
529 }
530
531
532
533
534
535
536 public String getLiquibaseChangeLogPath() {
537 return applicationConfig.getOption(QuadrigeConfigurationOption.LIQUIBASE_CHANGE_LOG_PATH.getKey());
538 }
539
540
541
542
543
544
545 public String getDbCreateScriptPath() {
546 return applicationConfig.getOption(QuadrigeConfigurationOption.DB_CREATE_SCRIPT_PATH.getKey());
547 }
548
549 public String getPostgisSchema() {
550 return applicationConfig.getOption(QuadrigeConfigurationOption.POSTGIS_SCHEMA.getKey());
551 }
552
553
554
555
556
557
558 public String getHibernateDialect() {
559 return applicationConfig.getOption(QuadrigeConfigurationOption.HIBERNATE_DIALECT.getKey());
560 }
561
562
563
564
565
566
567 public String getHibernateClientQueriesFile() {
568 return applicationConfig.getOption(QuadrigeConfigurationOption.HIBERNATE_CLIENT_QUERIES_FILE.getKey());
569 }
570
571
572
573
574
575
576 public String getJdbcDriver() {
577 return applicationConfig.getOption(QuadrigeConfigurationOption.JDBC_DRIVER.getKey());
578 }
579
580
581
582
583
584
585 public String getJdbcURL() {
586 return applicationConfig.getOption(QuadrigeConfigurationOption.JDBC_URL.getKey());
587 }
588
589
590
591
592
593
594 public String getJdbcCatalog() {
595 return applicationConfig.getOption(QuadrigeConfigurationOption.JDBC_CATALOG.getKey());
596 }
597
598
599
600
601
602
603 public String getJdbcSchema() {
604 return applicationConfig.getOption(QuadrigeConfigurationOption.JDBC_SCHEMA.getKey());
605 }
606
607
608
609
610
611
612 public boolean debugEntityLoad() {
613 return applicationConfig.getOptionAsBoolean(QuadrigeConfigurationOption.DEBUG_ENTITY_LOAD.getKey());
614 }
615
616
617
618
619
620
621 public String getDbName() {
622 return applicationConfig.getOption(QuadrigeConfigurationOption.DB_NAME.getKey());
623 }
624
625
626
627
628
629
630 public String getDbValidationQuery() {
631 return applicationConfig.getOption(QuadrigeConfigurationOption.DB_VALIDATION_QUERY.getKey());
632 }
633
634
635
636
637
638
639 public String getJdbcUsername() {
640 return applicationConfig.getOption(QuadrigeConfigurationOption.JDBC_USERNAME.getKey());
641 }
642
643
644
645
646
647
648 public String getJdbcPassword() {
649 return applicationConfig.getOption(QuadrigeConfigurationOption.JDBC_PASSWORD.getKey());
650 }
651
652
653
654
655
656
657 public int getJdbcBatchSize() {
658 return applicationConfig.getOptionAsInt(QuadrigeConfigurationOption.JDBC_BATCH_SIZE.getKey());
659 }
660
661
662
663
664
665
666 public String getStatusCodeTemporary() {
667 return applicationConfig.getOption(QuadrigeConfigurationOption.STATUS_CODE_TEMPORARY.getKey());
668 }
669
670
671
672
673
674
675 public String getStatusCodeValid() {
676 return applicationConfig.getOption(QuadrigeConfigurationOption.STATUS_CODE_ENABLE.getKey());
677 }
678
679
680
681
682
683
684 public Version getVersion() {
685 return applicationConfig.getOptionAsVersion(QuadrigeConfigurationOption.VERSION.getKey());
686 }
687
688
689
690
691
692
693 public File getI18nDirectory() {
694 return applicationConfig.getOptionAsFile(
695 QuadrigeConfigurationOption.I18N_DIRECTORY.getKey());
696 }
697
698
699
700
701
702
703 public Locale getI18nLocale() {
704 return applicationConfig.getOptionAsLocale(
705 QuadrigeConfigurationOption.I18N_LOCALE.getKey());
706 }
707
708
709
710
711
712
713 public void setI18nLocale(Locale locale) {
714 applicationConfig.setOption(QuadrigeConfigurationOption.I18N_LOCALE.getKey(), locale.toString());
715 }
716
717
718
719
720
721
722
723 public Set<String> getImportDataTablesIncludes() {
724 String dataTablesStr = applicationConfig.getOption(QuadrigeConfigurationOption.IMPORT_TABLES_DATA_INCLUDES.getKey());
725 Set<String> result = null;
726 if (StringUtils.isNotBlank(dataTablesStr)) {
727 result = ImmutableSet.<String> builder()
728 .add(dataTablesStr.toUpperCase().split("\\s*,\\s*"))
729 .build();
730 }
731 return result;
732 }
733
734
735
736
737
738
739 public Set<String> getImportReferentialTablesIncludes() {
740 String referentialTablesStr = applicationConfig.getOption(QuadrigeConfigurationOption.IMPORT_TABLES_REFERENTIAL_INCLUDES.getKey());
741 Set<String> result = null;
742 if (StringUtils.isNotBlank(referentialTablesStr)) {
743 result = ImmutableSet.<String> builder().add(referentialTablesStr.split("\\s*,\\s*")).build();
744 }
745 return result;
746 }
747
748
749
750
751
752
753 public boolean isEnableImportTablesRules() {
754 return applicationConfig.getOptionAsBoolean(QuadrigeConfigurationOption.IMPORT_TABLES_RULES_ENABLE.getKey());
755 }
756
757
758
759
760
761
762 public String getImportDataPkIncludes() {
763 return applicationConfig.getOption(QuadrigeConfigurationOption.IMPORT_DATA_PK_INCLUDES.getKey());
764 }
765
766
767
768
769
770
771 public int getImportNbYearDataHistory() {
772 return applicationConfig.getOptionAsInt(QuadrigeConfigurationOption.IMPORT_NB_YEARS_DATA_HISTORY.getKey());
773 }
774
775
776
777
778
779
780 public int getExportDataUpdateDateDelayInSecond() {
781 return applicationConfig.getOptionAsInt(QuadrigeConfigurationOption.EXPORT_DATA_UPDATE_DATE_DELAY.getKey());
782 }
783
784
785
786
787
788
789 public int getExportDataUpdateDateShortDelayInSecond() {
790 return applicationConfig.getOptionAsInt(QuadrigeConfigurationOption.EXPORT_DATA_UPDATE_DATE_SHORT_DELAY.getKey());
791 }
792
793 public long getExportDataFileMaxUploadSize() {
794 return applicationConfig.getOptionAsLong(QuadrigeConfigurationOption.EXPORT_DATA_FILE_MAX_UPLOAD_SIZE.getKey());
795 }
796
797
798
799
800
801
802 public int getImportReferentialUpdateDateOffsetInSecond() {
803 return applicationConfig.getOptionAsInt(QuadrigeConfigurationOption.IMPORT_REFERENTIAL_UPDATE_DATE_OFFSET.getKey());
804 }
805
806
807
808
809
810
811 public String getImportReferentialStatusIncludes() {
812 return applicationConfig.getOption(QuadrigeConfigurationOption.IMPORT_REFERENTIAL_STATUS_INCLUDES.getKey());
813 }
814
815
816
817
818
819
820 public String getImportTranscribingItemTypeLbIncludes() {
821 return applicationConfig.getOption(QuadrigeConfigurationOption.IMPORT_TRANSCRIBING_ITEM_TYPE_LB_INCLUDES.getKey());
822 }
823
824
825
826
827
828
829 public Set<String> getSynchroProgramCodeIncludes() {
830 String programCodesStr = applicationConfig.getOption(QuadrigeConfigurationOption.SYNCHRO_PROGRAM_CODES_INCLUDES.getKey());
831 if (StringUtils.isBlank(programCodesStr)) {
832 return new HashSet<>();
833 }
834
835 return Sets.newLinkedHashSet(
836 Splitter.on(',').trimResults().omitEmptyStrings().split(programCodesStr)
837 );
838 }
839
840 public void setSynchroProgramCodeIncludes(Set<String> programCodes) {
841 String option = CollectionUtils.isEmpty(programCodes) ? null : Joiner.on(',').join(programCodes);
842 applicationConfig.setOption(QuadrigeConfigurationOption.SYNCHRO_PROGRAM_CODES_INCLUDES.getKey(), option);
843 }
844
845
846
847
848
849
850 public Properties getConnectionProperties() {
851 return Daos.getConnectionProperties(
852 getJdbcURL(),
853 getJdbcUsername(),
854 getJdbcPassword(),
855 null,
856 getHibernateDialect(),
857 getJdbcDriver());
858 }
859
860
861
862
863
864
865 public String getLiquibaseDiffTypes() {
866 return applicationConfig.getOption(QuadrigeConfigurationOption.LIQUIBASE_DIFF_TYPES.getKey());
867 }
868
869
870
871
872
873
874 public File getLiquibaseOutputFile() {
875 return applicationConfig.getOptionAsFile(QuadrigeConfigurationOption.LIQUIBASE_OUTPUT_FILE.getKey());
876 }
877
878
879
880
881
882
883 public boolean isForceLiquibaseOutputFile() {
884 return applicationConfig.getOptionAsBoolean(QuadrigeConfigurationOption.LIQUIBASE_FORCE_OUTPUT_FILE.getKey());
885 }
886
887
888
889
890
891
892 public Integer getServerPort() {
893 return applicationConfig.getOptionAsInt(QuadrigeConfigurationOption.SERVER_PORT.getKey());
894 }
895
896
897
898
899
900
901 public String[] getEnumerationFilesPath() {
902 String enumerationFilesPath = applicationConfig.getOption(QuadrigeConfigurationOption.DB_ENUMERATION_RESOURCE.getKey());
903 return enumerationFilesPath.split(",");
904 }
905
906
907
908
909
910
911
912
913
914
915 public URL getSynchronizationSiteUrl() {
916 return getOptionAsURL(QuadrigeConfigurationOption.SYNCHRONIZATION_SITE_URL.getKey());
917 }
918
919
920
921
922
923
924 public Integer getSynchronizationSiteTimeout() {
925 return applicationConfig.getOptionAsInt(QuadrigeConfigurationOption.SYNCHRONIZATION_SITE_TIMEOUT.getKey());
926 }
927
928
929
930
931
932
933 public Integer getSynchronizationRefreshTimeout() {
934 return applicationConfig.getOptionAsInt(QuadrigeConfigurationOption.SYNCHRONIZATION_REFRESH_TIMEOUT.getKey());
935 }
936
937
938
939
940
941
942 public Integer getSynchronizationMaxRetryCount() {
943 return applicationConfig.getOptionAsInt(QuadrigeConfigurationOption.SYNCHRONIZATION_RETRY_COUNT.getKey());
944 }
945
946
947
948
949
950
951 public Integer getSynchronizationRetryTimeout() {
952 return applicationConfig.getOptionAsInt(QuadrigeConfigurationOption.SYNCHRONIZATION_RETRY_TIMEOUT.getKey());
953 }
954
955
956
957
958
959
960 public File getSynchronizationDirectory() {
961 return applicationConfig.getOptionAsFile(QuadrigeConfigurationOption.SYNCHRONIZATION_DIRECTORY.getKey());
962 }
963
964
965
966
967
968 public File getSynchroDirectory() {
969 return applicationConfig.getOptionAsFile(QuadrigeConfigurationOption.SYNCHRONIZATION_DIRECTORY.getKey());
970 }
971
972
973
974
975
976
977 public boolean isSynchronizationUsingServer() {
978 return applicationConfig.getOptionAsBoolean(QuadrigeConfigurationOption.SYNCHRONIZATION_USE_SERVER.getKey());
979 }
980
981
982
983
984
985
986 public String getSynchroZipFilePrefix() {
987 return applicationConfig.getOption(QuadrigeConfigurationOption.SYNCHRONIZATION_ZIP_FILE_PREFIX.getKey());
988 }
989
990
991
992
993
994
995
996 public File getExtractionDirectory(String type) {
997 switch (type.toUpperCase()) {
998 case "SINP" :
999 return applicationConfig.getOptionAsFile(QuadrigeConfigurationOption.EXTRACTION_SINP_DIRECTORY.getKey());
1000 case "PAMPA":
1001 return applicationConfig.getOptionAsFile(QuadrigeConfigurationOption.EXTRACTION_PAMPA_DIRECTORY.getKey());
1002 }
1003 return null;
1004 }
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023 public int getImportDataMaxRootRowCount() {
1024 return applicationConfig.getOptionAsInt(QuadrigeConfigurationOption.IMPORT_DATA_MAX_ROOT_ROW_COUNT.getKey());
1025 }
1026
1027 public String getMailSmtpHost() {
1028 return applicationConfig.getOption(QuadrigeConfigurationOption.MAIL_SMTP_HOST.getKey());
1029 }
1030
1031 public int getMailSmtpPort() {
1032 return applicationConfig.getOptionAsInt(QuadrigeConfigurationOption.MAIL_SMTP_PORT.getKey());
1033 }
1034
1035 public String getMailSmtpUsername() {
1036 return applicationConfig.getOption(QuadrigeConfigurationOption.MAIL_SMTP_USERNAME.getKey());
1037 }
1038
1039 public String getMailSmtpPassword() {
1040 return applicationConfig.getOption(QuadrigeConfigurationOption.MAIL_SMTP_PASSWORD.getKey());
1041 }
1042
1043 public String getMailSmtpSender() {
1044 return applicationConfig.getOption(QuadrigeConfigurationOption.MAIL_SMTP_SENDER.getKey());
1045 }
1046
1047 public boolean getMailSmtpStartTLS() {
1048 return applicationConfig.getOptionAsBoolean(QuadrigeConfigurationOption.MAIL_SMTP_STARTTLS.getKey());
1049 }
1050
1051 public boolean getMailSmtpUseSSL() {
1052 return applicationConfig.getOptionAsBoolean(QuadrigeConfigurationOption.MAIL_SMTP_SSL.getKey());
1053 }
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064 protected URL getOptionAsURL(String key) {
1065 String urlString = applicationConfig.getOption(key);
1066
1067
1068 if (StringUtils.isBlank(urlString)) {
1069 return null;
1070 }
1071
1072
1073 if (!urlString.endsWith("/")) {
1074 int schemeIndex = urlString.indexOf("://");
1075 int firstSlashIndex = urlString.indexOf('/', schemeIndex + 3);
1076 boolean addSlash = false;
1077 if (firstSlashIndex == -1) {
1078 addSlash = true;
1079 }
1080 else {
1081 int lastSlashIndex = urlString.lastIndexOf('/');
1082 if (lastSlashIndex > firstSlashIndex) {
1083 addSlash = urlString.indexOf('.', lastSlashIndex) == -1;
1084 }
1085 }
1086
1087 if (addSlash) {
1088 urlString += '/';
1089 }
1090 }
1091
1092 URL url = null;
1093 try {
1094 url = new URL(urlString);
1095 } catch (MalformedURLException ex) {
1096 log.error(ex.getLocalizedMessage(), ex);
1097 }
1098
1099 return url;
1100 }
1101 }