PenaSide/docxTemplater
3
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

Task (#862kbz8hr)

Browse Source
This commit is contained in:
Danil Solovyov 2023-09-06 15:13:15 +05:00
parent 36684badfd
commit ae7f7ccbd3
22 changed files with 405 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
amo/api.go
View File

@ -67,8 +67,9 @@ func NewClientApp(clientID, clientSecret string, redirectURI string) *ClientApp
}
}
func (ca *ClientApp) GenerateOAuthURL(penaID, redirectURL string) (string, error) {
func (ca *ClientApp) GenerateOAuthURL(amoID, penaID, redirectURL string) (string, error) {
state, err := tools.EncryptTokenAES(tools.StateToken{
AmoID: amoID,
PenaID: penaID,
Service: "amo",
RedirectURL: redirectURL,

2
dal/model/gdisk.go
View File

@ -13,6 +13,8 @@ type GDisk struct {
PenaID string `bson:"pena_id" json:"pena_id"`
AmoID string `bson:"amo_id" json:"amo_id"`
/* Google email. Уникальное поле и закрепляется только за одним пользователем. */
Email string `bson:"email" json:"email"`

2
dal/model/penadisk.go
View File

@ -7,6 +7,8 @@ type PenaDisk struct {
PenaID string `bson:"pena_id" json:"pena_id"`
AmoID string `bson:"amo_id" json:"amo_id"`
/* Пользовательское название хранилища */
Name string `bson:"name" json:"name"`

2
dal/model/template.go
View File

@ -7,6 +7,8 @@ import (
type Template struct {
ID string `bson:"_id,omitempty" json:"id"`
AmoID string `bson:"amo_id" json:"amo_id"`
PenaID string `bson:"pena_id" json:"pena_id"`
/* AMO lead */

1
dal/model/templateGroup.go
View File

@ -6,6 +6,7 @@ import (
type TemplateGroup struct {
ID string `bson:"_id,omitempty" json:"id"`
AmoID string `bson:"amo_id" json:"amo_id"`
PenaID string `bson:"pena_id" json:"pena_id"`
Name string `bson:"name" json:"name"`
CreatedAt time.Time `bson:"created_at" json:"created_at"`

2
dal/model/yadisk.go
View File

@ -14,6 +14,8 @@ YaDisk (StorageType) - хранит информацию о пользовате
type YaDisk struct {
ID string `bson:"_id,omitempty" json:"id"`
AmoID string `bson:"amo_id" json:"amo_id"`
PenaID string `bson:"pena_id" json:"pena_id"`
/* Yandex UID. уникальное поле и закрепляется только за одним пользователем */

62
dal/mongos/gdisk.go
View File

@ -121,6 +121,27 @@ func (d *GDisk) GetByEmail(ctx context.Context, email string) (*model.GDisk, err
return &result, nil
}
func (d *GDisk) GetByAmoID(ctx context.Context, amoID string) (*model.GDisk, error) {
filter := bson.M{"amo_id": amoID, "is_deleted": false}
var result model.GDisk
err := d.coll.FindOne(ctx, filter).Decode(&result)
if err != nil {
if err == mongo.ErrNoDocuments {
d.logger.Info("InfoGetGDisk", zap.String("id", "not found"))
return nil, nil
}
d.logger.Error("ErrorGetGDisk", zap.Error(err))
return nil, err
}
d.logger.Info("InfoGetGDisk", zap.String("id", result.ID))
return &result, nil
}
func (d *GDisk) GetListByPenaID(ctx context.Context, penaID string) ([]model.GDisk, error) {
filter := bson.M{"pena_id": penaID, "is_deleted": false}
@ -148,6 +169,33 @@ func (d *GDisk) GetListByPenaID(ctx context.Context, penaID string) ([]model.GDi
return result, nil
}
func (d *GDisk) GetListByAmoID(ctx context.Context, amoID string) ([]model.GDisk, error) {
filter := bson.M{"amo_id": amoID, "is_deleted": false}
var result []model.GDisk
cur, err := d.coll.Find(ctx, filter)
if err != nil {
if err == mongo.ErrNoDocuments {
d.logger.Info("InfoGetListGDisk", zap.String("id", "not found"))
return nil, nil
}
d.logger.Error("ErrorGetListGDisk", zap.Error(err))
return nil, err
}
err = cur.All(ctx, &result)
if err != nil {
d.logger.Error("ErrorGetListGDisk", zap.Error(err))
return nil, err
}
d.logger.Info("InfoGetListGDisk")
return result, nil
}
func (d *GDisk) Update(ctx context.Context, record *model.GDisk) error {
filter := bson.M{"is_deleted": false}
@ -239,6 +287,20 @@ func (d *GDisk) Update(ctx context.Context, record *model.GDisk) error {
return nil
}
func (d *GDisk) DeleteByAmoID(ctx context.Context, amoID string) error {
filter := bson.M{"amo_id": amoID, "is_deleted": false}
update := bson.M{"updated_at": time.Now(), "is_deleted": true}
_, err := d.coll.UpdateOne(ctx, filter, bson.D{{Key: "$set", Value: update}})
if err != nil {
d.logger.Error("ErrorDeleteGDisk", zap.Error(err))
return err
}
return nil
}
func (d *GDisk) DeleteByPenaID(ctx context.Context, penaID string) error {
filter := bson.M{"pena_id": penaID, "is_deleted": false}

52
dal/mongos/penadisk.go
View File

@ -26,7 +26,16 @@ func (d *PenaDisk) InsertOrUpdate(ctx context.Context, record *model.PenaDisk) (
record.CreatedAt = time.Now()
record.UpdatedAt = record.CreatedAt
found, err := d.GetByPenaID(ctx, record.PenaID)
found, err := d.GetByAmoID(ctx, record.AmoID)
if err != nil {
d.logger.Error("ErrorInsertOrUpdatePenaDisk", zap.Error(err))
return "", err
}
if found == nil {
found, err = d.GetByAmoID(ctx, record.AmoID)
}
if err != nil {
d.logger.Error("ErrorInsertOrUpdatePenaDisk", zap.Error(err))
@ -102,7 +111,28 @@ func (d *PenaDisk) GetByPenaID(ctx context.Context, penaID string) (*model.PenaD
return &result, nil
}
// Update - обновляет запись по её id или PenaID.
func (d *PenaDisk) GetByAmoID(ctx context.Context, amoID string) (*model.PenaDisk, error) {
filter := bson.M{"amo_id": amoID, "is_deleted": false}
var result model.PenaDisk
err := d.coll.FindOne(ctx, filter).Decode(&result)
if err != nil {
if err == mongo.ErrNoDocuments {
d.logger.Info("InfoGetPenaDisk", zap.String("id", "not found"))
return nil, nil
}
d.logger.Error("ErrorGetPenaDisk", zap.Error(err))
return nil, err
}
d.logger.Info("InfoGetPenaDisk", zap.String("id", result.ID))
return &result, nil
}
// Update - обновляет запись по её id, AmoID или PenaID.
func (d *PenaDisk) Update(ctx context.Context, record *model.PenaDisk) error {
filter := bson.M{"is_deleted": false}
@ -115,8 +145,10 @@ func (d *PenaDisk) Update(ctx context.Context, record *model.PenaDisk) error {
filter["_id"] = objID
} else if record.PenaID != "" {
filter["pena_id"] = record.PenaID
} else if record.AmoID != "" {
filter["amo_id"] = record.AmoID
} else {
err := errors.New("got empty id and pena_id")
err := errors.New("got empty id, amo_id and pena_id")
d.logger.Error("ErrorUpdatePenaDisk", zap.Error(err))
return err
}
@ -145,6 +177,20 @@ func (d *PenaDisk) Update(ctx context.Context, record *model.PenaDisk) error {
return nil
}
func (d *PenaDisk) DeleteByAmoID(ctx context.Context, amoID string) error {
filter := bson.M{"amo_id": amoID, "is_deleted": false}
update := bson.M{"updated_at": time.Now(), "is_deleted": true}
_, err := d.coll.UpdateOne(ctx, filter, bson.D{{Key: "$set", Value: update}})
if err != nil {
d.logger.Error("ErrorDeletePenaDisk", zap.Error(err))
return err
}
return nil
}
func (d *PenaDisk) DeleteByPenaID(ctx context.Context, penaID string) error {
filter := bson.M{"pena_id": penaID, "is_deleted": false}

126
dal/mongos/template.go
View File

@ -28,12 +28,6 @@ func (d *Template) Insert(ctx context.Context, record *model.Template) (string,
record.UpdatedAt = now
record.IsDeleted = false
if record.PenaID == "" {
err := errors.New("got empty pena_id")
d.logger.Error("ErrorDeleteTemplate", zap.Error(err))
return "", err
}
if record.GroupIDs == nil {
record.GroupIDs = []string{}
}
@ -125,6 +119,30 @@ func (d *Template) GetByNameAndPenaID(ctx context.Context, name, penaID string)
return &result, nil
}
func (d *Template) GetByNameAndAmoID(ctx context.Context, name, amoID string) (*model.Template, error) {
filter := bson.M{"name": name, "amo_id": amoID, "is_deleted": false}
fmt.Println("-----------------------------------")
fmt.Println(filter)
var result model.Template
err := d.coll.FindOne(ctx, filter).Decode(&result)
if err != nil {
if err == mongo.ErrNoDocuments {
d.logger.Info("InfoGetTemplate", zap.String("id", "not found"))
return nil, nil
}
d.logger.Error("ErrorGetTemplate", zap.Error(err))
return nil, err
}
d.logger.Info("InfoGetTemplate", zap.String("id", result.ID))
return &result, nil
}
func (d *Template) GetByFilenameAndPenaID(ctx context.Context, name, penaID string) (*model.Template, error) {
filter := bson.M{"filename": name, "pena_id": penaID, "is_deleted": false}
@ -147,6 +165,28 @@ func (d *Template) GetByFilenameAndPenaID(ctx context.Context, name, penaID stri
return &result, nil
}
func (d *Template) GetByFilenameAndAmoID(ctx context.Context, name, amoID string) (*model.Template, error) {
filter := bson.M{"filename": name, "amo_id": amoID, "is_deleted": false}
var result model.Template
err := d.coll.FindOne(ctx, filter).Decode(&result)
if err != nil {
if err == mongo.ErrNoDocuments {
d.logger.Info("InfoGetTemplate", zap.String("id", "not found"))
return nil, nil
}
d.logger.Error("ErrorGetTemplate", zap.Error(err))
return nil, err
}
d.logger.Info("InfoGetTemplate", zap.String("id", result.ID))
return &result, nil
}
func (d *Template) GetListByPenaID(ctx context.Context, penaID string) ([]model.Template, error) {
filter := bson.M{"pena_id": penaID, "is_deleted": false}
@ -176,6 +216,35 @@ func (d *Template) GetListByPenaID(ctx context.Context, penaID string) ([]model.
return result, nil
}
func (d *Template) GetListByAmoID(ctx context.Context, amoID string) ([]model.Template, error) {
filter := bson.M{"amo_id": amoID, "is_deleted": false}
var result []model.Template
cursor, err := d.coll.Find(ctx, filter)
if err == mongo.ErrNoDocuments {
return nil, nil
} else if err != nil {
d.logger.Error("ErrorGetTemplate", zap.Error(err))
return nil, err
}
err = cursor.All(ctx, &result)
if err != nil {
if err == mongo.ErrNoDocuments {
d.logger.Info("InfoGetTemplate", zap.String("id", "not found"))
return nil, nil
}
d.logger.Error("ErrorGetTemplate", zap.Error(err))
return nil, err
}
return result, nil
}
func (d *Template) GetListByPenaIDAndStorageType(ctx context.Context, penaID, storageType string) ([]model.Template,
error) {
filter := bson.M{"pena_id": penaID, "storage_type": storageType, "is_deleted": false}
@ -205,8 +274,37 @@ func (d *Template) GetListByPenaIDAndStorageType(ctx context.Context, penaID, st
return result, nil
}
func (d *Template) GetListByGroupID(ctx context.Context, groupID, penaID string) ([]model.Template, error) {
filter := bson.M{"pena_id": penaID}
func (d *Template) GetListByAmoIDAndStorageType(ctx context.Context, amoID, storageType string) ([]model.Template,
error) {
filter := bson.M{"amo_id": amoID, "storage_type": storageType, "is_deleted": false}
var result []model.Template
cursor, err := d.coll.Find(ctx, filter)
if err == mongo.ErrNoDocuments {
return nil, nil
} else if err != nil {
d.logger.Error("ErrorGetTemplate", zap.Error(err))
return nil, err
}
err = cursor.All(ctx, &result)
if err != nil {
if err == mongo.ErrNoDocuments {
d.logger.Info("InfoGetTemplate", zap.String("id", "not found"))
return nil, nil
}
d.logger.Error("ErrorGetTemplate", zap.Error(err))
return nil, err
}
return result, nil
}
func (d *Template) GetListByGroupID(ctx context.Context, groupID, amoID, penaID string) ([]model.Template, error) {
filter := bson.M{"pena_id": penaID, "amo_id": amoID}
if groupID == "" {
filter["group_ids"] = []string{}
@ -232,7 +330,7 @@ func (d *Template) GetListByGroupID(ctx context.Context, groupID, penaID string)
return result, nil
}
func (d *Template) PushGroup(ctx context.Context, id, groupID, penaID string) error {
func (d *Template) PushGroup(ctx context.Context, id, groupID, amoID, penaID string) error {
objID, err := primitive.ObjectIDFromHex(id)
if err != nil {
@ -252,6 +350,10 @@ func (d *Template) PushGroup(ctx context.Context, id, groupID, penaID string) er
filter["pena_id"] = penaID
}
if amoID != "" {
filter["amo_id"] = amoID
}
update := bson.M{
"$addToSet": bson.M{"group_ids": groupID},
"$set": bson.M{"updated_at": time.Now()},
@ -269,7 +371,7 @@ func (d *Template) PushGroup(ctx context.Context, id, groupID, penaID string) er
return nil
}
func (d *Template) PullGroup(ctx context.Context, id, groupID, penaID string) error {
func (d *Template) PullGroup(ctx context.Context, id, groupID, amoID, penaID string) error {
objID, err := primitive.ObjectIDFromHex(id)
if err != nil {
@ -289,6 +391,10 @@ func (d *Template) PullGroup(ctx context.Context, id, groupID, penaID string) er
filter["pena_id"] = penaID
}
if amoID != "" {
filter["amo_id"] = amoID
}
update := bson.M{
"$pull": bson.M{"group_ids": groupID},
"$set": bson.M{"updated_at": time.Now()},

64
dal/mongos/templateGroup.go
View File

@ -26,18 +26,6 @@ func (d *TemplateGroup) Insert(ctx context.Context, record *model.TemplateGroup)
record.CreatedAt = now
record.UpdatedAt = now
if record.PenaID == "" {
err := errors.New("pena_id required")
d.logger.Error("ErrorInsertTemplateGroup", zap.Error(err))
return "", err
}
if record.Name == "" {
err := errors.New("name required")
d.logger.Error("ErrorInsertTemplateGroup", zap.Error(err))
return "", err
}
result, err := d.coll.InsertOne(ctx, record)
if err != nil {
@ -115,6 +103,41 @@ func (d *TemplateGroup) GetListByPenaID(ctx context.Context, penaID string) ([]m
return result, err
}
func (d *TemplateGroup) GetListByAmoID(ctx context.Context, amoID string) ([]model.TemplateGroup, error) {
if amoID == "" {
err := errors.New("amo_id required")
d.logger.Error("ErrorGetListTemplateGroup")
return nil, err
}
filter := bson.M{"amo_id": amoID}
var result []model.TemplateGroup
cur, err := d.coll.Find(ctx, filter)
if err != nil {
if err == mongo.ErrNoDocuments {
d.logger.Info("InfoGetTemplateGroup", zap.String("id", "not found"))
return nil, nil
}
d.logger.Error("ErrorGetTemplateGroup", zap.Error(err))
return nil, err
}
err = cur.All(ctx, &result)
if err != nil {
d.logger.Error("ErrorGetListTemplateGroup", zap.Error(err))
return nil, err
}
d.logger.Info("InfoGetListTemplateGroup")
return result, err
}
func (d *TemplateGroup) Update(ctx context.Context, record *model.TemplateGroup) error {
objID, err := primitive.ObjectIDFromHex(record.ID)
@ -129,6 +152,10 @@ func (d *TemplateGroup) Update(ctx context.Context, record *model.TemplateGroup)
filter["pena_id"] = record.PenaID
}
if record.AmoID != "" {
filter["amo_id"] = record.AmoID
}
update := bson.M{"updated_at": time.Now()}
if record.Name != "" {
@ -178,3 +205,16 @@ func (d *TemplateGroup) DeleteByPenaID(ctx context.Context, penaID string) error
return nil
}
func (d *TemplateGroup) DeleteByAmoID(ctx context.Context, amoID string) error {
filter := bson.M{"amo_id": amoID}
_, err := d.coll.DeleteMany(ctx, filter)
if err != nil {
d.logger.Error("ErrorDeleteTemplateGroup", zap.Error(err))
return err
}
return nil
}

37
dal/mongos/yadisk.go
View File

@ -145,6 +145,29 @@ func (d *YaDisk) GetListByPenaID(ctx context.Context, penaID string) ([]model.Ya
return result, nil
}
func (d *YaDisk) GetListByAmoID(ctx context.Context, amoID string) ([]model.YaDisk, error) {
filter := bson.M{"amo_id": amoID, "is_deleted": false}
result := []model.YaDisk{}
cur, err := d.coll.Find(ctx, filter)
if err == mongo.ErrNoDocuments {
return nil, nil
} else if err != nil {
d.logger.Error("ErrorGetListYaDisk", zap.Error(err))
return nil, err
}
err = cur.All(ctx, &result)
if err != nil {
d.logger.Error("ErrorGetListYaDisk", zap.Error(err))
}
d.logger.Info("InfoGetListYaDisk")
return result, nil
}
// Update - обновляет запись по её id или логину Yandex.
func (d *YaDisk) Update(ctx context.Context, record *model.YaDisk) error {
filter := bson.M{"is_deleted": false}
@ -226,3 +249,17 @@ func (d *YaDisk) DeleteByPenaID(ctx context.Context, penaID string) error {
return nil
}
func (d *YaDisk) DeleteByAmoID(ctx context.Context, amoID string) error {
filter := bson.M{"amo_id": amoID, "is_deleted": false}
update := bson.M{"updated_at": time.Now(), "is_deleted": true}
_, err := d.coll.UpdateMany(ctx, filter, bson.D{{Key: "$set", Value: update}})
if err != nil {
d.logger.Error("ErrorDeleteYaDisk", zap.Error(err))
return err
}
return nil
}

3
gdisk/api.go
View File

@ -54,8 +54,9 @@ func NewClientApp(credentials string) (*ClientApp, error) {
return &ClientApp{Config: config}, nil
}
func (ca *ClientApp) GenerateOAuthURL(penaID, redirectURL string) (string, error) {
func (ca *ClientApp) GenerateOAuthURL(amoID, penaID, redirectURL string) (string, error) {
state, err := tools.EncryptTokenAES(tools.StateToken{
AmoID: amoID,
PenaID: penaID,
Service: "google",
RedirectURL: redirectURL,

95
handlers/amo.go
View File

@ -144,47 +144,19 @@ func (h *Handlers) AmoState(w http.ResponseWriter, r *http.Request) {
amoData := middleware.GetAmoData(r)
if amoData == nil {
h.reportError(w, http.StatusUnauthorized, ErrorUnauthorized)
return
}
account, err := h.dal.Amo.GetByAccountID(ctx, amoData.AccountID)
if err != nil {
h.reportError(w, http.StatusInternalServerError, fmt.Errorf("db unexpected error %s", err.Error()))
return
}
if account == nil {
account = &model.Amo{
AccountID: amoData.AccountID,
PenaID: middleware.GetPenaUserID(r),
}
var id string
id, err = h.dal.Amo.InsertOrUpdate(ctx, account)
if err != nil {
h.reportError(w, http.StatusInternalServerError, fmt.Errorf("db unexpected error %s", err.Error()))
return
}
account.ID = id
}
yaStorages, err := h.dal.YaDisk.GetListByPenaID(r.Context(), account.PenaID)
yaStorages, err := h.dal.YaDisk.GetListByPenaID(r.Context(), amoData.PenaID)
if err != nil {
h.reportError(w, http.StatusInternalServerError, err)
return
}
gStorages, err := h.dal.GDisk.GetListByPenaID(r.Context(), account.PenaID)
gStorages, err := h.dal.GDisk.GetListByAmoID(r.Context(), amoData.ID)
if err != nil {
h.reportError(w, http.StatusInternalServerError, err)
return
}
penaStorage, err := h.dal.PenaDisk.GetByPenaID(ctx, account.PenaID)
penaStorage, err := h.dal.PenaDisk.GetByPenaID(ctx, amoData.PenaID)
if err != nil {
h.reportError(w, http.StatusInternalServerError, err)
return
@ -197,19 +169,19 @@ func (h *Handlers) AmoState(w http.ResponseWriter, r *http.Request) {
}
redirectURI := "https://" + amoData.Referer + h.opts.AmoRedirectUrn
authYandexURL, err := h.YaDisk.GenerateOAuthURL(account.PenaID, redirectURI)
authYandexURL, err := h.YaDisk.GenerateOAuthURL(amoData.ID, amoData.PenaID, redirectURI)
if err != nil {
h.reportError(w, http.StatusInternalServerError, err)
return
}
authGoogleURL, err := h.GDisk.GenerateOAuthURL(account.PenaID, redirectURI)
authGoogleURL, err := h.GDisk.GenerateOAuthURL(amoData.ID, amoData.PenaID, redirectURI)
if err != nil {
h.reportError(w, http.StatusInternalServerError, err)
return
}
authAmoURL, err := h.Amo.GenerateOAuthURL(account.PenaID, redirectURI)
authAmoURL, err := h.Amo.GenerateOAuthURL(amoData.ID, amoData.PenaID, redirectURI)
if err != nil {
h.reportError(w, http.StatusInternalServerError, err)
return
@ -303,36 +275,55 @@ func (h *Handlers) AmoState(w http.ResponseWriter, r *http.Request) {
}
// Amo tokens
amoList, err := h.dal.Amo.GetListByPenaID(r.Context(), amoData.PenaID)
// amoList, err := h.dal.Amo.GetListByPenaID(r.Context(), amoData.PenaID)
if err != nil {
h.reportError(w, http.StatusInternalServerError, err)
return
}
// if err != nil {
// h.reportError(w, http.StatusInternalServerError, err)
// return
// }
for _, amo := range amoList {
if amo.Token().Valid() {
continue
// for _, amo := range amoList {
// if amo.Token().Valid() {
// continue
// }
// var token *oauth2.Token
// token, err = h.Amo.RefreshToken(r.Context(), amo.Token(), amo.Referer)
// if err == nil {
// _, err = h.dal.Amo.InsertOrUpdate(r.Context(), &model.Amo{
// ID: amo.ID,
// AccountID: amo.AccountID,
// AccessToken: token.AccessToken,
// RefreshToken: token.RefreshToken,
// ExpiresIn: token.Expiry,
// TokenType: token.TokenType,
// })
// }
// if err != nil {
// h.logger.Error("ErrorCheckAmoTokens", zap.Error(err))
// invalidTokens["amo"] = amo
// }
// }
if !amoData.Token().Valid() {
token, err := h.Amo.RefreshToken(r.Context(), amoData.Token(), amoData.Referer)
if err != nil {
h.logger.Error("ErrorCheckAmoTokens", zap.Error(err))
invalidTokens["amo"] = amoData
}
var token *oauth2.Token
token, err = h.Amo.RefreshToken(r.Context(), amo.Token(), amo.Referer)
if err == nil {
_, err = h.dal.Amo.InsertOrUpdate(r.Context(), &model.Amo{
ID: amo.ID,
AccountID: amo.AccountID,
ID: amoData.ID,
AccountID: amoData.AccountID,
AccessToken: token.AccessToken,
RefreshToken: token.RefreshToken,
ExpiresIn: token.Expiry,
TokenType: token.TokenType,
})
}
if err != nil {
h.logger.Error("ErrorCheckAmoTokens", zap.Error(err))
invalidTokens["amo"] = amo
}
}
resp := RespAmoState{

3
handlers/gdisk.go
View File

@ -107,6 +107,7 @@ func (h *Handlers) GDiskSaveToken(w http.ResponseWriter, r *http.Request) {
// Insert/Update token in DB
_, err = h.dal.GDisk.InsertOrUpdate(r.Context(), &model.GDisk{
AmoID: state.AmoID,
PenaID: state.PenaID,
Name: fmt.Sprintf("Google Disk (%v)", gUser.EmailAddress),
DisplayName: gUser.DisplayName,
@ -314,7 +315,7 @@ func (h *Handlers) GDiskGetList(w http.ResponseWriter, r *http.Request) {
return
}
gdiskInfo, err := h.dal.GDisk.GetListByPenaID(r.Context(), amoData.PenaID)
gdiskInfo, err := h.dal.GDisk.GetListByAmoID(r.Context(), amoData.ID)
if err != nil {
h.reportError(w, http.StatusInternalServerError, err)
return

10
handlers/generator.go
View File

@ -226,7 +226,7 @@ func (h *Handlers) GeneratorByData(w http.ResponseWriter, r *http.Request) {
name = request.Name
}
exportURL, err := h.generate(r, file, name, storageID, storageType, amoData.PenaID, history, request.Data)
exportURL, err := h.generate(r, file, name, storageID, storageType, amoData.ID, history, request.Data)
if err != nil {
history.AddError(err)
h.sendResponse(w, http.StatusInternalServerError, err)
@ -322,7 +322,7 @@ func (h *Handlers) GeneratorByAmoWebhook(w http.ResponseWriter, r *http.Request)
task := &model.WorkerTask{
PenaID: amoData.PenaID,
AmoID: amoData.ID,
AmoUserID: 0,
AmoUserID: middleware.GetAmoUserID(r),
Status: model.WorkerTaskStatusNew,
LeadID: convertedLeadID,
TemplateID: templateID,
@ -353,8 +353,8 @@ func (h *Handlers) GeneratorByAmoWebhook(w http.ResponseWriter, r *http.Request)
// generate - локальная функция, для генерации файла, возвращает ссылку для скачивания сгенерированного файла.
func (h *Handlers) generate(r *http.Request, file, name, storageID, storageType,
penaID string, history *model.History, data any) (string, error) {
amoData, err := h.dal.Amo.GetByPenaID(r.Context(), penaID)
amoID string, history *model.History, data any) (string, error) {
amoData, err := h.dal.Amo.GetByID(r.Context(), amoID)
if err != nil {
return "", err
}
@ -452,7 +452,7 @@ func (h *Handlers) generate(r *http.Request, file, name, storageID, storageType,
exportURL = fmt.Sprintf("https://%v/%v", h.opts.Domain, generatedFile)
case "penadisk":
client := penadisk.NewClient(penaID)
client := penadisk.NewClient(amoID)
saveFolder := "templategen/saved"
history.Target.File, exportURL, err = templategen.PenaDiskGenerateDocBytes(r.Context(), file, name, saveFolder,

2
handlers/history.go
View File

@ -69,7 +69,7 @@ func (h *Handlers) GetHistoryListByFilter(w http.ResponseWriter, r *http.Request
request.AmoUserID = amoUserID
}
request.AmoID = amoData.AccountID
request.AmoID = amoData.ID
result, err := h.dal.History.GetByFilter(r.Context(), &request)
if err != nil {

15
handlers/penadisk.go
View File

@ -33,6 +33,7 @@ func (h *Handlers) PenaDiskSetSettings(w http.ResponseWriter, r *http.Request) {
err = h.dal.PenaDisk.Update(r.Context(), &model.PenaDisk{
PenaID: amoData.PenaID,
AmoID: amoData.ID,
Name: request.Name,
TemplateFolder: request.TemplateFolder,
SaveFolder: request.SaveFolder})
@ -48,7 +49,7 @@ func (h *Handlers) PenaDiskSetSettings(w http.ResponseWriter, r *http.Request) {
type ReqPenaDiskGetResources struct {
Path string `json:"path"`
Recursive bool `json:"recursive"`
WIthVersions bool `json:"w_ith_versions"`
WithVersions bool `json:"with_versions"`
}
func (h *Handlers) PenaDiskGetResources(w http.ResponseWriter, r *http.Request) {
@ -67,9 +68,9 @@ func (h *Handlers) PenaDiskGetResources(w http.ResponseWriter, r *http.Request)
return
}
client := penadisk.NewClient(amoData.PenaID)
client := penadisk.NewClient(amoData.ID)
resource, err := client.GetResources(r.Context(), request.Path, request.Recursive, request.WIthVersions)
resource, err := client.GetResources(r.Context(), request.Path, request.Recursive, request.WithVersions)
if err != nil {
h.reportError(w, http.StatusInternalServerError, err)
return
@ -101,7 +102,7 @@ func (h *Handlers) PenaDiskPutResources(w http.ResponseWriter, r *http.Request)
h.reportError(w, http.StatusBadRequest, errors.New("path required"))
}
client := penadisk.NewClient(amoData.PenaID)
client := penadisk.NewClient(amoData.ID)
err = client.PutResources(r.Context(), request.Path)
if err != nil {
@ -137,7 +138,7 @@ func (h *Handlers) PenaDiskDeleteResources(w http.ResponseWriter, r *http.Reques
h.reportError(w, http.StatusBadRequest, errors.New("path required"))
}
client := penadisk.NewClient(amoData.PenaID)
client := penadisk.NewClient(amoData.ID)
err = client.DeleteResources(r.Context(), request.Path, request.Permanently)
if err != nil {
@ -194,7 +195,7 @@ func (h *Handlers) PenaDiskUploadResources(w http.ResponseWriter, r *http.Reques
}
// Upload file to the storage
client := penadisk.NewClient(pd.PenaID)
client := penadisk.NewClient(pd.AmoID)
_, _, err = client.UploadResources(r.Context(), request.Path, fileHeader.Filename, false, fileData)
if err != nil {
@ -229,7 +230,7 @@ func (h *Handlers) PenaDiskDownloadLink(w http.ResponseWriter, r *http.Request)
h.reportError(w, http.StatusBadRequest, errors.New("path required"))
}
client := penadisk.NewClient(amoData.PenaID)
client := penadisk.NewClient(amoData.ID)
href, err := client.GetPublicDownloadURL(r.Context(), request.Path)
if err != nil {

7
handlers/template.go
View File

@ -58,6 +58,7 @@ func (h *Handlers) TemplateSet(w http.ResponseWriter, r *http.Request) {
update := &model.Template{
ID: request.TemplateID,
AmoID: amoData.ID,
PenaID: amoData.PenaID,
LeadID: request.LeadID,
Name: request.Name,
@ -93,7 +94,7 @@ func (h *Handlers) TemplateGetListByUser(w http.ResponseWriter, r *http.Request)
h.reportError(w, http.StatusUnauthorized, ErrorUnauthorized)
return
}
result, err := h.dal.Template.GetListByPenaID(r.Context(), amoData.PenaID)
result, err := h.dal.Template.GetListByAmoID(r.Context(), amoData.ID)
if err != nil {
h.reportError(w, http.StatusInternalServerError, err)
return
@ -123,7 +124,7 @@ func (h *Handlers) TemplateGetListByGroup(w http.ResponseWriter, r *http.Request
return
}
resp, err := h.dal.Template.GetListByGroupID(r.Context(), request.GroupID, amoData.PenaID)
resp, err := h.dal.Template.GetListByGroupID(r.Context(), request.GroupID, amoData.ID, amoData.PenaID)
if err != nil {
h.reportError(w, http.StatusInternalServerError, err)
@ -180,6 +181,7 @@ func (h *Handlers) TemplateGet(w http.ResponseWriter, r *http.Request) {
if template == nil {
var templateID string
templateID, err = h.dal.Template.Insert(r.Context(), &model.Template{
AmoID: amoData.ID,
PenaID: amoData.PenaID,
LeadID: request.LeadID,
})
@ -223,6 +225,7 @@ func (h *Handlers) TemplateUpdate(w http.ResponseWriter, r *http.Request) {
record := &model.Template{
ID: request.ID,
AmoID: amoData.ID,
PenaID: amoData.PenaID,
Name: request.Name,
File: request.File,

12
handlers/templateGroup.go
View File

@ -39,7 +39,8 @@ func (h *Handlers) TemplateGroupCreate(w http.ResponseWriter, r *http.Request) {
}
groupID, err := h.dal.TemplateGroup.Insert(r.Context(), &model.TemplateGroup{
PenaID: amoData.AccountID,
AmoID: amoData.ID,
PenaID: amoData.PenaID,
Name: request.Name,
})
@ -77,7 +78,7 @@ func (h *Handlers) TemplateGroupGetList(w http.ResponseWriter, r *http.Request)
return
}
resp, err := h.dal.TemplateGroup.GetListByPenaID(r.Context(), amoData.AccountID)
resp, err := h.dal.TemplateGroup.GetListByAmoID(r.Context(), amoData.ID)
if err != nil {
h.reportError(w, http.StatusInternalServerError, err)
@ -120,7 +121,8 @@ func (h *Handlers) TemplateGroupEdit(w http.ResponseWriter, r *http.Request) {
err = h.dal.TemplateGroup.Update(r.Context(), &model.TemplateGroup{
ID: request.ID,
PenaID: amoData.AccountID,
AmoID: amoData.ID,
PenaID: amoData.PenaID,
Name: request.Name,
})
@ -206,7 +208,7 @@ func (h *Handlers) TemplateGroupPut(w http.ResponseWriter, r *http.Request) {
return
}
err = h.dal.Template.PushGroup(r.Context(), request.TemplateID, request.GroupID, amoData.AccountID)
err = h.dal.Template.PushGroup(r.Context(), request.TemplateID, request.GroupID, amoData.ID, amoData.PenaID)
if err != nil {
h.reportError(w, http.StatusInternalServerError, err)
@ -247,7 +249,7 @@ func (h *Handlers) TemplateGroupRemove(w http.ResponseWriter, r *http.Request) {
return
}
err = h.dal.Template.PullGroup(r.Context(), request.TemplateID, request.GroupID, amoData.AccountID)
err = h.dal.Template.PullGroup(r.Context(), request.TemplateID, request.GroupID, amoData.ID, amoData.PenaID)
if err != nil {
h.reportError(w, http.StatusInternalServerError, err)

3
handlers/yadisk.go
View File

@ -93,6 +93,7 @@ func (h *Handlers) YaDiskSaveToken(w http.ResponseWriter, r *http.Request) {
// Insert/Update token in DB
_, err = h.dal.YaDisk.InsertOrUpdate(r.Context(), &model.YaDisk{
PenaID: state.PenaID,
AmoID: state.AmoID,
Name: fmt.Sprintf("Yandex Disk (%v)", yaUser.Login),
UID: yaUser.UID,
Login: yaUser.Login,
@ -179,7 +180,7 @@ func (h *Handlers) YaDiskGetList(w http.ResponseWriter, r *http.Request) {
return
}
yadiskInfo, err := h.dal.YaDisk.GetListByPenaID(r.Context(), amoData.PenaID)
yadiskInfo, err := h.dal.YaDisk.GetListByAmoID(r.Context(), amoData.ID)
if err != nil {
h.reportError(w, http.StatusInternalServerError, err)
return

1
tools/token.go
View File

@ -16,6 +16,7 @@ func SetToken(token string) {
}
type StateToken struct {
AmoID string `json:"amo_id"`
PenaID string `json:"pena_id"`
Service string `json:"service"` // yandex, google, etc
RedirectURL string `json:"redirect_url"`

3
yadisk/api.go
View File

@ -54,8 +54,9 @@ func NewClientApp(clientID, clientSecret, redirectURI, serviceURL string) *Clien
}
}
func (ca *ClientApp) GenerateOAuthURL(penaID, redirectURL string) (string, error) {
func (ca *ClientApp) GenerateOAuthURL(amoID, penaID, redirectURL string) (string, error) {
state, err := tools.EncryptTokenAES(tools.StateToken{
AmoID: amoID,
PenaID: penaID,
Service: "yandex",
RedirectURL: redirectURL,