github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/server/core/utils/joomeo/jommeo.go

package joomeo

import (
	"errors"
	"fmt"
	"time"

	rd "github.com/benoitkugler/goACVE/server/core/rawdata"

	"github.com/benoitkugler/goACVE/logs"
	"github.com/benoitkugler/xmlrpc"
)

const (
	URL              = "https://api.joomeo.com/xmlrpc.php"
	RootFolder       = "SEJOURS"
	folderType       = "folder" // différencie un dossier d'un album
	messageDirecteur = `Vous avez maintenant accès à l'album de votre camp (permission lecture/écriture).
	Vous pouvez retrouver les informations liées à cette album sur votre espace directeur (https://acve.fr/directeurs).
	`
	messageParents = `Bonjour,

    Envie d'avoir un aperçu des activités du %s édition %d?
    Des photos sont disponibles (ou le seront très prochainement) sur un espace (Joomeo) dédié.
    Vous y avez accès en suivant le lien ci-dessous. 
    
    Vous pouvez retrouver les informations de connexion sur votre espace personnel ACVE.

	Bon visionnage !
	`
)

type dict = map[string]interface{}
type mclist = []xmlrpc.MulticallArg

type repSuccess struct {
	Success int `xmlrpc:"success"`
}

type repNbFiles struct {
	NbFiles int `xmlrpc:"nbfiles"`
}

func (r repSuccess) Ok() bool {
	return r.Success == 1
}

type Date float64

func (d Date) Time() rd.Date {
	return rd.Date(time.Unix(int64(d/1000), 0))
}

type ApiJoomeo struct {
	client   *xmlrpc.Client
	baseArgs dict
	SpaceURL string
}

type Album struct {
	AlbumId    string `xmlrpc:"albumid" json:"album_id,omitempty"`
	Label      string `xmlrpc:"label" json:"label,omitempty"`
	Date       Date   `xmlrpc:"date" json:"-,omitempty"`
	FolderId   string `xmlrpc:"folderid" json:"folder_id,omitempty"`
	NbFiles    int    `json:"nb_files,omitempty"`
	id         int64
	DateParsed rd.Date `json:"date"`
}

// Contact représente un contact Joomeo
type Contact struct {
	ContactId string `xmlrpc:"contactid" json:"contact_id,omitempty"`
	Mail      string `xmlrpc:"email" json:"mail,omitempty"`
	Login     string `xmlrpc:"login" json:"login,omitempty"`
	Password  string `xmlrpc:"password" json:"password,omitempty"`
}

// ContactPermission ajoute à un contact les permissions
// pour un album donné.
type ContactPermission struct {
	Contact
	Allowupload   int `json:"allowupload,omitempty"`
	Allowdownload int `json:"allowdownload,omitempty"`
}

type permission struct {
	ContactId     string `xmlrpc:"contactid"`
	Allowupload   int    `xmlrpc:"allowupload"`
	Allowdownload int    `xmlrpc:"allowdownload"`
}

// args ajoute les arguments donnés aux arguments de base
// et renvoi le dictionnaire correspondant
func (api *ApiJoomeo) args(addArgs dict) dict {
	out := make(dict)
	for i, v := range api.baseArgs {
		out[i] = v
	}
	for i, v := range addArgs {
		out[i] = v
	}
	return out
}

func InitApi(credences logs.Joomeo) (*ApiJoomeo, error) {
	client, err := xmlrpc.NewClient(URL, nil)
	if err != nil {
		return nil, err
	}
	args := map[string]string{
		"apikey":   credences.Apikey,
		"login":    credences.Login,
		"password": credences.Password,
	}
	rep := struct {
		SessionId string `xmlrpc:"sessionid"`
		SpaceURL  string `xmlrpc:"spaceURL"`
	}{}
	err = client.Call("joomeo.session.init", args, &rep)
	if err != nil {
		return nil, err
	}
	api := ApiJoomeo{
		client,
		dict{"sessionid": rep.SessionId, "apikey": credences.Apikey},
		rep.SpaceURL,
	}
	return &api, nil
}

// Kill termine la session, rendant `api` inutilisable.
func (api *ApiJoomeo) Kill() {
	rep := struct {
		Success string `xmlrpc:"success"`
	}{}
	_ = api.client.Call("joomeo.session.kill", api.args(nil), &rep) // fail silencieux
}

// newMCArgs ajoute les arguments de bases sont ajoutés.
func (api *ApiJoomeo) newMCArgs(methodName string, args dict) xmlrpc.MulticallArg {
	return xmlrpc.NewMulticallArg(methodName, api.args(args))
}

// GetAlbumMetadatas renvoi un dictionnaire contenant un résumé des informations
// de l'album demandé
func (api *ApiJoomeo) GetAlbumMetadatas(albumid string) (Album, error) {
	calls := mclist{
		api.newMCArgs("joomeo.user.getAlbumList", nil),
		api.newMCArgs("joomeo.user.album.getNumberOfFiles", dict{"albumid": albumid}),
	}
	var (
		albumsList []Album
		nbFilesRep repNbFiles
	)
	err := api.client.Multicall(calls, &albumsList, &nbFilesRep)
	if err != nil {
		return Album{}, err
	}

	for _, alb := range albumsList {
		alb.DateParsed = alb.Date.Time()
		if alb.AlbumId == albumid {
			alb.NbFiles = nbFilesRep.NbFiles
			return alb, nil
		}
	}
	return Album{}, errors.New("Album non trouvé sur le serveur Joomeo.")
}

type Folder struct {
	FolderId string `xmlrpc:"folderid"`
	Type     string `xmlrpc:"type"`
	Label    string `xmlrpc:"label"`
	id       int64
	childs   []Album
}

func (api *ApiJoomeo) GetAlbumsContacts() (map[string]Folder, map[string]Album, map[string]Contact, error) {
	calls := mclist{
		api.newMCArgs("joomeo.user.getFolderChildren", nil),
		api.newMCArgs("joomeo.user.getAlbumList", nil),
		api.newMCArgs("joomeo.user.getContactList", nil),
	}
	var (
		albumsList   []Album
		contactsList []Contact
		rootFolders  []Folder
	)
	err := api.client.Multicall(calls, &rootFolders, &albumsList, &contactsList)
	if err != nil {
		return nil, nil, nil, err
	}
	var campsFolderid string
	for _, folder := range rootFolders {
		if folder.Type != folderType {
			continue
		}
		if folder.Label == RootFolder {
			campsFolderid = folder.FolderId
		}
	}
	if campsFolderid == "" {
		return nil, nil, nil, fmt.Errorf("Aucun dossier %s trouvé sur le serveur Joomeo !", RootFolder)
	}

	calls = mclist{
		api.newMCArgs("joomeo.user.getFolderChildren", dict{"folderid": campsFolderid}),
	}
	var repFolders []Folder
	repNbFiles := make([]repNbFiles, len(albumsList))
	outs := []interface{}{&repFolders}
	for index, album := range albumsList {
		calls = append(calls, api.newMCArgs("joomeo.user.album.getNumberOfFiles", dict{"albumid": album.AlbumId}))
		outs = append(outs, &repNbFiles[index])
	}

	err = api.client.Multicall(calls, outs...)
	if err != nil {
		return nil, nil, nil, err
	}

	folders := make(map[string]Folder)
	for i, folder := range repFolders {
		if folder.Type == folderType {
			folder.id = int64(i)
			folders[folder.FolderId] = folder
		}
	}

	albums := make(map[string]Album, len(albumsList))
	for i, alb := range albumsList {
		alb.NbFiles = repNbFiles[i].NbFiles
		if folder, isIn := folders[alb.FolderId]; isIn {
			alb.id = int64(i)
			albums[alb.AlbumId] = alb

			folder.childs = append(folder.childs, alb)
			folders[alb.FolderId] = folder
		}
	}

	contacts := make(map[string]Contact, len(contactsList))
	for _, c := range contactsList {
		contacts[c.ContactId] = c
	}
	return folders, albums, contacts, nil
}

// AjouteDirecteur ajoute un directeur en contact avec droit d'écriture.
// Renvoie le contact créé.
// EleveSuperContact devrait être appelée ensuite.
func (api *ApiJoomeo) AjouteDirecteur(albumid, mailDirecteur string, envoiMail bool) (Contact, error) {
	var contact Contact
	err := api.client.Call("joomeo.user.addContact", api.args(dict{"email": mailDirecteur}), &contact)
	if err != nil {
		return Contact{}, err
	}
	var successAllow, succesMail repSuccess
	outs := []interface{}{&successAllow}
	calls := mclist{
		api.newMCArgs("joomeo.user.album.allowContactAccess", dict{
			"contactid": contact.ContactId,
			"albumid":   albumid, "allowupload": 1, "allowdownload": 1,
			"allowprintorder": 1, "allowsendcomments": 1,
		}),
	}

	if envoiMail {
		calls = append(calls, api.newMCArgs("joomeo.user.contact.sendInvite", dict{
			"contactid": contact.ContactId, "subject": "Album photos Joomeo",
			"message": messageDirecteur,
		}))
		outs = append(outs, &succesMail)
	}

	err = api.client.Multicall(calls, outs...)
	if err != nil {
		return Contact{}, err
	}
	if !successAllow.Ok() {
		return Contact{}, errors.New("Erreur côté Joomeo : impossible d'ajouter le directeur.")
	}

	if envoiMail && !succesMail.Ok() {
		return Contact{}, errors.New("Erreur côté Joomeo : impossible d'envoyer un mail d'invitation.")
	}

	return contact, nil
}

// AjouteContacts imite AjouteDirecteur mais pour plusieurs contacts,
// avec une permission lecture et un message adapté.
// Renvoie une liste d'erreurs (mail par mail) et une erreur globale.
func (api *ApiJoomeo) AjouteContacts(campNom string, campAnnee int, albumid string, mails []string, envoiMail bool) ([]string, error) {
	Nc := len(mails)
	calls := make(mclist, Nc)
	outs, addedContacts := make([]interface{}, Nc), make([]Contact, Nc)
	for index, mail := range mails {
		calls[index] = api.newMCArgs("joomeo.user.addContact", dict{"email": mail})
		outs[index] = &addedContacts[index]
	}
	err := api.client.Multicall(calls, outs...)
	if err != nil {
		return nil, err
	}

	calls = make(mclist, Nc)
	success, successMail := make([]repSuccess, Nc), make([]repSuccess, Nc)
	for index, contact := range addedContacts {
		calls[index] = api.newMCArgs("joomeo.user.album.allowContactAccess", dict{
			"albumid": albumid, "contactid": contact.ContactId,
			"allowupload": 0, "allowdownload": 1, "allowprintorder": 1, "allowsendcomments": 1,
		})
		outs[index] = &success[index]
	}
	if envoiMail {
		message := fmt.Sprintf(messageParents, campNom, campAnnee)

		for index, contact := range addedContacts {
			calls = append(calls, api.newMCArgs("joomeo.user.contact.sendInvite", dict{
				"contactid": contact.ContactId, "subject": "Album photos ACVE",
				"message": message}))
			outs = append(outs, &successMail[index])
		}
	}

	err = api.client.Multicall(calls, outs...)
	if err != nil {
		return nil, err
	}
	var errs []string
	for i := 0; i < Nc; i++ {
		mail := mails[i]
		if !success[i].Ok() {
			errs = append(errs, fmt.Sprintf("Ajout du contact %s impossible (erreur côté Joomeo).", mail))
		}
		if envoiMail && !successMail[i].Ok() {
			errs = append(errs, fmt.Sprintf("Envoi d'un mail d'invitation à %s impossible (erreur côté Joomeo).", mail))
		}
	}
	return errs, nil
}

// GetContacts renvoi les contacts de l'album demandé,
// avec les permissions correspondantes.
func (api *ApiJoomeo) GetContacts(albumid string) ([]ContactPermission, error) {
	calls := mclist{
		api.newMCArgs("joomeo.user.album.getAllowedContactAccessList", dict{"albumid": albumid}),
		api.newMCArgs("joomeo.user.getContactList", nil),
	}
	var (
		albContacts []permission
		contacts    []Contact
	)

	err := api.client.Multicall(calls, &albContacts, &contacts)
	if err != nil {
		return nil, err
	}
	dicCont := make(map[string]Contact)
	for _, c := range contacts {
		dicCont[c.ContactId] = c
	}
	rep := make([]ContactPermission, len(albContacts))
	for index, c := range albContacts {
		rep[index] = ContactPermission{dicCont[c.ContactId], c.Allowupload, c.Allowdownload}
	}

	return rep, nil
}

func (api *ApiJoomeo) RemoveContact(albumid, contactid string) error {
	var out repSuccess
	err := api.client.Call("joomeo.user.album.removeContactAccess",
		api.args(dict{"albumid": albumid, "contactid": contactid}), &out)
	if err != nil {
		return err
	}
	if !out.Ok() {
		return errors.New("Suppression du contact impossible (erreur côté Joomeo).")
	}
	return nil
}

// SetContactUploader ajoute le contact comme uploader.
// EleveSuperContact devrait être appelée ensuite.
func (api *ApiJoomeo) SetContactUploader(albumid, contactid string) error {
	var out repSuccess
	err := api.client.Call("joomeo.user.album.allowContactAccess",
		api.args(dict{"albumid": albumid, "contactid": contactid,
			"allowupload": 1, "allowdownload": 1, "allowprintorder": 1, "allowsendcomments": 1}), &out)
	if err != nil {
		return err
	}
	if !out.Ok() {
		return errors.New("Ajout du droit en écriture impossible (erreur côté Joomeo).")
	}
	return nil
}

func (api *ApiJoomeo) EleveSuperContact(contactid string) error {
	var out repSuccess
	// On demande les droits de super contacts
	err := api.client.Call("joomeo.user.contact.update", api.args(dict{"contactid": contactid, "type": 1}), &out)
	if err != nil || !out.Ok() {
		return errors.New("L'élévation vers un super contact a échoué. Est-ce que le compte Joomeo dispose d'une offre suffisante ?")
	}
	// Ici, on est sur que le compte a les droits.
	err = api.client.Call("joomeo.user.contact.updatePermissions",
		api.args(dict{"contactid": contactid, "allowFileDelete": 1, "allowFileEditCaption": 1}), &out)
	if err != nil {
		return err
	}
	if !out.Ok() {
		return errors.New("Impossible d'attribuer le droit de suppression (erreur côté Joomeo).")
	}
	return nil
}

// Renvoi le contact et la liste des albums authorisés du contact associé à l'adresse mail fournie.
// Le contact peut être zéro.
func (api *ApiJoomeo) GetLoginFromMail(mail string) (Contact, []Album, error) {
	var (
		albums   []Album
		contacts []Contact
		contact  Contact
	)
	calls := mclist{
		api.newMCArgs("joomeo.user.getAlbumList", nil),
		api.newMCArgs("joomeo.user.getContactList", nil),
	}

	err := api.client.Multicall(calls, &albums, &contacts)
	if err != nil {
		return contact, nil, err
	}

	albumsMap, albumsId := make(map[string]Album), make([]string, len(albums))
	for index, album := range albums {
		albId := album.AlbumId
		albumsMap[albId] = album
		albumsId[index] = albId
	}

	for _, cont := range contacts {
		if cont.Mail == mail {
			contact = cont
			break
		}
	}
	if contact.ContactId == "" { // contact inconnu
		return contact, nil, nil
	}

	N := len(albumsId)
	allowedContactsLists := make([][]Contact, N)
	repNbFiles := make([]repNbFiles, N)
	calls, outs := make(mclist, 2*N), make([]interface{}, 2*N)
	for index, albId := range albumsId {
		calls[2*index] = api.newMCArgs("joomeo.user.album.getAllowedContactAccessList", dict{"albumid": albId})
		calls[2*index+1] = api.newMCArgs("joomeo.user.album.getNumberOfFiles", dict{"albumid": albId})

		outs[2*index] = &allowedContactsLists[index]
		outs[2*index+1] = &repNbFiles[index]
	}
	err = api.client.Multicall(calls, outs...)
	if err != nil {
		return contact, nil, err
	}
	var albumsLinked []Album
	for index, cList := range allowedContactsLists {
		albId := albumsId[index]
		album := albumsMap[albId]
		album.NbFiles = repNbFiles[index].NbFiles
		for _, cont := range cList {
			if cont.ContactId == contact.ContactId {
				albumsLinked = append(albumsLinked, album)
			}
		}
	}
	return contact, albumsLinked, nil
}