deploy.yml

# DSpace Docker deploy on dataquest servers
name: Deploy DSpace

on:
  workflow_call:
    inputs:
      DEV_MACHINE:
        required: false
        type: string
        default: 'dev-6'
      INSTANCE:
        required: false
        type: string
        default: '8563'
      IMPORT:
        required: false
        default: true
        type: boolean
      ERASE_DB:
        required: false
        default: false
        type: boolean

  workflow_dispatch:
    inputs:
      INSTANCE:
        required: true
        default: '8563'
        type: choice
        options:
          - '8563'
      IMPORT:
        required: true
        default: true
        type: boolean
      ERASE_DB:
        required: false
        default: false
        type: boolean
      DEV_MACHINE:
        required: false
        type: string
        default: 'dev-6'

jobs:
  deploy-3:
    if: inputs.INSTANCE == '*' || inputs.INSTANCE == '8563'
    runs-on: dspace-${{inputs.DEV_MACHINE}}-dep-1
    timeout-minutes: 60
    env:
      INSTANCE: '8563'
      CONFIG_PATH: /opt/dspace-envs/${{inputs.INSTANCE}}
      ENVFILE: /opt/dspace-envs/${{inputs.INSTANCE}}/.env
    steps:
      - uses: actions/checkout@v4

      - uses: ./.github/actions/erase-db
        if: inputs.ERASE_DB
        with:
          INSTANCE: ${{ env.INSTANCE }}
          NAME: dspace-${{ env.INSTANCE }}

      - name: deploy to ${{inputs.DEV_MACHINE}}
        working-directory: build-scripts/run/
        run: |
          ./start.sh dspace-$INSTANCE
          cd ../..
          # use customized docker-compose file for the `85` port because the server is exposed with the namespace `repository`
          # `/repository/server`
          docker compose --env-file $ENVFILE -p dspace-$INSTANCE -f docker/docker-compose.yml -f docker/docker-compose-rest.yml -f $CONFIG_PATH/docker-compose-rest.yml -f $CONFIG_PATH/docker-compose.yml up -d --no-build --remove-orphans

  playwright-after-deploy3:
    needs: deploy-3
    if: '!inputs.IMPORT'
    uses: ./.github/workflows/playwright-tests.yml
    secrets: inherit

  playwright-after-import3:
    needs: import-3
    if: inputs.IMPORT
    uses: ./.github/workflows/playwright-tests.yml
    secrets: inherit

  import-3:
    runs-on: dspace-${{inputs.DEV_MACHINE}}-dep-1
    if: inputs.IMPORT
    timeout-minutes: 900
    needs: deploy-3
    env:
      INSTANCE: ${{inputs.INSTANCE}}
      CONFIG_PATH: /opt/dspace-envs/
    steps:
      - name: vanilla import
        env:
          FNAME: old_dump.sql
        run: |
          export DATADIR=$CONFIG_PATH/${{inputs.INSTANCE}}/dump/$FNAME
          export DNAME=dspace${{inputs.INSTANCE}}
          export DDBNAME=dspacedb${{inputs.INSTANCE}}

          docker stop $DNAME || true

          echo "====="
          # echo Starting vanilla import DB
          docker cp $DATADIR $DDBNAME:/tmp/

          # Create dspace5 user as subgroup of dspace and prepare database
          docker exec $DDBNAME /bin/bash -c "
          dropdb -U dspace -p 10563 dspace || true &&
          createdb -U dspace -p 10563 --owner=dspace --encoding=UNICODE dspace &&
          psql -p 10563 -U dspace -d dspace -c \"
            DO \\\$\\\$
            BEGIN
              -- Create dspace5 role if it doesn't exist
              IF NOT EXISTS (SELECT FROM pg_catalog.pg_roles WHERE rolname = 'dspace5') THEN
                CREATE ROLE dspace5;
                GRANT dspace5 TO dspace;
                ALTER ROLE dspace5 LOGIN;
                ALTER ROLE dspace5 INHERIT;
              END IF;

              -- Create postgres role if it doesn't exist
              IF NOT EXISTS (SELECT FROM pg_catalog.pg_roles WHERE rolname = 'postgres') THEN
                CREATE ROLE postgres;
                GRANT postgres TO dspace;
                ALTER ROLE postgres LOGIN;
                ALTER ROLE postgres INHERIT;
                ALTER ROLE postgres SUPERUSER;
                ALTER ROLE postgres CREATEDB;
                ALTER ROLE postgres CREATEROLE;
              END IF;
            END
            \\\$\\\$;

            -- Create pgcrypto extension if it doesn't exist (required by DSpace)
            CREATE EXTENSION IF NOT EXISTS pgcrypto;
          \" &&
          psql -p 10563 -U dspace -d dspace -f /tmp/$FNAME &&
          rm /tmp/$FNAME
          "
          echo "====="
          docker start $DNAME

      - uses: actions/checkout@v4

      - name: cleanup database duplicates
        run: |
          export DNAME=dspace${{inputs.INSTANCE}}

          echo "Stopping DSpace container before database cleanup..."
          docker stop $DNAME || true

          echo "Waiting for connections to close..."
          sleep 5

          echo "Cleaning up duplicate entries after data import..."
          chmod +x ./build-scripts/run/cleanup-db-duplicates.sh
          ./build-scripts/run/cleanup-db-duplicates.sh ${{inputs.INSTANCE}}

          echo "Waiting for connections and locks to fully terminate..."
          sleep 15

      - name: run database migration
        run: |
          export DNAME=dspace${{inputs.INSTANCE}}
          export DDBNAME=dspacedb${{inputs.INSTANCE}}

          echo "Starting DSpace container for migration..."
          docker start $DNAME

          echo "Waiting longer for DSpace to be fully ready and locks to clear..."
          sleep 20

          echo "Terminating any remaining database connections..."
          docker exec $DDBNAME /bin/bash -c "psql -p 10563 -U dspace -d postgres -c \"
          SELECT pg_terminate_backend(pid) FROM pg_locks WHERE locktype = 'advisory';
          \""

          echo "Synchronizing database sequences before migration..."
          docker exec $DDBNAME /bin/bash -c "psql -p 10563 -U dspace -d dspace -c \"
          DO \\\$\\\$
          BEGIN
              -- Fix alert_id_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'alert_id_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'systemwidealert') THEN
                  PERFORM setval('alert_id_seq', COALESCE((SELECT max(alert_id) FROM systemwidealert), 1));
              END IF;

              -- Fix bitstreamformatregistry_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'bitstreamformatregistry_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'bitstreamformatregistry') THEN
                  PERFORM setval('bitstreamformatregistry_seq', COALESCE((SELECT max(bitstream_format_id) FROM bitstreamformatregistry), 1));
              END IF;

              -- Fix checksum_history_check_id_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'checksum_history_check_id_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'checksum_history') THEN
                  PERFORM setval('checksum_history_check_id_seq', COALESCE((SELECT max(check_id) FROM checksum_history), 1));
              END IF;

              -- Fix cwf_claimtask_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'cwf_claimtask_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'cwf_claimtask') THEN
                  PERFORM setval('cwf_claimtask_seq', COALESCE((SELECT max(claimtask_id) FROM cwf_claimtask), 1));
              END IF;

              -- Fix cwf_collectionrole_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'cwf_collectionrole_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'cwf_collectionrole') THEN
                  PERFORM setval('cwf_collectionrole_seq', COALESCE((SELECT max(collectionrole_id) FROM cwf_collectionrole), 1));
              END IF;

              -- Fix cwf_in_progress_user_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'cwf_in_progress_user_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'cwf_in_progress_user') THEN
                  PERFORM setval('cwf_in_progress_user_seq', COALESCE((SELECT max(in_progress_user_id) FROM cwf_in_progress_user), 1));
              END IF;

              -- Fix cwf_pooltask_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'cwf_pooltask_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'cwf_pooltask') THEN
                  PERFORM setval('cwf_pooltask_seq', COALESCE((SELECT max(pooltask_id) FROM cwf_pooltask), 1));
              END IF;

              -- Fix cwf_workflowitem_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'cwf_workflowitem_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'cwf_workflowitem') THEN
                  PERFORM setval('cwf_workflowitem_seq', COALESCE((SELECT max(workflowitem_id) FROM cwf_workflowitem), 1));
              END IF;

              -- Fix cwf_workflowitemrole_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'cwf_workflowitemrole_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'cwf_workflowitemrole') THEN
                  PERFORM setval('cwf_workflowitemrole_seq', COALESCE((SELECT max(workflowitemrole_id) FROM cwf_workflowitemrole), 1));
              END IF;

              -- Fix doi_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'doi_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'doi') THEN
                  PERFORM setval('doi_seq', COALESCE((SELECT max(doi_id) FROM doi), 1));
              END IF;

              -- Fix entity_type_id_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'entity_type_id_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'entity_type') THEN
                  PERFORM setval('entity_type_id_seq', COALESCE((SELECT max(id) FROM entity_type), 1));
              END IF;

              -- Fix fileextension_seq if both sequence and table exist (this is the one causing the original error)
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'fileextension_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'fileextension') THEN
                  PERFORM setval('fileextension_seq', COALESCE((SELECT max(file_extension_id) FROM fileextension), 1));
              END IF;

              -- Fix handle_id_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'handle_id_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'handle') THEN
                  PERFORM setval('handle_id_seq', COALESCE((SELECT max(handle_id) FROM handle), 1));
              END IF;

              -- Fix harvested_collection_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'harvested_collection_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'harvested_collection') THEN
                  PERFORM setval('harvested_collection_seq', COALESCE((SELECT max(id) FROM harvested_collection), 1));
              END IF;

              -- Fix harvested_item_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'harvested_item_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'harvested_item') THEN
                  PERFORM setval('harvested_item_seq', COALESCE((SELECT max(id) FROM harvested_item), 1));
              END IF;

              -- Fix metadatafieldregistry_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'metadatafieldregistry_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'metadatafieldregistry') THEN
                  PERFORM setval('metadatafieldregistry_seq', COALESCE((SELECT max(metadata_field_id) FROM metadatafieldregistry), 1));
              END IF;

              -- Fix metadataschemaregistry_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'metadataschemaregistry_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'metadataschemaregistry') THEN
                  PERFORM setval('metadataschemaregistry_seq', COALESCE((SELECT max(metadata_schema_id) FROM metadataschemaregistry), 1));
              END IF;

              -- Fix metadatavalue_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'metadatavalue_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'metadatavalue') THEN
                  PERFORM setval('metadatavalue_seq', COALESCE((SELECT max(metadata_value_id) FROM metadatavalue), 1));
              END IF;

              -- Fix openurltracker_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'openurltracker_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'openurltracker') THEN
                  PERFORM setval('openurltracker_seq', COALESCE((SELECT max(tracker_id) FROM openurltracker), 1));
              END IF;

              -- Fix orcid_history_id_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'orcid_history_id_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'orcid_history') THEN
                  PERFORM setval('orcid_history_id_seq', COALESCE((SELECT max(id) FROM orcid_history), 1));
              END IF;

              -- Fix orcid_queue_id_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'orcid_queue_id_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'orcid_queue') THEN
                  PERFORM setval('orcid_queue_id_seq', COALESCE((SELECT max(id) FROM orcid_queue), 1));
              END IF;

              -- Fix orcid_token_id_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'orcid_token_id_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'orcid_token') THEN
                  PERFORM setval('orcid_token_id_seq', COALESCE((SELECT max(id) FROM orcid_token), 1));
              END IF;

              -- Fix process_id_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'process_id_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'process') THEN
                  PERFORM setval('process_id_seq', COALESCE((SELECT max(process_id) FROM process), 1));
              END IF;

              -- Fix registrationdata_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'registrationdata_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'registrationdata') THEN
                  PERFORM setval('registrationdata_seq', COALESCE((SELECT max(registrationdata_id) FROM registrationdata), 1));
              END IF;

              -- Fix relationship_id_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'relationship_id_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'relationship') THEN
                  PERFORM setval('relationship_id_seq', COALESCE((SELECT max(id) FROM relationship), 1));
              END IF;

              -- Fix relationship_type_id_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'relationship_type_id_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'relationship_type') THEN
                  PERFORM setval('relationship_type_id_seq', COALESCE((SELECT max(id) FROM relationship_type), 1));
              END IF;

              -- Fix requestitem_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'requestitem_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'requestitem') THEN
                  PERFORM setval('requestitem_seq', COALESCE((SELECT max(requestitem_id) FROM requestitem), 1));
              END IF;

              -- Fix resourcepolicy_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'resourcepolicy_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'resourcepolicy') THEN
                  PERFORM setval('resourcepolicy_seq', COALESCE((SELECT max(policy_id) FROM resourcepolicy), 1));
              END IF;

              -- Fix subscription_parameter_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'subscription_parameter_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'subscription_parameter') THEN
                  PERFORM setval('subscription_parameter_seq', COALESCE((SELECT max(subscription_id) FROM subscription_parameter), 1));
              END IF;

              -- Fix subscription_seq if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'subscription_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'subscription') THEN
                  PERFORM setval('subscription_seq', COALESCE((SELECT max(subscription_id) FROM subscription), 1));
              END IF;

              -- Fix supervision_orders sequence if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'supervision_orders_id_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'supervision_orders') THEN
                  PERFORM setval('supervision_orders_id_seq', COALESCE((SELECT max(id) FROM supervision_orders), 1));
              END IF;

              -- Fix versionhistory sequence if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'versionhistory_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'versionhistory') THEN
                  PERFORM setval('versionhistory_seq', COALESCE((SELECT max(versionhistory_id) FROM versionhistory), 1));
              END IF;

              -- Fix versionitem sequence if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'versionitem_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'versionitem') THEN
                  PERFORM setval('versionitem_seq', COALESCE((SELECT max(versionitem_id) FROM versionitem), 1));
              END IF;

              -- Fix workspaceitem sequence if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'workspaceitem_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'workspaceitem') THEN
                  PERFORM setval('workspaceitem_seq', COALESCE((SELECT max(workspace_item_id) FROM workspaceitem), 1));
              END IF;

              -- Fix most_recent_checksum sequence if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'most_recent_checksum_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'most_recent_checksum') THEN
                  PERFORM setval('most_recent_checksum_seq', COALESCE((SELECT max(result_id) FROM most_recent_checksum), 1));
              END IF;

              -- Fix checksum_history sequence if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'checksum_history_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'checksum_history') THEN
                  PERFORM setval('checksum_history_seq', COALESCE((SELECT max(result_id) FROM checksum_history), 1));
              END IF;

              -- Fix preview sequences if both sequence and table exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'preview_content_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'preview_content') THEN
                  PERFORM setval('preview_content_seq', COALESCE((SELECT max(preview_content_id) FROM preview_content), 1));
              END IF;

              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'preview_content_bitstream_seq') AND
                 EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'preview_content_bitstream') THEN
                  PERFORM setval('preview_content_bitstream_seq', COALESCE((SELECT max(preview_content_bitstream_id) FROM preview_content_bitstream), 1));
              END IF;
          END \\\$\\\$;
          \""

          echo "Running conditional sequence updates..."
          docker exec $DDBNAME /bin/bash -c "psql -p 10563 -U dspace -d dspace -c \"
          DO \\\$\\\$
          BEGIN
              -- Fix supervision_orders sequence if it exists
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'supervision_orders_id_seq') THEN
                  PERFORM setval('supervision_orders_id_seq', COALESCE((SELECT max(id) FROM supervision_orders), 1));
              END IF;

              -- Fix versionhistory sequence if it exists
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'versionhistory_seq') THEN
                  PERFORM setval('versionhistory_seq', COALESCE((SELECT max(versionhistory_id) FROM versionhistory), 1));
              END IF;

              -- Fix versionitem sequence if it exists
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'versionitem_seq') THEN
                  PERFORM setval('versionitem_seq', COALESCE((SELECT max(versionitem_id) FROM versionitem), 1));
              END IF;

              -- Fix workspaceitem sequence if it exists
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'workspaceitem_seq') THEN
                  PERFORM setval('workspaceitem_seq', COALESCE((SELECT max(workspace_item_id) FROM workspaceitem), 1));
              END IF;

              -- Fix most_recent_checksum sequence if it exists
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'most_recent_checksum_seq') THEN
                  PERFORM setval('most_recent_checksum_seq', COALESCE((SELECT max(result_id) FROM most_recent_checksum), 1));
              END IF;

              -- Fix checksum_history sequence if it exists
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'checksum_history_seq') THEN
                  PERFORM setval('checksum_history_seq', COALESCE((SELECT max(result_id) FROM checksum_history), 1));
              END IF;

              -- Fix preview sequences if they exist
              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'preview_content_seq') THEN
                  PERFORM setval('preview_content_seq', COALESCE((SELECT max(preview_content_id) FROM preview_content), 1));
              END IF;

              IF EXISTS (SELECT 1 FROM information_schema.sequences WHERE sequence_name = 'preview_content_bitstream_seq') THEN
                  PERFORM setval('preview_content_bitstream_seq', COALESCE((SELECT max(preview_content_bitstream_id) FROM preview_content_bitstream), 1));
              END IF;
          END \\\$\\\$;
          \""

          echo "Running DSpace database migration..."
          docker exec $DNAME /bin/bash -c "cd /dspace/bin && ./dspace database migrate ignored"

          echo "Waiting for DSpace to be ready..."
          sleep 10


      - name: create administrator
        run: |
          export DNAME=dspace${{inputs.INSTANCE}}
          echo "Creating DSpace administrator..."
          docker exec $DNAME /bin/bash -c "cd /dspace/bin && ./dspace create-administrator -e dspace.admin.dev@dataquest.sk -f admin -l user -p admin -c en -o dataquest"

      - name: rebuild discovery index and run oai import
        run: |
          export DNAME=dspace${{inputs.INSTANCE}}
          echo "Rebuilding discovery index..."
          docker exec $DNAME /bin/bash -c "cd /dspace/bin && ./dspace index-discovery -b"
          
          echo "Running OAI import..."
          docker exec $DNAME /bin/bash -c "cd /dspace/bin && ./dspace oai import -c"

      - name: restart dspace container
        run: |
          export DNAME=dspace${{inputs.INSTANCE}}
          echo "Restarting DSpace container..."
          docker restart $DNAME
          sleep 60