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          
      - 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 ./OInt
          opm build
          opm install *.ospx            

      - name: Собрать бинарник
        run: |
          cd ./cli
          oscript -make core/Classes/Приложение.os oint          
      - name: Записать артефакт
        uses: actions/upload-artifact@v4
        with:
          name: oint
          path: ./cli/oint

      - name: Создать каталог deb-пакета
        run: |
          mkdir -p .debpkg/usr/bin
          cp ./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.6.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 ./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.6.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_bin




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



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



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



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



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



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



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



      - name: Выполнить ПереслатьСообщение
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint_bin 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_bin telegram Бан --debug --test \
          --token "${{ env.json_Telegram_Token }}" \
          --chat "${{ env.json_Telegram_ChannelID }}" \
          --user "${{ env.json_Telegram_ChatID }}" \



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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


  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_bin




      - name: Выполнить СоздатьСсылкуПолученияТокена
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin 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_bin vk ПолучитьСписокЗаказов --debug --test \
          --auth "auth.json" \



      - name: Выполнить СформироватьКлавиатуру
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint_bin 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_bin




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



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



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



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



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



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



      - name: Выполнить ОтправитьЛокацию
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint_bin 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_bin viber ОтправитьСсылку --debug --test \
          --token "${{ env.json_Viber_Token }}" \
          --url "" \
          --user "${{ env.json_Viber_UserID }}" \
          --ischannel true \



      - name: Выполнить СформироватьКлавиатуруИзМассиваКнопок
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint_bin 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_bin




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



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



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



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



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



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



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



      - name: Выполнить СоздатьТвитОпрос
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint_bin 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_bin




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



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



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



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



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



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



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



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



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



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



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



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



      - name: Выполнить ПолучитьДанныеПользователя
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint_bin 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_bin




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



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



      - name: Выполнить ОбновитьТокен
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint_bin 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_bin




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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



      - name: Выполнить СохранитьПубличныйОбъектНаДиск
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint_bin 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_bin




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



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



      - name: Выполнить ОбновитьТокен
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint_bin 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_bin




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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



      - name: Выполнить УдалитьСобытие
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint_bin 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_bin




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



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



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



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



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



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



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



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



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



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



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



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



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


  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"