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
        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/app.os oint

      - name: Собрать exe
        run: |
          cd ./src/ru/cli
          oscript -make core/Classes/app.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.12.0' # refs/tags/v*.*.*
          arch: 'all'
          depends: 'mono-devel, 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 различных онлайн-сервисов из командной строки'

      - name: Изменить имя пакета deb
        run: |
          cp oint_1.12.0_all.deb oint_1.12.0_all_ru.deb
          rm oint_1.12.0_all.deb

      - uses: actions/upload-artifact@v3
        with:
          name: oint-deb
          path: |
            oint_1.12.0_all_ru.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.12.0'
          arch: 'x86_64'
          desc: 'OInt CLI - приложение для работы с API различных онлайн-сервисов из командной строки'
          requires: |
            mono-devel
            Requires:       mono-locale-extras

      - name: Изменить имя пакета rpm
        run: |
          cp oint-1.12.0-1.el7.x86_64.rpm oint-1.12.0-1.el7.x86_64_ru.rpm
          rm oint-debuginfo-1.12.0-1.el7.x86_64.rpm
          rm oint-1.12.0-1.el7.x86_64.rpm

      - uses: actions/upload-artifact@v4
        with:
          name: oint-rpm
          path: |
            ./oint-1.12.0-1.el7.x86_64_ru.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 "" \
          --reply "" \



      - 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 "" \
          --filename "" \



      - 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 }}" \
          --chat "${{ env.json_Telegram_ChannelID }}" \
          --message "${{ env.json_Telegram_ChannelMessageID }}" \



      - 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 "" \

  Testing-bitrix24:
    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 bitrix24 ПолучитьСсылкуАвторизацииПриложения --debug --test \
          --domain "" \
          --clientid "" \



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



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



      - name: Выполнить СерверноеВремя
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 СерверноеВремя --debug --test \
          --url "" \
          --token "" \



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



      - name: Выполнить ИзменитьНовость
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ИзменитьНовость --debug --test \
          --url "" \
          --postid "" \
          --text "Тестовый текст" \
          --vision "" \
          --files "" \
          --title "Тест" \
          --token "" \



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



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



      - name: Выполнить ПолучитьНовости
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПолучитьНовости --debug --test \
          --url "" \
          --postid "" \
          --sel "" \
          --token "" \



      - name: Выполнить ДобавитьКомментарийНовости
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ДобавитьКомментарийНовости --debug --test \
          --url "" \
          --postid "" \
          --text "Тестовый текст" \
          --token "" \



      - name: Выполнить ДобавитьПолучателейКНовости
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ДобавитьПолучателейКНовости --debug --test \
          --url "" \
          --postid "" \
          --vision "" \
          --token "" \



      - name: Выполнить ПолучитьЗадачу
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПолучитьЗадачу --debug --test \
          --url "" \
          --task "" \
          --token "" \



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



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



      - name: Выполнить ИзменитьЗадачу
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ИзменитьЗадачу --debug --test \
          --url "" \
          --task "" \
          --fields "" \
          --token "" \



      - name: Выполнить УдалитьЗадачу
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 УдалитьЗадачу --debug --test \
          --url "" \
          --task "" \
          --token "" \



      - name: Выполнить ДобавитьФайлВЗадачу
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ДобавитьФайлВЗадачу --debug --test \
          --url "" \
          --task "" \
          --fileid "" \
          --token "" \



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



      - name: Выполнить ОтклонитьЗадачу
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ОтклонитьЗадачу --debug --test \
          --url "" \
          --task "" \
          --token "" \



      - name: Выполнить ЗавершитьЗадачу
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ЗавершитьЗадачу --debug --test \
          --url "" \
          --task "" \
          --token "" \



      - name: Выполнить ВозобновитьЗадачу
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ВозобновитьЗадачу --debug --test \
          --url "" \
          --task "" \
          --token "" \



      - name: Выполнить ОтложитьЗадачу
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ОтложитьЗадачу --debug --test \
          --url "" \
          --task "" \
          --token "" \



      - name: Выполнить ПриостановитьЗадачу
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПриостановитьЗадачу --debug --test \
          --url "" \
          --task "" \
          --token "" \



      - name: Выполнить НачатьВыполнениеЗадачи
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 НачатьВыполнениеЗадачи --debug --test \
          --url "" \
          --task "" \
          --token "" \



      - name: Выполнить НачатьНаблюдатьЗаЗадачей
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 НачатьНаблюдатьЗаЗадачей --debug --test \
          --url "" \
          --task "" \
          --token "" \



      - name: Выполнить ПрекратитьНаблюдатьЗаЗадачей
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПрекратитьНаблюдатьЗаЗадачей --debug --test \
          --url "" \
          --task "" \
          --token "" \



      - name: Выполнить ДелегироватьЗадачу
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ДелегироватьЗадачу --debug --test \
          --url "" \
          --task "" \
          --user "" \
          --token "" \



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



      - name: Выполнить УбратьЗадачуИзИзбранного
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 УбратьЗадачуИзИзбранного --debug --test \
          --url "" \
          --task "" \
          --token "" \



      - name: Выполнить ПолучитьИсториюЗадачи
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПолучитьИсториюЗадачи --debug --test \
          --url "" \
          --task "" \
          --token "" \



      - name: Выполнить ПроверитьДоступКЗадаче
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПроверитьДоступКЗадаче --debug --test \
          --url "" \
          --task "" \
          --users "" \
          --token "" \



      - name: Выполнить ОтключитьЗвукЗадачи
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ОтключитьЗвукЗадачи --debug --test \
          --url "" \
          --task "" \
          --token "" \



      - name: Выполнить ВключитьЗвукЗадачи
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ВключитьЗвукЗадачи --debug --test \
          --url "" \
          --task "" \
          --token "" \



      - name: Выполнить СоздатьЗависимостьЗадач
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 СоздатьЗависимостьЗадач --debug --test \
          --url "" \
          --taskfrom "" \
          --taskto "" \
          --linktype "" \
          --token "" \



      - name: Выполнить УдалитьЗависимостьЗадач
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 УдалитьЗависимостьЗадач --debug --test \
          --url "" \
          --taskfrom "" \
          --taskto "" \
          --linktype "" \
          --token "" \



      - name: Выполнить ПолучитьПланЗадачНаДень
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПолучитьПланЗадачНаДень --debug --test \
          --url "" \
          --token "" \



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



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



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



      - name: Выполнить ДобавитьПользовательскоеПолеЗадачи
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ДобавитьПользовательскоеПолеЗадачи --debug --test \
          --url "" \
          --type "" \
          --fieldname "" \
          --externalid "" \
          --title "Тест" \
          --label "" \
          --token "" \



      - name: Выполнить ИзменитьПользовательскоеПолеЗадачи
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ИзменитьПользовательскоеПолеЗадачи --debug --test \
          --url "" \
          --fieldid "" \
          --externalid "" \
          --title "Тест" \
          --label "" \
          --token "" \



      - name: Выполнить ПолучитьПользовательскоеПолеЗадачи
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПолучитьПользовательскоеПолеЗадачи --debug --test \
          --url "" \
          --fieldid "" \
          --token "" \



      - name: Выполнить УдалитьПользовательскоеПолеЗадачи
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 УдалитьПользовательскоеПолеЗадачи --debug --test \
          --url "" \
          --fieldid "" \
          --token "" \



      - name: Выполнить ДобавитьЭлементЧеклистаЗадачи
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ДобавитьЭлементЧеклистаЗадачи --debug --test \
          --url "" \
          --task "" \
          --text "Тестовый текст" \
          --complete "" \
          --token "" \



      - name: Выполнить ИзменитьЭлементЧеклистаЗадачи
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ИзменитьЭлементЧеклистаЗадачи --debug --test \
          --url "" \
          --task "" \
          --element "" \
          --text "Тестовый текст" \
          --token "" \



      - name: Выполнить УдалитьЭлементЧеклистаЗадачи
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 УдалитьЭлементЧеклистаЗадачи --debug --test \
          --url "" \
          --task "" \
          --element "" \
          --token "" \



      - name: Выполнить ПолучитьЧеклистЗадачи
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПолучитьЧеклистЗадачи --debug --test \
          --url "" \
          --task "" \
          --token "" \



      - name: Выполнить ПолучитьЭлементЧеклистаЗадачи
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПолучитьЭлементЧеклистаЗадачи --debug --test \
          --url "" \
          --task "" \
          --element "" \
          --token "" \



      - name: Выполнить ВыполнитьЭлементЧеклистаЗадачи
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ВыполнитьЭлементЧеклистаЗадачи --debug --test \
          --url "" \
          --task "" \
          --element "" \
          --token "" \



      - name: Выполнить ВозобновитьЭлементЧеклистаЗадачи
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ВозобновитьЭлементЧеклистаЗадачи --debug --test \
          --url "" \
          --task "" \
          --element "" \
          --token "" \



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



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



      - name: Выполнить ДобавитьКомментарийЗадачи
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ДобавитьКомментарийЗадачи --debug --test \
          --url "" \
          --task "" \
          --text "Тестовый текст" \
          --token "" \



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



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



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



      - name: Выполнить СоздатьРезультатИзКомментария
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 СоздатьРезультатИзКомментария --debug --test \
          --url "" \
          --comment "" \
          --token "" \



      - name: Выполнить УдалитьРезультатИзКомментария
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 УдалитьРезультатИзКомментария --debug --test \
          --url "" \
          --comment "" \
          --token "" \



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



      - name: Выполнить ДобавитьСтадиюКанбана
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ДобавитьСтадиюКанбана --debug --test \
          --url "" \
          --title "Тест" \
          --color "" \
          --prevstage "" \
          --entityid "" \
          --admin "" \
          --token "" \



      - name: Выполнить ИзменитьСтадиюКанбана
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ИзменитьСтадиюКанбана --debug --test \
          --url "" \
          --title "Тест" \
          --stage "" \
          --color "" \
          --prevstage "" \
          --admin "" \
          --token "" \



      - name: Выполнить УдалитьСтадиюКанбана
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 УдалитьСтадиюКанбана --debug --test \
          --url "" \
          --stage "" \
          --admin "" \
          --token "" \



      - name: Выполнить ПолучитьСтадииКанбана
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПолучитьСтадииКанбана --debug --test \
          --url "" \
          --entityid "" \
          --admin "" \
          --token "" \



      - name: Выполнить ПеренестиЗадачуВСтадиюКанбана
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПеренестиЗадачуВСтадиюКанбана --debug --test \
          --url "" \
          --task "" \
          --stage "" \
          --before "" \
          --after "" \
          --token "" \



      - name: Выполнить ДобавитьТрудозатратыЗадачи
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ДобавитьТрудозатратыЗадачи --debug --test \
          --url "" \
          --task "" \
          --amount "" \
          --user "" \
          --text "Тестовый текст" \
          --date "" \
          --token "" \



      - name: Выполнить УдалитьТрудозатратыЗадачи
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 УдалитьТрудозатратыЗадачи --debug --test \
          --url "" \
          --task "" \
          --record "" \
          --token "" \



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



      - name: Выполнить ПолучитьТрудозатратыЗадачи
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПолучитьТрудозатратыЗадачи --debug --test \
          --url "" \
          --task "" \
          --record "" \
          --token "" \



      - name: Выполнить ИзменитьТрудозатратыЗадачи
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ИзменитьТрудозатратыЗадачи --debug --test \
          --url "" \
          --task "" \
          --record "" \
          --amount "" \
          --text "Тестовый текст" \
          --date "" \
          --token "" \



      - name: Выполнить НачатьУчетВремени
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 НачатьУчетВремени --debug --test \
          --url "" \
          --userid "" \
          --time "" \
          --report "" \
          --token "" \



      - name: Выполнить ЗавершитьУчетВремени
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ЗавершитьУчетВремени --debug --test \
          --url "" \
          --userid "" \
          --time "" \
          --report "" \
          --token "" \



      - name: Выполнить ПриостановитьУчетВремени
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПриостановитьУчетВремени --debug --test \
          --url "" \
          --userid "" \
          --token "" \



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



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



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



      - name: Выполнить ПолучитьХранилищеПриложения
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПолучитьХранилищеПриложения --debug --test \
          --url "" \
          --token "" \



      - name: Выполнить ПолучитьХранилище
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПолучитьХранилище --debug --test \
          --url "" \
          --storageid "" \
          --token "" \



      - name: Выполнить ПереименоватьХранилище
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПереименоватьХранилище --debug --test \
          --url "" \
          --storageid "" \
          --title "Тест" \
          --token "" \



      - name: Выполнить ПолучитьСодержимоеХранилища
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПолучитьСодержимоеХранилища --debug --test \
          --url "" \
          --storageid "" \
          --token "" \



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



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



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



      - name: Выполнить СкопироватьКаталог
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 СкопироватьКаталог --debug --test \
          --url "" \
          --folderid "" \
          --tagetid "" \
          --token "" \



      - name: Выполнить ПереместитьКаталог
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПереместитьКаталог --debug --test \
          --url "" \
          --folderid "" \
          --tagetid "" \
          --token "" \



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



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



      - name: Выполнить ПолучитьДочерниеЭлементыКаталога
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПолучитьДочерниеЭлементыКаталога --debug --test \
          --url "" \
          --folderid "" \
          --filter "" \
          --token "" \



      - name: Выполнить ПоместитьКаталогВКорзину
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПоместитьКаталогВКорзину --debug --test \
          --url "" \
          --folderid "" \
          --token "" \



      - name: Выполнить ВосстановитьКаталог
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ВосстановитьКаталог --debug --test \
          --url "" \
          --folderid "" \
          --token "" \



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



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



      - name: Выполнить ЗагрузитьФайлВХранилище
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ЗагрузитьФайлВХранилище --debug --test \
          --url "" \
          --title "Тест" \
          --file "" \
          --storageid "" \
          --rights "" \
          --token "" \



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



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



      - name: Выполнить УдалитьФайл
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 УдалитьФайл --debug --test \
          --url "" \
          --fileid "" \
          --token "" \



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



      - name: Выполнить ПоместитьФайлВКорзину
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПоместитьФайлВКорзину --debug --test \
          --url "" \
          --fileid "" \
          --token "" \



      - name: Выполнить ВосстановитьФайл
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ВосстановитьФайл --debug --test \
          --url "" \
          --fileid "" \
          --token "" \



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



      - name: Выполнить ПереместитьФайлВКаталог
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПереместитьФайлВКаталог --debug --test \
          --url "" \
          --fileid "" \
          --folderid "" \
          --token "" \



      - name: Выполнить ПереименоватьФайл
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПереименоватьФайл --debug --test \
          --url "" \
          --fileid "" \
          --title "Тест" \
          --token "" \



      - name: Выполнить СоздатьЧат
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 СоздатьЧат --debug --test \
          --url "" \
          --fields "" \
          --token "" \



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



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



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



      - name: Выполнить ДобавитьПользователейВЧат
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ДобавитьПользователейВЧат --debug --test \
          --url "" \
          --chat "" \
          --users "" \
          --hide "" \
          --token "" \



      - name: Выполнить ИсключитьПользователяИзЧата
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ИсключитьПользователяИзЧата --debug --test \
          --url "" \
          --chat "" \
          --user "" \
          --token "" \



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



      - name: Выполнить ИзменитьЦветЧата
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ИзменитьЦветЧата --debug --test \
          --url "" \
          --chat "" \
          --color "" \
          --token "" \



      - name: Выполнить ИзменитьКартинкуЧата
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ИзменитьКартинкуЧата --debug --test \
          --url "" \
          --chat "" \
          --picture "${{ env.json_Picture }}" \
          --token "" \



      - name: Выполнить СменитьВладельцаЧата
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 СменитьВладельцаЧата --debug --test \
          --url "" \
          --chat "" \
          --user "" \
          --token "" \



      - name: Выполнить ОтключитьУведомленияЧата
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ОтключитьУведомленияЧата --debug --test \
          --url "" \
          --chat "" \
          --token "" \



      - name: Выполнить ВключитьУведомленияЧата
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ВключитьУведомленияЧата --debug --test \
          --url "" \
          --chat "" \
          --token "" \



      - name: Выполнить ПолучитьСписокСообщенийЧата
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПолучитьСписокСообщенийЧата --debug --test \
          --url "" \
          --chat "" \
          --last "" \
          --first "" \
          --token "" \



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



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



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



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



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



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



      - name: Выполнить ПолучитьКаталогФайловЧата
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПолучитьКаталогФайловЧата --debug --test \
          --url "" \
          --chat "" \
          --token "" \



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



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



      - name: Выполнить ИзменитьСообщение
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ИзменитьСообщение --debug --test \
          --url "" \
          --message "" \
          --text "Тестовый текст" \
          --blocks "" \
          --token "" \



      - name: Выполнить УстановитьРеакциюНаСообщение
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 УстановитьРеакциюНаСообщение --debug --test \
          --url "" \
          --message "" \
          --token "" \



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



      - name: Выполнить ОтправитьФайл
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ОтправитьФайл --debug --test \
          --url "" \
          --chat "" \
          --fileid "" \
          --description "Тестовое описание" \
          --token "" \



      - name: Выполнить ОтметитьСообщениеКакПрочитанное
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ОтметитьСообщениеКакПрочитанное --debug --test \
          --url "" \
          --chat "" \
          --message "" \
          --token "" \



      - name: Выполнить ОтметитьСообщениеКакНепрочитанное
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ОтметитьСообщениеКакНепрочитанное --debug --test \
          --url "" \
          --chat "" \
          --message "" \
          --token "" \



      - name: Выполнить ПолучитьБлокКартинки
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПолучитьБлокКартинки --debug --test \
          --title "Тест" \
          --url "" \



      - name: Выполнить ПолучитьБлокФайла
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПолучитьБлокФайла --debug --test \
          --title "Тест" \
          --url "" \



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



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



      - name: Выполнить УдалитьУведомление
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 УдалитьУведомление --debug --test \
          --url "" \
          --notif "" \
          --token "" \



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



      - name: Выполнить ИзменитьПодразделение
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ИзменитьПодразделение --debug --test \
          --url "" \
          --depid "" \
          --title "Тест" \
          --parentid "" \
          --headid "" \
          --token "" \



      - name: Выполнить ПолучитьПодразделения
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ПолучитьПодразделения --debug --test \
          --url "" \
          --depid "" \
          --title "Тест" \
          --parentid "" \
          --headid "" \
          --token "" \



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



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



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



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



      - name: Выполнить ИзменитьПользователя
        if: ${{ cancelled() }} == false
        run: |
 
          ./oint bitrix24 ИзменитьПользователя --debug --test \
          --url "" \
          --userid "" \
          --fields "" \
          --token "" \



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



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



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



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

  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"