Commit e16acfc6 authored by Bertrand Gauthier's avatar Bertrand Gauthier
Browse files

Déplacement de la doc dans l'appli (répertoire doc)

parent 9abbbb96
# Installation de SyGAL
## Création de la base de données
Reportez-vous au [README consacré à la création de la base de données](database/README.md).
## Installation
Pour ce qui est de l'installation du serveur d'application, n'ayant pas à Caen les compétences
en déploiement Docker autres que pour le développement (d'où la présence d'un `Dockerfile` et d'un `docker-compose.yml`
dans les sources), nous documenterons une installation à l'ancienne sur un serveur *entièrement dédié à l'application*.
Si vous voulez déployer l'application avec Docker, faites-le à partir du `Dockerfile` présent et n'hésitez pas à
proposer votre contribution pour améliorer cette doc d'install !
### Première obtention des sources de l'application
*NB: la procédure proposée ici part d'un serveur *Debian Stretch* tout nu et couvre l'installation de tous les packages
requis.* Si ce n'était pas le cas, merci de contribuer en le signalant.
En `root` sur votre serveur, pour obtenir les sources de SyGAL, lancez l'une des commandes suivantes en fonction
du site sur lequel vous lisez la présente page :
```bash
# Si vous êtes sur git.unicaen.fr :
git clone https://git.unicaen.fr/open-source/sygal.git /app
# Si vous êtes sur github.com :
git clone https://github.com/EsupPortail/sygal.git /app
```
*NB: merci de respecter dans un premier temps le choix de `/app` comme répertoire d'installation.
Libre à vous une fois que tout fonctionne de changer d'emplacement et de modifier en conséquence les configs
nécessaires.*
### Configuration du serveur
Sur le serveur, placez-vous dans le répertoire des sources de SyGAL et jetez un oeil au script `Dockerfile.sh`.
Ce script est en quelque sorte l'équivalent du `Dockerfile` traduit en bash.
(Vous y verrez que le dépôt git d'une image Docker Unicaen est cloné pour lancer
son script `Dockerfile.sh` qui est lui aussi l'équivalent du `Dockerfile` de l'image
traduit en bash.)
Lancez le script `Dockerfile.sh` ainsi :
```bash
cd /app
bash Dockerfile.sh 7.0
```
Ensuite, vérifiez et ajustez si besoin sur votre serveur les fichiers de configs suivants,
créés par le script `Dockerfile.sh` :
- ${APACHE_CONF_DIR}/ports.conf
- ${APACHE_CONF_DIR}/sites-available/app.conf
- ${APACHE_CONF_DIR}/sites-available/app-ssl.conf
- ${PHP_CONF_DIR}/fpm/pool.d/app.conf
- ${PHP_CONF_DIR}/fpm/conf.d/90-app.ini
NB: Vérifiez dans le script `Dockerfile.sh` que vous venez de lancer mais normalement
`APACHE_CONF_DIR=/etc/apache2` et `PHP_CONF_DIR=/etc/php/7.0`.
### Installation d'une version précise de l'application
Normalement, vous ne devez installer que les versions officielles, c'est à dire les versions taguées, du genre `1.4.2`
par exemple.
Placez-vous dans le répertoire des sources de l'application puis lancez les commandes suivantes pour obtenir la liste des
versions officielles (taguées) :
```bash
git fetch && git fetch --tags && git tag
```
Si la version la plus récente est par exemple la `1.4.2`, utilisez les commandes suivantes pour "installer" cette version
sur votre serveur :
```bash
git checkout --force 1.4.2 && bash install.sh
```
### Configuration du moteur PHP pour SyGAL
Si vous êtes sur un serveur de PROD, corrigez les lignes suivantes du fichier de config PHP
`/etc/php/7.0/fpm/conf.d/90-app.ini` :
display_errors = Off
...
opcache.enable = 1
...
xdebug.remote_enable = 0
### Fichiers de config de l'application
Placez-vous dans le répertoire de l'application puis descendez dans le répertoire `config/autoload/`.
Supprimez l'extension `.dist` des fichiers `local.php.dist` et `secret.local.php.dist`, ex :
```bash
cp -n local.php.dist local.php
cp -n secret.local.php.dist secret.local.php
```
Dans la suite, vous adapterez le contenu de ces fichiers à votre situation.
#### `unicaen-app.global.php`
- Adaptez les URL des pages "Mentions légales" et "Informatique et liberté" pour votre établissement :
```php
'unicaen-app' => [
'app_infos' => [
//...
'mentionsLegales' => "http://www.unicaen.fr/acces-direct/mentions-legales/",
'informatiqueEtLibertes' => "http://www.unicaen.fr/acces-direct/informatique-et-libertes/",
```
#### `local.php`
- Adaptez le `'label'`, `'title'` et `'uri'` du lien mentionnant votre établissement dans le pied de page de
l'application :
```php
'navigation' => [
'default' => [
'home' => [
'pages' => [
'etab' => [
'label' => _("Normandie Université"),
'title' => _("Page d'accueil du site de Normandie Université"),
'uri' => 'http://www.normandie-univ.fr',
'class' => 'logo-etablissement',
// NB: Spécifier la classe 'logo-etablissement' sur une page de navigation provoque le "remplacement"
// du label du lien par l'image 'public/logo-etablissement.png' (à créer le cas échéant).
```
*NB: ensuite créez le fichier `public/logo-etablissement.png` correspondant au logo de votre établissement.*
- Adaptez le chemin du répertoire où seront stockés les fichiers uploadés par les utilisateurs de l'application :
```php
'fichier' => [
'root_dir_path' => '/app/upload',
],
```
*NB: ce répertoire doit être autorisé en écriture à l'utilisateur `www-data` (ou équivalent).*
#### `secret.local.php`
- Dans la config de connexion au WS suivante, `UCN` doit être remplacé par le code établissement choisi lors
de la création de votre établissement dans la base de données (dans le script `05-init.sql`) :
```php
'import-api' => [
'etablissements' => [
// code établissement => [config]
'UCN' => [
'url' => 'https://sygal-import-ws:443',
'proxy' => false,
'verify' => false, // si true et faux certif : cURL error 60: SSL certificate problem: self signed certificate
'user' => 'xxx',
'password' => 'yyy',
```
- Renseignez les infos de connexion à la base de données :
```php
'doctrine' => [
'connection' => [
'orm_default' => [
'params' => [
'host' => 'host.domain.fr',
'dbname' => 'DBNAME',
'port' => '1523',
'user' => $user = 'sygal',
'password' => 'xxxxxxxxxxx',
'charset' => 'AL32UTF8',
'CURRENT_SCHEMA' => $user,
```
- La config fournie permet de simuler l'authentification Shibboleth de l'utilisateur 'premierf@univ.fr'
créé en base de données (dans le script `06-test.sql`) avec le rôle "Administrateur technique".
Cela permet d'accéder aux pages de gestion des droits d'accès.
```php
'unicaen-auth' => [
'shibboleth' => [
'simulate' => [
'HTTP_EPPN' => $eppn = 'premierf@univ.fr',
'HTTP_SUPANNEMPID' => '00012345',
'HTTP_DISPLAYNAME' => $eppn,
'HTTP_MAIL' => $eppn,
'HTTP_GIVENNAME' => 'François',
'HTTP_SN' => 'Premier',
'HTTP_SUPANNCIVILITE' => 'M.'
```
- Théoriquement, à ce stade l'application SyGAL devrait être accessible.
## Dans l'application SyGAL elle-même
Si vous n'avez rien changé à la config de l'application concernant Shibboleth et si vous cliquez en haut à droite de
la page d'accueil de SyGAL sur "Connexion" puis sur "Fédération d'identité", vous devriez être dans la peau de
François Premier, administrateur technique de test créé en base de données (dans le script `05-init.sql`).
### Droits d'accès
Dans l'application SyGAL, allez dans menu "Droits d'accès" > "Gestion des profils de rôle".
Appliquez, svp :
- le profil `ADMIN_TECH` au rôle *Administrateur technique*
- le profil `OBSERV` au rôle *Observateur*
- le profil `DOCTORANT` au rôle *Doctorant UCN*
- le profil `ADMIN` au rôle *Administrateur UCN*
- le profil `BU` au rôle *Bibliothèque universitaire UCN*
- le profil `BDD` au rôle *Bureau des doctorats UCN*
Par exemple, pour appliquer le profil `ADMIN_TECH` au rôle *Administrateur technique*, il faut :
- cliquer sur l'icône bleu en forme de maillon de chaîne tout au bout de la ligne "ADMIN_TECH" du tableau "Liste des profils" ;
- dans la page qui s'ouvre, sélectionner "Administrateur technique" dans la liste déroulante de droite ;
- appuyer sur le bouton "Ajouter un rôle".
NB: "UCN" n'est qu'un exemple et pour vous ce sera le code établissement choisi lors
de la création de votre établissement dans la base de données (dans le script `05-init.sql`)
### Import
Allez dans menu "Import" pour contrôler que l'application parvient à contacter votre web service.
La version de l'API devrait s'afficher, ex: 1.2.4.
Ne tenez pas compte du menu "Lancement" car il n'est pas possible de lancer l'import des données
depuis l'interface graphique.
## En ligne de commande
### Import de données
Placez-vous dans le répertoire de SyGAL sur le serveur.
Ce qui suit n'est possible que si le web service d'import de données est installé, si ce n'est pas le cas,
reportez-vous au projet `sygal-import-ws` [sur github.com/EsupPortail](https://github.com/EsupPortail/sygal-import-ws)
ou [sur git.unicaen.fr](https://git.unicaen.fr/open-source/sygal-import-ws).
#### Lancement de l'import
Il s'agit de l'interrogation du web service pour remplir les tables temporaires TMP_*.
php public/index.php import-all --etablissement=UCN --synchronize=0 --breakOnServiceNotFound=0
*NB: `UCN` doit être remplacé par le code établissement choisi lors
de la création de votre établissement dans la base de données (dans le script `05-init.sql`).*
#### Lancement de la synchro
Il s'agit de la synchronisation des tables définitives de travail de l'application avec les tables TMP_*
contenant les données déjà importées.
php public/index.php synchronize-all
Pour plus de détails, vous pouvez vous reporter à la documentation sur les [lignes de commandes](cli.md).
Une fois la synchro effectuée, vous devriez voir des thèses apparaître en cliquant sur le menu "Thèses" de
l'application.
#### Lancement des 2
Pour lancer l'interrogation du web service *puis* la synchronisation des tables définitives de travail, faites :
php public/index.php import-all --etablissement=UCN --synchronize=1 --breakOnServiceNotFound=0
*NB: `UCN` doit être remplacé par le code établissement choisi lors
de la création de votre établissement dans la base de données (dans le script `05-init.sql`).*
### Programmation des tâches périodiques
Un certains nombres de tâches périodiques doivent être programmées sur le serveur.
Pour cela, créez le fichier `/etc/cron.d/sygal` et adaptez le contenu suivant à votre contexte :
```cron
MAILTO=nom.prenom@domaine.fr
#
# Application SyGAL.
#
APP_DIR=/app
##### Traitements en fonction des résultats de l'import #####
0 5-17 * * 1-5 root /usr/bin/php $APP_DIR/public/index.php process-observed-import-results --etablissement=UCN 1> /tmp/sygal-process-observed-import-results.log 2>&1
# (du lundi au vendredi, chaque heure de 5h à 17h)
##### Import des données des établissements #####
*/20 * * * * root /usr/bin/php $APP_DIR/public/index.php import-all --etablissement=UCN --synchronize=1 --breakOnServiceNotFound=0 1> /tmp/cron-sygal-import.log 2>&1
## (toutes les 20 minutes)
##### Ménage dans /tmp #####
0 4 * * * root bash $APP_DIR/bin/purge_temp_files.sh 1> /tmp/sygal_purge_temp_files.sh.log 2>&1
## (tous les jours à 4h du mat')
```
*NB: `UCN` doit être remplacé par le code établissement choisi lors
de la création de votre établissement dans la base de données (dans le script `05-init.sql`).*
La doc a déménagé [ici](https://git.unicaen.fr/open-source/sygal/-/blob/master/doc/INSTALL.md).
Documentation SyGAL
===================
- [Installation](INSTALL.md)
- [Ligne de commande](cli.md)
- [Base de données](database/README.md)
Ce dépôt est abandonné.
Maintenant, ça se passe [ici...](https://git.unicaen.fr/open-source/sygal/-/blob/master/doc)
\ No newline at end of file
# bin
## [generate-database-scripts.sh](generate-database-scripts.sh)
Ce script doit être utilisé pour générer une partie des scripts SQL nécessaires à l'installation de
la base de données de SyGAL *de zéro*.
Les scripts générés dans le répertoire temporaire `/tmp/sygal-doc/database` sont les suivants :
- `00-oracle-clear-schema-SYGAL.sql`
- `00-oracle-generate-schema-SYGAL.sql`
- `02-inserts/oracle-data-insert-from-SYGAL.*-into-SYGAL.sql`
- `03-oracle-generate-ref-constraints-SYGAL.sql`
Les autres scripts sont gérés à la main :
- [`00-crea-users.sql`](../database/00-crea-users.sql)
- [`01-bootstrap.sql`](../database/01-bootstrap.sql)
- [`04-crea-comue.sql`](../database/04-crea-comue.sql)
- [`05-init.sql`](../database/05-init.sql)
- [`06-test.sql`](../database/06-test.sql)
Usage :
```bash
# génération des scripts
./generate-database-scripts.sh
# récupération du résultat
cp -r /tmp/sygal-doc/database/* database/
```
#!/usr/bin/env bash
#
# Script de génération d'une partie des scripts SQL permettant de créer de zéro la base de données de SyGAL.
#
# Arguments :
# $1 : Nom du schéma de base de données. Ex: "SYGAL". Obligatoire.
#
# NB: Attention, cet argument n'a pas la vocation de "sélectionner" le schéma de base de données à utiliser,
# il est simplement exploité pour les noms de fichiers SQL générés.
# Le schéma de base de données utilisé est celui spécifié dans la config Doctrine de l'appli
# (cf. fichier `config/autoload/*.secret.local.php` de l'appli).
#
# Exemple d'usage :
# bash gen-db-scripts.sh "SYGAL"
#
[[ -z "$1" ]] && echo "Le nom du schéma de base de données doit être spécifié, ex: SYGAL." && exit 1
SCHEMA=$1
# fonction mettant en commentaire certains options de création de séquence dans le(s) fichier(s) spécifié(s)
commentSeqOptionsInFile() {
for f in $1; do
sed -i 's/\(START WITH [0-9]\+\)/\/*\1*\//ig; s/\(CACHE [0-9]\+\)/\/*\1*\//ig' ${f}
done
}
# fonction remplaçant 'SYGAL.' par '/*SYGAL.*/' et '"SYGAL".' par '/*"SYGAL".*/' dans le(s) fichier(s) spécifié(s)
commentPrefixInFile() {
for f in $1; do
sed -i "s/\(${SCHEMA}\.\)/\/*\1*\//ig" ${f}
sed -i "s/\(\"${SCHEMA}\"\.\)/\/*\1*\//ig" ${f}
done
}
# fonction remplaçant par exemple "/*HISTO::*/1234" par "$2/*SUBSTIT*/" dans le(s) fichier(s) spécifié(s) en $1
replaceHistoIdInFile() {
for f in $1; do
sed -i "s/\/\*HISTO::\*\/[0-9]\+/$2\/\*SUBSTIT\*\//ig" ${f}
done
}
FROM_FILE_PATH_CLEAR="/tmp/oracle-clear-schema-${SCHEMA}.sql"
FROM_FILE_PATH_SCHEMA="/tmp/oracle-generate-schema-${SCHEMA}-from-${SCHEMA}.sql"
FROM_FILE_PATH_INSERTS="/tmp/inserts"
FROM_FILE_PATH_REF="/tmp/oracle-generate-ref-constraints-${SCHEMA}-from-${SCHEMA}.sql"
TABLES="CATEGORIE_PRIVILEGE,DOMAINE_SCIENTIFIQUE,IMPORT_OBSERV,INFORMATION,NATURE_FICHIER,PRIVILEGE,PROFIL,PROFIL_PRIVILEGE,TYPE_STRUCTURE,TYPE_VALIDATION,VERSION_FICHIER,WF_ETAPE"
HISTO_ID_SUBSTIT=1 # valeur forcée pour les colonnes d'historique
rm -rf ${FROM_FILE_PATH_INSERTS} && mkdir -p ${FROM_FILE_PATH_INSERTS}
php public/index.php generate-script-for-schema-clearing \
--connection=doctrine.connection.orm_default && \
\
php public/index.php generate-script-for-schema-creation \
--src-connection=doctrine.connection.orm_default \
--dst-connection=doctrine.connection.orm_default \
--ref-constraints-included=0 && \
\
php public/index.php generate-scripts-for-data-inserts \
--src-connection=doctrine.connection.orm_default \
--dst-connection=doctrine.connection.orm_default \
--tables=${TABLES} \
--output-dir=${FROM_FILE_PATH_INSERTS} && \
\
php public/index.php generate-script-for-ref-constraints-creation \
--src-connection=doctrine.connection.orm_default \
--dst-connection=doctrine.connection.orm_default && \
\
commentPrefixInFile ${FROM_FILE_PATH_CLEAR} && \
commentPrefixInFile ${FROM_FILE_PATH_SCHEMA} && \
commentSeqOptionsInFile ${FROM_FILE_PATH_SCHEMA} && \
commentPrefixInFile "${FROM_FILE_PATH_INSERTS}/*" && \
replaceHistoIdInFile "${FROM_FILE_PATH_INSERTS}/*" ${HISTO_ID_SUBSTIT} && \
commentPrefixInFile ${FROM_FILE_PATH_REF}
#!/usr/bin/env bash
#
# Script de génération d'une partie des scripts SQL permettant de créer de zéro la base de données de SyGAL.
#
# Arguments :
# Aucun.
#
# Exemple d'usage :
# bash generate-database-scripts.sh
#
echo "
####################################################################################################
#
# Génération d'une partie des scripts SQL permettant de créer de zéro la base de données de SyGAL
#
####################################################################################################"
THIS_DIR=$(cd `dirname $0` && pwd)
SCHEMA="SYGAL"
# répertoire de destination des résultats
OUTPUT_DIR=/tmp/sygal-doc/database
[[ -d ${OUTPUT_DIR} ]] && echo "Le répertoire de destination existe déjà : ${OUTPUT_DIR}" && exit 1
mkdir -p ${OUTPUT_DIR}
# copie et lancement du script dans le container docker
docker cp ${THIS_DIR}/docker/gen-db-scripts.sh sygal-container:/app && \
docker exec -it -w /app sygal-container bash gen-db-scripts.sh ${SCHEMA} && \
docker exec -it -w /app sygal-container rm gen-db-scripts.sh
FROM_FILE_PATH_CLEAR="/tmp/oracle-clear-schema-${SCHEMA}.sql"
FROM_FILE_PATH_SCHEMA="/tmp/oracle-generate-schema-${SCHEMA}-from-${SCHEMA}.sql"
FROM_FILE_PATH_INSERTS="/tmp/inserts"
FROM_FILE_PATH_REF="/tmp/oracle-generate-ref-constraints-${SCHEMA}-from-${SCHEMA}.sql"
TO_FILE_PATH_CLEAR="${OUTPUT_DIR}/00-oracle-clear-schema-${SCHEMA}.sql"
TO_FILE_PATH_SCHEMA="${OUTPUT_DIR}/00-oracle-generate-schema-${SCHEMA}.sql"
TO_FILE_PATH_INSERTS="${OUTPUT_DIR}/02-inserts"
TO_FILE_PATH_REF="${OUTPUT_DIR}/03-oracle-generate-ref-constraints-${SCHEMA}.sql"
# récupération des scripts SQL générés
docker cp sygal-container:${FROM_FILE_PATH_CLEAR} ${TO_FILE_PATH_CLEAR} && \
docker cp sygal-container:${FROM_FILE_PATH_SCHEMA} ${TO_FILE_PATH_SCHEMA} && \
docker cp sygal-container:${FROM_FILE_PATH_INSERTS}/. ${TO_FILE_PATH_INSERTS} && \
docker cp sygal-container:${FROM_FILE_PATH_REF} ${TO_FILE_PATH_REF}
echo
echo "> Terminé."
echo "> Résultat dans ${OUTPUT_DIR}."
# Ligne de commande de SyGAL
Pour afficher l'aide de toutes les commandes fournies par l'application, se placer à la racine du projet
et faire :
$ php public/index.php
## Import
En fait, on peut désigner par "import" l'enchainement des actions suivantes :
- "importer" les données d'un établissement, càd :
- interroger le WS d'un établissement (projet "sygal-import-ws") ;
- enregistrer les données reçues dans des tables temporaires `TMP_*` ;
- "synchroniser" les tables définitives à partir des tables temporaires (module "unicaen/import").
### Les services disponibles
Les données importées sont fractionnées en domaines ou "services", qui reflètent en réalité chacun une table dans
la base de données de l'application.
Voici les codes des services existants :
- structure
- ecole-doctorale
- unite-recherche
- etablissement
- individu
- doctorant
- these
- role
- acteur
- variable
- financement
- titre-acces
Lorsqu'on importe les écoles doctorales, on référence le service dont le code est `ecole-doctorale`.
C'est ce code du service qui devra être spécifié via l'argument `--etablissement` des commandes présentées ici.
### Commandes d'import
L'import se fait pour *un seul établissement à la fois*. Les établissements dont on veut importer les données
doivent être déclarés dans la config PHP de l'appli : cf. [local.php.dist](../config/autoload/local.php.dist)
C'est le "code établissement" choisi dans la config qui devra être spécifié via l'argument `--etablissement`
des commandes présentées ici.
#### `import`
On parle ici de lancer l'import d'un service précis.
Par exemple, pour lancer l'import des variables de l'UCN, mais sans lancer la synchro des tables définitives :
$ php public/index.php import --service=variable --etablissement=UCN --synchronize=0
Pour lancer en plus la synchro après l'interrogation du WS, mettre `--synchronize=1`.
#### `import-all`
Cette commande lance l'import de tous les services.
Par exemple, pour lancer l'import complet des données de l'UCN, sans lancer la synchro des tables définitives :
$ php public/index.php import-all --etablissement=UCN --synchronize=0
Pour que la synchro se fasse après l'interrogation du WS, mettre `--synchronize=1`.
### Commandes de synchro
On parle ici de synchroniser les données des tables définitives de l'application avec celles des tables
temporaires `TMP_*`.
Même s'il s'agit de tables, on raisonne tout de même en service. Par exemple, la synchronisation de la table des
unités de recherches (`UNITE_RECH`) se fait en spécifiant le code de service `unite-recherche`.
Dans ces commandes, il n'est pas possible de spécifier un établissement précis.
#### `synchronize`
Cette commande lance la synchro d'une table définitive `TABLE` à partir de la table temporaire `TMP_TABLE`
correspondante.
Par exemple, pour lancer la synchro des variables :
$ php public/index.php synchronize --service=variable
#### `synchronize-all`
Cette commande lance la synchro de toutes les tables définitives :
$ php public/index.php synchronize-all
--
-- Tablespace, user, etc.
--
--
-- ATTENTION, ce sript doit être personnalisé pour votre contexte :
--
-- Taille du tablespace (cf. `SIZE`).
-- Mot de passe du user "SYGAL" (cf `IDENTIFIED BY`).
--
--
-- Tablespace
--
CREATE TABLESPACE SYGAL_TS DATAFILE 'SYGAL_TS' SIZE 8000000000;
--
-- User
--
CREATE USER "SYGAL" IDENTIFIED BY "azerty" DEFAULT TABLESPACE "SYGAL_TS" TEMPORARY TABLESPACE "TEMP";
--
-- Grants
--
GRANT "CONNECT" TO "SYGAL";
GRANT "RESOURCE" TO "SYGAL";
GRANT "SELECT_CATALOG_ROLE" TO "SYGAL";
GRANT CREATE JOB TO "SYGAL";
GRANT FLASHBACK ANY TABLE TO "SYGAL";
GRANT DEBUG ANY PROCEDURE TO "SYGAL";
GRANT DEBUG CONNECT SESSION TO "SYGAL";
GRANT SELECT ANY DICTIONARY TO "SYGAL";
GRANT ON COMMIT REFRESH TO "SYGAL";
GRANT CREATE MATERIALIZED VIEW TO "SYGAL";
GRANT CREATE DATABASE LINK TO "SYGAL";
GRANT CREATE VIEW TO "SYGAL";
GRANT DROP PUBLIC SYNONYM TO "SYGAL";
GRANT CREATE PUBLIC SYNONYM TO "SYGAL";
GRANT UNLIMITED TABLESPACE TO "SYGAL";
GRANT ALTER SESSION TO "SYGAL";
GRANT SELECT ON "SYS"."DBA_ROLE_PRIVS" TO "SYGAL";
GRANT SELECT ON "SYS"."DBA_TAB_PRIVS" TO "SYGAL";
GRANT SELECT ON "SYS"."DBA_ROLES" TO "SYGAL";
GRANT FLASHBACK ON "SYS"."ALL_SOURCE" TO "SYGAL";
GRANT EXECUTE ON "SYS"."DBMS_LOCK" TO "SYGAL";
GRANT EXECUTE ON "SYS"."DBMS_ALERT" TO "SYGAL";
This diff is collapsed.
This diff is collapsed.