core/service/telegram_svc.go

package service

import (
	"fmt"
	"github.com/gofiber/fiber/v2"
	"github.com/rs/xid"
	"path/filepath"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/model"
	"penahub.gitlab.yandexcloud.net/backend/quiz/core/clients/telegram"
	"penahub.gitlab.yandexcloud.net/backend/tdlib/client"
)

type Message struct {
	Type string `json:"type"`
	Data string `json:"data"`
}

func (s *Service) GetPoolTgAccounts(ctx *fiber.Ctx) error {
	return nil
}

func (s *Service) AddingTgAccount(ctx *fiber.Ctx) error {
	var req telegram.AuthTgUserReq
	if err := ctx.BodyParser(&req); err != nil {
		return ctx.Status(fiber.StatusBadRequest).SendString("Invalid request data")
	}
	authorizer := client.ClientAuthorizerr()
	authorizer.TdlibParameters <- &client.SetTdlibParametersRequest{
		UseTestDc:           false,
		DatabaseDirectory:   filepath.Join(".tdlib", "database"),
		FilesDirectory:      filepath.Join(".tdlib", "files"),
		UseFileDatabase:     false,
		UseChatInfoDatabase: false,
		UseMessageDatabase:  false,
		UseSecretChats:      false,
		ApiId:               req.ApiID,
		ApiHash:             req.ApiHash,
		SystemLanguageCode:  "en",
		DeviceModel:         "Server",
		SystemVersion:       "1.0.0",
		ApplicationVersion:  "1.0.0",
	}

	_, err := client.SetLogVerbosityLevel(&client.SetLogVerbosityLevelRequest{
		NewVerbosityLevel: 1,
	})
	if err != nil {
		return ctx.Status(fiber.StatusInternalServerError).SendString(err.Error())
	}

	var tdlibClient *client.Client
	// завершается уже в другом контроллере
	var goErr error
	go func() {
		tdlibClient, goErr = client.NewClient(authorizer)
		if goErr != nil {
			fmt.Println("new client failed", err)
			return
		}
		fmt.Println("i am down")
	}()
	if goErr != nil {
		return ctx.Status(fiber.StatusInternalServerError).SendString(goErr.Error())
	}

	for {
		state, ok := <-authorizer.State
		if !ok {
			return ctx.Status(fiber.StatusOK).SendString("state chan is close auth maybe ok")
		}
		fmt.Println("currnet state:", state)
		switch state.AuthorizationStateType() {
		case client.TypeAuthorizationStateWaitPhoneNumber:
			authorizer.PhoneNumber <- req.PhoneNumber
		case client.TypeAuthorizationStateWaitCode:
			id := xid.New()
			s.telegramClient.AddedToMap(telegram.WaitingClient{
				TdLibClient: tdlibClient,
				PreviousReq: req,
				Authorizer:  authorizer,
			}, id.String())
			return ctx.Status(fiber.StatusOK).JSON(fiber.Map{"id": id.String()})

		case client.TypeAuthorizationStateLoggingOut, client.TypeAuthorizationStateClosing, client.TypeAuthorizationStateClosed:
			return ctx.Status(fiber.StatusForbidden).SendString(fmt.Sprintf("auth failed, last state is %s", state))
		}
	}
}

func (s *Service) SettingTgCode(ctx *fiber.Ctx) error {
	var req struct {
		Code string `json:"code"`
		ID   string `json:"id"`
	}
	if err := ctx.BodyParser(&req); err != nil {
		return ctx.Status(fiber.StatusBadRequest).SendString("Invalid request data")
	}

	data, ok := s.telegramClient.GetFromMap(req.ID)
	if !ok {
		return ctx.Status(fiber.StatusBadRequest).SendString("Invalid id, don't have data")
	}
	data.Authorizer.Code <- req.Code
	for {
		state, ok := <-data.Authorizer.State
		if !ok {
			return ctx.Status(fiber.StatusOK).SendString("state chan is close auth maybe ok")
		}
		fmt.Println("currnet state:", state)
		switch state.AuthorizationStateType() {
		case client.TypeAuthorizationStateReady:
			s.telegramClient.TgClients = append(s.telegramClient.TgClients, data.TdLibClient)
			id, err := s.dal.TgRepo.CreateTgAccount(ctx.Context(), model.TgAccount{
				ApiID:       data.PreviousReq.ApiID,
				ApiHash:     data.PreviousReq.ApiHash,
				PhoneNumber: data.PreviousReq.PhoneNumber,
				Status:      model.ActiveTg,
				Password:    data.PreviousReq.Password,
			})
			if err != nil {
				return ctx.Status(fiber.StatusInternalServerError).SendString(err.Error())
			}
			return ctx.Status(fiber.StatusOK).JSON(fiber.Map{"id": id})
		case client.TypeAuthorizationStateWaitPassword:
			data.Authorizer.Password <- data.PreviousReq.Password
		case client.TypeAuthorizationStateLoggingOut, client.TypeAuthorizationStateClosing, client.TypeAuthorizationStateClosed:
			return ctx.Status(fiber.StatusForbidden).SendString(fmt.Sprintf("auth failed, last state is %s", state))
		}
	}
}

func (s *Service) DeleteTgAccountByID(ctx *fiber.Ctx) error {
	return nil
}