GitLab

at 2019-07-03T12:56:02Z

update pom

On ne peut pas sauvegarder une configuration d'un serveur distant en mode admin - Closes #1340

L'assistant migration via serveur pourrait refuser de continuer si l'utilisateur n'est pas assez acrédité - Closes #1145

Assistant création de base PG échoue - Closes #1331

 observe.storage.error.rest.user.unknown

 observe.storage.error.serverVersionMismatch

 observe.storage.error.serverVersionModelMismatch

+observe.storage.error.user.not.owner

 observe.storage.internalDump.last.modified

 observe.storage.internalDump.not.exist

 observe.storage.label.data.import.db

 import fr.ird.observe.client.ui.actions.main.menu.storage.ChangeStorageAction;

 import fr.ird.observe.client.ui.storage.StorageUIModel;

 import fr.ird.observe.client.ui.util.ProgressModel;

-import org.nuiton.topia.persistence.script.TopiaSqlScript;

 import fr.ird.observe.services.ObserveDataSourceConfigurationMainFactory;

 import fr.ird.observe.services.configuration.DataSourceCreateConfigurationDto;

 import fr.ird.observe.services.configuration.ObserveDataSourceConfiguration;

 import fr.ird.observe.services.service.BabModelVersionException;

 import fr.ird.observe.services.service.DatabaseConnexionNotAuthorizedException;

 import fr.ird.observe.services.service.DatabaseNotFoundException;

+import org.nuiton.topia.persistence.script.TopiaSqlScript;

 import javax.swing.JLabel;

 import javax.swing.JOptionPane;

                 dataSource = newDataSource(configuration);

                 break;

         }

-

+        if (model.getDataSourceInformation() != null) {

+            dataSource.setOwner(model.getDataSourceInformation().isOwner());

+        }

         return dataSource;

     }

             try {

-                ObserveDataSourceInformation dataSourceInformation = dataSource.checkCanConnect();

-

+                ObserveDataSourceInformation dataSourceInformation = dataSource.checkCanConnect(false);

+                dataSource.setOwner(dataSourceInformation.isOwner());

                 dataSource.migrateDataIfPossible(dataSourceInformation, config.getModelVersion());

                 // la source sera utilisée dans les ui

             try {

-                ObserveDataSourceInformation dataSourceInformation = dataSource.checkCanConnect();

+                ObserveDataSourceInformation dataSourceInformation = dataSource.checkCanConnect(false);

+                dataSource.setOwner(dataSourceInformation.isOwner());

                 dataSource.migrateData(dataSourceInformation, config.getModelVersion());

         }

     }

+    @SuppressWarnings({"unused", "WeakerAccess"})

     public static class InitStorageModel {

         private final File localDb;

         private final BackupStorage lastAutomaticBackup;

             return lastAutomaticBackup != null;

         }

-        String getBackupDate() {

+        public String getBackupDate() {

             return Optional.ofNullable(lastAutomaticBackup).map(l -> simpleDateFormat.format(l.getDate())).orElse("");

         }

     }

  * it under the terms of the GNU General Public License as

  * published by the Free Software Foundation, either version 3 of the

  * License, or (at your option) any later version.

- * 

+ *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

- * 

+ *

  * You should have received a copy of the GNU General Public

  * License along with this program.  If not, see

  * <http://www.gnu.org/licenses/gpl-3.0.html>.

  */

 public class ObserveSwingDataSource extends AbstractSerializableBean implements Closeable, ObserveServicesProvider {

+    public static final ObserveServicesProvider MAIN = new ObserveMainDataSourceServicesProvider();

     private static final long serialVersionUID = 1L;

-

     private static final Logger log = LogManager.getLogger(ObserveSwingDataSource.class);

-

-    public static final ObserveServicesProvider MAIN = new ObserveMainDataSourceServicesProvider();

-

     private final EventListenerList listenerList;

     private final ObserveDataSourceConfiguration configuration;

     // indique si une modification a été effectuéé sur la base depuis son ouverture

     private boolean modified;

+    private boolean owner;

     public ObserveSwingDataSource(ObserveDataSourceConfiguration configuration) {

         this.configuration = configuration;

                 canWriteReferential(),

                 canReadData(),

                 canWriteData(),

+                isOwner(),

                 getVersion(),

                 getVersion(),

                 ImmutableList.of());

     @Override

     public void close() {

-        if (connection==null) {

+        if (connection == null) {

             return;

         }

         checkIsOpen();

     }

+    public boolean isOwner() {

+        return owner;

+    }

+

     void migrateDataIfPossible(ObserveDataSourceInformation dataSourceInformation, Version targetVersion) {

         checkIsNotOpen();

     }

     public <D extends IdDto> ImmutableDtoMap<ReferentialDtoReferenceSet<?>> updateReferentialReferenceSetsCache(Class<D> dtoType) {

-

         ReferentialService referentialService = servicesProvider.getReferentialService();

         return referentialCache.loadReferenceSets(referentialService, dtoType);

-

     }

-    private <R extends ReferentialDtoReference> ReferentialDtoReferenceSet<R> getReferentialReferenceSet(Class<R> type) {

-

+    @SuppressWarnings("unchecked")

+    public <R extends ReferentialDtoReference> ReferentialDtoReferenceSet<R> getReferentialReferenceSet(Class<R> type) {

         checkIsOpen();

-

         ReferentialService referentialService = servicesProvider.getReferentialService();

         return referentialCache.getReferentialReferenceSet(referentialService, type);

     }

     public <R extends ReferentialDtoReference> Set<R> getReferentialReferences(Class<R> type) {

-

         ReferentialDtoReferenceSet<R> referentialReferenceSet = getReferentialReferenceSet(type);

         return referentialReferenceSet.toSet();

-

     }

     public boolean isOpen() {

         return connection != null;

     }

-    public ObserveDataSourceInformation checkCanConnect() throws DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {

-

+    public ObserveDataSourceInformation checkCanConnect(boolean canBeEmpty) throws DatabaseConnexionNotAuthorizedException, DatabaseNotFoundException {

         checkIsNotAlreadyOpen();

-

         DataSourceService dataSourceService = servicesProvider.getDataSourceService();

-

-        return dataSourceService.checkCanConnect(configuration);

-

+        return canBeEmpty ? dataSourceService.checkCanConnectOrBeEmpty(configuration) : dataSourceService.checkCanConnect(configuration);

     }

     public boolean isLocal() {

     }

     public void removeObserveSwingDataSourceListener(ObserveSwingDataSourceListener listener) {

-        if (log.isInfoEnabled()) {

-            log.info("removing listener " + listener);

-        }

+        log.info("removing listener " + listener);

         listenerList.remove(ObserveSwingDataSourceListener.class, listener);

     }

     public void setProgressModel(ProgressModel progressModel) {

         this.progressModel = progressModel;

     }

+

+    public void setOwner(boolean owner) {

+        this.owner = owner;

+    }

 }
  * #L%

  */

+import fr.ird.observe.client.ObserveSwingApplicationContext;

 import fr.ird.observe.client.ui.ObserveMainUI;

 import fr.ird.observe.client.ui.actions.main.menu.MenuActionSupport;

 import fr.ird.observe.client.ui.storage.StorageUIModel;

         configuration.setLogin(model.getRemoteLogin());

         configuration.setPassword(new String(model.getRemotePassword()));

         configuration.setDatabaseName(model.getServerDatabase());

-        getMainUI().getConfig().addServerDataSourceConfiguration(configuration);

-

+        ObserveSwingApplicationContext.get().getConfig().addServerDataSourceConfiguration(configuration);

         configUI.getHandler().addServerConfiguration(getMainUI(), configuration, configUI.getServerMenu().getComponentCount() - 2);

     }

 }

         ObserveSwingDataSource dataSource = ObserveSwingApplicationContext.get().getDataSourcesManager().newDataSource(config);

         try {

-            ObserveDataSourceInformation dataSourceInformation = dataSource.checkCanConnect();

+            ObserveDataSourceInformation dataSourceInformation = dataSource.checkCanConnect(false);

+            dataSource.setOwner(dataSourceInformation.isOwner());

             Version versionDataSource = dataSourceInformation.getVersion();

             }

             if (connexionStatusError == null) {

-                ObserveDataSourceInformation dataSourceInformation = dataSource.checkCanConnect();

+                ObserveDataSourceInformation dataSourceInformation = dataSource.checkCanConnect(false);

                 Version versionDataSource = dataSourceInformation.getVersion();

             try {

-                localSourceInformation = localSource.checkCanConnect();

+                localSourceInformation = localSource.checkCanConnect(false);

             } catch (Exception e) {

                 //FIXME ! il faut faire quelque chose dans ce cas précis, au moins avertir l'utilisateur

             // si on utilise la base local on lance une migration de la base si necessaire

             if (DbMode.USE_LOCAL.equals((model.getDbMode()))) {

-                ObserveDataSourceInformation dataSourceInformation = currentDataSource.checkCanConnect();

-

+                ObserveDataSourceInformation dataSourceInformation = currentDataSource.checkCanConnect(false);

+                currentDataSource.setOwner(dataSourceInformation.isOwner());

                 progressModel.incrementsCurrentStep();

                 currentDataSource.migrateData(dataSourceInformation, config.getModelVersion());

                     if (!error) {

-                        dataSourceInformation = dataSource.checkCanConnect();

+                        boolean createAction = ObstunaAdminAction.CREATE.equals(adminAction);

+                        dataSourceInformation = dataSource.checkCanConnect(createAction);

+                        dataSource.setOwner(dataSourceInformation.isOwner());

                         Version versionDataSource = dataSourceInformation.getVersion();

                         // en mise a jour de la base on ne test pas la version

-                        if (getModelVersion().equals(versionDataSource) || isCanMigrate() || ObstunaAdminAction.CREATE.equals(adminAction)) {

+                        if (isCanMigrate() || createAction || getModelVersion().equals(versionDataSource)) {

                             setConnexionStatus(ConnexionStatus.SUCCESS);

             setBusy(false);

         }

+        if (result && dataSourceInformation != null && adminAction != null) {

+

+            // must be owner of database to perform a such action

+            if (!dataSourceInformation.isOwner()) {

+                connexionStatusError = t("observe.storage.error.user.not.owner");

+                log.error(connexionStatusError);

+                setConnexionStatus(ConnexionStatus.FAILED);

+                result = false;

+            }

+        }

         return result;

     }

         if (h2DataSourceInformation == null && localStorageExist) {

             ObserveSwingDataSource dataSource = ObserveSwingApplicationContext.get().getDataSourcesManager().newDataSource(h2Config);

             try {

-                h2DataSourceInformation = dataSource.checkCanConnect();

+                h2DataSourceInformation = dataSource.checkCanConnect(false);

             } catch (Exception e) {

                 if (log.isDebugEnabled()) {

                     log.debug("error on load data source information for local storage", e);

 observe.storage.error.rest.user.unknown=User "%s" is not defined on server

 observe.storage.error.serverVersionMismatch=Remote server version (%s) is not compliant with the client version (%s)

 observe.storage.error.serverVersionModelMismatch=Remote server model version (%s) is not compliant with the client model version (%s)

+observe.storage.error.user.not.owner=User must be owner of database to perform this action\!

 observe.storage.import.data.fromBackup=Import data from a backup of a local database (*.sql.gz)

 observe.storage.import.data.fromRemoteStorage=Import data from a remote database

 observe.storage.import.data.fromServerStorage=Import data from a remove server

 observe.storage.error.rest.user.unknown=El usuario "%s" no es conocido por el servidor

 observe.storage.error.serverVersionMismatch=La versión del servidor remoto (%s) no es compatible con la versión del modelo (%s)

 observe.storage.error.serverVersionModelMismatch=La versión del modelo del servidor remoto (%s) no es compatible con la versión del modelo (%s)

+observe.storage.error.user.not.owner=User must be owner of database to perform this action\! \#TODO

 observe.storage.import.data.fromBackup=Importar los datos de una copia de seguridad de la base local (*.sql.gz)

 observe.storage.import.data.fromRemoteStorage=Importar los datos de una base remota

 observe.storage.import.data.fromServerStorage=Importar los datos de un servidor remoto

 observe.storage.error.rest.user.unknown=L'utilisateur "%s" est inconnu sur le serveur

 observe.storage.error.serverVersionMismatch=La version du serveur distant (%s) n'est pas compatible avec la version du client (%s)

 observe.storage.error.serverVersionModelMismatch=La version du modèle du serveur distant (%s) n'est pas compatible avec la version du modèle du client (%s)

+observe.storage.error.user.not.owner=L'utilisateur doit être le propriétaire de la base pour effectuer cette opération \!

 observe.storage.import.data.fromBackup=Importer les données depuis une sauvegarde de base locale (*.sql.gz)

 observe.storage.import.data.fromRemoteStorage=Importer les données depuis une base distante

 observe.storage.import.data.fromServerStorage=Importer les données depuis un serveur distant

   <parent>

     <groupId>io.ultreia.maven</groupId>

     <artifactId>pom</artifactId>

-    <version>2019.8.22</version>

+    <version>2019.8.23</version>

   </parent>

   <groupId>fr.ird.observe</groupId>

     <maven.build.timestamp.format>dd/MM/yyyy HH:mm z</maven.build.timestamp.format>

     <buildDate>${maven.build.timestamp}</buildDate>

-    <observeToolkitVersion>3.7.17</observeToolkitVersion>

+    <observeToolkitVersion>3.7.19-SNAPSHOT</observeToolkitVersion>

     <!--<lib.version.java4all.http>1.0.13</lib.version.java4all.http>-->

     <lib.version.nuiton.validation>3.1</lib.version.nuiton.validation>

     <!--<lib.version.java4all.config>1.0.3</lib.version.java4all.config>-->

     <lib.version.java4all.eugene>3.0-alpha-26</lib.version.java4all.eugene>

     <!--lib.version.java4all.jaxx>3.0-alpha-50</lib.version.java4all.jaxx-->

     <!--<lib.version.java4all.i18n>4.0-beta-8-SNAPSHOT</lib.version.java4all.i18n>-->

-    <lib.version.java4all.topia>1.1.14</lib.version.java4all.topia>

+    <lib.version.java4all.topia>1.1.15-SNAPSHOT</lib.version.java4all.topia>

     <!--<lib.version.nuiton.topia>3.6-SNAPSHOT</lib.version.nuiton.topia>-->

     <!--<lib.version.java4all.eugene>3.0-alpha-21</lib.version.java4all.eugene>-->

 GET    /api/v1/DataSourceService/applySecurity                                                                                       v1.DataSourceServiceRestApi.applySecurity

 GET    /api/v1/DataSourceService/backup                                                                                              v1.DataSourceServiceRestApi.backup

 GET    /api/v1/DataSourceService/checkCanConnect                                                                                     v1.DataSourceServiceRestApi.checkCanConnect

+GET    /api/v1/DataSourceService/checkCanConnectOrBeEmpty                                                                            v1.DataSourceServiceRestApi.checkCanConnectOrBeEmpty

 GET    /api/v1/DataSourceService/close                                                                                               v1.DataSourceServiceRestApi.close

 GET    /api/v1/DataSourceService/create                                                                                              v1.DataSourceServiceRestApi.create

 GET    /api/v1/DataSourceService/destroy                                                                                             v1.DataSourceServiceRestApi.destroy

         return privileges != null && !privileges.isEmpty();

     }

+    private static boolean isOwner(ObserveDataSourceConfigurationTopiaSupport dataSourceConfiguration, JdbcPostgresHelper jdbcHelper) {

+        if (dataSourceConfiguration.isH2Database()) {

+            return true;

+        }

+        return jdbcHelper.isOwner();

+    }

+

+    @Override

+    public ObserveDataSourceInformation checkCanConnectOrBeEmpty(ObserveDataSourceConfiguration dataSourceConfiguration) throws DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException {

+        Preconditions.checkState(dataSourceConfiguration instanceof ObserveDataSourceConfigurationTopiaSupport);

+        ObserveDataSourceConfigurationTopiaSupport dataSourceConfigurationTopiaSupport = (ObserveDataSourceConfigurationTopiaSupport) dataSourceConfiguration;

+

+        ObserveDataSourceInformation dataSourceInformation;

+

+        if (dataSourceConfigurationTopiaSupport.isH2Database()) {

+

+            ObserveDataSourceConfigurationTopiaH2 h2DataSourceConfiguration = (ObserveDataSourceConfigurationTopiaH2) dataSourceConfigurationTopiaSupport;

+

+            // On vérifie que le fichier de la base existe

+            File databaseFile = h2DataSourceConfiguration.getDatabaseFile();

+

+            if (!databaseFile.exists()) {

+

+                String message = l(getApplicationLocale(), "observe.services.topia.error.h2.database.notFound");

+                throw new DatabaseNotFoundException(message, dataSourceConfiguration);

+

+            }

+

+            // On vérifier que la base n'est pas déjà en cours d'utilisation

+            File databaseLockFile = h2DataSourceConfiguration.getLockFile();

+            if (databaseLockFile.exists()) {

+

+                String message = l(getApplicationLocale(), "observe.services.topia.error.h2.database.locked");

+                if (log.isWarnEnabled()) {

+                    log.warn(message);

+                }

+                // FIXME even if file is lock we still authorize to connect,

+                //throw new DatabaseConnexionNotAuthorizedException(message, dataSourceConfiguration);

+            }

+

+            // On tente une connection à la base

+            ObserveTopiaConfiguration topiaConfiguration = ObserveTopiaConfigurationFactory.forH2Database(h2DataSourceConfiguration.getDirectory(),

+                                                                                                          h2DataSourceConfiguration.getDbName(),

+                                                                                                          h2DataSourceConfiguration.getUsername(),

+                                                                                                          new String(h2DataSourceConfiguration.getPassword()),

+                                                                                                          false,

+                                                                                                          false);

+

+

+            try {

+                new JdbcHelper(topiaConfiguration).runSelectOnString("SELECT 1;");

+            } catch (Exception e) {

+

+                // Authentification refusée

+                String message = l(getApplicationLocale(), "observe.services.topia.error.h2.database.badAuthentication");

+                throw new DatabaseConnexionNotAuthorizedException(message, e, dataSourceConfiguration);

+

+            }

+

+            dataSourceInformation = getDataSourceInformation(h2DataSourceConfiguration, topiaConfiguration, false);

+

+

+        } else {

+

+            ObserveDataSourceConfigurationTopiaPG pgDataSourceConfiguration = (ObserveDataSourceConfigurationTopiaPG) dataSourceConfigurationTopiaSupport;

+            // On tente une connexion au serveur

+            ObserveTopiaConfiguration topiaConfiguration = ObserveTopiaConfigurationFactory.forPostgresqlDatabase(pgDataSourceConfiguration.getJdbcUrl(),

+                                                                                                                  pgDataSourceConfiguration.getUsername(),

+                                                                                                                  new String(pgDataSourceConfiguration.getPassword()),

+                                                                                                                  false,

+                                                                                                                  false);

+

+            try {

+                new JdbcHelper(topiaConfiguration).runSelectOnString("SELECT 1;");

+            } catch (Exception e) {

+

+                throw new DatabaseConnexionNotAuthorizedException(e.getMessage(), e, dataSourceConfiguration);

+

+            }

+

+            dataSourceInformation = getDataSourceInformation(pgDataSourceConfiguration, topiaConfiguration, true);

+

+        }

+

+        return dataSourceInformation;

+

+    }

+

+

     @Override

     public ObserveDataSourceInformation checkCanConnect(ObserveDataSourceConfiguration dataSourceConfiguration) throws DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException {

             // On tente une connection à la base

             ObserveTopiaConfiguration topiaConfiguration = ObserveTopiaConfigurationFactory.forH2Database(h2DataSourceConfiguration.getDirectory(),

-                    h2DataSourceConfiguration.getDbName(),

-                    h2DataSourceConfiguration.getUsername(),

-                    new String(h2DataSourceConfiguration.getPassword()),

-                    false,

-                    false);

+                                                                                                          h2DataSourceConfiguration.getDbName(),

+                                                                                                          h2DataSourceConfiguration.getUsername(),

+                                                                                                          new String(h2DataSourceConfiguration.getPassword()),

+                                                                                                          false,

+                                                                                                          false);

             try {

             }

-            dataSourceInformation = getDataSourceInformation(h2DataSourceConfiguration, topiaConfiguration);

+            dataSourceInformation = getDataSourceInformation(h2DataSourceConfiguration, topiaConfiguration, false);

         } else {

             ObserveDataSourceConfigurationTopiaPG pgDataSourceConfiguration = (ObserveDataSourceConfigurationTopiaPG) dataSourceConfigurationTopiaSupport;

             // On tente une connexion au serveur

             ObserveTopiaConfiguration topiaConfiguration = ObserveTopiaConfigurationFactory.forPostgresqlDatabase(pgDataSourceConfiguration.getJdbcUrl(),

-                    pgDataSourceConfiguration.getUsername(),

-                    new String(pgDataSourceConfiguration.getPassword()),

-                    false,

-                    false);

+                                                                                                                  pgDataSourceConfiguration.getUsername(),

+                                                                                                                  new String(pgDataSourceConfiguration.getPassword()),

+                                                                                                                  false,

+                                                                                                                  false);

             try {

                 new JdbcHelper(topiaConfiguration).runSelectOnString("SELECT 1;");

             }

-            dataSourceInformation = getDataSourceInformation(pgDataSourceConfiguration, topiaConfiguration);

+            dataSourceInformation = getDataSourceInformation(pgDataSourceConfiguration, topiaConfiguration, false);

         }

         }

-        ObserveDataSourceInformation dataSourceInformation = getDataSourceInformation((ObserveDataSourceConfigurationTopiaSupport) dataSourceConfiguration, topiaApplicationContext.getConfiguration());

+        ObserveDataSourceInformation dataSourceInformation = getDataSourceInformation((ObserveDataSourceConfigurationTopiaSupport) dataSourceConfiguration, topiaApplicationContext.getConfiguration(), false);

         return createDataSourceConnection(dataSourceInformation, topiaApplicationContext.getAuthenticationToken());

                 dataSourceInformation.getVersion());

     }

-    private ObserveDataSourceInformation getDataSourceInformation(ObserveDataSourceConfigurationTopiaSupport dataSourceConfiguration, ObserveTopiaConfiguration topiaConfiguration) {

+    private ObserveDataSourceInformation getDataSourceInformation(ObserveDataSourceConfigurationTopiaSupport dataSourceConfiguration, ObserveTopiaConfiguration topiaConfiguration, boolean canBeEmpty) {

         boolean writeReferential;

         boolean readData;

         Version version;

         JdbcPostgresHelper jdbcHelper = new JdbcPostgresHelper(topiaConfiguration);

+        boolean owner = isOwner(dataSourceConfiguration, jdbcHelper);

-        version = TMSVersionHibernateDao.getVersion(jdbcHelper, "tms_version").map(TMSVersion::toVersion).orElse(Version.VZERO);

+        try {

+            version = TMSVersionHibernateDao.getVersion(jdbcHelper, "tms_version").map(TMSVersion::toVersion).orElse(Version.VZERO);

+        } catch (Exception e) {

+            if (!canBeEmpty) {

+                throw e;

+            }

+            if (dataSourceConfiguration.isH2Database()) {

+

+                // Sur une base H2, on a le droit de tout lire, mais uniquement d'écrire les données

+                writeReferential = false;

+                readData = true;

+                writeData = true;

+                owner = true;

+

+            } else {

+                writeReferential = true;

+                readData = true;

+                writeData = true;

+            }

+            return new ObserveDataSourceInformation(

+                    true,

+                    writeReferential,

+                    readData,

+                    writeData,

+                    owner,

+                    ObserveTopiaMigrationServiceAskUserToMigrate.getMinimumVersion(),

+                    null,

+                    null);

+        }

         if (dataSourceConfiguration.isH2Database()) {

                 writeReferential,

                 readData,

                 writeData,

+                owner,

                 ObserveTopiaMigrationServiceAskUserToMigrate.getMinimumVersion(),

                 version,

                 observeMigrationConfigurationProvider.getVersionsAfter(version));

     @Get(addAuthtoken = false)

     ObserveDataSourceInformation checkCanConnect(ObserveDataSourceConfiguration dataSourceConfiguration) throws DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException;

+    @Get(addAuthtoken = false)

+    ObserveDataSourceInformation checkCanConnectOrBeEmpty(ObserveDataSourceConfiguration dataSourceConfiguration) throws DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException;

+

     @Get(addAuthtoken = false)

     ObserveDataSourceConnection create(ObserveDataSourceConfiguration dataSourceConfiguration, DataSourceCreateConfigurationDto dataSourceCreateConfiguration)

             throws IncompatibleDataSourceCreateConfigurationException, DataSourceCreateWithNoReferentialImportException,

Tony CHEMIT pushed to branch develop-7.x at ultreiaio / ird-observe

Commits:

16 changed files:

Changes: