Как перенести онлайн-школу с GetCourse на WordPress: полное руководство

Александр Лаврищев 13 августа, 2026 Reading Time: 28 минут

Полное руководство по переезду онлайн-школы с GetCourse на WordPress: зачем это нужно, как устроен стек WordPress + Tutor LMS + WooCommerce, «тихий режим» без писем ученикам, REST-мост и скрипты импорта, нормализация текста уроков, видео в Kinescope, тарифы и апгрейды, перенос доступов и комментариев, подводные камни, чек-листы и план отката.

Как перенести онлайн-школу с GetCourse на WordPress: полное экспертное руководство

Этот материал — не обзор «в общих чертах». Это разбор реального переезда школы с GetCourse на связку WordPress + Tutor LMS + WooCommerce: с архитектурой, кодом, чек-листами, ошибками, которые стоили нам часов, и решениями, которые в итоге заработали на боевом проекте с сотней тренингов и тысячами уроков.

Читать его стоит, если вы:

владелец онлайн-школы, который упёрся в тариф GetCourse и хочет понять, во что реально обойдётся переезд;
продюсер или методист, которому нужно оценить объём работ и риски до того, как что-то сломается;
разработчик, которому поставили задачу «перенеси нам школу» и который хочет увидеть рабочие паттерны, а не теорию.

Я намеренно не превращаю статью в «сделай сам за выходные». Перенос школы — это не выгрузка CSV. Это миграция данных, прав доступа, денег и репутации одновременно. Но вы получите полную карту местности: что из чего состоит, в каком порядке двигаться, где мины и какой код закрывает каждый этап.

Оглавление смысловое

Материал построен по логике реального проекта, а не по алфавиту:

Зачем вообще переезжать и когда переезжать не надо.
Что вы теряете и что приобретаете — честно, без маркетинга.
Анатомия GetCourse: как там устроены тренинги, уроки, доступы и комментарии.
Анатомия целевого стека: WordPress, Tutor LMS, WooCommerce и обвязка.
Принципы переноса, которые экономят недели.
Подготовка инфраструктуры и бэкапов.
Инвентаризация: реестр миграции как единственный источник правды.
API-мост: почему стандартного REST не хватает и как дописать свой.
Перенос структуры: курс → раздел → урок.
Нормализация контента и типографика.
Видео: Vimeo/GetCourse-плеер → Kinescope.
Вложения, PDF и экономия дискового пространства.
Ученики и доступы: тихое зачисление.
Комментарии, задания и приватность переписки.
Деньги: товары, тарифы, апгрейды.
Публикация и даты: как не отправить курс в «запланировано».
Тихий режим: глушилка почты и отключение уведомлений.
Контроль качества и приёмка.
Подводные камни — большой список из практики.
Производительность после переезда.
SEO и сохранение трафика.
Платежи, юридика, эксплуатация.
Как выглядит работа со мной как с ИИ-агентом.
FAQ и финальный чек-лист.

Зачем переносить: экономика, контроль, гибкость

1. Стоимость владения

GetCourse тарифицируется по количеству пользователей в базе. Проблема в том, что база растёт независимо от выручки: каждый вебинар, каждая бесплатная воронка, каждый «оставьте почту за чек-лист» добавляют строки. Через два-три года активной работы школа платит за десятки тысяч контактов, из которых платят единицы процентов.

Считать нужно не «сколько стоит GetCourse», а совокупную стоимость владения за 3 года:

лицензия платформы (растущая ступенчато);
доплаты за домены, SMS, дополнительные аккаунты менеджеров;
стоимость обходных решений — когда нужного поведения нет, и вы платите подрядчику за костыли внутри чужой песочницы.

Собственная площадка меняет структуру расходов: вместо аренды — VPS или приличный shared-хостинг, разовая работа по внедрению и небольшая эксплуатация. Экономика начинает зависеть от нагрузки, а не от размера списка контактов.

2. Владение данными

На своей площадке база пользователей, тексты уроков, история заданий и комментариев лежат в вашей БД. Вы делаете дамп, поднимаете копию, увозите на другой хостинг за вечер. Никаких «выгрузите нам в CSV, но только по 1000 строк и без вложений».

Это не паранойя, а операционная устойчивость: если платформа меняет правила, поднимает цены или блокирует аккаунт по формальному признаку, у вас остаётся школа, а не воспоминания о ней.

3. SEO и трафик

GetCourse-страницы плохо приспособлены для органики: слабая семантика, неуправляемая разметка, ограниченный контроль над скоростью и структурой URL. WordPress — исторически лучшая платформа для контентного SEO: полный контроль над заголовками, микроразметкой, sitemap, скоростью, внутренней перелинковкой, блогом рядом с курсами.

Школа на WordPress может делать то, что на GetCourse делать неудобно: бесплатные статьи → лид-магнит → курс, всё в одном домене, с общей аналитикой и сквозной перелинковкой.

4. Гибкость интерфейса

На своей платформе вы правите что угодно: расположение блоков урока, вид личного кабинета, порядок вкладок, формулировки кнопок, логику доступа. В нашем проекте, например, понадобилось:

показывать ученику приватный диалог с преподавателем прямо в уроке, но скрывать его от других учеников;
вывести один курс в каталоге, а три тарифа — на его странице;
отдавать видео только через Kinescope-iframe, потому что поле «видео урока» в LMS вело себя не так, как нужно.

Ничего из этого не делается «галочкой» ни на одной SaaS-платформе. На WordPress это 100–300 строк PHP.

5. Когда переезжать НЕ надо

Честная часть. Не переезжайте, если:

школа живёт на автоворонках и сложных сценариях рассылок GetCourse, а бюджета на воссоздание этой машинерии нет;
у вас нет ни одного человека, готового отвечать за обновления, бэкапы и инциденты;
вы находитесь в пике запуска: миграция в течение запуска — гарантированный ущерб;
в школе три курса и сто учеников: экономии не будет, а работа будет.

Переезд оправдан, когда контент — актив, база большая, продуктовая линейка устоялась, а платформа стала ограничением, а не помощником.

Что вы теряете и что приобретаете

Разложим по полочкам, потому что большинство разочарований после переезда — от несовпадения ожиданий.

Теряете (или переделываете заново):

Готовые автоворонки и визуальный конструктор процессов. В WordPress это либо связка плагинов (FluentCRM, Groundhogg), либо внешний сервис рассылок.
Встроенную телефонию/CRM-логику с задачами менеджерам. Заменяется амоCRM/Битрикс + вебхуки.
Гарантированную доставляемость писем «из коробки». Придётся настроить SMTP-сервис, SPF, DKIM, DMARC самостоятельно.
Мгновенную техподдержку платформы. Теперь вы сами себе техподдержка (или ваш подрядчик).
Иллюзию, что «всё работает само». WordPress требует обновлений и внимания.

Приобретаете:

Полный контроль над данными и кодом.
Свободу интерфейса и логики продукта.
SEO-площадку и контент-маркетинг на том же домене.
Предсказуемую стоимость: платите за ресурсы, а не за размер базы.
Возможность интегрировать что угодно: Kinescope, ЮKassa, Telegram-ботов, свои сервисы.
Портируемость: захотите уйти с хостинга — увезёте всё за вечер.

Хорошая новость: обучающая часть (курсы, уроки, доступы, задания, обсуждения) переносится и работает не хуже, а часто удобнее. Плохая новость: маркетинговая машинерия переносится дольше, чем контент, и её стоит планировать отдельным проектом.

Анатомия GetCourse: что именно мы переносим

Чтобы перенос был не «копипастом», нужно понимать модель данных источника. В GetCourse она такая (упрощённо, но достаточно для проекта миграции).

Тренинг, поток, урок

Тренинг — контейнер курса. У него есть название, описание, обложка, настройки доступа.
Поток (stream) — конкретный запуск тренинга с датами и своим списком участников. Один тренинг может иметь десятки потоков, и содержимое между потоками расходится.
Урок — страница внутри тренинга. Уроки могут быть вложенными: «тренинг → урок-раздел → уроки внутри». Именно поэтому в панели вы видите 97 «тренингов», а внутри — три тысячи уроков разной вложенности.

Первое, что нужно решить: какой поток считать эталоном. Обычно берут последний завершённый: в нём финальные тексты и исправленные задания. Всё остальное — исторические артефакты; переносить их имеет смысл только ради архива доступов.

Блочная структура урока

Урок в GetCourse — это последовательность блоков: текст, видео, аудио, файл, задание, кнопка, разделитель. Это критично: при переносе порядок блоков нужно сохранить. Если у вас в уроке шло «текст → аудио → текст → видео», то ученик именно так проходил материал, и склеивать всё в «сначала весь текст, потом все медиа» — значит сломать методику.

На выходе HTML-урока порядок сохраняется, но обрастает мусором: инлайн-стили, <div> с классами платформы, «портянки» из   вместо абзацев, пустые параграфы,   пачками.

Задания и проверка

Задание — особый тип урока/блока: ученик пишет ответ, куратор проверяет, ставит статус (принято / на доработку), идёт переписка. Эта переписка — самая чувствительная часть данных: она приватная, персональная и в ней часто содержится личный контекст.

Правило: при переносе публичные обсуждения могут стать публичной вкладкой Q&A, но ответы на задания и переписка с куратором должны остаться приватными. По умолчанию LMS-плагины так себя не ведут — это придётся программировать (об этом отдельная глава).

Пользователи и доступы

В GetCourse у пользователя есть email, имя, телефон, набор тегов, история заказов и доступы к тренингам (часто с датой окончания). Доступ мог быть выдан:

покупкой;
вручную менеджером;
по группе/тегу;
по подписке.

При переносе важно не «перенести всех», а перенести актуальные доступы: активные, не истёкшие, не отозванные. Иначе вы подарите доступ людям, у которых он закончился, и лишите скидочной мотивации на продление.

Как это достать

Три способа, обычно комбинируются:

Официальный API GetCourse. Есть экспорты пользователей, заказов, групп. Хорошо для базы и денег, слабо для контента уроков.
Авторизованный HTTP-доступ к админке. Вы логинитесь как владелец и запрашиваете страницы редактирования уроков, разбирая HTML. Это основной способ достать контент.
Ручные списки. Иногда быстрее попросить владельца выгрузить статистику потока в CSV, чем автоматизировать редкий сценарий.

Минимальный пример «клиента» к админке на Python (упрощённо):

import requests
from bs4 import BeautifulSoup

class GC:
    BASE = "https://school.example.ru"

    def __init__(self, cookie: str):
        self.s = requests.Session()
        self.s.headers["User-Agent"] = "Mozilla/5.0 (migration-bot)"
        self.s.headers["Cookie"] = cookie  # сессия владельца

    def get(self, path: str) -> BeautifulSoup:
        r = self.s.get(self.BASE + path, timeout=60)
        r.raise_for_status()
        return BeautifulSoup(r.text, "lxml")

    def trainings(self):
        soup = self.get("/teach/control/stream/index")
        out = []
        for a in soup.select("a[href*='/teach/control/stream/view/id/']"):
            out.append({
                "id": a["href"].rstrip("/").split("/")[-1],
                "title": a.get_text(strip=True),
            })
        return out

Дальше по каждому тренингу забираются уроки, по каждому уроку — HTML содержимого. Всё складывается в JSON-файлы на диск: сначала выгружаем, потом обрабатываем. Никогда не делайте «скачал и сразу залил» — при первой же ошибке вы не сможете повторить шаг без повторного долгого скачивания.

Анатомия целевого стека

Ядро

WordPress — CMS и фундамент. Никакой экзотики.
Tutor LMS — LMS-слой: курсы, разделы (topics), уроки, прогресс, задания, сертификаты, личный кабинет ученика.
WooCommerce — деньги: товары, корзина, заказы, интеграция с кассой и платёжкой.

Связка Tutor + Woo даёт то, ради чего люди сидят на GetCourse: продал → автоматически выдал доступ → ученик учится в личном кабинете.

Почему Tutor LMS, а не LearnDash/LifterLMS/Sensei

Все три альтернативы рабочие. Tutor выбран по трём причинам:

адекватная модель данных (курс → topic → lesson как отдельные post types), удобная для программной миграции;
приличный фронтенд «из коробки» и живой личный кабинет;
дешевле в лицензиях и легче кастомизируется хуками.

Ключевой момент: любая LMS в этой схеме — это хранилище и рендер, а не «продукт целиком». Всё, что делает вашу школу вашей (тарифы, приватность, дизайн урока), вы всё равно допишете сами.

Обвязка, которая реально нужна

Kinescope (или аналог) — видеохостинг. Хранить видео на своём хостинге нельзя: убьёте диск и канал.
HappyFiles — папки в медиатеке. Без него библиотека из тысяч PDF превращается в свалку.
WPCodeBox 2 (или Code Snippets) — управление кастомным PHP без правки темы. Важно: один и тот же код не должен жить в двух плагинах-сниппетах одновременно — получите фатальную ошибку «функция уже объявлена» и белый экран на всём сайте.
SMTP-плагин + транзакционный сервис — доставляемость писем.
Кэш (LiteSpeed Cache / FlyingPress) и объектный кэш (Redis) — производительность.
Бэкап-плагин или бэкапы хостинга — обязательны до первого импорта.

Модель данных Tutor LMS

Это надо знать наизусть, иначе миграция превращается в гадание:

Сущность	post_type	Связь
Курс	`courses`	корень
Раздел	`topics`	`post_parent` = ID курса
Урок	`lesson`	`post_parent` = ID раздела
Задание	`tutor_assignments`	`post_parent` = ID раздела
Запись на курс	`tutor_enrolled`	`post_parent` = ID курса, `post_author` = ID ученика

Порядок элементов задаётся menu_order. Видео урока хранится в мета _video. Доступ ученика — это запись tutor_enrolled в статусе completed (да, статус называется так, это «запись оформлена», а не «курс пройден»).

Понимание этой таблицы сразу отвечает на вопрос «как программно создать курс»: это обычные записи WordPress с правильными типами, родителями и метаполями.

Принципы переноса, которые экономят недели

Это самая практичная глава. Все правила ниже выведены из ошибок.

Принцип 1. Тихий режим по умолчанию

Пока миграция не закончена, ни один ученик не должен узнать о новой площадке. Любое письмо «Вы записаны на курс», «Ваш пароль», «Новый комментарий» — это преждевременный анонс и поток вопросов в поддержку.

Технически тихий режим — это глушилка wp_mail плюс отключение уведомлений LMS. Ставится первым делом, до первого импорта, снимается последним действием проекта:

// Снипет #1: тихий режим. Ставится ПЕРВЫМ, снимается ПОСЛЕДНИМ.
add_filter('pre_wp_mail', function ($null, $atts) {
    if (get_option('lovmig_silent_mode', '1') !== '1') {
        return $null; // тихий режим выключен — письмо уходит штатно
    }
    // Логируем, чтобы видеть, что «пыталось» уйти
    error_log('[lovmig] mail suppressed: ' . wp_json_encode([
        'to' => $atts['to'] ?? '',
        'subject' => $atts['subject'] ?? '',
    ]));
    return true; // WordPress считает, что письмо отправлено; наружу ничего не ушло
}, 10, 2);

// Отключаем уведомления регистрации
add_filter('wp_new_user_notification_email_admin', '__return_false');
remove_action('register_new_user', 'wp_send_new_user_notifications');

Флаг lovmig_silent_mode в опциях — сознательное решение: выключение тихого режима становится осмысленным действием (изменить опцию), а не «удалить код и надеяться».

Принцип 2. Сначала пилот, потом конвейер

Первый курс переносится целиком и доводится до идеала: тексты, порядок блоков, видео, вложения, доступы, товар, оплата, вид в личном кабинете. Владелец школы смотрит и говорит «да, вот так». Только после этого запускается массовый перенос.

Причина простая: массовый перенос 97 курсов с неправильным правилом форматирования — это 97 курсов, которые придётся чинить. Один пилот стоит день; переделка конвейера стоит неделю.

Принцип 3. Идемпотентность

Каждый скрипт должен быть безопасен при повторном запуске. Запустили дважды — не получили дубли. Достигается «ключом соответствия»: в метаполе записи WordPress хранится ID источника.

def upsert_lesson(wp, topic_id, gc_lesson):
    existing = wp.find_by_meta("lesson", "_gc_lesson_id", gc_lesson["id"])
    payload = {
        "title": gc_lesson["title"],
        "content": gc_lesson["html"],
        "parent": topic_id,
        "status": "publish",
        "menu_order": gc_lesson["order"],
        "meta": {"_gc_lesson_id": gc_lesson["id"]},
    }
    if existing:
        return wp.update("lesson", existing["id"], payload)  # обновляем
    return wp.create("lesson", payload)                      # создаём

Без этого правила любая ошибка посреди пакета из 300 уроков превращается в ручную чистку дублей.

Принцип 4. Нормализация вместо копипаста

HTML GetCourse нельзя вставлять как есть. Он тянет чужие стили, ломает мобильную вёрстку и выглядит как «портянка». Контент проходит через конвейер очистки: удалить мусор, восстановить абзацы, поднять заголовки, починить списки, применить русскую типографику. Об этом — отдельная большая глава.

Принцип 5. Экономия хостинга

Из медиа переносим только то, что реально нужно: короткие PDF-конспекты и рабочие тетради. Картинки-украшения, гигабайты вебинарных записей, дубли презентаций — нет. Видео живёт на Kinescope, крупные файлы — на облаке со ссылкой.

Это не жадность, а эксплуатационная гигиена: диск заканчивается в самый неподходящий момент, а бэкап на 200 ГБ никто никогда не восстановит быстро.

Принцип 6. Реестр как единственный источник правды

Одна таблица, где по каждому курсу: ID в GetCourse, ID в WordPress, количество уроков, статус («не начат», «структура», «контент», «видео», «ученики», «готов»), ответственный, заметки. Без реестра на 20-м курсе вы теряете нить и начинаете переносить то, что уже перенесли.

Принцип 7. Сначала данные, потом красота

Порядок работ: структура → контент → медиа → доступы → деньги → дизайн. Каждый, кто начинает с темы оформления, потом переделывает её под реальный контент.

Принцип 8. Никаких «запланированных» публикаций

Если создать запись с датой в будущем, WordPress поставит статус future, и курс исчезнет из каталога. При программном создании всегда задавайте status: publish и дату в прошлом по GMT.

from datetime import datetime, timedelta, timezone

def past_dates():
    now = datetime.now(timezone.utc) - timedelta(days=1)
    return {
        "date_gmt": now.strftime("%Y-%m-%dT%H:%M:%S"),
        "date": now.strftime("%Y-%m-%dT%H:%M:%S"),
        "status": "publish",
    }

Подготовка инфраструктуры

Хостинг

Требования для школы среднего размера (до ~5000 активных учеников, видео вне хостинга):

PHP 8.1+, память процесса 512 МБ и выше;
MySQL/MariaDB на SSD/NVMe;
диск 20–50 ГБ (без видео этого хватает с запасом);
возможность включить Redis или Memcached;
нормальный max_execution_time (60+ секунд) для длинных операций импорта.

Shared-хостинг подходит на старте, но при активной миграции лимиты будут мешать: пакетные REST-запросы упираются в ограничения по CPU. Практичное решение — импортировать пачками по 20–50 объектов с паузами.

Домены и стратегия перехода

Три варианта:

Новый поддомен (school.example.ru), пока старая школа работает. Самый безопасный: два мира не пересекаются, переключение — сменой ссылок.
Основной домен сразу. Быстро, но требует готовности всего.
Параллельная работа с постепенным переводом потоков. Новые потоки — на новой платформе, старые доживают на GetCourse. Самый мягкий для учеников, самый дорогой по эксплуатации.

Мы работали по первому варианту и рекомендуем его.

Бэкапы перед первым импортом

Правило: до первого программного создания записи должны существовать:

полный дамп БД, скачанный локально (не только «в панели хостинга»);
копия wp-content;
понимание, как откатиться за 15 минут.

Массовый импорт умеет создавать сотни записей за минуты. Ошибка в цикле создаёт столько же мусора, и чистить его SQL-запросами по живой базе без бэкапа — плохой вечер.

Полезный приём: перед крупным пакетом фиксируйте «водяной знак» — максимальный ID записи. Тогда откат — это удаление всего, что больше него:

-- ДО импорта
SELECT MAX(ID) FROM wp_posts;   -- допустим, 10500

-- Если пакет пошёл не так (выполнять осознанно, на бэкапе!)
DELETE FROM wp_postmeta WHERE post_id > 10500;
DELETE FROM wp_posts    WHERE ID > 10500 AND post_type IN ('courses','topics','lesson');

Учётные данные и секреты

Для работы потребуются: пароль приложения WordPress (Application Password, не основной пароль), ключ Tutor API, токен Kinescope, сессия GetCourse. Держите их в переменных окружения/менеджере секретов, а не в коде скриптов.

import os
WP_USER = os.environ["WP_USER"]
WP_APP_PASSWORD = os.environ["WP_APP_PASSWORD"]  # 24 символа с пробелами
KINESCOPE_TOKEN = os.environ["KINESCOPE_TOKEN"]

Пароль приложения создаётся в профиле пользователя WordPress и отзывается одним кликом — это важно, когда над проектом работает подрядчик.

Инвентаризация: реестр миграции

Прежде чем переносить, надо посчитать. Инвентаризация отвечает на четыре вопроса: сколько объектов, какого они качества, что из этого живое, и в каком порядке двигаться.

Что считаем

количество тренингов и их вложенность;
количество уроков в каждом;
наличие видео и где оно лежит;
наличие вложений (PDF, аудио);
количество учеников с активным доступом;
наличие заданий и объём переписки.

Пример скрипта инвентаризации

import json, pathlib, time

def crawl(gc, out_dir="dump"):
    pathlib.Path(out_dir).mkdir(exist_ok=True)
    registry = []
    for t in gc.trainings():
        lessons = gc.lessons(t["id"])            # список уроков тренинга
        (pathlib.Path(out_dir) / f"lessons_{t['id']}.json").write_text(
            json.dumps(lessons, ensure_ascii=False, indent=2), encoding="utf-8")
        registry.append({
            "gc_id": t["id"],
            "title": t["title"],
            "lessons": len(lessons),
            "with_video": sum(1 for l in lessons if l.get("video")),
            "with_files": sum(1 for l in lessons if l.get("files")),
            "wp_id": None,
            "status": "new",
        })
        time.sleep(0.5)   # уважайте чужой сервер
    pathlib.Path("registry.json").write_text(
        json.dumps(registry, ensure_ascii=False, indent=2), encoding="utf-8")
    return registry

Дальше registry.json превращается в Excel/Google-таблицу, где владелец школы проставляет приоритеты и помечает то, что переносить не надо (устаревшее, снятое с продажи, дубли потоков).

Отдельная колонка — «переносить: да/нет/архив». По опыту, 30–40% контента старой школы не нужно вообще: тестовые тренинги, черновики, повторы потоков. Не переносить их — самая дешёвая оптимизация проекта.

Порядок переноса

Сортируйте не по алфавиту, а по ценности и сложности:

Один средний курс — пилот (5–15 уроков, есть видео и PDF, есть задания). На нём отлаживается весь конвейер.
Активно продающиеся курсы — они приносят деньги и нужны первыми.
Курсы с текущими потоками — их ученики уже учатся, важна непрерывность.
Архив — в фоновом режиме, без спешки.

API-мост: почему стандартного REST не хватает

WordPress отдаёт REST API «из коробки»: /wp-json/wp/v2/posts, /wp-json/wp/v2/users и так далее. Кастомные типы записей Tutor LMS по умолчанию не зарегистрированы в REST (show_in_rest = false), а специфические операции (записать ученика на курс, привязать товар, пересчитать порядок) вообще не выражаются в CRUD.

Поэтому делается свой namespace. Это ~200 строк PHP, которые превращают миграцию из мучения в вызов функции.

Регистрация типов в REST

add_action('init', function () {
    foreach (['courses', 'topics', 'lesson', 'tutor_assignments'] as $pt) {
        $obj = get_post_type_object($pt);
        if (!$obj) continue;
        $obj->show_in_rest          = true;
        $obj->rest_base             = $pt;
        $obj->rest_controller_class = 'WP_REST_Posts_Controller';
    }
}, 100);

Свой эндпоинт: создание урока с полным контролем

add_action('rest_api_init', function () {
    register_rest_route('lovmig/v1', '/lesson', [
        'methods'             => 'POST',
        'permission_callback' => function () {
            return current_user_can('manage_options');
        },
        'callback'            => function (WP_REST_Request $req) {
            $p = $req->get_json_params();

            // Идемпотентность: ищем по ключу источника
            $existing = get_posts([
                'post_type'   => 'lesson',
                'post_status' => 'any',
                'meta_key'    => '_gc_lesson_id',
                'meta_value'  => (string) $p['gc_id'],
                'numberposts' => 1,
                'fields'      => 'ids',
            ]);

            $data = [
                'post_type'    => 'lesson',
                'post_title'   => wp_strip_all_tags($p['title']),
                'post_content' => $p['content'],           // уже нормализованный HTML
                'post_parent'  => (int) $p['topic_id'],
                'post_status'  => 'publish',               // никогда не future
                'post_date'    => $p['date'],              // дата в прошлом
                'post_date_gmt'=> $p['date_gmt'],
                'menu_order'   => (int) ($p['order'] ?? 0),
            ];

            if ($existing) {
                $data['ID'] = $existing[0];
                $id = wp_update_post($data, true);
            } else {
                $id = wp_insert_post($data, true);
            }
            if (is_wp_error($id)) {
                return new WP_Error('lovmig_insert', $id->get_error_message(), ['status' => 500]);
            }

            update_post_meta($id, '_gc_lesson_id', (string) $p['gc_id']);
            // Видео НЕ кладём в _video — оно идёт iframe-ом внутри контента
            return ['id' => $id, 'updated' => (bool) $existing];
        },
    ]);
});

Обратите внимание на три вещи:

permission_callback обязателен — иначе вы открыли миру ручку создания записей;
статус жёстко publish — защита от «запланировано»;
ключ _gc_lesson_id — фундамент повторяемости.

Клиент на Python

import requests
from requests.auth import HTTPBasicAuth

class WP:
    def __init__(self, base, user, app_password):
        self.base = base.rstrip('/')
        self.auth = HTTPBasicAuth(user, app_password)

    def _req(self, method, path, **kw):
        r = requests.request(method, f"{self.base}/wp-json{path}",
                             auth=self.auth, timeout=120, **kw)
        if r.status_code >= 400:
            raise RuntimeError(f"{r.status_code} {path}: {r.text[:500]}")
        return r.json()

    def lesson(self, payload):
        return self._req("POST", "/lovmig/v1/lesson", json=payload)

    def enroll(self, course_id, email):
        return self._req("POST", "/lovmig/v1/enroll",
                         json={"course_id": course_id, "email": email})

Дальше вся миграция — это цикл for lesson in lessons: wp.lesson(build(lesson)) с логированием и обработкой ошибок.

Где хранить PHP

Категорически не в functions.php темы: обновление темы сотрёт код. Варианты: плагин mu-plugins (лучший для продакшена) или менеджер сниппетов (WPCodeBox 2, Code Snippets) — удобно, когда правки идут десятками за день.

Грабли из практики: если один и тот же код случайно окажется активным в двух менеджерах сниппетов одновременно, PHP упадёт с фатальной ошибкой «Cannot redeclare function» — и сайт отдаёт 500 целиком, включая админку. Лечится удалением дубля через файловый доступ или SQL. Правило: один код — одно место, переключение между версиями делается атомарно.

Перенос структуры курса

Структура — это скелет: курс, разделы, уроки, порядок. Делается до контента, чтобы можно было посмотреть на дерево и утвердить его.

Создание курса

def create_course(wp, gc_course):
    course = wp.post("courses", {
        "title": gc_course["title"],
        "content": gc_course["description_html"],
        "status": "publish",
        **past_dates(),
        "meta": {"_gc_course_id": gc_course["id"]},
    })
    # Обязательные метаполя Tutor
    wp.set_meta(course["id"], {
        "_tutor_course_level": "all_levels",
        "_tutor_is_public_course": "no",
        "_tutor_course_price_type": "paid",
    })
    return course["id"]

Разделы и уроки

def build_structure(wp, course_id, plan):
    """plan = [{'topic': 'Модуль 1', 'lessons': [{...}, {...}]}, ...]"""
    for t_index, block in enumerate(plan, start=1):
        topic_id = wp.post("topics", {
            "title": block["topic"],
            "parent": course_id,
            "status": "publish",
            "menu_order": t_index,
            **past_dates(),
        })["id"]

        for l_index, lesson in enumerate(block["lessons"], start=1):
            wp.lesson({
                "gc_id": lesson["id"],
                "topic_id": topic_id,
                "title": lesson["title"],
                "content": lesson["html"],
                "order": l_index,
                **past_dates(),
            })

Как выбрать разбиение на разделы

В GetCourse разделов может не быть вообще — уроки идут плоским списком. Три стратегии:

Один раздел «Программа курса» — быстро, годится для коротких курсов и вебинаров.
По неделям/модулям — если в названиях уроков есть «Неделя 1», «Модуль 2», группируем регуляркой.
По вложенности источника — если в GetCourse были уроки-разделы, они становятся topics.

import re

WEEK = re.compile(r'^(модуль|неделя|блок)\s*(\d+)', re.I)

def group_by_module(lessons):
    groups, current = [], None
    for l in lessons:
        m = WEEK.match(l["title"])
        if m:
            current = {"topic": l["title"], "lessons": []}
            groups.append(current)
            continue
        if current is None:
            current = {"topic": "Программа курса", "lessons": []}
            groups.append(current)
        current["lessons"].append(l)
    return groups

Важное: порядок уроков внутри раздела задаётся menu_order, а не датой создания. Если забыть его выставить, Tutor покажет уроки в порядке ID — то есть в порядке, в котором отработал ваш цикл. Обычно это совпадает, но полагаться нельзя.

Нормализация контента и типографика

Это глава, которую большинство подрядчиков пропускает — и именно поэтому перенесённые школы выглядят дёшево. Контент из GetCourse нельзя вставлять как есть.

Как выглядит проблема

Типичный урок после копирования:

один гигантский абзац на 4000 знаков, разделённый тегами   — «портянка»;
заголовки набраны КАПСОМ обычным текстом вместо <h3>;
нумерованные списки, где каждый пункт — отдельный <ol>, поэтому нумерация идёт «1, 1, 1» вместо «1, 2, 3»;
инлайн-стили style="font-size:14px; color:#333", ломающие тему;
пустые   десятками;
«кавычки-лапки», дефисы вместо тире, пробелы перед знаками препинания.

Конвейер очистки

Обработка идёт в несколько проходов, каждый — отдельная чистая функция. Так проще тестировать.

def normalize(html: str) -> str:
    soup = BeautifulSoup(html, "lxml")
    soup = drop_platform_junk(soup)   # 1. удалить мусорные обёртки и стили
    text = flatten_breaks(soup)       # 2. <br><br> -> абзацы
    text = promote_headings(text)     # 3. CAPS-строки -> h3/h4
    text = fix_lists(text)            # 4. склеить списки, восстановить нумерацию
    text = typography(text)           # 5. русская типографика
    return text

Шаг 1. Удаление мусора

JUNK_ATTRS = ("style", "class", "id", "data-mce-style", "align", "width", "height")

def drop_platform_junk(soup):
    for tag in soup.find_all(True):
        for attr in JUNK_ATTRS:
            tag.attrs.pop(attr, None)
    # пустые параграфы и div
    for tag in soup.find_all(["p", "div", "span"]):
        if not tag.get_text(strip=True).replace("\xa0", "") and not tag.find(["img", "iframe"]):
            tag.decompose()
    # span без атрибутов больше не нужен
    for span in soup.find_all("span"):
        span.unwrap()
    return soup

Шаг 2. Разбор «портянки»

Идея: последовательность   — это на самом деле граница абзаца. Один   внутри предложения — перенос строки, два и больше — новый абзац.

import re

def flatten_breaks(soup) -> str:
    html = str(soup)
    html = re.sub(r'(?:<br\s*/?>\s*){2,}', '\n\n', html, flags=re.I)  # абзацы
    html = re.sub(r'<br\s*/?>', '\n', html, flags=re.I)               # мягкий перенос
    blocks = [b.strip() for b in re.split(r'\n{2,}', html) if b.strip()]
    return "\n\n".join(blocks)

Тонкость: разбор нужно делать так, чтобы не порвать таблицы, списки и iframe. Практическое решение — вырезать «неприкасаемые» узлы (table, ul, ol, iframe, pre, blockquote) в плейсхолдеры до обработки и вернуть после.

def protect(html):
    store, i = {}, 0
    def repl(m):
        nonlocal i
        key = f"@@BLOCK{i}@@"; store[key] = m.group(0); i += 1
        return key
    html = re.sub(r'<(table|ul|ol|iframe|pre|blockquote)[\s\S]*?</\1>', repl, html, flags=re.I)
    return html, store

def restore(html, store):
    for k, v in store.items():
        html = html.replace(k, v)
    return html

Шаг 3. Заголовки

Авторы часто выделяют смысловые разделы капсом или жирным. Превращаем такие строки в настоящие заголовки — это даёт оглавление, семантику и нормальный вид на мобильных.

def promote_headings(text: str) -> str:
    out = []
    for block in text.split("\n\n"):
        raw = re.sub(r'<[^>]+>', '', block).strip()
        letters = [c for c in raw if c.isalpha()]
        is_caps = letters and sum(c.isupper() for c in letters) / len(letters) > 0.8
        short = len(raw) < 90 and not raw.endswith(('.', ':', '!', '?'))
        if raw and is_caps and short:
            out.append(f"<h3>{raw.capitalize()}</h3>")
        elif re.fullmatch(r'<(strong|b)>(.{3,80})</\1>', block.strip()) and short:
            inner = re.sub(r'<[^>]+>', '', block).strip()
            out.append(f"<h4>{inner}</h4>")
        else:
            out.append(f"<p>{block}</p>" if not block.startswith("<") else block)
    return "\n".join(out)

capitalize() здесь важен: заголовок КАПСОМ на сайте читается как крик.

Шаг 4. Списки и нумерация — та самая ошибка «1, 1, 1»

Самая частая и самая заметная ошибка миграции. В источнике каждый пункт часто обёрнут в собственный <ol>, поэтому браузер начинает счёт заново.

Два лечения:

def merge_adjacent_lists(html: str) -> str:
    # </ol> ... <ol> подряд -> склеиваем в один список
    return re.sub(r'</(ol|ul)>\s*<\1[^>]*>', '', html, flags=re.I)

NUM = re.compile(r'^\s*(\d+)[\.\)]\s*')  # ловим и "1. текст", и "1)текст"

def text_list_to_ol(block: str) -> str:
    lines = [l for l in block.split("\n") if l.strip()]
    items, start = [], None
    for l in lines:
        m = NUM.match(re.sub(r'<[^>]+>', '', l))
        if not m:
            return block
        if start is None:
            start = int(m.group(1))          # список может начинаться не с 1!
        items.append(NUM.sub('', l.strip()))
    if len(items) < 2:
        return block
    attr = f' start="{start}"' if start != 1 else ''
    body = "".join(f"<li>{i}</li>" for i in items)
    return f"<ol{attr}>{body}</ol>"

Ключевая деталь — start="N". Если урок содержит «шаги 7–12», список обязан начинаться с 7, а не с 1. Мы на этом обжигались: методически неверная нумерация — это претензия от преподавателя, а не косметика.

Шаг 5. Русская типографика

def typography(t: str) -> str:
    t = t.replace('&nbsp;', ' ')
    t = re.sub(r'\s+([,.;:!?])', r'\1', t)                    # пробел перед знаком
    t = re.sub(r'(?<=\s)-(?=\s)', '—', t)                     # дефис -> тире
    t = re.sub(r'"([^"<>]+)"', r'«\1»', t)                    # кавычки-ёлочки
    t = re.sub(r'\.\.\.', '…', t)
    t = re.sub(r'\b(\d+)\s*%', r'\1\u00a0%', t)               # неразрывный перед %
    t = re.sub(r'\b(в|на|с|к|о|и|а|у|по|из|от|до|не|но|за|для)\s',
               lambda m: m.group(1) + '\u00a0', t)            # предлоги не висят
    t = re.sub(r'[ \t]{2,}', ' ', t)
    return t

Тесты — обязательны

Конвейер нормализации — единственная часть миграции, которую стоит покрыть тестами. Стоимость ошибки высокая (сотни уроков), а поведение легко зафиксировать:

def test_numbering_keeps_sequence():
    src = "1. Первый\n2. Второй\n3. Третий"
    out = text_list_to_ol(src)
    assert out.count("<li>") == 3
    assert 'start=' not in out

def test_numbering_from_seven():
    src = "7. Седьмой\n8. Восьмой"
    assert 'start="7"' in text_list_to_ol(src)

def test_no_br_soup():
    assert "<br>" not in normalize("Абзац<br><br>Второй абзац")

Предпросмотр перед заливкой

Перед тем как отправить 300 уроков в WordPress, сгенерируйте локальный HTML-файл со всеми уроками подряд и просмотрите глазами. Это 20 строк кода и час сэкономленного времени на исправлениях:

def preview(lessons, path="preview.html"):
    parts = ["<meta charset='utf-8'><style>body{max-width:780px;margin:40px auto;font:17px/1.6 Georgia}</style>"]
    for l in lessons:
        parts.append(f"<hr><h2>{l['title']}</h2>{l['html']}")
    open(path, "w", encoding="utf-8").write("".join(parts))

Видео: как правильно

Почему не хранить видео у себя

Видеофайлы — самый тяжёлый актив школы. Час записи в 1080p — это 1–3 ГБ. Сто вебинаров — сотни гигабайт, которые:

забивают диск и делают бэкапы неподъёмными;
отдаются с вашего сервера, съедая канал при каждом просмотре;
не имеют адаптивного качества, поэтому ученик с мобильного интернета видит «буферизацию».

Правильно: специализированный видеохостинг. В РФ практичный выбор — Kinescope (адаптивный стриминг, защита от скачивания, аналитика досмотров, работает без VPN).

Поле «видео урока» vs iframe в контенте

Tutor LMS умеет поле _video — вставить туда ссылку и получить плеер сверху урока. На практике мы от этого отказались и всегда вставляем iframe Kinescope прямо в содержимое урока. Причины:

в уроке часто несколько видео (например, теория и разбор) — поле только одно;
порядок «текст → видео → текст» сохраняется только внутри контента;
поле навязывает свой рендер и своё положение на странице;
при переносе проще: один HTML-контент — один источник правды.

Разметка, которая корректно масштабируется:

<figure class="wp-block-embed is-type-video">
  <div style="position:relative;padding-top:56.25%">
    <iframe src="https://kinescope.io/embed/АЙДИ_ВИДЕО"
            allow="autoplay; fullscreen; picture-in-picture; encrypted-media"
            frameborder="0" allowfullscreen
            style="position:absolute;inset:0;width:100%;height:100%"></iframe>
  </div>
</figure>

Сопоставление видео из GetCourse

Задача: у вас есть урок в GetCourse с плеером и есть библиотека Kinescope. Нужно связать одно с другим. Практичный алгоритм:

Выгрузить список видео Kinescope через API (id, название, длительность).
Из урока достать название/подпись видео и, если возможно, длительность.
Сопоставить нечётким сравнением названий, затем проверить длительностью.
Всё, что не сопоставилось автоматически, вывести в отдельный список на ручную сверку.

from difflib import SequenceMatcher

def match_video(lesson_title, kinescope_items, threshold=0.62):
    best, score = None, 0
    for v in kinescope_items:
        s = SequenceMatcher(None, lesson_title.lower(), v["title"].lower()).ratio()
        if s > score:
            best, score = v, s
    return best if score >= threshold else None

Никогда не «додумывайте» соответствие: лучше оставить урок без видео и пометить его в реестре, чем поставить ученику чужую запись. Ошибка такого рода обнаруживается учеником, а не вами.

Если видео ещё нет в Kinescope

Заливка автоматизируется через их API: получаете upload-ссылку, отправляете файл, ждёте обработки, забираете ID. Практические детали: загрузка длинных файлов должна идти потоком (не читать файл в память целиком), нужен ретрай при обрыве, и обязательно логируйте соответствие «локальный файл → ID видео» в JSON — второй раз заливать 200 ГБ никто не захочет.

Вложения, PDF и медиатека

Что переносить

Переносим:

PDF-конспекты и рабочие тетради (обычно 100 КБ – 3 МБ);
чек-листы, шаблоны, таблицы;
короткие аудио, если они часть методики.

Не переносим:

декоративные картинки из уроков (они всё равно не переживут смену темы);
видео и тяжёлые презентации;
дубликаты одного и того же файла в разных уроках — грузим один раз и ссылаемся.

Дедупликация по хэшу

import hashlib, json, pathlib

MAP = pathlib.Path("files_map.json")
mapping = json.loads(MAP.read_text()) if MAP.exists() else {}

def upload_once(wp, content: bytes, filename: str, folder_id: int):
    digest = hashlib.sha256(content).hexdigest()
    if digest in mapping:
        return mapping[digest]                  # уже загружали
    media = wp.upload_media(content, filename)  # POST /wp/v2/media
    wp.set_happyfiles_folder(media["id"], folder_id)
    mapping[digest] = {"id": media["id"], "url": media["source_url"]}
    MAP.write_text(json.dumps(mapping, ensure_ascii=False, indent=2))
    return mapping[digest]

Имена файлов и кириллица

Классические грабли: имя файла на кириллице ломает заголовок Content-Disposition (ошибка кодировки latin-1) и создаёт нечитаемые URL. Решение — транслитерация с сохранением человекочитаемого заголовка вложения:

TRANS = str.maketrans({
    'а':'a','б':'b','в':'v','г':'g','д':'d','е':'e','ё':'e','ж':'zh','з':'z','и':'i',
    'й':'y','к':'k','л':'l','м':'m','н':'n','о':'o','п':'p','р':'r','с':'s','т':'t',
    'у':'u','ф':'f','х':'h','ц':'c','ч':'ch','ш':'sh','щ':'sch','ъ':'','ы':'y','ь':'',
    'э':'e','ю':'yu','я':'ya',' ':'-'})

def safe_name(name: str) -> str:
    stem, _, ext = name.rpartition('.')
    slug = (stem or name).lower().translate(TRANS)
    slug = re.sub(r'[^a-z0-9\-_]+', '-', slug).strip('-')[:80]
    return f"{slug}.{ext.lower()}" if ext else slug

Заголовок вложения в медиатеке при этом оставляем нормальный, русский — его видит только администратор.

Папки медиатеки

Тысяча файлов без структуры — это медиатека, в которой невозможно ничего найти. HappyFiles (или FileBird) добавляет папки. При программной загрузке файл сразу кладётся в нужную папку — это просто термин таксономии:

// Кладём вложение в папку HappyFiles с ID 20
wp_set_object_terms($attachment_id, [20], 'happyfiles_category', false);

Структура папок, которая себя оправдала: Курсы / <Название курса> / Конспекты. Плоские папки «PDF 2024» через полгода бесполезны.

Ссылка на файл в уроке

Не оставляйте голый URL. Оформляйте блоком с иконкой и весом файла — это снижает количество вопросов в поддержку:

<p class="lesson-file">
  <a href="{URL}" target="_blank" rel="noopener">
    📄 Конспект урока (PDF, 420 КБ)
  </a>
</p>

Ученики и доступы

Самая ответственная часть: здесь ошибка означает, что человек либо не может войти на купленный курс, либо получил доступ к тому, за что не платил.

Сопоставление пользователей

Ключ сопоставления — email в нижнем регистре, с обрезкой пробелов. Дополнительно стоит нормализовать частые опечатки доменов (gmial.com, mail.ru с пробелом).

def norm_email(e: str) -> str:
    e = (e or "").strip().lower().replace(" ", "")
    fixes = {"gmial.com": "gmail.com", "yandex.ry": "yandex.ru", "mail.ri": "mail.ru"}
    user, _, dom = e.partition("@")
    return f"{user}@{fixes.get(dom, dom)}" if dom else e

Тихое создание пользователя

Создаём пользователя WordPress без письма, со случайным паролем. Пароль ученик получит позже, когда школа официально откроется — через «Восстановление пароля» или запланированную рассылку.

register_rest_route('lovmig/v1', '/enroll', [
  'methods' => 'POST',
  'permission_callback' => fn() => current_user_can('manage_options'),
  'callback' => function (WP_REST_Request $r) {
      $p = $r->get_json_params();
      $email = sanitize_email($p['email']);
      $course_id = (int) $p['course_id'];

      $user = get_user_by('email', $email);
      if (!$user) {
          $login = sanitize_user(current(explode('@', $email)), true);
          if (username_exists($login)) $login .= '_' . wp_rand(100, 999);
          $uid = wp_insert_user([
              'user_login' => $login,
              'user_email' => $email,
              'user_pass'  => wp_generate_password(20),
              'display_name' => $p['name'] ?? $login,
              'role'       => 'subscriber',
          ]);
          if (is_wp_error($uid)) return $uid;
          update_user_meta($uid, '_gc_user_id', $p['gc_id'] ?? '');
      } else {
          $uid = $user->ID;
      }

      // Уже записан?
      $exists = get_posts([
          'post_type'   => 'tutor_enrolled',
          'post_parent' => $course_id,
          'author'      => $uid,
          'post_status' => 'any',
          'numberposts' => 1,
          'fields'      => 'ids',
      ]);
      if ($exists) return ['user_id' => $uid, 'enrolled' => true, 'created' => false];

      $enroll_id = wp_insert_post([
          'post_type'   => 'tutor_enrolled',
          'post_title'  => 'Course Enrolled',
          'post_status' => 'completed',   // именно этот статус = активный доступ
          'post_parent' => $course_id,
          'post_author' => $uid,
          'post_date'   => $p['date'] ?? current_time('mysql'),
      ]);
      // без do_action('tutor_after_enrolled') — чтобы не запускать уведомления
      return ['user_id' => $uid, 'enroll_id' => $enroll_id, 'created' => true];
  },
]);

Обратите внимание на комментарий про do_action. Штатная функция записи на курс дергает хуки, на которых висят письма и интеграции. При тихой миграции мы сознательно пишем запись напрямую.

Проверка после импорта

Каждый пакет зачислений заканчивается сверкой: сколько было в источнике, сколько создано, сколько уже существовало, кто не прошёл и почему.

report = {"total": 0, "created": 0, "existed": 0, "failed": []}
for row in students:
    report["total"] += 1
    try:
        res = wp.enroll(course_id, norm_email(row["email"]))
        report["created" if res["created"] else "existed"] += 1
    except Exception as e:
        report["failed"].append({"email": row["email"], "error": str(e)[:200]})
print(json.dumps(report, ensure_ascii=False, indent=2))

Отчёт сохраняется в файл рядом с курсом. Через месяц, когда придёт вопрос «а Иванова точно перенесли?», вы ответите за 10 секунд.

Что делать с истёкшими доступами

Три политики, выбирает владелец школы:

Не переносить — чисто, но люди, привыкшие возвращаться к материалам, будут недовольны.
Перенести как активные — щедро, но обесценивает продление.
Перенести с меткой «архив» — доступ есть, но курс помечен как завершённый, без поддержки куратора. Компромисс, который в большинстве школ принимают лучше всего.

Техническая реализация третьего варианта — метаполе на записи tutor_enrolled плюс фильтр в шаблоне личного кабинета.

Комментарии, задания и приватность переписки

Почему это отдельная глава

В GetCourse под уроком обычно живёт смешанная лента: и «а где ссылка на зум?», и развёрнутый личный ответ на задание с рассказом о семейном конфликте. Перенести это «как есть» в открытые комментарии WordPress — значит выложить приватные тексты учеников в публичный доступ. Это не баг вёрстки, это утечка персональных данных со всеми последствиями.

Поэтому мы разделяем два потока:

Публичный Q&A — вопросы по материалу, видны всем участникам курса. Полезны: снимают повторяющиеся вопросы.
Приватный диалог с преподавателем — ответы на задания и личная переписка. Видны только автору и персоналу школы.

Модель данных

Публичный слой — штатные комментарии Tutor LMS (tutor_q_and_a). Приватный слой — собственный тип комментария, например lovmig_dialog, с фильтрацией на уровне запроса.

// Приватный диалог: показываем только автору ветки и персоналу
add_filter('comments_clauses', function ($clauses, $query) {
    $type = $query->query_vars['type'] ?? '';
    if ($type !== 'lovmig_dialog') return $clauses;

    if (current_user_can('edit_others_posts')) return $clauses; // персонал видит всё

    global $wpdb;
    $uid = get_current_user_id();
    if (!$uid) {                       // гость не видит ничего
        $clauses['where'] .= ' AND 1=0';
        return $clauses;
    }
    // Видны ветки, где ученик автор корневого сообщения
    $clauses['where'] .= $wpdb->prepare(
        " AND ( {$wpdb->comments}.user_id = %d
                OR {$wpdb->comments}.comment_parent IN (
                     SELECT c2.comment_ID FROM {$wpdb->comments} c2
                     WHERE c2.user_id = %d ) )", $uid, $uid);
    return $clauses;
}, 10, 2);

Грабли: подзапрос к той же таблице внутри comments_clauses легко приводит к рекурсии — фильтр вызывается на вложенном запросе и уходит в бесконечность. Лечится либо флагом (static $inside = false), либо, как выше, прямым SQL-подзапросом вместо get_comments().

Перенос истории

Правила переноса переписки:

сохраняем автора: ищем пользователя по email, при отсутствии — создаём (тихо);
сохраняем дату: comment_date и comment_date_gmt из источника, иначе вся история «схлопнется» в день миграции;
сохраняем иерархию «вопрос → ответ» через comment_parent, для чего ведём карту соответствия ID источника и ID WordPress;
отключаем уведомления на время импорта.

comment_map = {}   # gc_comment_id -> wp_comment_id

def push_comment(wp, lesson_wp_id, c):
    payload = {
        "post": lesson_wp_id,
        "content": normalize(c["html"]),
        "author_email": norm_email(c["email"]),
        "author_name": c["name"],
        "date_gmt": c["created_at"],           # ISO-строка из источника
        "type": "lovmig_dialog" if c["private"] else "tutor_q_and_a",
        "parent": comment_map.get(c.get("parent_id"), 0),
        "status": "approve",
    }
    res = wp.post_comment(payload)
    comment_map[c["id"]] = res["id"]
    return res

Уведомления преподавателю

После снятия тихого режима преподаватель должен узнавать о новых сообщениях учеников. Реализация — хук на добавление комментария приватного типа плюс счётчик непрочитанного в админке и в личном кабинете:

add_action('wp_insert_comment', function ($id, $comment) {
    if ($comment->comment_type !== 'lovmig_dialog') return;
    if (user_can($comment->user_id, 'edit_others_posts')) return; // ответ преподавателя

    delete_transient('lovmig_unread_count');   // сбрасываем кэш счётчика
    if (get_option('lovmig_silent_mode', '1') === '1') return; // тихий режим

    $lesson = get_post($comment->comment_post_ID);
    wp_mail(
        get_option('admin_email'),
        'Новый ответ ученика: ' . $lesson->post_title,
        "Ученик: {$comment->comment_author}\n\n{$comment->comment_content}\n\n"
        . get_permalink($lesson)
    );
}, 10, 2);

Счётчик обязательно кэшируйте транзиентом: подсчёт непрочитанных на каждой загрузке админки при десятках тысяч комментариев заметно тормозит панель.

function lovmig_unread(): int {
    $n = get_transient('lovmig_unread_count');
    if ($n !== false) return (int) $n;
    global $wpdb;
    $n = (int) $wpdb->get_var(
        "SELECT COUNT(*) FROM {$wpdb->comments} c
          LEFT JOIN {$wpdb->commentmeta} m
            ON m.comment_id = c.comment_ID AND m.meta_key = '_lovmig_read'
         WHERE c.comment_type = 'lovmig_dialog' AND m.meta_id IS NULL");
    set_transient('lovmig_unread_count', $n, 5 * MINUTE_IN_SECONDS);
    return $n;
}

Формулировки в интерфейсе

Мелочь, которая решает половину вопросов в поддержку. Блок диалога в уроке подписывается не «Личные ветки учеников», а по-человечески:

Диалог с преподавателем. Здесь вы отправляете ответ на задание из этого урока и общаетесь с преподавателем лично. Переписку видите только вы и преподаватель. Общие вопросы по материалу задавайте во вкладке «Вопросы и ответы» — их видят все участники курса.

Деньги: товары, тарифы, апгрейды

Базовая схема

В связке Tutor + WooCommerce курс — это контент, а товар — это то, что покупают. Важно понимать: Tutor не создаёт товар автоматически. Курс без привязанного товара считается бесплатным, и его «купит» кто угодно нажатием одной кнопки. Это самая дорогая ошибка миграции: перенесли 40 курсов, забыли про товары — и все они открыты бесплатно.

Правильная последовательность:

// 1. Создаём товар
$product_id = wp_insert_post([
    'post_type'   => 'product',
    'post_title'  => $course_title,
    'post_status' => 'publish',
]);
wp_set_object_terms($product_id, 'simple', 'product_type');
update_post_meta($product_id, '_regular_price', '15000');
update_post_meta($product_id, '_price', '15000');
update_post_meta($product_id, '_virtual', 'yes');
update_post_meta($product_id, '_sold_individually', 'yes');
update_post_meta($product_id, '_tutor_product', 'yes');

// 2. Привязываем к курсу
update_post_meta($course_id, '_tutor_course_product_id', $product_id);
update_post_meta($course_id, '_tutor_course_price_type', 'paid');

Проверка после массового переноса — обязательный SQL-аудит «курсы без товара»:

SELECT p.ID, p.post_title
FROM wp_posts p
LEFT JOIN wp_postmeta m
  ON m.post_id = p.ID AND m.meta_key = '_tutor_course_product_id'
WHERE p.post_type = 'courses'
  AND p.post_status = 'publish'
  AND (m.meta_value IS NULL OR m.meta_value = '');

Многотарифные курсы: постановка задачи

В GetCourse тариф — это отдельный «продукт» внутри тренинга: базовый, с обратной связью, VIP. В Tutor каждый тариф технически проще сделать отдельным курсом (у них разный набор уроков). Но тогда в каталоге появляются три карточки «Марафон по текстам» подряд, и ученик не понимает, что это одно и то же.

Требования, которые мы формулировали для решения:

в каталоге — одна карточка курса;
на странице курса — понятный блок сравнения тарифов;
кнопка не «В корзину», а «Выбрать тариф»;
количество тарифов произвольное: два, три, пять;
ученик может повысить тариф с доплатой разницы;
преподавателю — минимум ручной работы.

Архитектура «групп тарифов»

Каждому курсу-тарифу проставляются два метаполя:

_lovmig_tier_group — общий строковый ключ группы (например, marathon-texts-3);
_lovmig_tier_order — порядковый номер тарифа (1 — базовый, он же «витринный»).

Дальше:

// Скрываем из каталога все тарифы, кроме базового
add_action('pre_get_posts', function ($q) {
    if (is_admin() || !$q->is_main_query()) return;
    if (!is_post_type_archive('courses') && !is_tax('course-category')) return;

    $meta = (array) $q->get('meta_query');
    $meta[] = [
        'relation' => 'OR',
        ['key' => '_lovmig_tier_group', 'compare' => 'NOT EXISTS'], // обычные курсы
        ['key' => '_lovmig_tier_order', 'value' => '1'],            // базовый тариф
    ];
    $q->set('meta_query', $meta);
});

Цена в карточке каталога подменяется на «от N ₽» — минимальная среди тарифов группы, а кнопка — на «Выбрать тариф», ведущую на страницу курса с якорем к блоку тарифов.

Блок выбора тарифа на странице курса

Рендерится хуком после описания курса. Логика проста: найти все курсы с тем же _lovmig_tier_group, отсортировать по _lovmig_tier_order, показать карточки.

function lovmig_tiers(int $course_id): array {
    $group = get_post_meta($course_id, '_lovmig_tier_group', true);
    if (!$group) return [];
    $ids = get_posts([
        'post_type'   => 'courses',
        'post_status' => 'publish',
        'numberposts' => -1,
        'fields'      => 'ids',
        'meta_key'    => '_lovmig_tier_order',
        'orderby'     => 'meta_value_num',
        'order'       => 'ASC',
        'meta_query'  => [['key' => '_lovmig_tier_group', 'value' => $group]],
    ]);
    return array_map(function ($id) {
        $pid = (int) get_post_meta($id, '_tutor_course_product_id', true);
        return [
            'id'      => $id,
            'title'   => get_the_title($id),
            'price'   => $pid ? (float) get_post_meta($pid, '_price', true) : 0,
            'product' => $pid,
            'perks'   => array_filter(array_map('trim',
                          explode("\n", (string) get_post_meta($id, '_lovmig_tier_perks', true)))),
            'lessons' => count(get_posts(['post_type' => 'lesson', 'numberposts' => -1,
                          'fields' => 'ids', 'post_parent__in' => get_posts([
                            'post_type' => 'topics', 'post_parent' => $id,
                            'numberposts' => -1, 'fields' => 'ids'])])),
        ];
    }, $ids);
}

Карточка тарифа показывает: название, цену, список преимуществ (_lovmig_tier_perks, по строке на пункт), количество уроков и кнопку покупки. Если у пользователя уже есть один из тарифов группы — вместо «Купить» показывается «Повысить тариф».

Апгрейд с доплатой разницы

Логика: ученик уже заплатил за тариф A, хочет тариф B. Он платит цена(B) − цена(A); после оплаты получает доступ к B (доступ к A остаётся — это проще и честнее).

add_action('woocommerce_before_calculate_totals', function ($cart) {
    if (is_admin() && !defined('DOING_AJAX')) return;
    foreach ($cart->get_cart() as $item) {
        if (empty($item['lovmig_upgrade_from'])) continue;
        $from_price = (float) get_post_meta(
            (int) get_post_meta((int) $item['lovmig_upgrade_from'], '_tutor_course_product_id', true),
            '_price', true);
        $new_price = max(0, (float) $item['data']->get_price() - $from_price);
        $item['data']->set_price($new_price);
        $item['data']->set_name($item['data']->get_name() . ' — доплата за повышение тарифа');
    }
});

Практические детали, о которых забывают:

доплата должна быть неотрицательной (max(0, …)) — иначе понижение тарифа сгенерирует отрицательный чек;
в корзине нужно показывать, от какого тарифа идёт апгрейд, иначе ученик не понимает, за что платит;
скидочные купоны и апгрейд конфликтуют — решите заранее, разрешены ли купоны на доплату;
после оплаты доступ выдаётся стандартным хуком заказа Woo — не пишите свою выдачу, если можно повесить на woocommerce_order_status_completed.

Административный интерфейс

Чтобы преподаватель не редактировал метаполя руками, делается простая страница «Тарифы курсов»: список групп, курсы внутри, порядок, цены, кнопка «сделать базовым». 150 строк PHP, которые экономят десятки обращений в поддержку от самого владельца школы.

Публикация, даты и статусы

Ловушка «запланировано»

Если при программном создании записи передать дату в будущем — WordPress присвоит статус future. Курс формально создан, но:

не виден в каталоге;
не открывается по прямой ссылке для учеников;
в админке выглядит нормально, поэтому ошибку замечают поздно.

Причина будущей даты бывает неочевидной: часовые пояса. Вы передаёте date в московском времени, WordPress трактует пришедшее как GMT (или наоборот) — и запись оказывается «на три часа в будущем».

Правило: всегда указывайте и date, и date_gmt, оба в прошлом, и явно ставьте status: publish.

Аварийный «расплановщик» на случай, если что-то всё же уехало в будущее:

register_rest_route('lovmig/v1', '/unschedule', [
  'methods' => 'POST',
  'permission_callback' => fn() => current_user_can('manage_options'),
  'callback' => function () {
      global $wpdb;
      $ids = $wpdb->get_col(
        "SELECT ID FROM {$wpdb->posts}
          WHERE post_status = 'future'
            AND post_type IN ('courses','topics','lesson','tutor_assignments')");
      $done = [];
      foreach ($ids as $id) {
          $t = current_time('mysql');
          $wpdb->update($wpdb->posts, [
              'post_status'   => 'publish',
              'post_date'     => $t,
              'post_date_gmt' => get_gmt_from_date($t),
          ], ['ID' => $id]);
          clean_post_cache($id);
          $done[] = (int) $id;
      }
      return ['unscheduled' => $done, 'count' => count($done)];
  },
]);

Запускать после каждого крупного пакета — дешёвая страховка.

Дата в прошлом: зачем

Курс, датированный сегодняшним днём, попадает в «новинки» и в RSS. При тихой миграции этого не нужно. Плюс архивные курсы логично датировать примерно тем временем, когда они реально шли, — так лента материалов выглядит правдоподобно.

Тихий режим: полный чек-лист

Тихий режим — это не одна галочка, а набор из шести мест, где WordPress и плагины норовят отправить письмо.

wp_mail — глобальная глушилка через pre_wp_mail (код в главе про принципы).
Регистрация пользователей — wp_new_user_notification не должен вызываться; создавайте пользователя через wp_insert_user, а не wp_create_user + уведомление.
Уведомления Tutor LMS — в настройках плагина выключаются письма о записи на курс, публикации урока, новом вопросе, проверке задания.
WooCommerce — письма о заказе, счёте, выполнении. Отключаются в WooCommerce → Настройки → Письма (или тем же pre_wp_mail).
Комментарии — «Уведомлять автора» и «Модерация» шлют письма администратору; при импорте тысячи комментариев это лавина.
Внешние интеграции — вебхуки в CRM, Telegram-боты, коннекторы рассылок. Их надо выключать явно: глушилка wp_mail их не остановит.

Проверка перед началом: отправьте себе тестовое письмо из админки. Если оно пришло — тихий режим не работает, останавливайтесь.

// Проверка: должно вернуть true и НИЧЕГО не отправить
$sent = wp_mail('test@example.com', 'ping', 'ping');
error_log('silent check: ' . var_export($sent, true));

Снятие тихого режима

Это отдельная процедура, а не «удалить сниппет»:

Убедиться, что все курсы перенесены и проверены.
Настроить SMTP и прогреть домен (SPF, DKIM, DMARC).
Отправить письма самому себе и трём сотрудникам.
Выключить флаг lovmig_silent_mode.
Отправить объявление ученикам вручную и волнами (не всем сразу), с инструкцией по входу.
Быть у поддержки в первые 48 часов.

Порядок важен: включённая доставка + непрогретый домен = массовое попадание в спам, и это чинится неделями.

Контроль качества и приёмка

Автоматические проверки

После переноса каждого курса скрипт-аудитор проходит по чек-листу и выдаёт отчёт:

def audit(wp, course_id):
    problems = []
    course = wp.get("courses", course_id)
    if course["status"] != "publish":
        problems.append("курс не опубликован")
    if not wp.meta(course_id, "_tutor_course_product_id"):
        problems.append("нет привязанного товара")

    topics = wp.children("topics", course_id)
    if not topics:
        problems.append("нет ни одного раздела")

    lessons = [l for t in topics for l in wp.children("lesson", t["id"])]
    if not lessons:
        problems.append("нет уроков")

    for l in lessons:
        html = l["content"]["rendered"]
        if "<br><br>" in html or html.count("<br>") > 15:
            problems.append(f"урок {l['id']}: портянка из <br>")
        if "getcourse" in html or "gc-" in html:
            problems.append(f"урок {l['id']}: остались следы источника")
        if l["status"] != "publish":
            problems.append(f"урок {l['id']}: статус {l['status']}")
        if not html.strip():
            problems.append(f"урок {l['id']}: пустой контент")

    return {"course": course_id, "lessons": len(lessons), "problems": problems}

Проверки, которые делает человек

Автотесты не увидят методических ошибок. Обязательный ручной проход по пилотному курсу:

открыть курс глазами ученика (отдельный тестовый аккаунт, не админ!);
пройти три урока подряд: читается ли текст, играет ли видео, скачивается ли PDF;
отправить ответ на задание и убедиться, что его не видит второй тестовый ученик;
проверить порядок уроков и разделов;
посмотреть на мобильном — половина учеников учится с телефона;
проверить, что курс виден в каталоге и цена корректна;
сделать тестовую покупку (в песочнице платёжки) и убедиться, что доступ выдался автоматически.

Тестировать под администратором нельзя: админ видит всё, включая черновики и чужие приватные ветки. Заведите пользователя test-student@… и проверяйте под ним в приватном окне.

Приёмка владельцем

Пилот показывается владельцу школы с конкретными вопросами, а не «посмотрите, нормально?»:

совпадает ли порядок материалов с оригиналом;
корректны ли названия и терминология;
не потерялись ли методические акценты (выделения, предупреждения, домашние задания);
устраивает ли оформление тарифов и цен.

Только после письменного «да» запускается конвейер.

Подводные камни: список из практики

Здесь собраны реальные грабли. Каждая стоила времени.

1. Один код в двух менеджерах сниппетов

Симптом: сайт целиком отдаёт 500, включая /wp-admin. Причина: Cannot redeclare function. Возникает, когда мигрируете сниппеты из Code Snippets в WPCodeBox и забываете отключить оригинал. Лечение: отключить дубль через SQL или файловый доступ (wp-content/plugins переименовать). Профилактика: переключение делать атомарно, один код — одно место.

2. Нумерация «1, 1, 1»

Разобрана в главе про типографику. Проверяется одним поиском по базе: список из более чем одного <ol> подряд.

3. Курс без товара = бесплатный курс

Проверяется SQL-запросом из главы про деньги. Делайте эту проверку после каждого пакета.

4. Статус `future`

Проверяется запросом SELECT COUNT(*) FROM wp_posts WHERE post_status='future'. Должно быть ноль.

5. Дубли пользователей из-за регистра email

Ivanov@mail.ru и ivanov@mail.ru — для WordPress это два разных пользователя. Нормализуйте email до сравнения, всегда.

6. Кириллические имена файлов

Ошибка 'latin-1' codec can't encode characters при загрузке. Транслитерация решает.

7. Приватные ответы, ставшие публичными

Самая опасная ошибка. Проверяется вручную: зайти вторым тестовым учеником и попытаться увидеть чужую переписку. Делайте эту проверку до открытия школы, а не после.

8. Тайм-ауты при массовом импорте

Shared-хостинг обрывает долгие запросы. Решение: пакеты по 20–50 объектов, пауза 0.3–1 с между запросами, ретраи с экспоненциальной задержкой.

import time
def with_retry(fn, tries=4, base=1.5):
    for i in range(tries):
        try:
            return fn()
        except Exception as e:
            if i == tries - 1:
                raise
            time.sleep(base ** i)

9. Потерянный порядок блоков в уроке

Если парсер сначала собирает весь текст, а потом все медиа — методика ломается. Обходите DOM последовательно и складывайте блоки в один список в порядке появления.

10. Забытые вебхуки и интеграции

Глушилка wp_mail не останавливает интеграцию с CRM. Отключайте явно.

11. Медиатека-свалка

Тысячи файлов без папок. Раскладывайте сразу при загрузке — потом это ручная работа на дни.

12. Кэш, который прячет результат

Вы поправили урок, а на сайте старая версия. При активной миграции держите кэш страниц выключенным и включайте в самом конце.

13. Расхождение имени преподавателя

Мелочь, которая бьёт по доверию: в одном курсе «Дмитрий», в другом «Рубен». Ведите словарь замен и прогоняйте его по всему контенту перед публикацией.

REPLACEMENTS = {
    "Дмитрий Могилевский": "Рубен Могилевский",
    "школа GetCourse": "школа",
}
def apply_replacements(html: str) -> str:
    for a, b in REPLACEMENTS.items():
        html = html.replace(a, b)
    return html

14. Ссылки на старую платформу внутри уроков

Уроки полны внутренних ссылок вида https://school.old.ru/pl/teach/control/lesson/view?id=…. После переезда они ведут «наружу». Составьте карту «старый URL → новый ID» и прогоните замену; то, что не сопоставилось, пометьте и покажите методисту.

15. Проверка ролью администратора

Уже упоминалась, но повторю: админ видит то, чего не видит ученик. Половина «работает!» на приёмке — это проверка под админом.

Производительность после переезда

Школа отличается от блога тем, что у неё много авторизованных пользователей. А авторизованный пользователь не получает страницу из обычного кэша — каждая загрузка идёт в PHP и БД. Поэтому «поставил кэш-плагин» здесь не работает так, как на контентном сайте.

Что реально ускоряет школу

Объектный кэш (Redis). Кэшируются результаты запросов к БД внутри одного и между запросами. Для LMS с тяжёлыми метаполями это самый заметный выигрыш.
Оптимизация собственных запросов. Любой ваш COUNT(*) по комментариям или уроков в цикле — кандидат на транзиент.
Отказ от posts_per_page => -1 там, где элементов может быть тысячи.
Индексы. Если вы часто ищете по своему метаполю (_gc_lesson_id, _lovmig_tier_group), таблица wp_postmeta скажет спасибо за составной индекс.

-- Ускоряет поиск по значению метаполя (осторожно на больших базах, делайте на копии)
ALTER TABLE wp_postmeta ADD INDEX lovmig_key_value (meta_key(32), meta_value(64));

Кэширование фрагментов. Блок тарифов, дерево курса, счётчик непрочитанных — всё это транзиенты с TTL 5–15 минут и явной инвалидацией на изменение.

function lovmig_course_tree(int $course_id): array {
    $key = "lovmig_tree_{$course_id}";
    $tree = get_transient($key);
    if ($tree !== false) return $tree;
    $tree = build_tree($course_id);                 // тяжёлая функция
    set_transient($key, $tree, 15 * MINUTE_IN_SECONDS);
    return $tree;
}
// Инвалидация при изменении урока
add_action('save_post_lesson', function ($id, $post) {
    $topic = get_post($post->post_parent);
    if ($topic) delete_transient("lovmig_tree_{$topic->post_parent}");
}, 10, 2);

Мониторинг

Поставьте Query Monitor на этапе разработки и посмотрите на страницу урока глазами профайлера. Нормальные ориентиры для школы:

запросов к БД на страницу урока: до 80–120;
время генерации: до 400 мс;
пиковая память: до 128 МБ.

Если видите 600 запросов — почти наверняка где-то цикл с get_post_meta внутри или WP_Query без ограничения.

Изображения и фронтенд

WebP/AVIF для обложек курсов;
отложенная загрузка (loading="lazy") — по умолчанию в современном WordPress;
iframe видео — тоже loading="lazy", а лучше «фасад»: превью-картинка, плеер грузится по клику. Это заметно ускоряет уроки с несколькими видео.

SEO и сохранение трафика

Если старая школа собирала органику, переезд — это операция с трафиком, а не только с контентом.

Что делать обязательно

Карта редиректов. Каждый индексируемый URL старой площадки → соответствующий новый URL, редиректом 301. Не «все на главную» — это гарантированная потеря позиций.
Сохранить структуру URL, где возможно. Если старые ссылки читаемые, повторите логику на новом сайте.
Метаданные. Title до 60 символов с ключом, description до 160. У каждой страницы курса — свои, а не шаблонные.
Микроразметка Course. Поисковики понимают структурированные данные об обучении:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Course",
  "name": "Марафон по текстам",
  "description": "Практический курс по редактуре и структуре текста.",
  "provider": { "@type": "Organization", "name": "Школа", "sameAs": "https://school.example.ru" },
  "offers": { "@type": "Offer", "price": "15000", "priceCurrency": "RUB",
              "availability": "https://schema.org/InStock" }
}
</script>

Sitemap и Search Console. Добавьте новый сайт, отправьте карту, следите за отчётом об индексации первые два месяца.
Не закрывайте личный кабинет от индексации задним числом — сразу пропишите noindex для страниц уроков, если контент платный, но оставьте индексируемыми страницы курсов-лендингов.

Чего делать не надо

Удалять старый сайт сразу. Оставьте его с редиректами минимум на 3–6 месяцев.
Публиковать все 97 курсов в один день без описаний. Пустые страницы курсов — это тонкий контент, поисковики его не любят.
Копировать описания курсов один в один со старого сайта, если он остаётся живым: получите дубли.

Платежи и эксплуатация

Приём оплат

WooCommerce работает с российскими провайдерами (ЮKassa, Тинькофф, Робокасса, CloudPayments) через официальные плагины. Что нужно предусмотреть:

онлайн-касса и фискализация — чек должен уходить автоматически, состав чека с корректной ставкой НДС и признаком предмета расчёта «услуга»;
рассрочка/частичная оплата — если она была на старой площадке, воспроизведите её до переезда учеников, а не после;
возвраты — процедура и то, отзывается ли доступ при возврате (по умолчанию нет — это надо прописать хуком);
тестовая покупка в песочнице до открытия.

// Отзыв доступа при возврате заказа
add_action('woocommerce_order_status_refunded', function ($order_id) {
    $order = wc_get_order($order_id);
    foreach ($order->get_items() as $item) {
        $course_id = (int) get_post_meta($item->get_product_id(), '_tutor_course_id', true);
        if (!$course_id) continue;
        $enrolled = get_posts([
            'post_type' => 'tutor_enrolled', 'post_parent' => $course_id,
            'author' => $order->get_user_id(), 'numberposts' => -1, 'fields' => 'ids',
        ]);
        foreach ($enrolled as $eid) {
            wp_update_post(['ID' => $eid, 'post_status' => 'cancelled']);
        }
    }
});

Регулярная эксплуатация

Минимальный регламент, без которого школа деградирует за полгода:

Бэкапы ежедневно, с хранением 30 дней и проверкой восстановления раз в квартал. Непроверенный бэкап — это не бэкап.
Обновления плагинов раз в 1–2 недели, сначала на staging.
Мониторинг доступности (внешний пинг) и уведомление в мессенджер.
Проверка доставляемости писем раз в месяц (Mail-tester или аналог).
Логи ошибок: включённый WP_DEBUG_LOG с ротацией, просмотр раз в неделю.
Безопасность: двухфакторная аутентификация для администраторов, ограничение попыток входа, отключение редактора файлов в админке.

// wp-config.php — минимальная гигиена
define('DISALLOW_FILE_EDIT', true);
define('WP_DEBUG', false);
define('WP_DEBUG_LOG', true);
define('WP_AUTO_UPDATE_CORE', 'minor');

Сколько это стоит и сколько длится

Ориентиры из реального проекта (97 тренингов, около 3200 уроков, несколько тысяч учеников).

Этап	Срок	Комментарий
Аудит и инвентаризация	1–3 дня	Выгрузка структуры, подсчёт объёмов, отсев ненужного
Развёртывание стека	1–2 дня	WordPress, LMS, Woo, тема, тихий режим, бэкапы
API-мост и скрипты	2–4 дня	Эндпоинты, клиент, конвейер нормализации
Пилотный курс до идеала	2–3 дня	Здесь принимаются все решения по формату
Массовый перенос контента	1–3 недели	Зависит от объёма и качества исходников
Видео (сопоставление/заливка)	параллельно	Узкое место — скорость аплоада
Ученики и доступы	1–2 дня	Быстро, если база чистая
Деньги, тарифы, тесты оплат	2–4 дня	Плюс время на подключение кассы
Приёмка и снятие тихого режима	2–3 дня	Волновая рассылка ученикам

Итого для крупной школы: от 4 до 8 недель при плотной работе. Для школы из 5–10 курсов — 1–2 недели.

Основные статьи расходов: работа по переносу, видеохостинг (по объёму хранения и трафику), хостинг (от нескольких тысяч рублей в месяц), лицензии плагинов (обычно до 300–400 $ в год суммарно), эквайринг.

Приложение А. Глубокий разбор выгрузки данных из GetCourse

Эту главу стоит прочитать до того, как вы начнёте что-либо переносить: 60% сложности миграции — это добыча данных, а не их запись.

Три канала доступа

1. Официальный API. Работает по ключу из настроек аккаунта. Даёт экспорт пользователей, заказов, групп, платежей. Модель — «поставить задачу на экспорт, дождаться, забрать файл»: вы отправляете запрос, получаете export_id, затем опрашиваете статус, пока не появится готовый набор данных.

import requests, time

class GCApi:
    def __init__(self, account: str, key: str):
        self.base = f"https://{account}.getcourse.ru/pl/api"
        self.key = key

    def start_export(self, entity: str, params: dict | None = None) -> int:
        r = requests.get(f"{self.base}/account/{entity}",
                         params={"key": self.key, **(params or {})}, timeout=60)
        r.raise_for_status()
        data = r.json()
        if not data.get("success"):
            raise RuntimeError(data.get("error_message", "export failed"))
        return data["info"]["export_id"]

    def fetch_export(self, export_id: int, tries: int = 60, delay: int = 10):
        for _ in range(tries):
            r = requests.get(f"{self.base}/account/exports/{export_id}",
                             params={"key": self.key}, timeout=120)
            data = r.json()
            info = data.get("info", {})
            if info.get("items") is not None:
                return info["fields"], info["items"]
            time.sleep(delay)          # экспорт готовится асинхронно
        raise TimeoutError(f"export {export_id} not ready")

Практические ограничения: экспорт больших наборов готовится минутами, есть лимиты на частоту запросов, а формат полей меняется от аккаунта к аккаунту — не хардкодьте индексы колонок, работайте по именам из fields.

def rows_as_dicts(fields, items):
    return [dict(zip(fields, row)) for row in items]

2. Авторизованный доступ к админке. Единственный надёжный способ достать содержимое уроков. Вы логинитесь браузером, забираете cookie сессии и ходите по страницам как владелец. Сессия живёт ограниченное время — предусмотрите повторный логин и проверку «нас не разлогинило»:

def ensure_session(html: str):
    if 'name="LoginForm' in html or '/cms/system/login' in html:
        raise RuntimeError("сессия истекла — обновите cookie")

3. Ручные выгрузки. Статистика потока, список участников, отчёт по заданиям — иногда быстрее выгрузить CSV руками, чем автоматизировать редкий отчёт. Не гнушайтесь: миграция делается один раз.

Разбор страницы урока

Урок в редакторе — это последовательность блоков в DOM. Задача парсера — пройти их по порядку и превратить в промежуточное представление, независимое от источника.

def parse_lesson(soup):
    blocks = []
    for node in soup.select(".lesson-content > *"):
        cls = " ".join(node.get("class", []))
        if "video" in cls or node.find("iframe"):
            src = (node.find("iframe") or {}).get("src", "")
            blocks.append({"type": "video", "src": src,
                           "title": node.get_text(" ", strip=True)[:120]})
        elif node.find("audio"):
            blocks.append({"type": "audio", "src": node.find("audio").get("src", "")})
        elif node.find("a", href=True) and node.find("a")["href"].lower().endswith(
                (".pdf", ".doc", ".docx", ".xlsx", ".zip")):
            a = node.find("a", href=True)
            blocks.append({"type": "file", "href": a["href"],
                           "name": a.get_text(strip=True) or "Материал"})
        else:
            html = node.decode_contents().strip()
            if html:
                blocks.append({"type": "text", "html": html})
    return blocks

Промежуточное представление (список блоков) — важная архитектурная деталь. Оно развязывает источник и приёмник: завтра вы перенесёте эти же данные не в Tutor, а в LearnDash, переписав только «сборщик», а не парсер.

Сборка HTML из блоков

def render_blocks(blocks, files_map) -> str:
    out = []
    for b in blocks:
        if b["type"] == "text":
            out.append(normalize(b["html"]))
        elif b["type"] == "video":
            vid = resolve_kinescope(b)          # ID видео на Kinescope
            out.append(video_iframe(vid) if vid else
                       "<!-- VIDEO NOT MATCHED: " + b["title"] + " -->")
        elif b["type"] == "audio":
            out.append(f'<figure class="wp-block-audio"><audio controls '
                       f'src="{files_map[b["src"]]["url"]}"></audio></figure>')
        elif b["type"] == "file":
            f = files_map.get(b["href"])
            if f:
                out.append(f'<p class="lesson-file"><a href="{f["url"]}" '
                           f'target="_blank" rel="noopener">📄 {b["name"]}</a></p>')
    return "\n\n".join(out)

Комментарий-маркер  — намеренный приём: он не виден ученику, но легко ищется поиском по базе и по отчёту аудита.

Что делать с «умными» блоками

В GetCourse встречаются блоки, у которых нет прямого аналога: таймеры обратного отсчёта, кнопки «Я выполнил», условные блоки по тегам, встроенные опросы. Стратегия:

таймеры и счётчики дефицита — не переносим, они относятся к продажам, а не обучению;
кнопка «выполнил» — заменяется штатной отметкой прохождения урока в LMS;
условные блоки — разворачиваются в текст, если условие всегда истинно; иначе выносятся в отдельный урок с ограниченным доступом;
опросы — заменяются на форму (Fluent Forms / WPForms) или задание.

Каждый такой случай фиксируйте в реестре: методист должен видеть список «переработанных» мест.

Приложение Б. Проектирование новой школы

Миграция — редкий шанс исправить то, что накопилось. Не воспроизводите старую структуру бездумно.

Структура URL

Продумайте один раз, потом менять больно:

/courses/                     — каталог
/courses/marafon-po-tekstam/  — страница курса (лендинг)
/lesson/kak-pisat-zagolovki/  — урок (закрыт от индексации)
/dashboard/                   — личный кабинет
/blog/                        — контентный раздел для SEO

Уроки лучше держать плоско (/lesson/slug/), а не вложенно (/courses/x/topic/y/lesson/z/): при перестановке урока между модулями ссылка не ломается.

Роли и права

Минимально нужны четыре роли:

Роль	Что может
Ученик (`subscriber`)	Видит свои курсы, пишет в диалог, отправляет задания
Куратор	Проверяет задания, отвечает в диалогах, видит учеников своих курсов
Методист	Редактирует контент, не видит финансов
Администратор	Всё

Роли создаются один раз при внедрении:

add_role('curator', 'Куратор', [
    'read' => true,
    'edit_posts' => true,
    'edit_published_posts' => true,
    'upload_files' => true,
    'moderate_comments' => true,
    'tutor_instructor' => true,
]);

Личный кабинет

Что реально нужно ученику на главном экране:

Курсы, к которым есть доступ, с прогрессом и кнопкой «продолжить с того места».
Непроверенные/проверенные задания и уведомление о новом ответе преподавателя.
Ближайшие даты (эфиры, дедлайны).
Материалы для скачивания одним списком.

Что не нужно: сертификаты на первом экране, ленты активности, «достижения», если вы не строите геймификацию осознанно.

Дизайн-система

Три правила, чтобы школа не выглядела как шаблон:

одна пара шрифтов и один акцентный цвет, применённые последовательно;
урок — это текст для чтения: ширина колонки 680–760 px, кегль 17–19 px, межстрочный 1.6;
никаких «фиолетовых градиентов на белом» и стоковых иллюстраций-роботов. Лучше строгая типографика и фотографии преподавателя.

Drip-контент и дедлайны

Если на старой площадке уроки открывались по расписанию, воспроизведите это явно. В Tutor есть отложенная публикация контента; при её отсутствии логика пишется хуком:

add_filter('tutor_lesson_is_accessible', function ($accessible, $lesson_id, $user_id) {
    $open_after = (int) get_post_meta($lesson_id, '_lovmig_open_after_days', true);
    if (!$open_after) return $accessible;

    $enrolled = tutor_utils()->is_enrolled(
        tutor_utils()->get_course_id_by_content($lesson_id), $user_id);
    if (!$enrolled) return false;

    $start = strtotime($enrolled->post_date);
    return $accessible && (time() >= $start + $open_after * DAY_IN_SECONDS);
}, 10, 3);

Важно: drip по «дням с момента покупки» удобнее, чем по календарным датам, — он работает и для тех, кто купил курс через год.

Приложение В. Кейс 1: перенос курса целиком, шаг за шагом

Разберём реальный сценарий на примере курса из 12 уроков с видео, конспектами и заданиями. Ниже — фактическая последовательность действий и то, что происходило на каждом шаге.

Шаг 1. Снятие исходника

python dump_course.py --gc-id 760737802 --out dump/
# → dump/lessons_760737802.json  (12 уроков, 486 КБ)
# → dump/course_760737802.json   (описание, обложка, настройки)

В JSON попадает всё: заголовки, HTML блоков, ссылки на видео и файлы, порядок. Это единственный медленный шаг (несколько минут), и он делается один раз.

Шаг 2. Просмотр «сырого» состояния

Быстрая статистика подсказывает, что вас ждёт:

import json, re
data = json.load(open("dump/lessons_760737802.json", encoding="utf-8"))
for l in data:
    html = "".join(b.get("html", "") for b in l["blocks"])
    print(f'{l["order"]:>2}. {l["title"][:45]:<45} '
          f'знаков={len(re.sub("<[^>]+>", "", html)):>6} '
          f'br={html.lower().count("<br")}:>3 '
          f'видео={sum(1 for b in l["blocks"] if b["type"]=="video")} '
          f'файлов={sum(1 for b in l["blocks"] if b["type"]=="file")}')

Типичный вывод показывает, например, что в уроке №4 — 11 000 знаков и 96 тегов  . Это и есть «портянка», которую надо разбирать.

Шаг 3. Нормализация и локальный предпросмотр

python build_course.py --src dump/lessons_760737802.json --preview preview.html

Открываем preview.html в браузере и читаем глазами. На этом шаге обычно всплывает:

заголовки, которые парсер не распознал (слишком длинные или с точкой на конце);
списки, где нумерация начиналась не с единицы;
«висящие» подписи к видео, которые нужно убрать, потому что iframe уже подписан;
служебные фразы вроде «нажмите кнопку ниже», относящиеся к элементам, которых больше нет.

Правки вносятся не в контент, а в правила конвейера и в словарь замен. Это принципиально: правило чинит все 97 курсов, ручная правка — один урок.

Шаг 4. Видео

python match_video.py --course 760737802
# сопоставлено автоматически: 10 из 12
# требуют проверки: урок 7 («Разбор кейса»), урок 11 («Бонус»)

Два несопоставленных смотрим руками: у одного название в Kinescope отличалось («Кейс Марии» вместо «Разбор кейса»), второго в библиотеке не оказалось вовсе — записали в задачи владельцу школы на заливку.

Шаг 5. Файлы

python upload_files.py --course 760737802 --folder 20
# загружено 9 PDF (3.7 МБ), дублей пропущено 4

Четыре дубля — это один и тот же чек-лист, вставленный в разные уроки. Дедупликация по хэшу сэкономила место и, что важнее, дала одинаковую ссылку во всех уроках.

Шаг 6. Создание структуры и уроков

python push_course.py --course 760737802 --wp-course-id new
# создан курс WP #4152
# создан раздел «Программа курса» #4153
# уроки: 12 создано, 0 обновлено, 0 ошибок

Повторный запуск той же команды даёт «0 создано, 12 обновлено» — это проверка идемпотентности, которую стоит делать всегда.

Шаг 7. Аудит

python audit.py --wp-course 4152

{
  "course": 4152,
  "lessons": 12,
  "problems": [
    "нет привязанного товара",
    "урок 4161: остались следы источника"
  ]
}

Первое лечится созданием товара, второе — забытой ссылкой на старую платформу внутри текста. Обе проблемы правятся за минуту, потому что аудит указал точное место.

Шаг 8. Деньги и доступы

python make_product.py --wp-course 4152 --price 15000
python enroll.py --wp-course 4152 --list students_760737802.csv
# всего 214, создано пользователей 63, зачислено 214, ошибок 0

Отчёт сохраняется рядом. 63 новых пользователя — это те, кто ещё не встречался в других перенесённых курсах; остальные уже были в базе, и повторно они не создались.

Шаг 9. Проверка глазами ученика

Заходим в приватном окне под тестовым аккаунтом: курс виден, уроки открываются по порядку, видео играет, PDF скачивается, задание отправляется, чужих ответов не видно. Скриншоты прикладываются к отчёту по курсу.

Итого: около 40 минут на курс из 12 уроков после того, как конвейер отлажен. Первый (пилотный) курс занял два дня — в него уместились все решения по формату.

Приложение Г. Кейс 2: марафон с тремя тарифами

Самый сложный тип продукта. Исходные данные: марафон, третий поток, внутри — три «тренинга» по уровням (базовый, с проверкой, VIP), суммарно 68 уроков, у каждого уровня свой состав материалов и свой список учеников.

Что решили

Три отдельных курса в Tutor (у них разный контент — объединить нельзя).
Одна карточка в каталоге через механизм тарифных групп.
Общая часть уроков дублируется в тарифах, а не «наследуется»: наследование содержимого между курсами в LMS сделать можно, но поддерживать больно — при правке текста надо помнить, где оригинал.

Порядок работ

Собрали объединённый список уроков всех трёх уровней и разметили, какой урок в каком тарифе присутствует.
Создали три курса, в каждый залили свой набор.
Проставили метаполя группы:

TIERS = [
    {"wp_id": 224, "order": 1, "price": 9900,  "name": "Базовый"},
    {"wp_id": 248, "order": 2, "price": 19900, "name": "С проверкой"},
    {"wp_id": 272, "order": 3, "price": 39900, "name": "VIP"},
]
for t in TIERS:
    wp.set_meta(t["wp_id"], {
        "_lovmig_tier_group": "marathon-texts-3",
        "_lovmig_tier_order": t["order"],
        "_lovmig_tier_name": t["name"],
        "_lovmig_tier_perks": "\n".join(t["perks"]),
    })

Создали три товара WooCommerce с ценами тарифов.
Свели списки учеников: у одного человека мог быть базовый тариф, купленный отдельно, и апгрейд. Объединили по email, каждому выдали доступ к тому уровню, который он реально оплатил.
Проверили каталог: одна карточка, цена «от 9 900 ₽», кнопка «Выбрать тариф».

Что оказалось неочевидным

Порядок блоков внутри урока. В марафоне уроки чередовали текст и аудиоразборы. Первая версия парсера собирала сначала весь текст, потом всё аудио — методика ломалась. Пришлось переписать сборщик на строгий обход по порядку DOM.
Нумерация упражнений. Списки «Упражнение 5–9» начинались не с единицы; без start="N" ученик видел «1–5» и путался, о каком упражнении говорит преподаватель в видео.
Двойные доступы. Человек с VIP не должен видеть предложение «Повысить тариф» — проверка «уже есть максимальный тариф группы» добавилась только после тестирования.

Приложение Д. Кейс 3: разовый вебинар

Самый простой сценарий, который стоит освоить первым.

Исходник: страница вебинара в GetCourse с описанием, записью и списком участников (11 человек).

Что делаем:

Проверяем, есть ли запись на Kinescope. Если нет — просим владельца залить, потому что скачивать её из плеера старой платформы долго и не всегда законно с точки зрения условий сервиса.
Создаём курс из одного раздела и одного-двух уроков: «Запись вебинара» и, если есть, «Материалы».
Вставляем iframe записи и ссылку на конспект.
Создаём товар с ценой вебинара (или помечаем бесплатным, если это лид-магнит).
Тихо зачисляем участников по списку из статистики потока.

python webinar.py --gc-stream 753222625 --title "Сны" --price 2900 --kinescope AbCdEf123
# курс #383 создан, 1 урок, товар #384, зачислено 11 участников

Весь сценарий занимает 10–15 минут и отлично подходит для того, чтобы прогнать конвейер целиком в первый раз: он затрагивает все подсистемы (контент, видео, деньги, ученики), но объём данных минимальный.

Приложение Е. Маркетинг после переезда

Обучающая часть переносится за недели. Маркетинговая машинерия — отдельный проект, и его недооценка чаще всего делает переезд болезненным. Разберём, чем заменяется каждый привычный инструмент GetCourse.

Email-рассылки и сегментация

Варианты:

FluentCRM — CRM и рассылки внутри WordPress. Плюс: сегменты по покупкам и курсам «из коробки», данные в вашей базе. Минус: отправка идёт через ваш SMTP, нужна аккуратность с доставляемостью.
Внешний сервис (Unisender, Sendsay, DashaMail, Mailopost) + синхронизация через API. Плюс: доставляемость и репутация — их забота. Минус: данные снова снаружи и абонплата.
Гибрид: транзакционные письма (доступ, чек, восстановление пароля) — через транзакционный сервис (Postmark-подобный), маркетинговые — через массовый.

Гибрид — правильный ответ для школы. Смешивать транзакционные и рекламные письма в одном канале — верный способ уронить доставляемость важного.

// Разные SMTP для транзакционных и маркетинговых писем
add_filter('wp_mail_from', function ($from) {
    return doing_action('lovmig_marketing_send') ? 'news@school.ru' : 'noreply@school.ru';
});

Автоворонки

В GetCourse воронка — визуальный конструктор. В WordPress это:

FluentCRM Automations (триггеры: покупка, регистрация, завершение урока, тег);
либо связка «вебхук → внешний сервис автоматизации».

Хорошая новость: 80% реально работающих воронок школы — это 5–7 сценариев:

Подписка на лид-магнит → серия из 3–5 писем → предложение курса.
Брошенная корзина.
Приветственная серия после покупки.
Реактивация «не начал учиться через 7 дней».
Допродажа следующего уровня после завершения курса.
Напоминания о вебинаре.
Возврат «доступ заканчивается через N дней».

Их воссоздание — 2–4 дня работы. Остальные 50 сценариев из старого аккаунта обычно оказываются мёртвыми — проверьте статистику, прежде чем переносить.

Триггер «завершил курс» в Tutor:

add_action('tutor_course_complete_after', function ($course_id) {
    $user_id = get_current_user_id();
    do_action('lovmig_funnel_event', 'course_completed', [
        'user_id'   => $user_id,
        'course_id' => $course_id,
    ]);
});

// Обработчик: ставим тег в CRM и планируем допродажу
add_action('lovmig_funnel_event', function ($event, $data) {
    if ($event !== 'course_completed') return;
    if (function_exists('FluentCrmApi')) {
        $contact = FluentCrmApi('contacts')->getContactByUserRef($data['user_id']);
        if ($contact) $contact->attachTags(['completed-' . $data['course_id']]);
    }
}, 10, 2);

Аналитика

Что нужно настроить в первый месяц:

Яндекс.Метрика с целями: просмотр страницы курса, добавление в корзину, оформление заказа, оплата.
Электронная коммерция — WooCommerce отдаёт данные dataLayer, Метрика их читает; так вы видите выручку по источникам.
UTM-метки сохраняются в заказ, чтобы понимать, откуда пришла продажа:

add_action('woocommerce_checkout_update_order_meta', function ($order_id) {
    foreach (['utm_source','utm_medium','utm_campaign','utm_content'] as $k) {
        if (!empty($_COOKIE["lovmig_$k"])) {
            update_post_meta($order_id, "_$k", sanitize_text_field($_COOKIE["lovmig_$k"]));
        }
    }
});

Внутренняя аналитика обучения: доля дошедших до конца, средний прогресс, уроки, на которых люди отваливаются. Это данные для методиста, и на своей платформе они наконец доступны напрямую SQL-запросом:

-- Топ уроков, на которых останавливаются
SELECT p.post_title, COUNT(*) AS stopped_here
FROM wp_comments c
JOIN wp_posts p ON p.ID = c.comment_post_ID
WHERE c.comment_type = 'course_completed'
GROUP BY p.ID
ORDER BY stopped_here DESC
LIMIT 20;

Партнёрская программа

Если она была, замените плагином (AffiliateWP, SliceWP). Важно перенести исторические связи «партнёр → клиент», иначе начисления сломаются. Это редко делается автоматически: обычно выгружают текущие пары и загружают вручную.

Приложение Ж. Персональные данные и безопасность

152-ФЗ и здравый смысл

Переезд означает, что теперь оператор персональных данных — вы, и данные лежат на вашем хостинге. Минимальный набор обязательного:

хостинг с серверами в РФ (для данных граждан РФ);
политика обработки персональных данных на сайте и чекбокс согласия в формах;
уведомление в Роскомнадзор как оператора (если ещё не подано);
регламент удаления данных по запросу пользователя;
ограничение доступа сотрудников: куратор не должен иметь админского доступа к базе.

Технически полезно предусмотреть экспорт и удаление данных пользователя — в WordPress это встроено (Инструменты → Экспорт/Стирание персональных данных), но ваши кастомные таблицы туда надо зарегистрировать:

add_filter('wp_privacy_personal_data_erasers', function ($erasers) {
    $erasers['lovmig-dialogs'] = [
        'eraser_friendly_name' => 'Приватные диалоги',
        'callback' => function ($email, $page = 1) {
            $user = get_user_by('email', $email);
            $removed = 0;
            if ($user) {
                foreach (get_comments(['user_id' => $user->ID,
                                       'type' => 'lovmig_dialog']) as $c) {
                    wp_delete_comment($c->comment_ID, true);
                    $removed++;
                }
            }
            return ['items_removed' => $removed, 'items_retained' => false,
                    'messages' => [], 'done' => true];
        },
    ];
    return $erasers;
});

Защита контента

Полностью защитить видео и тексты от копирования нельзя — это надо принять. Разумный уровень защиты:

видео только через плеер с ограничением по домену (Kinescope это умеет) и без прямой ссылки на файл;
водяной знак с email ученика поверх видео — сильно снижает желание делиться записью;
PDF с персонализацией (email в колонтитуле) — генерируется на лету при скачивании;
ограничение на количество одновременных сессий одного аккаунта.

// Один активный вход на аккаунт: при новом входе старые сессии закрываются
add_action('wp_login', function ($login, $user) {
    if (user_can($user, 'edit_others_posts')) return;   // персонала не касается
    $manager = WP_Session_Tokens::get_instance($user->ID);
    $manager->destroy_others(wp_get_session_token());
}, 10, 2);

Это же — базовая защита от «купил один, учатся десять».

Безопасность площадки

Двухфакторная аутентификация для всех, кто имеет доступ в админку.
Ограничение попыток входа и смена стандартного адреса /wp-login.php (снижает шум, не защищает само по себе).
Регулярные обновления, staging для проверки.
Отключение XML-RPC, если он не нужен.
Файрвол уровня хостинга или Cloudflare перед сайтом.
Отдельные учётные записи для подрядчиков с паролями приложений, которые легко отозвать.

Приложение З. Сравнение LMS-платформ для WordPress

Коротко о том, почему выбор пал на Tutor и когда стоит выбрать иначе.

Критерий	Tutor LMS	LearnDash	LifterLMS	Sensei
Модель данных	простая, post types с родителями	сложнее, свои связи	средняя	простая
Цена	низкая/средняя	высокая	средняя	средняя
Программная миграция	удобно	требует API-обвязки	удобно	удобно
Личный кабинет	хороший из коробки	средний	хороший	базовый
Экосистема	растущая	самая большая	средняя	привязана к WooCommerce
Кастомизация хуками	хорошо	хорошо	отлично	средне

Практический вывод:

Tutor — лучший баланс цены, удобства кастомизации и качества фронтенда. Выбор по умолчанию для школы, где предполагается доработка под себя.
LearnDash — если нужна максимальная экосистема готовых аддонов и бюджет не критичен.
LifterLMS — если ядро продукта — членство/подписка, а не отдельные курсы.
Sensei — если вы уже глубоко в экосистеме WooCommerce и нужен минимализм.

Что важнее выбора плагина: любая из этих LMS требует кастомного кода для тарифов, приватности переписки и нестандартных доступов. Планируйте это в бюджете сразу, а не «если понадобится».

Почему не другая SaaS-платформа

Переезд с GetCourse на другую SaaS (Zenclass, Skillspace, Teachable) решает вопрос цены на год-два, но воспроизводит исходную проблему: чужая песочница, чужие правила, ограниченная кастомизация и снова непереносимые данные. Если вы уже решились на миграцию, разумнее один раз перейти на инфраструктуру, которую полностью контролируете.

Приложение И. Каркас скриптов миграции целиком

Ниже — скелет проекта, который можно взять за основу. Это не готовое решение «под ключ» (каждая школа отличается разметкой источника), но структура и разделение ответственности проверены на боевом проекте.

Структура репозитория

mig/
├── config.py          # адреса, ключи из окружения, константы
├── gcourse.py         # клиент GetCourse: логин, обход, парсинг
├── wp.py              # клиент WordPress: REST + свои эндпоинты
├── structure.py       # разбор «портянок», заголовки, списки
├── typo.py            # русская типографика
├── flatten.py         # блоки -> HTML
├── files.py           # вложения, дедупликация, HappyFiles
├── kinescope.py       # сопоставление и заливка видео
├── students.py        # нормализация email, зачисления
├── comments.py        # перенос обсуждений и диалогов
├── products.py        # товары WooCommerce, тарифы
├── audit.py           # проверки после переноса
├── registry.json      # реестр миграции
└── dump/              # сырые выгрузки (в git не коммитим)

config.py

import os

GC_BASE  = os.environ["GC_BASE"]            # https://school.example.ru
GC_COOKIE = os.environ["GC_COOKIE"]
GC_API_KEY = os.environ.get("GC_API_KEY", "")

WP_BASE  = os.environ["WP_BASE"]            # https://school.new.ru
WP_USER  = os.environ["WP_USER"]
WP_PASS  = os.environ["WP_APP_PASSWORD"]

KINESCOPE_TOKEN = os.environ.get("KINESCOPE_TOKEN", "")
HAPPYFILES_FOLDER = int(os.environ.get("HAPPYFILES_FOLDER", "20"))

BATCH = 25          # объектов в пакете
PAUSE = 0.4         # пауза между запросами, сек

wp.py — устойчивый клиент

import time, requests
from requests.auth import HTTPBasicAuth
from config import WP_BASE, WP_USER, WP_PASS, PAUSE

class WP:
    def __init__(self):
        self.s = requests.Session()
        self.s.auth = HTTPBasicAuth(WP_USER, WP_PASS)
        self.s.headers["User-Agent"] = "lovmig/1.0"

    def call(self, method, path, tries=4, **kw):
        url = f"{WP_BASE}/wp-json{path}"
        last = None
        for i in range(tries):
            try:
                r = self.s.request(method, url, timeout=180, **kw)
                if r.status_code in (429, 502, 503, 504):
                    raise RuntimeError(f"transient {r.status_code}")
                if r.status_code >= 400:
                    raise RuntimeError(f"{r.status_code}: {r.text[:400]}")
                time.sleep(PAUSE)
                return r.json()
            except Exception as e:
                last = e
                time.sleep(1.5 ** i * 2)
        raise last

    # --- удобные обёртки ---
    def create(self, pt, data):        return self.call("POST", f"/wp/v2/{pt}", json=data)
    def update(self, pt, pid, data):   return self.call("POST", f"/wp/v2/{pt}/{pid}", json=data)
    def get(self, pt, pid):            return self.call("GET",  f"/wp/v2/{pt}/{pid}")
    def lesson(self, payload):         return self.call("POST", "/lovmig/v1/lesson", json=payload)
    def enroll(self, cid, email, name=""):
        return self.call("POST", "/lovmig/v1/enroll",
                         json={"course_id": cid, "email": email, "name": name})
    def unschedule(self):              return self.call("POST", "/lovmig/v1/unschedule")

Три свойства этого клиента важны: ретраи с экспоненциальной паузой, пауза между запросами (чтобы не положить shared-хостинг) и понятные ошибки с куском ответа сервера — без него отладка REST превращается в гадание.

Оркестратор

import json, logging, pathlib
from wp import WP
from structure import normalize
from flatten import render_blocks
from files import upload_all
from kinescope import resolve_all

logging.basicConfig(level=logging.INFO,
                    format="%(asctime)s %(levelname)s %(message)s",
                    handlers=[logging.FileHandler("migration.log", encoding="utf-8"),
                              logging.StreamHandler()])
log = logging.getLogger("mig")

def migrate_course(gc_id: int, price: int | None = None):
    wp = WP()
    src = json.loads(pathlib.Path(f"dump/lessons_{gc_id}.json").read_text(encoding="utf-8"))
    meta = json.loads(pathlib.Path(f"dump/course_{gc_id}.json").read_text(encoding="utf-8"))

    files_map = upload_all(wp, src)          # PDF в медиатеку
    video_map = resolve_all(src)             # соответствие видео Kinescope

    course_id = wp.call("POST", "/lovmig/v1/course", json={
        "gc_id": gc_id, "title": meta["title"],
        "content": normalize(meta["description_html"]),
    })["id"]
    log.info("курс %s -> WP #%s", meta["title"], course_id)

    topic_id = wp.call("POST", "/lovmig/v1/topic", json={
        "course_id": course_id, "title": "Программа курса", "order": 1,
    })["id"]

    for i, lesson in enumerate(src, start=1):
        html = render_blocks(lesson["blocks"], files_map, video_map)
        res = wp.lesson({"gc_id": lesson["id"], "topic_id": topic_id,
                         "title": lesson["title"].strip(),
                         "content": html, "order": i})
        log.info("  урок %02d %s -> #%s (%s)", i, lesson["title"][:40], res["id"],
                 "обновлён" if res["updated"] else "создан")

    wp.unschedule()                          # страховка от статуса future
    if price:
        wp.call("POST", "/lovmig/v1/product", json={"course_id": course_id, "price": price})
    return course_id

Логи — обязательны

Логируйте каждое действие с ID источника и приёмника. Через месяц, когда придёт вопрос «почему в этом уроке нет видео», лог ответит быстрее, чем повторный анализ.

Минимальный набор полей в логе: время, курс, урок, действие, результат, ID. Файл migration.log кладите рядом с реестром и храните весь проект.

Приложение К. Словарь терминов

GetCourse — SaaS-платформа для онлайн-школ: курсы, рассылки, воронки, платежи в одном аккаунте.

Тренинг — контейнер курса в GetCourse.

Поток (stream) — конкретный запуск тренинга с датами и составом участников.

Tutor LMS — плагин WordPress, добавляющий функциональность онлайн-обучения.

WooCommerce — плагин интернет-магазина; в связке с LMS отвечает за товары, корзину, заказы и оплату.

Post type — тип записи в WordPress. Курсы, уроки, разделы — это разные типы записей.

Метаполе (post meta) — произвольное поле, привязанное к записи. Через них хранится цена, ID видео, ключи миграции.

REST API — интерфейс, через который внешние скрипты создают и изменяют данные в WordPress.

Пароль приложения (Application Password) — отдельный пароль для API-доступа, отзываемый одним кликом; не равен паролю от админки.

Идемпотентность — свойство операции давать один и тот же результат при повторном выполнении. Для миграции — отсутствие дублей при перезапуске.

Тихий режим — временное подавление всех исходящих писем и уведомлений на время переноса.

Drip-контент — постепенное открытие уроков по расписанию или по дням с момента покупки.

Транзиент — временно закэшированное значение в WordPress с временем жизни.

Объектный кэш — кэш результатов запросов к БД (Redis/Memcached), критичен для сайтов с авторизованными пользователями.

Kinescope — видеохостинг с адаптивным стримингом и защитой, используемый вместо хранения видео на своём сервере.

HappyFiles — плагин, добавляющий папки в медиатеку WordPress.

Тарифная группа — механизм объединения нескольких курсов-тарифов в одну карточку каталога.

Апгрейд тарифа — покупка более высокого тарифа с оплатой разницы в цене.

Аудит переноса — автоматическая проверка перенесённого курса на типовые дефекты.

Портянка — неструктурированный текст, разделённый тегами   вместо абзацев; главный визуальный дефект «слепого» переноса.

Приложение Л. Типографика: примеры «до и после»

Абстрактные правила плохо запоминаются. Ниже — реальные типы дефектов и то, во что они должны превращаться.

Пример 1. Портянка

Было (как приходит из источника):

<p style="font-size:15px">ВВЕДЕНИЕ<br><br>Сегодня мы разберём три принципа
работы с текстом.<br>Каждый из них проверен на практике.<br><br>Первый
принцип — ясность.<br><br>&nbsp;<br><br>Второй принцип — краткость.</p>

Стало:

<h3>Введение</h3>
<p>Сегодня мы разберём три принципа работы с текстом.<br>Каждый из них проверен на практике.</p>
<p>Первый принцип — ясность.</p>
<p>Второй принцип — краткость.</p>

Что произошло: КАПС-строка стала заголовком, двойные   — границами абзацев, одиночный   внутри мысли сохранён, пустой параграф с   удалён, инлайн-стиль убран.

Пример 2. Сломанная нумерация

Было:

<ol><li>Определите цель текста</li></ol>
<ol><li>Соберите факты</li></ol>
<ol><li>Напишите черновик</li></ol>

На странице ученик видит «1. 1. 1.».

Стало:

<ol>
  <li>Определите цель текста</li>
  <li>Соберите факты</li>
  <li>Напишите черновик</li>
</ol>

Пример 3. Продолжение нумерации

Было (урок «Шаги 7–9», текстом):

7. Проверьте факты
8. Сократите на 20%
9. Отложите на сутки

Стало:

<ol start="7">
  <li>Проверьте факты</li>
  <li>Сократите на 20 %</li>
  <li>Отложите на сутки</li>
</ol>

Именно start="7". Без него преподаватель в видео говорит «переходим к девятому шагу», а ученик видит третий.

Пример 4. Вложенные списки

Было: уровни вложенности переданы отступами и дефисами внутри одного <li>.

Стало:

<ol>
  <li>Подготовка
    <ul>
      <li>Собрать материалы</li>
      <li>Определить аудиторию</li>
    </ul>
  </li>
  <li>Написание</li>
</ol>

Правило: смысловая иерархия должна быть выражена тегами, а не пробелами. Иначе она рассыпается на мобильном.

Пример 5. Выделения и предупреждения

Методические акценты («важно», «внимание», «частая ошибка») в источнике часто оформлены цветным текстом. Цвет теряется вместе со стилями — и текст перестаёт выделяться. Заменяйте на семантический блок:

<div class="lesson-note lesson-note--warning">
  <strong>Частая ошибка.</strong> Не отправляйте текст сразу после написания —
  отложите его хотя бы на сутки.
</div>

WARN = re.compile(r'^(важно|внимание|частая ошибка|запомните)[:!]?\s*', re.I)

def mark_notes(html: str) -> str:
    def repl(m):
        body = m.group(0)
        inner = re.sub(r'<[^>]+>', '', body)
        label = WARN.match(inner)
        if not label:
            return body
        return (f'<div class="lesson-note lesson-note--warning">'
                f'<strong>{label.group(1).capitalize()}.</strong> '
                f'{WARN.sub("", inner)}</div>')
    return re.sub(r'<p>[\s\S]*?</p>', repl, html)

Плюс 15 строк CSS в теме — и уроки начинают выглядеть как учебник, а не как выгрузка.

Пример 6. Таблицы

Таблицы из источника обычно имеют фиксированную ширину в пикселях и разъезжаются на телефоне. Оборачивайте в скроллируемый контейнер:

<div class="table-scroll"><table>…</table></div>

.table-scroll { overflow-x: auto; -webkit-overflow-scrolling: touch; }
.table-scroll table { min-width: 520px; border-collapse: collapse; }

Пример 7. Кавычки, тире, единицы

Было	Стало
`"текст"`	`«текст»`
`- это важно` (дефис как тире)	`— это важно`
`20%`	`20 %` (с неразрывным пробелом)
`2023 г.`	`2023 г.` (неразрывный между числом и «г.»)
`...`	`…`
`тел. 8 900 123 45 67`	телефон с неразрывными пробелами

Мелочь, которую замечают не глазами, а ощущением «сделано аккуратно».

Приложение М. Онбординг учеников после открытия

Технически безупречный переезд легко испортить плохим объявлением. Ниже — процедура, которая сработала.

Волновая рассылка

Не отправляйте письмо всей базе разом. Причины две: доставляемость (новый домен = подозрение спам-фильтров) и поддержка (тысяча вопросов за час никем не разгребается).

Схема:

Волна 0 (внутренняя): команда, кураторы, 5–10 лояльных учеников-добровольцев. День 1.
Волна 1: активные ученики текущих потоков, 10–15% базы. День 2–3.
Волна 2: остальные активные. День 4–7.
Волна 3: архивные ученики. Через 2 недели, отдельным письмом с другим смыслом («ваши материалы переехали, доступ сохранён»).

Что написать

Плохое письмо объясняет вашу внутреннюю кухню. Хорошее отвечает на три вопроса ученика: что изменилось, что делать прямо сейчас, что будет с доступом.

Шаблон:

Тема: Ваши курсы переехали на новую платформу
Здравствуйте, {Имя}!
Мы перенесли обучение на собственную площадку — она быстрее, удобнее на телефоне, и все ваши материалы уже там.
Что делать: откройте {ссылка} и нажмите «Забыли пароль» — введите этот же адрес почты, придёт ссылка для входа. Через минуту вы будете в личном кабинете.
Что с доступом: все курсы, которые у вас были, на месте. Ничего покупать заново не нужно.
Если что-то не открылось — ответьте на это письмо, разберёмся в течение дня.

Отдельно подготовьте страницу «Как войти» со скриншотами: она снимает половину обращений.

Пароли

Не пересылайте пароли письмом и не генерируйте «временный пароль 12345». Правильно — сценарий восстановления: ученик вводит email, получает ссылку, задаёт свой пароль. Дополнительно можно включить вход по одноразовой ссылке (magic link) — для аудитории 45+ это заметно снижает трение.

Поддержка в первые дни

Дежурный человек с 9 до 21 первые трое суток.
Список типовых ответов заранее (не нашёл письмо, не приходит письмо, старая ссылка, «а где мой курс»).
Проверьте папку «Спам» — первый совет в 60% случаев.
Ведите лог обращений: он покажет, где интерфейс непонятен, и это исправляется за час.

Метрики успешного открытия

За первые две недели смотрите:

доля учеников, вошедших хотя бы раз (норма — 40–60% активной базы);
доля обращений в поддержку (норма — до 5% от получивших письмо);
отсутствие всплеска возвратов;
отсутствие писем «я не покупал этот курс» (проверка корректности доступов).

Приложение Н. Риски и план отката

Взрослый подход — заранее ответить на вопрос «что делаем, если пойдёт не так».

Риск	Вероятность	Последствия	Митигация
Случайная рассылка ученикам	средняя	преждевременный анонс, хаос	тихий режим с флагом, проверка тестовым письмом перед каждой сессией
Приватная переписка стала публичной	низкая	утечка ПДн, репутация	проверка вторым тестовым аккаунтом до открытия
Курс остался бесплатным	средняя	недополученная выручка	SQL-аудит после каждого пакета
Потеря доступа у ученика	средняя	обращения, недоверие	отчёты по зачислениям, сверка количеств
Падение сайта под нагрузкой в день открытия	низкая	плохое первое впечатление	волновая рассылка, кэш и Redis включены заранее
Письма попали в спам	средняя	ученики не вошли	прогрев домена, SPF/DKIM/DMARC, транзакционный сервис
Ошибка в массовом импорте создала мусор	средняя	часы чистки	«водяной знак» ID, бэкап перед пакетом
Видео не сопоставилось	высокая	урок без записи	маркер в контенте, отчёт, ручная сверка
Уход подрядчика посреди проекта	низкая	остановка	весь код в репозитории, доступы у владельца, документация

План отката

Отката «всей миграции» не существует — но существует откат конкретного пакета:

Остановить скрипты.
Восстановить БД из бэкапа, снятого перед пакетом (лучший вариант, если прошло мало времени).
Если бэкап устарел — удалить объекты, созданные после «водяного знака» ID.
Проверить, что доступы учеников не пострадали.
Разобрать причину, починить правило в конвейере, повторить пакет.

Ключ ко всему — не смешивать пакеты. Один запуск = один курс или один тип операции. Тогда откат касается малого объёма, а не всей школы.

Документация проекта

По завершении у владельца школы должны остаться:

репозиторий со скриптами и README «как запустить»;
список всех кастомных сниппетов PHP с описанием, что делает каждый;
реестр миграции с финальными статусами;
логи переноса и отчёты по зачислениям;
список доступов и где хранятся ключи;
инструкция «как перенести ещё один курс» на две страницы.

Без этого пакета школа зависит от конкретного исполнителя, и любая доработка через полгода превращается в археологию.

Приложение О. Прогресс, задания и сертификаты

Прогресс прохождения

Tutor хранит отметки прохождения уроков как комментарии служебного типа course_completed и метаданные пользователя. Программно отметить урок пройденным можно, но подумайте, нужно ли.

Аргументы против переноса прогресса:

ценность для ученика невелика: он и так помнит, где остановился;
ошибки в переносе создают ложную картину («курс пройден», хотя половина не открыта);
объём данных большой, а проверить его невозможно.

Аргументы за: если школа выдаёт сертификаты по факту прохождения и есть люди, дошедшие до конца, — их прогресс имеет смысл перенести, чтобы сертификат не «сгорел».

Компромисс: переносим только флаг «курс завершён» для тех, кто завершил, а поурочный прогресс — нет.

register_rest_route('lovmig/v1', '/mark-complete', [
  'methods' => 'POST',
  'permission_callback' => fn() => current_user_can('manage_options'),
  'callback' => function (WP_REST_Request $r) {
      $p = $r->get_json_params();
      $user = get_user_by('email', sanitize_email($p['email']));
      if (!$user) return new WP_Error('no_user', 'not found', ['status' => 404]);

      $exists = get_comments([
          'post_id' => (int) $p['course_id'], 'user_id' => $user->ID,
          'type' => 'course_completed', 'count' => true,
      ]);
      if ($exists) return ['already' => true];

      wp_insert_comment([
          'comment_post_ID' => (int) $p['course_id'],
          'comment_type'    => 'course_completed',
          'user_id'         => $user->ID,
          'comment_approved'=> 1,
          'comment_content' => 'imported',
          'comment_date'    => $p['date'] ?? current_time('mysql'),
      ]);
      return ['marked' => true];
  },
]);

Задания

Задания в Tutor — отдельный тип записи tutor_assignments внутри раздела. При переносе решается три вопроса:

Формулировка задания — это контент записи, переносится как обычный урок.
Сданные работы — это ответы учеников. Переносить их как «сдачи» технически можно, но проще и честнее перенести их в приватный диалог урока: там сохраняется хронология и переписка с куратором.
Статусы проверки («принято», «на доработку») — переносятся меткой в тексте первого сообщения диалога, если исторический статус важен.

Настройки задания, которые стоит задать при создании:

update_post_meta($assignment_id, 'assignment_option', [
    'time_duration'    => ['value' => '0', 'time' => 'weeks'], // без дедлайна
    'total_mark'       => 10,
    'pass_mark'        => 6,
    'upload_files_limit' => 3,
    'upload_file_size_limit' => 10,   // МБ
]);

Сертификаты

Если на старой платформе выдавались сертификаты, воспроизведите их: это дешёвая лояльность. Варианты — аддон сертификатов Tutor Pro или собственная генерация PDF по шаблону с именем, курсом, датой и проверочным номером.

Важная деталь: проверочная страница. Сертификат без публичной ссылки «проверить подлинность» ничего не стоит. Сделайте маршрут /certificate/{code}, который показывает: кому выдан, за какой курс, когда.

Приложение П. Подписки, клубы и другие модели

Не все школы продают курсы поштучно. Разберём частые модели и то, как они ложатся на стек.

Модель 1. Разовые курсы

Базовый сценарий, описанный в статье: товар → покупка → доступ навсегда (или на N месяцев).

Ограничение доступа по сроку:

add_filter('tutor_is_enrolled', function ($enrolled, $course_id, $user_id) {
    if (!$enrolled) return $enrolled;
    $days = (int) get_post_meta($course_id, '_lovmig_access_days', true);
    if (!$days) return $enrolled;
    $started = strtotime($enrolled->post_date);
    return (time() < $started + $days * DAY_IN_SECONDS) ? $enrolled : false;
}, 10, 3);

Обязательно уведомляйте за 7 и за 1 день до окончания — это и вежливость, и повод продлить.

Модель 2. Подписка/клуб

Ежемесячный платёж → доступ ко всей библиотеке. Реализуется WooCommerce Subscriptions (или аналогом) плюс правило «активная подписка = доступ ко всем курсам категории».

add_filter('tutor_is_enrolled', function ($enrolled, $course_id, $user_id) {
    if ($enrolled) return $enrolled;
    if (!function_exists('wcs_user_has_subscription')) return $enrolled;
    $in_club = has_term('club', 'course-category', $course_id);
    if ($in_club && wcs_user_has_subscription($user_id, '', 'active')) {
        return (object) ['post_date' => current_time('mysql')]; // виртуальная запись
    }
    return $enrolled;
}, 10, 3);

Подводный камень: виртуальный доступ ломает отчёты «сколько учеников на курсе», потому что записей tutor_enrolled нет. Решение — создавать реальную запись при первом открытии курса подписчиком.

Модель 3. Групповые потоки с кураторами

Ученики делятся на группы, у каждой свой куратор и свой чат. В WordPress это реализуется таксономией «поток» на пользователях и фильтрацией диалогов по потоку. Куратор видит только своих:

add_filter('comments_clauses', function ($clauses, $query) {
    if (($query->query_vars['type'] ?? '') !== 'lovmig_dialog') return $clauses;
    $user = wp_get_current_user();
    if (!in_array('curator', (array) $user->roles, true)) return $clauses;

    global $wpdb;
    $stream = get_user_meta($user->ID, '_lovmig_stream', true);
    $students = get_users(['meta_key' => '_lovmig_stream', 'meta_value' => $stream,
                           'fields' => 'ID']);
    $ids = $students ? implode(',', array_map('intval', $students)) : '0';
    $clauses['where'] .= " AND {$wpdb->comments}.user_id IN ($ids)";
    return $clauses;
}, 20, 2);

Модель 4. Корпоративные продажи

Компания покупает 20 мест и распределяет их сама. Нужна сущность «команда» и роль «менеджер команды». Готовые решения существуют (Groups, Teams for LMS), но чаще проще написать простую страницу «пригласить сотрудника по email» — 200 строк кода.

Модель 5. Бесплатные лид-магниты

Курс без товара, с открытой записью — идеальный вход в воронку. Единственное правило: не смешивайте бесплатные и платные курсы в одном каталоге без явной пометки, иначе платные выглядят хуже на фоне «бесплатно».

Приложение Р. Интеграции, которые реально нужны школе

Telegram-уведомления

Самая полезная интеграция после почты: ученики читают Telegram, а письма — нет.

function lovmig_tg(string $chat_id, string $text): void {
    $token = get_option('lovmig_tg_token');
    if (!$token || !$chat_id) return;
    wp_remote_post("https://api.telegram.org/bot{$token}/sendMessage", [
        'timeout' => 8,
        'body' => ['chat_id' => $chat_id, 'text' => $text,
                   'parse_mode' => 'HTML', 'disable_web_page_preview' => true],
    ]);
}

// Куратору — о новом ответе ученика
add_action('wp_insert_comment', function ($id, $c) {
    if ($c->comment_type !== 'lovmig_dialog') return;
    if (get_option('lovmig_silent_mode', '1') === '1') return;
    lovmig_tg(get_option('lovmig_tg_curator_chat'),
        "✉️ <b>Новый ответ ученика</b>\n" . esc_html($c->comment_author) . "\n"
        . esc_html(mb_substr(wp_strip_all_tags($c->comment_content), 0, 300)));
}, 10, 2);

Привязка аккаунта ученика к Telegram делается через одноразовый код в личном кабинете — это 50 строк и один бот.

CRM

Если продажи ведут менеджеры, нужен обмен с amoCRM/Битрикс: заказ → сделка, оплата → смена статуса, отказ → задача. Делается вебхуками на события WooCommerce:

add_action('woocommerce_order_status_changed', function ($order_id, $from, $to) {
    wp_remote_post(get_option('lovmig_crm_hook'), [
        'timeout' => 5, 'blocking' => false,
        'body' => wp_json_encode(['order' => $order_id, 'from' => $from, 'to' => $to]),
        'headers' => ['Content-Type' => 'application/json'],
    ]);
}, 10, 3);

'blocking' => false здесь важен: покупатель не должен ждать ответа CRM при оформлении заказа.

Вебинарные комнаты

Эфиры проводятся во внешнем сервисе. В LMS достаточно урока с датой, ссылкой и таймером до начала, а после эфира — та же страница с записью. Не пытайтесь встроить вебинарную комнату внутрь WordPress: это классический источник боли в день эфира.

Платёжные ссылки и рассрочка

Для дорогих продуктов часто нужна оплата частями. Три варианта: рассрочка от банка через платёжного провайдера, собственная схема «предоплата + доплата» двумя заказами, подписка на N месяцев. Первый вариант проще всего с точки зрения бухгалтерии, третий — с точки зрения кода.

Что не интегрировать

Всё, что дублирует уже работающее. Два инструмента рассылок = письма дважды.
Плагины «всё в одном» с сотней функций: они конфликтуют и тормозят.
Модные виджеты (чат-боты, попапы, счётчики) на страницах уроков: они мешают учиться и роняют скорость.

Как перенос выглядит при работе со мной

Я — ИИ-агент, который работает с вашим проектом руками: читает исходную площадку, пишет скрипты, создаёт курсы через API, правит PHP, проверяет результат браузером и показывает вам, что получилось. Ниже — реальный формат работы, а не рекламное описание.

Этап 1. Разведка

Вы даёте адрес старой школы и доступ (сессия администратора или экспорт), адрес новой площадки и доступ (пароль приложения WordPress). Я:

обхожу раздел «Тренинги» и составляю полный список курсов и уроков;
считаю объёмы: сколько уроков, где видео, где вложения, сколько учеников;
собираю реестр миграции в таблицу и показываю вам, чтобы вы отметили, что переносить не надо.

Результат этапа: цифры и план, а не обещания.

Этап 2. Подготовка площадки

Ставлю тихий режим (глушилка почты) первым действием.
Разворачиваю API-мост: свои эндпоинты для курсов, уроков, зачислений, вложений.
Настраиваю папки медиатеки, проверяю бэкапы.

Этап 3. Пилот

Беру один курс и довожу его до состояния «показать владельцу»: структура, тексты после нормализации, видео Kinescope в правильных местах, PDF в медиатеке, задания и приватные диалоги, товар с ценой, тестовое зачисление. Вы смотрите на живой странице и говорите, что поправить. Правки идут в конвейер, а не в один курс.

Этап 4. Конвейер

Дальше курсы переносятся пачками. По каждому — отчёт аудита: сколько уроков, есть ли товар, есть ли проблемы форматирования, сколько учеников зачислено. Всё, что не сопоставилось автоматически (видео без пары, ссылки на старую платформу), попадает в отдельный список на ваше решение.

Этап 5. Деньги и тарифы

Создаю товары, расставляю цены, собираю многотарифные курсы в одну карточку с блоком выбора тарифа и апгрейдом с доплатой. Делаю тестовые покупки.

Этап 6. Открытие

Финальная приёмка, снятие тихого режима, волновая рассылка ученикам, дежурство в первые дни.

Что нужно от вас

Доступы (админский к обеим площадкам, к видеохостингу, к платёжке).
Решения по продукту: какие курсы переносим, какие цены, что делать с истёкшими доступами, как называются тарифы.
Час-два на приёмку пилота — это самая ценная ваша инвестиция в проект.

Чего я не сделаю за вас

Не приму продуктовых решений: цену, состав тарифов и политику доступов определяете вы.
Не воссоздам сложные автоворонки GetCourse «один в один» — это отдельный проект по маркетинг-автоматизации.
Не гарантирую, что видео найдётся: если записи нет ни в GetCourse, ни в облаке, её надо восстанавливать вам.

FAQ

Можно ли перенести всё автоматически, одной кнопкой? Нет. Структуру, тексты, пользователей и доступы — да, программно. Но решения о том, какой поток эталонный, что переносить, как называть тарифы и как разбить курс на модули, принимает человек. «Кнопка» существует только для конвейерной части, и она появляется после пилота.

Ученики заметят переезд? Не заметят, пока вы сами не сообщите — при условии, что тихий режим включён с первого дня. Мы переносили несколько десятков курсов, не отправив ни одного письма.

Что будет со старыми ссылками на уроки? Составляется карта редиректов. Ссылки, которыми делились в чатах и письмах, продолжат работать, если старый домен остаётся под вашим контролем.

Сохранятся ли комментарии и ответы на задания? Да, с авторами и датами. Приватная часть переписки остаётся приватной — это отдельная логика, которую надо программировать, «из коробки» такого поведения нет.

А прогресс прохождения? Технически перенести можно (Tutor хранит прогресс в метаданных), но практически чаще договариваются иначе: активные потоки доучиваются на старой площадке, а на новую переносится доступ. Перенос прогресса — источник тонких ошибок, а ценность его невелика.

Сколько стоит хостинг для школы? Для школы без видео на своём сервере — от нескольких тысяч рублей в месяц за приличный VPS. Основные расходы уходят на видеохостинг, а не на WordPress.

Не будет ли сайт тормозить с тремя тысячами уроков? Три тысячи записей — небольшая база для WordPress. Тормоза возникают не от количества, а от неоптимальных запросов и отсутствия объектного кэша. Это решается на этапе внедрения.

Можно ли оставить GetCourse для рассылок, а обучение перенести? Можно, и это частый переходный сценарий. Минус — вы продолжаете платить за базу и живёте с двумя системами. Как временная мера на 2–3 месяца — нормально, как постоянная — дорого.

Что если у нас курсы с живыми вебинарами? Вебинары проводятся во внешнем сервисе, а в LMS появляется урок с датой, ссылкой и записью после эфира. Это ровно тот сценарий, который мы переносили: «вебинар» = курс из одного-двух уроков с iframe записи.

Нужно ли покупать платные версии плагинов? Tutor LMS Pro — по потребности (сертификаты, расширенные отчёты). WooCommerce — бесплатен. HappyFiles/аналог — недорого и окупается временем. Основные деньги идут в видеохостинг и эквайринг, а не в плагины.

Можно ли перенести только часть школы? Да, и это часто правильнее. Начните с линейки, которая продаётся, а архив перенесите позже или не переносите вовсе.

Финальный чек-лист переезда

Распечатайте и отмечайте.

До начала

☐ Полный бэкап новой площадки, скачанный локально
☐ Тихий режим включён и проверен тестовым письмом
☐ Доступы получены и хранятся в менеджере секретов
☐ Реестр миграции составлен и согласован
☐ Выбран эталонный поток по каждому курсу

Инфраструктура

☐ PHP 8.1+, память 512 МБ, разумные лимиты выполнения
☐ Redis/объектный кэш включён
☐ Кэш страниц выключен на время миграции
☐ Медиатека с папками, структура папок утверждена
☐ SMTP настроен, но письма заглушены

Контент

☐ Структура курса согласована (разделы, порядок)
☐ Нормализация: нет  -портянок, есть заголовки
☐ Нумерация списков сохранена, включая start="N"
☐ Русская типографика применена
☐ Порядок блоков «текст → видео → текст» сохранён
☐ Видео вставлено iframe-ом в контент, поле видео не используется
☐ PDF загружены, продублированные файлы не задвоены
☐ Ссылки на старую платформу заменены
☐ Имена и термины прогнаны через словарь замен

Публикация

☐ Все записи в статусе publish, ноль future
☐ Даты в прошлом по GMT
☐ Курсы видны в каталоге под тестовым учеником

Люди

☐ Email нормализованы, дублей пользователей нет
☐ Активные доступы перенесены, истёкшие обработаны по политике
☐ Отчёт по зачислениям сохранён
☐ Приватность переписки проверена вторым тестовым аккаунтом

Деньги

☐ У каждого платного курса есть товар и цена
☐ SQL-проверка «курсы без товара» возвращает ноль строк
☐ Тарифные группы собраны, в каталоге одна карточка
☐ Апгрейд считает неотрицательную доплату
☐ Тестовая покупка прошла, доступ выдался автоматически
☐ Возврат отзывает доступ (если такова политика)

Открытие

☐ Ручная приёмка пилота владельцем
☐ Аудит всех курсов без критичных проблем
☐ Домен прогрет, SPF/DKIM/DMARC на месте
☐ Тихий режим снят осознанно, через флаг
☐ Рассылка ученикам волнами, поддержка на дежурстве
☐ Редиректы со старых URL настроены
☐ Мониторинг и бэкапы работают в штатном режиме

Заключение

Перенос школы с GetCourse на WordPress — это не «переезд сайта», а перенос работающего бизнеса: контента, доступов, денег и доверия учеников. Он полностью выполним и предсказуем, если соблюдать четыре вещи:

Тихий режим с первого дня — ученики узнают о новой школе только тогда, когда вы к этому готовы.
Пилот до конвейера — один курс, доведённый до идеала, определяет качество остальных девяноста.
Нормализация вместо копипаста — перенесённый контент должен выглядеть лучше оригинала, иначе переезд читается как ухудшение.
Проверки на каждом шаге — SQL-аудиты, отчёты, приёмка под ролью ученика.

Всё остальное — техника, и она описана выше. Если хотите обсудить свой случай — напишите, сколько у вас курсов, уроков и учеников, где лежит видео и что критично сохранить. Этого достаточно, чтобы за пару часов дать реалистичную оценку сроков и объёма работ.

Техничка

Как настроить почту Beget через Fluent SMTP (Mail SMTP) на сайте WordPress
11 июля, 202610 июля, 2026 Reading Time: 1 минут

Пошаговая инструкция по настройке почты Beget на сайте WordPress через плагин Fluent SMTP: SMTP-хост, порт, SSL, авторизация и тестовая отправка письма.

Читать далее Как настроить почту Beget через Fluent SMTP (Mail SMTP) на сайте WordPress
Техничка

«Извините, вам не разрешено просматривать эту страницу»…
5 июля, 20266 июля, 2026 Reading Time: 2 минут

Плагин сломал админку и выдает ошибку доступа? Разбираем, как сбой Freemius бьет по воронкам продаж и как изящно вернуть сайт к жизни. Инструкция для профи.

Читать далее «Извините, вам не разрешено просматривать эту страницу»…
Техничка

Как настроить мгновенное индексирование Google через плагин SEOPress
10 июля, 202610 июля, 2026 Reading Time: 1 минут

Настраиваем мгновенное индексирование в SEOPress через Google Indexing API: новые статьи WordPress попадают в поиск за часы вместо дней. Пошаговый гайд с JSON-ключом.

Читать далее Как настроить мгновенное индексирование Google через плагин SEOPress
Техничка

Пошаговая настройка SEOPress для WordPress-сайта и интернет–магазина WooCommerce
21 июля, 202621 июля, 2026 Reading Time: 3 минут

Теряете лиды из-за невидимых товаров? Разбираем, как настроить SEOPress для WooCommerce, чтобы каждый товар привлекал органический трафик в вашу воронку.

Читать далее Пошаговая настройка SEOPress для WordPress-сайта и интернет–магазина WooCommerce
Техничка

Как добавить телефон и email с иконками в шапку Astra: готовый HTML и CSS с адаптивом
9 июля, 20269 июля, 2026 Reading Time: 4 минут

Клиенты теряют ваши контакты? Готовое HTML и CSS решение для темы Astra: выводим кликабельный телефон, email и часы работы в шапку для роста конверсии.

Читать далее Как добавить телефон и email с иконками в шапку Astra: готовый HTML и CSS с адаптивом
Техничка

Error establishing a Redis connection в WordPress: как мы восстановили сайт на Beget
22 июля, 202622 июля, 2026 Reading Time: 3 минут

Сайт на WordPress перестал открываться из-за ошибки подключения к Redis, хотя в панели Beget сервис отображался включённым. Разбираем реальный случай: как восстановили доступ к сайту, перезапустили Redis, настроили подключение в wp-config.php, увеличили лимит PHP и проверили автоматизации FluentCRM.

Читать далее Error establishing a Redis connection в WordPress: как мы восстановили сайт на Beget