docxTemplater/handlers/yadisk.go

package handlers

import (
	"amocrm_templategen_back/dal/model"
	"errors"
	"github.com/gorilla/schema"
	"go.uber.org/zap"
	"golang.org/x/oauth2"
	"net/http"
	"time"
)

type RespYaDiskSaveToken struct {
	AccessToken  string `json:"access_token" schema:"access_token"`
	ExpiresIn    int64  `json:"expires_in" schema:"expires_in"`
	TokenType    string `json:"token_type" schema:"token_type"`
	RefreshToken string `json:"refresh_token"`
	State        string `json:"state" schema:"state"`
	Scope        string `json:"scope" schema:"scope"`
	Error        string `json:"error" schema:"error"`
}

func (h *Handlers) YaDiskSaveToken(w http.ResponseWriter, r *http.Request) {
	var resp RespYaDiskSaveToken
	err := r.ParseForm()
	if err != nil {
		h.reportError(w, err, http.StatusBadRequest)
		return
	}

	err = schema.NewDecoder().Decode(&resp, r.Form)
	if err != nil {
		h.reportError(w, err, 500)
		return
	}

	if resp.Error != "" {
		err = errors.New("YaDiskErr:" + resp.Error)
		h.reportError(w, err, 500)
		return
	}

	if resp.AccessToken == "" {
		err = errors.New("YaDiskErr: got empty token")
		h.reportError(w, err, http.StatusBadRequest)
		return
	}

	user := getJwtUser(r)
	if user == nil {
		h.reportError(w, ErrorUnauthorized, http.StatusUnauthorized)
		return
	}

	token := &oauth2.Token{
		AccessToken:  resp.AccessToken,
		TokenType:    resp.TokenType,
		RefreshToken: resp.RefreshToken,
		Expiry:       time.Now().Add(time.Duration(resp.ExpiresIn) * time.Second),
	}

	// Insert/Update token in DB
	_, err = h.dal.YaDisk.InsertOrUpdate(r.Context(), &model.YaDisk{
		UserID:         user.UserID,
		AccessToken:    token.AccessToken,
		RefreshToken:   token.RefreshToken,
		ExpiresIn:      token.Expiry,
		TokenType:      token.TokenType,
		TemplateFolder: "disk:/templategen/templates",
		SaveFolder:     "disk:/templategen/saved",
	})

	if err != nil {
		h.reportError(w, err, 500)
		return
	}

	YaDiskClient := h.YaDisk.NewClient(token)

	// Make default directories in YandexDisk
	err = YaDiskClient.PutResources("disk:/templategen")
	if err != nil {
		h.logger.Error("ErrorHandler", zap.Error(err))
	}

	err = YaDiskClient.PutResources("disk:/templategen/templates")
	if err != nil {
		h.logger.Error("ErrorHandler", zap.Error(err))
	}

	err = YaDiskClient.PutResources("disk:/templategen/saved")
	if err != nil {
		h.logger.Error("ErrorHandler", zap.Error(err))
	}

	// Insert yandex token in cookies

	err = sendResponse(w, 200, map[string]string{"accessToken": resp.AccessToken})
	if err != nil {
		h.reportError(w, err, 500)
	}
}

type RespYaDiskSetFolders struct {
	TemplateFolder string `json:"template_folder"`
	SaveFolder     string `json:"save_folder"`
}

func (h *Handlers) YaDiskSetFolders(w http.ResponseWriter, r *http.Request) {
	var resp RespYaDiskSetFolders

	user := getJwtUser(r)
	if user == nil {
		h.reportError(w, ErrorUnauthorized, http.StatusUnauthorized)
		return
	}

	err := decodePost(&resp, r)
	if err != nil {
		h.reportError(w, err, http.StatusBadRequest)
		return
	}

	err = h.dal.YaDisk.Update(r.Context(), &model.YaDisk{
		TemplateFolder: resp.TemplateFolder,
		SaveFolder:     resp.SaveFolder},
	)

	if err != nil {
		h.reportError(w, err, http.StatusInternalServerError)
		return
	}

	sendResponse(w, 200, nil)
}

func (h *Handlers) YaDiskGetInfo(w http.ResponseWriter, r *http.Request) {
	user := getJwtUser(r)
	if user == nil {
		h.reportError(w, ErrorUnauthorized, http.StatusUnauthorized)
		return
	}

	userData, err := h.dal.YaDisk.GetByUserID(r.Context(), user.UserID)

	token := &oauth2.Token{
		AccessToken:  userData.AccessToken,
		TokenType:    userData.TokenType,
		RefreshToken: userData.RefreshToken,
		Expiry:       time.Time{},
	}

	if !token.Valid() {
		h.reportError(w, errors.New("invalid yandex token"), http.StatusForbidden)
		return
	}

	client := h.YaDisk.NewClient(token)
	disk, err := client.GetDisk()
	if err != nil {
		h.reportError(w, err, http.StatusInternalServerError)
	}

	sendResponse(w, 200, disk)
}