docxTemplater/handlers/yadisk.go

package handlers

import (
	"amocrm_templategen_back/dal/model"
	"amocrm_templategen_back/middleware"
	"errors"
	"github.com/dgrijalva/jwt-go"
	"github.com/gorilla/schema"
	"go.uber.org/zap"
	"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
	}

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

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

	YaDiskClient := h.YaDisk.NewClient(resp.AccessToken)

	// 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

	user.YaDiskAccessToken = resp.AccessToken

	token := jwt.NewWithClaims(jwt.SigningMethodHS256, user)

	ss, err := token.SignedString(middleware.JwtSecret)
	if err != nil {
		h.reportError(w, err, 500)
	}

	http.SetCookie(w, &http.Cookie{
		Name:   "Authorization",
		Value:  ss,
		MaxAge: 3600 * 24 * 30,
		Path:   "/",
	})

	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
	}

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

	sendResponse(w, 200, disk)
}