OpenIntegrations/.github/workflows/cli_test.yml

name: CLI | Сборка и тестирование

on:
  workflow_dispatch:

jobs:
  Decode:
    runs-on: ubuntu-latest
    steps:

      - uses: actions/checkout@v4 

      - name: Расшифровать тестовые данные
        run: gpg --quiet --batch --yes --decrypt --passphrase="$ENC_JSON" --output ./data.json ./data.json.gpg        
        env:
          ENC_JSON: ${{ secrets.ENC_JSON }}

      - name: Кэшировать данные
        uses: actions/cache/save@v3
        with:
          path: ./data.json
          key: test-data

  Build:
    runs-on: ubuntu-latest
    permissions:
      contents: write
    steps:
      - uses: actions/checkout@v4             
      - uses: otymko/setup-onescript@v1.4
        with:
          version: 1.9.0

      - name: Установить cmdline, asserts и osparser
        run: |
          opm install cmdline
          opm install asserts
          opm install osparser
          opm install coloratos
      - name: Сформировать список методов ОПИ -> CLI
        run: oscript ./.github/workflows/os/cli_parse.os

      - name: Записать измененный список методов CLI
        uses: stefanzweifel/git-auto-commit-action@v5   
        with:
          commit_user_name: Vitaly the Alpaca (bot) 
          commit_user_email: vitaly.the.alpaca@gmail.com
          commit_author: Vitaly the Alpaca <vitaly.the.alpaca@gmail.com>
          commit_message: Обновление зашифрованных данных по результатам тестов (workflow)

      - name: Собрать и установить OInt
        run: |
          cd ./src/ru/OInt
          opm build
          opm install *.ospx  

      - name: Собрать бинарник
        run: |
          cd ./src/ru/cli
          oscript -make core/Classes/Приложение.os oint

      - name: Собрать exe
        run: |
          cd ./src/ru/cli
          oscript -make core/Classes/Приложение.os oint.exe

      - name: Записать артефакт
        uses: actions/upload-artifact@v4
        with:
          name: oint
          path: ./src/ru/cli/oint

      - name: Создать каталог deb-пакета
        run: |
          mkdir -p .debpkg/usr/bin
          cp ./src/ru/cli/oint .debpkg/usr/bin/oint
          chmod +x .debpkg/usr/bin/oint

      - name: Собрать deb-пакет
        uses: jiro4989/build-deb-action@v3
        with:
          package: oint
          package_root: .debpkg
          maintainer: Anton Titovets <bayselonarrend@gmail.com>
          version: '1.10.0' # refs/tags/v*.*.*
          arch: 'all'
          depends: 'mono-runtime, libmono-system-core4.0-cil | libmono-system-core4.5-cil, libmono-system4.0-cil | libmono-system4.5-cil, libmono-corlib4.0-cil | libmono-corlib4.5-cil, libmono-i18n4.0-all | libmono-i18n4.5-all'
          desc: 'OInt CLI - приложение для работы с API различных онлайн-сервисов из командной строки'

      - uses: actions/upload-artifact@v3
        with:
          name: oint-deb
          path: |
            ./*.deb

      - name: Создать каталог rpm-пакета
        run: |
          mkdir -p .rpmpkg/usr/bin
          mkdir -p .rpmpkg/usr/share/oint/bin
          cp ./src/ru/cli/oint .rpmpkg/usr/share/oint/bin/oint
          echo 'mono /usr/share/oint/bin/oint "$@"' > .rpmpkg/usr/bin/oint
          chmod +x .rpmpkg/usr/bin/oint

      - name: Собрать rpm-пакет 
        uses: jiro4989/build-rpm-action@v2
        with:
          summary: 'OInt CLI - приложение для работы с API различных онлайн-сервисов из командной строки. Требуется mono-runtime с поддержкой .NET Framework 4.8'
          package: oint
          package_root: .rpmpkg
          maintainer: Anton Titovets <bayselonarrend@gmail.com>
          version: '1.10.0'
          arch: 'x86_64'
          desc: 'OInt CLI - приложение для работы с API различных онлайн-сервисов из командной строки'
          requires: |
            mono-core
            Requires:       mono-locale-extras

      - uses: actions/upload-artifact@v4
        with:
          name: oint-rpm
          path: |
            ./*.rpm
            !./*-debuginfo-*.rpm

  Testing-telegram:
    runs-on: ubuntu-latest
    needs: [Decode, Build]
    steps:

      - name: Получить тестовые данные из кэша
        uses: actions/cache/restore@v3
        with:
          path: ./data.json
          key: test-data

      - name: Скачать артефакт с исполняемым файлом
        uses: actions/download-artifact@v4
        with:
          name: oint 

      - name: JSON в переменные
        uses: rgarcia-phi/json-to-variables@v1.1.0
        with:
          filename: 'data.json'
          masked: true

      - name: chmod для OInt
        run: chmod +x ./oint




      - name: Выполнить ПолучитьИнформациюБота
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ПолучитьИнформациюБота --debug --test \
          --token "${{ env.json_Telegram_Token }}" \



      - name: Выполнить ПолучитьОбновления
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ПолучитьОбновления --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --timeout "" \
          --offset "" \



      - name: Выполнить УстановитьWebhook
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram УстановитьWebhook --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --url "${{ env.json_Telegram_URL }}" \



      - name: Выполнить УдалитьWebhook
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram УдалитьWebhook --debug --test \
          --token "${{ env.json_Telegram_Token }}" \



      - name: Выполнить СкачатьФайл
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram СкачатьФайл --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --fileid "" \



      - name: Выполнить ОтправитьТекстовоеСообщение
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ОтправитьТекстовоеСообщение --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --chat "${{ env.json_Telegram_ChannelID }}" \
          --text "Тестовый текст" \
          --keyboard "" \
          --parsemode "" \



      - name: Выполнить ОтправитьКартинку
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ОтправитьКартинку --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --chat "${{ env.json_Telegram_ChannelID }}" \
          --text "Тестовый текст" \
          --picture "${{ env.json_Picture }}" \
          --keyboard "" \
          --parsemode "" \



      - name: Выполнить ОтправитьВидео
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ОтправитьВидео --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --chat "${{ env.json_Telegram_ChannelID }}" \
          --text "Тестовый текст" \
          --video "${{ env.json_Video }}" \
          --keyboard "" \
          --parsemode "" \



      - name: Выполнить ОтправитьАудио
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ОтправитьАудио --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --chat "${{ env.json_Telegram_ChannelID }}" \
          --text "Тестовый текст" \
          --audio "${{ env.json_Audio }}" \
          --keyboard "" \
          --parsemode "" \



      - name: Выполнить ОтправитьДокумент
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ОтправитьДокумент --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --chat "${{ env.json_Telegram_ChannelID }}" \
          --text "Тестовый текст" \
          --doc "${{ env.json_Document }}" \
          --keyboard "" \
          --parsemode "" \



      - name: Выполнить ОтправитьГифку
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ОтправитьГифку --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --chat "${{ env.json_Telegram_ChannelID }}" \
          --text "Тестовый текст" \
          --gif "${{ env.json_GIF }}" \
          --keyboard "" \
          --parsemode "" \



      - name: Выполнить ОтправитьМедиагруппу
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"${{ env.json_Picture }}\" : \"photo\",
            \"${{ env.json_Picture2 }}\" : \"photo\"
          } " > mediagroup.json


          ./oint telegram ОтправитьМедиагруппу --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --chat "${{ env.json_Telegram_ChannelID }}" \
          --text "Тестовый текст" \
          --media "mediagroup.json" \
          --keyboard "" \
          --parsemode "" \



      - name: Выполнить ОтправитьМестоположение
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ОтправитьМестоположение --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --chat "${{ env.json_Telegram_ChannelID }}" \
          --lat "48.87373649724122" \
          --long "48.87373649724122" \
          --keyboard "" \



      - name: Выполнить ОтправитьКонтакт
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ОтправитьКонтакт --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --chat "${{ env.json_Telegram_ChannelID }}" \
          --name "Петр" \
          --surname "Петров" \
          --phone "+123456789" \
          --keyboard "" \



      - name: Выполнить ОтправитьОпрос
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ОтправитьОпрос --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --chat "${{ env.json_Telegram_ChannelID }}" \
          --question "Да или нет?" \
          --options "['Да', 'Нет', 'Затрудняюсь ответить']" \
          --anonymous true \



      - name: Выполнить ПереслатьСообщение
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ПереслатьСообщение --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --message "${{ env.json_Telegram_ChannelMessageID }}" \
          --from "${{ env.json_Telegram_ChannelID }}" \
          --to "${{ env.json_Telegram_ChatID }}" \



      - name: Выполнить СформироватьКлавиатуруПоМассивуКнопок
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram СформироватьКлавиатуруПоМассивуКнопок --debug --test \
          --buttons "['Кнопка1','Кнопка2','Кнопка3']" \
          --under true \
          --column false \



      - name: Выполнить Бан
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram Бан --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --chat "${{ env.json_Telegram_ChannelID }}" \
          --user "${{ env.json_Telegram_ChatID }}" \



      - name: Выполнить Разбан
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram Разбан --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --chat "${{ env.json_Telegram_ChannelID }}" \
          --user "${{ env.json_Telegram_ChatID }}" \



      - name: Выполнить СоздатьСсылкуПриглашение
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram СоздатьСсылкуПриглашение --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --chat "${{ env.json_Telegram_ChannelID }}" \
          --title "Тест" \
          --expire "1" \
          --limit "1" \



      - name: Выполнить ЗакрепитьСообщение
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ЗакрепитьСообщение --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --chat "${{ env.json_Telegram_ChannelID }}" \
          --message "${{ env.json_Telegram_ChannelMessageID }}" \



      - name: Выполнить ОткрепитьСообщение
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ОткрепитьСообщение --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --chat "${{ env.json_Telegram_ChannelID }}" \
          --message "${{ env.json_Telegram_ChannelMessageID }}" \



      - name: Выполнить ПолучитьЧислоУчастников
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ПолучитьЧислоУчастников --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --chat "${{ env.json_Telegram_ChannelID }}" \



      - name: Выполнить ПолучитьСписокИконокАватаров
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ПолучитьСписокИконокАватаров --debug --test \
          --token "${{ env.json_Telegram_Token }}" \



      - name: Выполнить СоздатьТемуФорума
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram СоздатьТемуФорума --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --forum "${{ env.json_Telegram_ForumID }}" \
          --title "Тест" \
          --icon "5350444672789519765 " \



      - name: Выполнить ИзменитьТемуФорума
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ИзменитьТемуФорума --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --forum "${{ env.json_Telegram_ForumID }}" \
          --topic "${{ env.json_Telegram_TopicID }}" \
          --title "Тест" \
          --icon "5350444672789519765 " \



      - name: Выполнить ЗакрытьТемуФорума
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ЗакрытьТемуФорума --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --forum "${{ env.json_Telegram_ForumID }}" \
          --topic "${{ env.json_Telegram_TopicID }}" \



      - name: Выполнить ОткрытьТемуФорума
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ОткрытьТемуФорума --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --forum "${{ env.json_Telegram_ForumID }}" \
          --topic "${{ env.json_Telegram_TopicID }}" \



      - name: Выполнить УдалитьТемуФорума
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram УдалитьТемуФорума --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --forum "${{ env.json_Telegram_ForumID }}" \
          --topic "${{ env.json_Telegram_TopicID }}" \



      - name: Выполнить СкрытьГлавнуюТемуФорума
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram СкрытьГлавнуюТемуФорума --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --forum "${{ env.json_Telegram_ForumID }}" \



      - name: Выполнить ПоказатьГлавнуюТемуФорума
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ПоказатьГлавнуюТемуФорума --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --forum "${{ env.json_Telegram_ForumID }}" \



      - name: Выполнить ИзменитьИмяГлавнойТемыФорума
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ИзменитьИмяГлавнойТемыФорума --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --forum "${{ env.json_Telegram_ForumID }}" \
          --title "Тест" \



      - name: Выполнить ОчиститьСписокЗакрепленныхСообщенийТемы
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint telegram ОчиститьСписокЗакрепленныхСообщенийТемы --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --forum "${{ env.json_Telegram_ForumID }}" \
          --topic "${{ env.json_Telegram_TopicID }}" \

  Testing-vk:
    runs-on: ubuntu-latest
    needs: [Decode, Build]
    steps:

      - name: Получить тестовые данные из кэша
        uses: actions/cache/restore@v3
        with:
          path: ./data.json
          key: test-data

      - name: Скачать артефакт с исполняемым файлом
        uses: actions/download-artifact@v4
        with:
          name: oint 

      - name: JSON в переменные
        uses: rgarcia-phi/json-to-variables@v1.1.0
        with:
          filename: 'data.json'
          masked: true

      - name: chmod для OInt
        run: chmod +x ./oint




      - name: Выполнить СоздатьСсылкуПолученияТокена
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint vk СоздатьСсылкуПолученияТокена --debug --test \
          --app "${{ env.json_VK_AppID }}" \



      - name: Выполнить СоздатьПост
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk СоздатьПост --debug --test \
          --text "Тестовый текст" \
          --pictures "['${{ env.json_Picture }}', '${{ env.json_Picture2 }}']" \
          --ad false \
          --url "https://github.com/Bayselonarrend/OpenIntegrations" \
          --auth "auth.json" \



      - name: Выполнить СоздатьСоставнойПост
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk СоздатьСоставнойПост --debug --test \
          --text "Тестовый текст" \
          --objects "" \
          --ad false \
          --url "https://github.com/Bayselonarrend/OpenIntegrations" \
          --auth "auth.json" \



      - name: Выполнить УдалитьПост
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk УдалитьПост --debug --test \
          --post "1159" \
          --auth "auth.json" \



      - name: Выполнить СоздатьОпрос
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk СоздатьОпрос --debug --test \
          --question "Да или нет?" \
          --options "['Да', 'Нет', 'Затрудняюсь ответить']" \
          --picture "${{ env.json_Picture }}" \
          --auth "auth.json" \



      - name: Выполнить СоздатьАльбом
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk СоздатьАльбом --debug --test \
          --title "Тест" \
          --description "Тестовое описание" \
          --auth "auth.json" \



      - name: Выполнить УдалитьАльбом
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk УдалитьАльбом --debug --test \
          --album "303733811" \
          --auth "auth.json" \



      - name: Выполнить СоздатьИсторию
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk СоздатьИсторию --debug --test \
          --picture "${{ env.json_Picture }}" \
          --url "https://github.com/Bayselonarrend/OpenIntegrations" \
          --auth "auth.json" \



      - name: Выполнить СохранитьКартинкуВАльбом
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk СохранитьКартинкуВАльбом --debug --test \
          --album "303733811" \
          --picture "${{ env.json_Picture }}" \
          --description "Тестовое описание" \
          --auth "auth.json" \



      - name: Выполнить УдалитьКартинку
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk УдалитьКартинку --debug --test \
          --pictureid "1" \
          --auth "auth.json" \



      - name: Выполнить ЗагрузитьВидеоНаСервер
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ЗагрузитьВидеоНаСервер --debug --test \
          --file "" \
          --title "Тест" \
          --description "Тестовое описание" \
          --album "303733811" \
          --auth "auth.json" \



      - name: Выполнить ЗагрузитьФотоНаСервер
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ЗагрузитьФотоНаСервер --debug --test \
          --file "" \
          --auth "auth.json" \
          --type "" \



      - name: Выполнить СоздатьОбсуждение
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk СоздатьОбсуждение --debug --test \
          --title "Тест" \
          --text "Тестовый текст" \
          --auth "auth.json" \



      - name: Выполнить ЗакрытьОбсуждение
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ЗакрытьОбсуждение --debug --test \
          --topic "1" \
          --remove false \
          --auth "auth.json" \



      - name: Выполнить ОткрытьОбсуждение
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ОткрытьОбсуждение --debug --test \
          --topic "1" \
          --auth "auth.json" \



      - name: Выполнить НаписатьВОбсуждение
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk НаписатьВОбсуждение --debug --test \
          --topic "1" \
          --text "Тестовый текст" \
          --auth "auth.json" \



      - name: Выполнить ПоставитьЛайк
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ПоставитьЛайк --debug --test \
          --post "1159" \
          --wall "-${{ env.json_VK_GroupID }}" \
          --auth "auth.json" \



      - name: Выполнить СделатьРепост
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk СделатьРепост --debug --test \
          --post "1159" \
          --from "-${{ env.json_VK_GroupID }}" \
          --to "-${{ env.json_VK_GroupID }}" \
          --ad false \
          --auth "auth.json" \



      - name: Выполнить НаписатьСообщение
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk НаписатьСообщение --debug --test \
          --text "Тестовый текст" \
          --user "${{ env.json_VK_UserID }}" \
          --ct "${{ env.json_VK_CommunityToken }}" \
          --keyboard "" \
          --auth "auth.json" \



      - name: Выполнить НаписатьКомментарий
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk НаписатьКомментарий --debug --test \
          --post "1159" \
          --wall "-${{ env.json_VK_GroupID }}" \
          --text "Тестовый текст" \
          --auth "auth.json" \



      - name: Выполнить СократитьСсылку
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk СократитьСсылку --debug --test \
          --url "https://github.com/Bayselonarrend/OpenIntegrations" \
          --auth "auth.json" \



      - name: Выполнить ПолучитьСтатистику
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ПолучитьСтатистику --debug --test \
          --datefrom "2024-02-30T23:50:08+03:00" \
          --dateto "2024-03-30T23:50:08+03:00" \
          --auth "auth.json" \



      - name: Выполнить ПолучитьСтатистикуПостов
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ПолучитьСтатистикуПостов --debug --test \
          --posts "['1111111','2222222']" \
          --auth "auth.json" \



      - name: Выполнить СоздатьРекламнуюКампанию
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk СоздатьРекламнуюКампанию --debug --test \
          --cabinet "${{ env.json_VK_AdsCabinetID }}" \
          --title "Тест" \
          --auth "auth.json" \



      - name: Выполнить СоздатьРекламноеОбъявление
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk СоздатьРекламноеОбъявление --debug --test \
          --campaign "1" \
          --limit "1" \
          --category "1" \
          --post "1159" \
          --cabinet "${{ env.json_VK_AdsCabinetID }}" \
          --auth "auth.json" \



      - name: Выполнить ПриостановитьРекламноеОбъявление
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ПриостановитьРекламноеОбъявление --debug --test \
          --cabinet "${{ env.json_VK_AdsCabinetID }}" \
          --adv "1" \
          --auth "auth.json" \



      - name: Выполнить ПолучитьСписокРекламныхКатегорий
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ПолучитьСписокРекламныхКатегорий --debug --test \
          --auth "auth.json" \



      - name: Выполнить ПолучитьСписокКатегорийТоваров
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ПолучитьСписокКатегорийТоваров --debug --test \
          --auth "auth.json" \



      - name: Выполнить ПолучитьСписокТоваров
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ПолучитьСписокТоваров --debug --test \
          --sel "1" \
          --auth "auth.json" \



      - name: Выполнить ПолучитьТоварыПоИД
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ПолучитьТоварыПоИД --debug --test \
          --items "['1111111','2222222']" \
          --auth "auth.json" \



      - name: Выполнить ДобавитьТовар
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"Имя\"                  : \"Тест\",
            \"Описание\"             : \"Тест\",
            \"Категория\"            : \"20173\",
            \"Цена\"                 : \"1\",
            \"СтараяЦена\"           : \"2\",
            \"ДополнительныеФото\"   : [],
            \"ЗначенияСвойств\"      : [],
            \"ГлавныйВГруппе\"       : false,
            \"Ширина\"               : \"1\",
            \"Высота\"               : \"1\",
            \"Глубина\"              : \"1\",
            \"Вес\"                  : \"1\",
            \"SKU\"                  : \"12345\",
            \"ДоступныйОстаток\"     : \"1\"
          } " > product.json


          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ДобавитьТовар --debug --test \
          --product "product.json" \
          --sel "1" \
          --auth "auth.json" \



      - name: Выполнить ИзменитьТовар
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"Имя\"                  : \"Тест\",
            \"Описание\"             : \"Тест\",
            \"Категория\"            : \"20173\",
            \"Цена\"                 : \"1\",
            \"СтараяЦена\"           : \"2\",
            \"ДополнительныеФото\"   : [],
            \"ЗначенияСвойств\"      : [],
            \"ГлавныйВГруппе\"       : false,
            \"Ширина\"               : \"1\",
            \"Высота\"               : \"1\",
            \"Глубина\"              : \"1\",
            \"Вес\"                  : \"1\",
            \"SKU\"                  : \"12345\",
            \"ДоступныйОстаток\"     : \"1\"
          } " > product.json


          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ИзменитьТовар --debug --test \
          --item "1" \
          --product "product.json" \
          --sel "1" \
          --auth "auth.json" \



      - name: Выполнить УдалитьТовар
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk УдалитьТовар --debug --test \
          --item "1" \
          --auth "auth.json" \



      - name: Выполнить СгруппироватьТовары
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk СгруппироватьТовары --debug --test \
          --items "['1111111','2222222']" \
          --sellgroup "1" \
          --auth "auth.json" \



      - name: Выполнить ПолучитьСписокПодборок
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ПолучитьСписокПодборок --debug --test \
          --auth "auth.json" \



      - name: Выполнить ПолучитьПодборкиПоИД
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ПолучитьПодборкиПоИД --debug --test \
          --sels "['1111111','2222222']" \
          --auth "auth.json" \



      - name: Выполнить СоздатьПодборкуТоваров
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk СоздатьПодборкуТоваров --debug --test \
          --title "Тест" \
          --picture "${{ env.json_Picture }}" \
          --main false \
          --hidden false \
          --auth "auth.json" \



      - name: Выполнить ИзменитьПодборкуТоваров
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ИзменитьПодборкуТоваров --debug --test \
          --title "Тест" \
          --sel "1" \
          --picture "${{ env.json_Picture }}" \
          --main false \
          --hidden false \
          --auth "auth.json" \



      - name: Выполнить ДобавитьТоварВПодборку
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ДобавитьТоварВПодборку --debug --test \
          --items "['1111111','2222222']" \
          --sel "1" \
          --auth "auth.json" \



      - name: Выполнить УдалитьТоварИзПодборки
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk УдалитьТоварИзПодборки --debug --test \
          --item "1" \
          --sel "1" \
          --auth "auth.json" \



      - name: Выполнить УдалитьПодборку
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk УдалитьПодборку --debug --test \
          --sel "1" \
          --auth "auth.json" \



      - name: Выполнить ПолучитьСписокСвойств
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ПолучитьСписокСвойств --debug --test \
          --auth "auth.json" \



      - name: Выполнить СоздатьСвойствоТовара
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk СоздатьСвойствоТовара --debug --test \
          --title "Тест" \
          --auth "auth.json" \



      - name: Выполнить ИзменитьСвойствоТовара
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ИзменитьСвойствоТовара --debug --test \
          --title "Тест" \
          --prop "1" \
          --auth "auth.json" \



      - name: Выполнить УдалитьСвойствоТовара
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk УдалитьСвойствоТовара --debug --test \
          --prop "1" \
          --auth "auth.json" \



      - name: Выполнить ДобавитьВариантСвойстваТовара
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ДобавитьВариантСвойстваТовара --debug --test \
          --value "Тест" \
          --prop "1" \
          --auth "auth.json" \



      - name: Выполнить ИзменитьВариантСвойстваТовара
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ИзменитьВариантСвойстваТовара --debug --test \
          --value "Тест" \
          --prop "1" \
          --option "1" \
          --auth "auth.json" \



      - name: Выполнить УдалитьВариантСвойстваТовара
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk УдалитьВариантСвойстваТовара --debug --test \
          --option "1" \
          --auth "auth.json" \



      - name: Выполнить ПолучитьСписокЗаказов
        if: ${{ cancelled() }} == false
        run: |
 
          echo " {
            \"access_token\": \"${{ env.json_VK_Token }}\",
            \"from_group\"  : \"1\",
            \"owner_id\"    : \"-${{ env.json_VK_GroupID }}\",
            \"v\"           : \"5.131\",
            \"app_id\"      : \"${{ env.json_VK_AppID }}\",
            \"group_id\"    : \"${{ env.json_VK_GroupID }}\"
          } " > auth.json


          ./oint vk ПолучитьСписокЗаказов --debug --test \
          --auth "auth.json" \



      - name: Выполнить СформироватьКлавиатуру
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint vk СформироватьКлавиатуру --debug --test \
          --buttons "['Кнопка1','Кнопка2','Кнопка3']" \

  Testing-viber:
    runs-on: ubuntu-latest
    needs: [Decode, Build]
    steps:

      - name: Получить тестовые данные из кэша
        uses: actions/cache/restore@v3
        with:
          path: ./data.json
          key: test-data

      - name: Скачать артефакт с исполняемым файлом
        uses: actions/download-artifact@v4
        with:
          name: oint 

      - name: JSON в переменные
        uses: rgarcia-phi/json-to-variables@v1.1.0
        with:
          filename: 'data.json'
          masked: true

      - name: chmod для OInt
        run: chmod +x ./oint




      - name: Выполнить УстановитьWebhook
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint viber УстановитьWebhook --debug --test \
          --token "${{ env.json_Viber_Token }}" \
          --url "" \



      - name: Выполнить ПолучитьИнформациюОКанале
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint viber ПолучитьИнформациюОКанале --debug --test \
          --token "${{ env.json_Viber_Token }}" \



      - name: Выполнить ПолучитьДанныеПользователя
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint viber ПолучитьДанныеПользователя --debug --test \
          --token "${{ env.json_Viber_Token }}" \
          --user "${{ env.json_Viber_UserID }}" \



      - name: Выполнить ПолучитьОнлайнПользователей
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint viber ПолучитьОнлайнПользователей --debug --test \
          --token "${{ env.json_Viber_Token }}" \
          --users "" \



      - name: Выполнить ОтправитьТекстовоеСообщение
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint viber ОтправитьТекстовоеСообщение --debug --test \
          --token "${{ env.json_Viber_Token }}" \
          --text "Тестовый текст" \
          --user "${{ env.json_Viber_UserID }}" \
          --ischannel true \
          --keyboard "" \



      - name: Выполнить ОтправитьКартинку
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint viber ОтправитьКартинку --debug --test \
          --token "${{ env.json_Viber_Token }}" \
          --picture "${{ env.json_Picture }}" \
          --user "${{ env.json_Viber_UserID }}" \
          --ischannel true \
          --description "Тестовое описание" \



      - name: Выполнить ОтправитьФайл
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint viber ОтправитьФайл --debug --test \
          --token "${{ env.json_Viber_Token }}" \
          --file "" \
          --user "${{ env.json_Viber_UserID }}" \
          --ischannel true \
          --ext ".txt" \
          --size "10" \



      - name: Выполнить ОтправитьКонтакт
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint viber ОтправитьКонтакт --debug --test \
          --token "${{ env.json_Viber_Token }}" \
          --name "Петр" \
          --phone "+123456789" \
          --user "${{ env.json_Viber_UserID }}" \
          --ischannel true \



      - name: Выполнить ОтправитьЛокацию
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint viber ОтправитьЛокацию --debug --test \
          --token "${{ env.json_Viber_Token }}" \
          --lat "48.87373649724122" \
          --long "48.87373649724122" \
          --user "${{ env.json_Viber_UserID }}" \
          --ischannel true \



      - name: Выполнить ОтправитьСсылку
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint viber ОтправитьСсылку --debug --test \
          --token "${{ env.json_Viber_Token }}" \
          --url "" \
          --user "${{ env.json_Viber_UserID }}" \
          --ischannel true \



      - name: Выполнить СформироватьКлавиатуруИзМассиваКнопок
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint viber СформироватьКлавиатуруИзМассиваКнопок --debug --test \
          --buttons "['Кнопка1','Кнопка2','Кнопка3']" \
          --color "" \

  Testing-twitter:
    runs-on: ubuntu-latest
    needs: [Decode, Build]
    steps:

      - name: Получить тестовые данные из кэша
        uses: actions/cache/restore@v3
        with:
          path: ./data.json
          key: test-data

      - name: Скачать артефакт с исполняемым файлом
        uses: actions/download-artifact@v4
        with:
          name: oint 

      - name: JSON в переменные
        uses: rgarcia-phi/json-to-variables@v1.1.0
        with:
          filename: 'data.json'
          masked: true

      - name: chmod для OInt
        run: chmod +x ./oint




      - name: Выполнить ПолучитьСсылкуАвторизации
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint twitter ПолучитьСсылкуАвторизации --debug --test \
          --auth "" \



      - name: Выполнить ПолучитьТокен
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint twitter ПолучитьТокен --debug --test \
          --code "" \
          --auth "" \



      - name: Выполнить ОбновитьТокен
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint twitter ОбновитьТокен --debug --test \
          --auth "" \



      - name: Выполнить СоздатьТекстовыйТвит
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint twitter СоздатьТекстовыйТвит --debug --test \
          --text "Тестовый текст" \
          --auth "" \



      - name: Выполнить СоздатьТвитКартинки
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint twitter СоздатьТвитКартинки --debug --test \
          --text "Тестовый текст" \
          --pictures "" \
          --auth "" \



      - name: Выполнить СоздатьТвитГифки
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint twitter СоздатьТвитГифки --debug --test \
          --text "Тестовый текст" \
          --gifs "" \
          --auth "" \



      - name: Выполнить СоздатьТвитВидео
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint twitter СоздатьТвитВидео --debug --test \
          --text "Тестовый текст" \
          --videos "" \
          --auth "" \



      - name: Выполнить СоздатьТвитОпрос
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint twitter СоздатьТвитОпрос --debug --test \
          --text "Тестовый текст" \
          --options "['Да', 'Нет', 'Затрудняюсь ответить']" \
          --duration "" \
          --auth "" \

  Testing-notion:
    runs-on: ubuntu-latest
    needs: [Decode, Build]
    steps:

      - name: Получить тестовые данные из кэша
        uses: actions/cache/restore@v3
        with:
          path: ./data.json
          key: test-data

      - name: Скачать артефакт с исполняемым файлом
        uses: actions/download-artifact@v4
        with:
          name: oint 

      - name: JSON в переменные
        uses: rgarcia-phi/json-to-variables@v1.1.0
        with:
          filename: 'data.json'
          masked: true

      - name: chmod для OInt
        run: chmod +x ./oint




      - name: Выполнить СоздатьСтраницу
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint notion СоздатьСтраницу --debug --test \
          --token "" \
          --page "" \
          --title "Тест" \



      - name: Выполнить СоздатьСтраницуВБазу
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint notion СоздатьСтраницуВБазу --debug --test \
          --token "" \
          --base "" \
          --data "" \



      - name: Выполнить ПолучитьСтраницу
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint notion ПолучитьСтраницу --debug --test \
          --token "" \
          --page "" \



      - name: Выполнить ИзменитьСвойстваСтраницы
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint notion ИзменитьСвойстваСтраницы --debug --test \
          --token "" \
          --page "" \
          --data "" \
          --icon "" \
          --cover "" \
          --archive "" \



      - name: Выполнить СоздатьБазуДанных
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint notion СоздатьБазуДанных --debug --test \
          --token "" \
          --page "" \
          --title "Тест" \
          --props "" \



      - name: Выполнить ПолучитьБазуДанных
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint notion ПолучитьБазуДанных --debug --test \
          --token "" \
          --base "" \



      - name: Выполнить ИзменитьСвойстваБазы
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint notion ИзменитьСвойстваБазы --debug --test \
          --token "" \
          --base "" \
          --props "" \
          --title "Тест" \
          --description "Тестовое описание" \



      - name: Выполнить СоздатьБлок
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint notion СоздатьБлок --debug --test \
          --token "" \
          --page "" \
          --block "" \
          --prev "" \



      - name: Выполнить ВернутьБлок
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint notion ВернутьБлок --debug --test \
          --token "" \
          --block "" \
          --core "" \



      - name: Выполнить ВернутьДочерниеБлоки
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint notion ВернутьДочерниеБлоки --debug --test \
          --token "" \
          --block "" \



      - name: Выполнить УдалитьБлок
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint notion УдалитьБлок --debug --test \
          --token "" \
          --block "" \



      - name: Выполнить СписокПользователей
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint notion СписокПользователей --debug --test \
          --token "" \



      - name: Выполнить ПолучитьДанныеПользователя
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint notion ПолучитьДанныеПользователя --debug --test \
          --token "" \
          --user "" \

  Testing-yandex:
    runs-on: ubuntu-latest
    needs: [Decode, Build]
    steps:

      - name: Получить тестовые данные из кэша
        uses: actions/cache/restore@v3
        with:
          path: ./data.json
          key: test-data

      - name: Скачать артефакт с исполняемым файлом
        uses: actions/download-artifact@v4
        with:
          name: oint 

      - name: JSON в переменные
        uses: rgarcia-phi/json-to-variables@v1.1.0
        with:
          filename: 'data.json'
          masked: true

      - name: chmod для OInt
        run: chmod +x ./oint




      - name: Выполнить ПолучитьКодПодтверждения
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint yandex ПолучитьКодПодтверждения --debug --test \
          --id "" \



      - name: Выполнить ПреобразоватьКодВТокен
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint yandex ПреобразоватьКодВТокен --debug --test \
          --id "" \
          --secret "" \
          --device "" \



      - name: Выполнить ОбновитьТокен
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint yandex ОбновитьТокен --debug --test \
          --id "" \
          --secret "" \
          --refresh "" \

  Testing-yadisk:
    runs-on: ubuntu-latest
    needs: [Decode, Build]
    steps:

      - name: Получить тестовые данные из кэша
        uses: actions/cache/restore@v3
        with:
          path: ./data.json
          key: test-data

      - name: Скачать артефакт с исполняемым файлом
        uses: actions/download-artifact@v4
        with:
          name: oint 

      - name: JSON в переменные
        uses: rgarcia-phi/json-to-variables@v1.1.0
        with:
          filename: 'data.json'
          masked: true

      - name: chmod для OInt
        run: chmod +x ./oint




      - name: Выполнить ПолучитьИнформациюОДиске
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint yadisk ПолучитьИнформациюОДиске --debug --test \
          --token "" \



      - name: Выполнить СоздатьПапку
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint yadisk СоздатьПапку --debug --test \
          --token "" \
          --path "" \



      - name: Выполнить ПолучитьОбъект
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint yadisk ПолучитьОбъект --debug --test \
          --token "" \
          --path "" \



      - name: Выполнить УдалитьОбъект
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint yadisk УдалитьОбъект --debug --test \
          --token "" \
          --path "" \
          --can "" \



      - name: Выполнить СоздатьКопиюОбъекта
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint yadisk СоздатьКопиюОбъекта --debug --test \
          --token "" \
          --from "" \
          --to "" \
          --rewrite "" \



      - name: Выполнить ПолучитьСсылкуДляСкачивания
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint yadisk ПолучитьСсылкуДляСкачивания --debug --test \
          --token "" \
          --path "" \



      - name: Выполнить СкачатьФайл
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint yadisk СкачатьФайл --debug --test \
          --token "" \
          --path "" \
          --out "" \



      - name: Выполнить ПолучитьСписокФайлов
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint yadisk ПолучитьСписокФайлов --debug --test \
          --token "" \
          --amount "" \
          --offset "" \
          --type "" \
          --datesort "" \



      - name: Выполнить ПереместитьОбъект
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint yadisk ПереместитьОбъект --debug --test \
          --token "" \
          --from "" \
          --to "" \
          --rewrite "" \



      - name: Выполнить ЗагрузитьФайл
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint yadisk ЗагрузитьФайл --debug --test \
          --token "" \
          --path "" \
          --file "" \
          --rewrite "" \



      - name: Выполнить ЗагрузитьФайлПоURL
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint yadisk ЗагрузитьФайлПоURL --debug --test \
          --token "" \
          --path "" \
          --url "" \



      - name: Выполнить ОпубликоватьОбъект
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint yadisk ОпубликоватьОбъект --debug --test \
          --token "" \
          --path "" \



      - name: Выполнить ОтменитьПубликациюОбъекта
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint yadisk ОтменитьПубликациюОбъекта --debug --test \
          --token "" \
          --path "" \



      - name: Выполнить ПолучитьСписокОпубликованныхОбъектов
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint yadisk ПолучитьСписокОпубликованныхОбъектов --debug --test \
          --token "" \
          --amount "" \
          --offset "" \



      - name: Выполнить ПолучитьПубличныйОбъект
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint yadisk ПолучитьПубличныйОбъект --debug --test \
          --token "" \
          --url "" \
          --amount "" \
          --offset "" \



      - name: Выполнить ПолучитьСсылкуСкачиванияПубличногоОбъекта
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint yadisk ПолучитьСсылкуСкачиванияПубличногоОбъекта --debug --test \
          --token "" \
          --url "" \
          --path "" \



      - name: Выполнить СохранитьПубличныйОбъектНаДиск
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint yadisk СохранитьПубличныйОбъектНаДиск --debug --test \
          --token "" \
          --url "" \
          --from "" \
          --to "" \

  Testing-google:
    runs-on: ubuntu-latest
    needs: [Decode, Build]
    steps:

      - name: Получить тестовые данные из кэша
        uses: actions/cache/restore@v3
        with:
          path: ./data.json
          key: test-data

      - name: Скачать артефакт с исполняемым файлом
        uses: actions/download-artifact@v4
        with:
          name: oint 

      - name: JSON в переменные
        uses: rgarcia-phi/json-to-variables@v1.1.0
        with:
          filename: 'data.json'
          masked: true

      - name: chmod для OInt
        run: chmod +x ./oint




      - name: Выполнить СформироватьСсылкуПолученияКода
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint google СформироватьСсылкуПолученияКода --debug --test \
          --id "" \
          --calendar "" \
          --drive "" \
          --sheets "" \



      - name: Выполнить ПолучитьТокенПоКоду
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint google ПолучитьТокенПоКоду --debug --test \
          --id "" \
          --secret "" \
          --code "" \



      - name: Выполнить ОбновитьТокен
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint google ОбновитьТокен --debug --test \
          --id "" \
          --secret "" \
          --refresh "" \

  Testing-gcalendar:
    runs-on: ubuntu-latest
    needs: [Decode, Build]
    steps:

      - name: Получить тестовые данные из кэша
        uses: actions/cache/restore@v3
        with:
          path: ./data.json
          key: test-data

      - name: Скачать артефакт с исполняемым файлом
        uses: actions/download-artifact@v4
        with:
          name: oint 

      - name: JSON в переменные
        uses: rgarcia-phi/json-to-variables@v1.1.0
        with:
          filename: 'data.json'
          masked: true

      - name: chmod для OInt
        run: chmod +x ./oint




      - name: Выполнить СоздатьКалендарь
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gcalendar СоздатьКалендарь --debug --test \
          --token "" \
          --title "Тест" \



      - name: Выполнить ПолучитьМетаданныеКалендаря
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gcalendar ПолучитьМетаданныеКалендаря --debug --test \
          --token "" \
          --calendar "" \



      - name: Выполнить ИзменитьМетаданныеКалендаря
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gcalendar ИзменитьМетаданныеКалендаря --debug --test \
          --token "" \
          --calendar "" \
          --title "Тест" \
          --description "Тестовое описание" \



      - name: Выполнить ОчиститьОсновнойКалендарь
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gcalendar ОчиститьОсновнойКалендарь --debug --test \
          --token "" \



      - name: Выполнить УдалитьКалендарь
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gcalendar УдалитьКалендарь --debug --test \
          --token "" \
          --calendar "" \



      - name: Выполнить ПолучитьСписокКалендарей
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gcalendar ПолучитьСписокКалендарей --debug --test \
          --token "" \



      - name: Выполнить ДобавитьКалендарьВСписок
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gcalendar ДобавитьКалендарьВСписок --debug --test \
          --token "" \
          --calendar "" \



      - name: Выполнить ПолучитьКалендарьСписка
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gcalendar ПолучитьКалендарьСписка --debug --test \
          --token "" \
          --calendar "" \



      - name: Выполнить УдалитьКалендарьИзСписка
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gcalendar УдалитьКалендарьИзСписка --debug --test \
          --token "" \
          --calendar "" \



      - name: Выполнить ИзменитьКалендарьСписка
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gcalendar ИзменитьКалендарьСписка --debug --test \
          --token "" \
          --calendar "" \
          --primary "" \
          --secondary "" \
          --hidden "" \



      - name: Выполнить ПолучитьСписокСобытий
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gcalendar ПолучитьСписокСобытий --debug --test \
          --token "" \
          --calendar "" \



      - name: Выполнить ПолучитьСобытие
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gcalendar ПолучитьСобытие --debug --test \
          --token "" \
          --calendar "" \
          --event "" \



      - name: Выполнить СоздатьСобытие
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gcalendar СоздатьСобытие --debug --test \
          --token "" \
          --calendar "" \
          --props "" \



      - name: Выполнить ПереместитьСобытие
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gcalendar ПереместитьСобытие --debug --test \
          --token "" \
          --from "" \
          --to "" \
          --event "" \



      - name: Выполнить ИзменитьСобытие
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gcalendar ИзменитьСобытие --debug --test \
          --token "" \
          --calendar "" \
          --props "" \
          --event "" \



      - name: Выполнить УдалитьСобытие
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gcalendar УдалитьСобытие --debug --test \
          --token "" \
          --calendar "" \
          --event "" \

  Testing-gdrive:
    runs-on: ubuntu-latest
    needs: [Decode, Build]
    steps:

      - name: Получить тестовые данные из кэша
        uses: actions/cache/restore@v3
        with:
          path: ./data.json
          key: test-data

      - name: Скачать артефакт с исполняемым файлом
        uses: actions/download-artifact@v4
        with:
          name: oint 

      - name: JSON в переменные
        uses: rgarcia-phi/json-to-variables@v1.1.0
        with:
          filename: 'data.json'
          masked: true

      - name: chmod для OInt
        run: chmod +x ./oint




      - name: Выполнить ПолучитьИнформациюОбОбъекте
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gdrive ПолучитьИнформациюОбОбъекте --debug --test \
          --token "" \
          --object "" \



      - name: Выполнить ПолучитьСписокКаталогов
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gdrive ПолучитьСписокКаталогов --debug --test \
          --token "" \
          --querry "" \
          --depth "" \



      - name: Выполнить ПолучитьСписокФайлов
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gdrive ПолучитьСписокФайлов --debug --test \
          --token "" \
          --querry "" \
          --catalog "" \



      - name: Выполнить ЗагрузитьФайл
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gdrive ЗагрузитьФайл --debug --test \
          --token "" \
          --file "" \
          --props "" \



      - name: Выполнить СоздатьПапку
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gdrive СоздатьПапку --debug --test \
          --token "" \
          --title "Тест" \
          --catalog "" \



      - name: Выполнить СкачатьФайл
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gdrive СкачатьФайл --debug --test \
          --token "" \
          --object "" \
          --out "" \



      - name: Выполнить СкопироватьОбъект
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gdrive СкопироватьОбъект --debug --test \
          --token "" \
          --object "" \
          --title "Тест" \
          --catalog "" \



      - name: Выполнить ОбновитьФайл
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gdrive ОбновитьФайл --debug --test \
          --token "" \
          --object "" \
          --file "" \
          --title "Тест" \



      - name: Выполнить УдалитьОбъект
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gdrive УдалитьОбъект --debug --test \
          --token "" \
          --object "" \



      - name: Выполнить СоздатьКомментарий
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gdrive СоздатьКомментарий --debug --test \
          --token "" \
          --object "" \
          --text "Тестовый текст" \



      - name: Выполнить ПолучитьКомментарий
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gdrive ПолучитьКомментарий --debug --test \
          --token "" \
          --object "" \
          --comment "" \



      - name: Выполнить ПолучитьСписокКомментариев
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gdrive ПолучитьСписокКомментариев --debug --test \
          --token "" \
          --object "" \



      - name: Выполнить УдалитьКомментарий
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gdrive УдалитьКомментарий --debug --test \
          --token "" \
          --object "" \
          --comment "" \

  Testing-gsheets:
    runs-on: ubuntu-latest
    needs: [Decode, Build]
    steps:

      - name: Получить тестовые данные из кэша
        uses: actions/cache/restore@v3
        with:
          path: ./data.json
          key: test-data

      - name: Скачать артефакт с исполняемым файлом
        uses: actions/download-artifact@v4
        with:
          name: oint 

      - name: JSON в переменные
        uses: rgarcia-phi/json-to-variables@v1.1.0
        with:
          filename: 'data.json'
          masked: true

      - name: chmod для OInt
        run: chmod +x ./oint




      - name: Выполнить СоздатьКнигу
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gsheets СоздатьКнигу --debug --test \
          --token "" \
          --title "Тест" \
          --sheets "" \



      - name: Выполнить ПолучитьКнигу
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gsheets ПолучитьКнигу --debug --test \
          --token "" \
          --spreadsheet "" \



      - name: Выполнить ИзменитьНаименованиеКниги
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gsheets ИзменитьНаименованиеКниги --debug --test \
          --token "" \
          --spreadsheet "" \
          --title "Тест" \



      - name: Выполнить ДобавитьЛист
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gsheets ДобавитьЛист --debug --test \
          --token "" \
          --spreadsheet "" \
          --title "Тест" \



      - name: Выполнить УдалитьЛист
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gsheets УдалитьЛист --debug --test \
          --token "" \
          --spreadsheet "" \
          --sheet "" \



      - name: Выполнить КопироватьЛист
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gsheets КопироватьЛист --debug --test \
          --token "" \
          --from "" \
          --to "" \
          --sheet "" \



      - name: Выполнить УстановитьЗначенияЯчеек
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gsheets УстановитьЗначенияЯчеек --debug --test \
          --token "" \
          --spreadsheet "" \
          --data "" \
          --sheetname "" \
          --dim "" \



      - name: Выполнить ОчиститьЯчейки
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gsheets ОчиститьЯчейки --debug --test \
          --token "" \
          --spreadsheet "" \
          --cells "" \
          --sheetname "" \



      - name: Выполнить ПолучитьЗначенияЯчеек
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint gsheets ПолучитьЗначенияЯчеек --debug --test \
          --token "" \
          --spreadsheet "" \
          --cells "" \
          --sheetname "" \

  Testing-dropbox:
    runs-on: ubuntu-latest
    needs: [Decode, Build]
    steps:

      - name: Получить тестовые данные из кэша
        uses: actions/cache/restore@v3
        with:
          path: ./data.json
          key: test-data

      - name: Скачать артефакт с исполняемым файлом
        uses: actions/download-artifact@v4
        with:
          name: oint 

      - name: JSON в переменные
        uses: rgarcia-phi/json-to-variables@v1.1.0
        with:
          filename: 'data.json'
          masked: true

      - name: chmod для OInt
        run: chmod +x ./oint




      - name: Выполнить ПолучитьСсылкуАвторизации
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ПолучитьСсылкуАвторизации --debug --test \
          --appkey "" \



      - name: Выполнить ПолучитьТокен
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ПолучитьТокен --debug --test \
          --appkey "" \
          --appsecret "" \
          --code "" \



      - name: Выполнить ОбновитьТокен
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ОбновитьТокен --debug --test \
          --appkey "" \
          --appsecret "" \
          --refresh "" \



      - name: Выполнить ПолучитьИнформациюОбАккаунте
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ПолучитьИнформациюОбАккаунте --debug --test \
          --token "" \
          --account "" \



      - name: Выполнить ПолучитьДанныеИспользованияПространства
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ПолучитьДанныеИспользованияПространства --debug --test \
          --token "" \



      - name: Выполнить ПолучитьИнформациюОбОбъекте
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ПолучитьИнформациюОбОбъекте --debug --test \
          --token "" \
          --path "" \
          --detail "" \



      - name: Выполнить ПолучитьСписокФайловПапки
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ПолучитьСписокФайловПапки --debug --test \
          --token "" \
          --path "" \
          --detail "" \
          --cursor "" \



      - name: Выполнить ПолучитьПревью
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ПолучитьПревью --debug --test \
          --token "" \
          --path "" \



      - name: Выполнить ЗагрузитьФайл
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ЗагрузитьФайл --debug --test \
          --token "" \
          --file "" \
          --path "" \
          --overwrite "" \



      - name: Выполнить ЗагрузитьФайлПоURL
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ЗагрузитьФайлПоURL --debug --test \
          --token "" \
          --url "" \
          --path "" \



      - name: Выполнить ПолучитьСтатусЗагрузкиПоURL
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ПолучитьСтатусЗагрузкиПоURL --debug --test \
          --token "" \
          --job "" \



      - name: Выполнить УдалитьОбъект
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox УдалитьОбъект --debug --test \
          --token "" \
          --path "" \
          --permanently "" \



      - name: Выполнить КопироватьОбъект
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox КопироватьОбъект --debug --test \
          --token "" \
          --form "" \
          --to "" \



      - name: Выполнить ПереместитьОбъект
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ПереместитьОбъект --debug --test \
          --token "" \
          --form "" \
          --to "" \



      - name: Выполнить СоздатьПапку
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox СоздатьПапку --debug --test \
          --token "" \
          --path "" \



      - name: Выполнить СкачатьФайл
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox СкачатьФайл --debug --test \
          --token "" \
          --path "" \



      - name: Выполнить СкачатьПапку
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox СкачатьПапку --debug --test \
          --token "" \
          --path "" \



      - name: Выполнить ПолучитьСписокВерсийОбъекта
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ПолучитьСписокВерсийОбъекта --debug --test \
          --token "" \
          --path "" \
          --amount "" \



      - name: Выполнить ВосстановитьОбъектКВерсии
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ВосстановитьОбъектКВерсии --debug --test \
          --token "" \
          --path "" \
          --rev "" \



      - name: Выполнить ПолучитьСписокТегов
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ПолучитьСписокТегов --debug --test \
          --token "" \
          --paths "" \



      - name: Выполнить ДобавитьТег
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ДобавитьТег --debug --test \
          --token "" \
          --path "" \
          --tag "" \



      - name: Выполнить УдалитьТег
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox УдалитьТег --debug --test \
          --token "" \
          --path "" \
          --tag "" \



      - name: Выполнить ОпубликоватьПапку
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ОпубликоватьПапку --debug --test \
          --token "" \
          --path "" \



      - name: Выполнить ОтменитьПубликациюПапки
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ОтменитьПубликациюПапки --debug --test \
          --token "" \
          --folder "" \



      - name: Выполнить ДобавитьПользователейКФайлу
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ДобавитьПользователейКФайлу --debug --test \
          --token "" \
          --fileid "" \
          --emails "" \
          --readonly "" \



      - name: Выполнить ДобавитьПользователейКПапке
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ДобавитьПользователейКПапке --debug --test \
          --token "" \
          --folder "" \
          --emails "" \
          --readonly "" \



      - name: Выполнить ПолучитьСтатусАсинхронногоИзменения
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ПолучитьСтатусАсинхронногоИзменения --debug --test \
          --token "" \
          --job "" \



      - name: Выполнить ОтменитьПубликациюФайла
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint dropbox ОтменитьПубликациюФайла --debug --test \
          --token "" \
          --fileid "" \

  Clear-Cache:
    runs-on: ubuntu-latest
    needs: [Testing-telegram, Testing-vk, Testing-viber]
    if: ${{ always() }}
    steps:
      - name: Очистка кэша
        run: |
          curl -L \
          -X DELETE \
          -H "Accept: application/vnd.github+json" \
          -H "Authorization: Bearer ${{ secrets.TOKEN }}" \
          -H "X-GitHub-Api-Version: 2022-11-28" \
          "https://api.github.com/repos/Bayselonarrend/OpenIntegrations/actions/caches?key=test-data"