hubl/.gitlab-ci.yml

# workflow
stages:
 - build
 - test
 - integration
 - acceptance
 - release
 - deployment

# default image for jobs
default:
  image: node:11

# cache modules between jobs
cache:
  key: ${CI_COMMIT_REF_SLUG}
  paths:
    - .npm/

## BUILD ##

build:
  stage: build
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - cp config.sample.json config.json
    - npm run build
  artifacts:
    when: on_success
    expire_in: 1 day
    paths:
      - dist/
  tags:
    - test

## TESTING ##

test:e2e:
  stage: test
  image: cypress/included:5.6.0
  services:
    - name: ${CI_REGISTRY_IMAGE}/server:0.1
  before_script:
    # install missing dependencies
    - npm install -g sirv-cli
    - npm install cypress-localstorage-commands
     # making sure the process is orphan
    - sirv dist --port 3000 > /dev/null 2>&1 &
  script:
    - cypress run -e CYPRESS_baseUrl=http://localhost:3000
  tags:
    - test

## VALIDATION ##

test1:
  stage: integration
  environment:
    name: test1
    url: https://test1.startinblox.com
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_TEST1" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* test1@astral.startinblox.com:~/front/
  only:
    - /^feature\/.*/
  when: manual
  tags:
    - deploy

test2:
  stage: integration
  environment:
    name: test2
    url: https://test2.startinblox.com
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_TEST2" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* test2@astral.startinblox.com:~/front/
  only:
    - /^feature\/.*/
  when: manual
  tags:
    - deploy

test3:
  stage: integration
  environment:
    name: test3
    url: https://test3.startinblox.com
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_TEST3" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - sed -i -E 's/component-chat@([0-9]+).([0-9]+)/component-chat@beta/g' src/dependencies.pug
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* test3@astral.startinblox.com:~/front/
  only:
    - /^feature\/.*/
  when: manual
  tags:
    - deploy

stg1:
  stage: acceptance
  environment:
    name: stg1
    url: https://stg1.startinblox.com
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_STG1" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* stg1@astral.startinblox.com:~/front/
  only:
    - /^release\/.*/
  when: manual
  tags:
    - deploy

stg2:
  stage: acceptance
  environment:
    name: stg2
    url: https://stg2.startinblox.com
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_STG2" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* stg2@astral.startinblox.com:~/front/
  only:
    - /^release\/.*/
  when: manual
  tags:
    - deploy

## RELEASE TAGGING ##

publish:
  stage: release
  script:
    - npm install -g semantic-release@v17 @semantic-release/gitlab
    - semantic-release
  only:
    - master
  tags:
    - deploy

## LIVE DEPLOYMENTS ##

community:
  stage: deployment
  environment:
    name: community
    url: https://community.startinblox.com
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_COMMUNITY" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* community@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

nantes:
  stage: deployment
  environment:
    name: nantes
    url: https://app.nantes.happy-dev.fr
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_NANTESHD" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* nantes@ssh-nantes.happy-dev.fr:~/sib/www/
  only:
    - master
  when: manual
  tags:
    - deploy

paris:
  stage: deployment
  environment:
    name: paris
    url: https://app.paris.happy-dev.fr
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_PARIS" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* paris@ssh-paris.happy-dev.fr:~/sib/www/
  only:
    - master
  when: manual
  tags:
    - deploy

smarttoulouse:
  stage: deployment
  environment:
    name: smarttoulouse
    url: https://smart-toulouse.happy-dev.fr
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_SMARTTOULOUSE" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* smart-toulouse@ssh-smart-toulouse.happy-dev.fr:~/www/
  only:
    - master
  when: manual
  tags:
    - deploy

volumes:
  stage: deployment
  environment:
    name: volumes
    url: https://volumes.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_VOLUMES" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* volumes-sib@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

communityhubl:
  stage: deployment
  environment:
    name: communityhubl
    url: https://community.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_HUBL_COMMUNITY" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* community-hubl@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

playground:
  stage: deployment
  environment:
    name: playground
    url: https://playground.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_PLAYGROUND" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* playground@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

casaco:
  stage: deployment
  environment:
    name: casaco
    url: https://casaco.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_CASACO" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* casaco@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

opteos:
  stage: deployment
  environment:
    name: opteos
    url: https://opteos.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_OPTEOS" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* opteos@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

fnk:
  stage: deployment
  environment:
    name: fnk
    url: https://fnk.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_FNK" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* fnk@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

labriqueterie:
  stage: deployment
  environment:
    name: labriqueterie
    url: https://labriqueterie.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_LABRIQUETERIE" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* labriqueterie@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

facttic:
  stage: deployment
  environment:
    name: facttic
    url: https://facttic.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_FACTTIC" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* facttic@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

cotech:
  stage: deployment
  environment:
    name: cotech
    url: https://hubl.coops.tech
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_COTECH" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* cotech@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

lelaptop:
  stage: deployment
  environment:
    name: lelaptop
    url: https://lelaptop.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_LELAPTOP" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* lelaptop@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

virtualassembly:
  stage: deployment
  environment:
    name: virtualassembly
    url: https://virtual-assembly.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_VIRTUAL_ASS" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* virtual-assembly@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

ouisharequebec:
  stage: deployment
  environment:
    name: ouisharequebec
    url: https://ouishare-quebec.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_OUISHARE" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* ouishare-quebec@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

nouvelleaquitaine:
  stage: deployment
  environment:
    name: nouvelleaquitaine
    url: https://app.nouvelle-aquitaine.happy-dev.fr
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_NVLE_AQ" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* nouvelle-aquitaine@ssh-nouvelle-aquitaine.happy-dev.fr:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

paca:
  stage: deployment
  environment:
    name: paca
    url: https://app.paca.happy-dev.fr
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_PACA" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* paca@ssh-paca.happy-dev.fr:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

strasbourg:
  stage: deployment
  environment:
    name: strasbourg
    url: https://app.strasbourg.happy-dev.fr
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_STRASBOURG" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* strasbourg@ssh-strasbourg.happy-dev.fr:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

bretagne:
  stage: deployment
  environment:
    name: bretagne
    url: https://app.bretagne.happy-dev.fr
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_BRETAGNE" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* bretagne@ssh-bretagne.happy-dev.fr:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

lemans:
  stage: deployment
  environment:
    name: lemans
    url: https://app.lemans.happy-dev.fr
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_LEMANS" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* lemans@ssh-lemans.happy-dev.fr:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

apidays:
  stage: deployment
  environment:
    name: apidays
    url: https://apidays.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_APIDAYS" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* apidays@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

toulouse:
  stage: deployment
  environment:
    name: toulouse
    url: https://app.toulouse.happy-dev.fr
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_TOULOUSE" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* toulouse@ssh-toulouse.happy-dev.fr:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

lepool:
  stage: deployment
  environment:
    name: lepool
    url: https://lepool.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_LEPOOL" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* lepool@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

cpe:
  stage: deployment
  environment:
    name: cpe
    url: https://cpe.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_CPE" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* cpe@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

lescanumeriques:
  stage: deployment
  environment:
    name: lescanumeriques
    url: https://fichemetier.fr.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_LESCANUMERIQUES" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* lescanumeriques@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

phares:
  stage: deployment
  environment:
    name: phares
    url: https://le.phares.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_LE_PHARES" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* phares@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

esspace:
  stage: deployment
  environment:
    name: esspace
    url: https://ess.pace.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_ESSPACE" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* esspace@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

grandecoco:
  stage: deployment
  environment:
    name: grandecoco
    url: https://la.grande.coco.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_COCO" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* grande-coco@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

espaceimaginaire:
  stage: deployment
  environment:
    name: espaceimaginaire
    url: https://espace-imaginaire.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_ESPACEIMAGINAIRE" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* espace-imaginaire@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

hallesciviques:
  stage: deployment
  environment:
    name: hallesciviques
    url: https://les.halles.civiques.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_HALLES" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* halles-civiques@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

ctc:
  stage: deployment
  environment:
    name: ctc
    url: https://collectif.tansition.citoyenne.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_CTC" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* collectif-tansition-citoyenne@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

studiossinguliers:
  stage: deployment
  environment:
    name: studiossinguliers
    url: https://studios-singuliers.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_SINGULIER" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* studios-singuliers@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

apluscestmieux:
  stage: deployment
  environment:
    name: apluscestmieux
    url: https://apluscestmieux.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_APLUS" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* apluscestmieux@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

projetlerepaire:
  stage: deployment
  environment:
    name: projetlerepaire
    url: https://projet.le.repaire.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_LEREPAIRE" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* projetlerepaire@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

oxamyne:
  stage: deployment
  environment:
    name: oxamyne
    url: https://oxamyne.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_OXAMYNE" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* oxamyne@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

laruchesaintgermain:
  stage: deployment
  environment:
    name: laruchesaintgermain
    url: https://la.ruche.saint-germain.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_LARUCHE" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* laruche-saint-germain@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

artefacts:
  stage: deployment
  environment:
    name: artefacts
    url: https://artefacts.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_ARTEFACTS" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* artefacts@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

lab01:
  stage: deployment
  environment:
    name: lab01
    url: https://le.lab01.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_LAB01" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* le-lab01@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

makesense:
  stage: deployment
  environment:
    name: makesense
    url: https://makesense.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_MAKESENSE" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* makesense@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

moulindepontru:
  stage: deployment
  environment:
    name: moulindepontru
    url: https://moulin.de.pont-ru.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_MOULINPONTRU" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* moulin-de-pont-ru@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

latreso:
  stage: deployment
  environment:
    name: latreso
    url: https://la.treso.hubl.world
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_LATRESO" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* la-treso@astral.startinblox.com:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy

montpellier:
  stage: deployment
  environment:
    name: montpellier
    url: https://app.montpellier.happy-dev.fr
  before_script:
    - npm ci --cache .npm --prefer-offline --only=production
  script:
    - echo "$APP_CONFIG_MONTPELLIER" > config.json
    - echo "$SSH_DEPLOY_KEY" | tr -d '\r' > gitlab.key && chmod 600 gitlab.key
    - npm run build
    - scp -i gitlab.key -o StrictHostKeyChecking=no -r dist/* montpellier@ssh-montpellier.happy-dev.fr:~/front/
  only:
    - master
  when: manual
  tags:
    - deploy