package media import ( "context" "errors" "fmt" "mime" "mime/multipart" "net/http" "git.agecem.com/agecem/agecem-org/config" "github.com/minio/minio-go/v7" "github.com/minio/minio-go/v7/pkg/credentials" "github.com/spf13/viper" ) func NewMediaClient(endpoint, accessKeyId, secretAccessKey string, useSSL bool) (*MediaClient, error) { if accessKeyId == "" { return nil, errors.New("accessKeyId was found empty, but cannot be") } if secretAccessKey == "" { return nil, errors.New("secretAccessKey was found empty, but cannot be") } var mediaClient MediaClient minioClient, err := minio.New(endpoint, &minio.Options{ Creds: credentials.NewStaticV4(accessKeyId, secretAccessKey, ""), Secure: useSSL, }) if err != nil { return &mediaClient, err } mediaClient.MinioClient = *minioClient return &mediaClient, nil } func NewMediaClientFromViper() (*MediaClient, error) { var cfg config.Config if err := viper.Unmarshal(&cfg); err != nil { return nil, err } mediaClient, err := NewMediaClient(cfg.Server.Documents.Endpoint, cfg.Server.Documents.AccessKeyId, cfg.Server.Documents.SecretAccessKey, cfg.Server.Documents.UseSSL) if err != nil { return mediaClient, err } return mediaClient, nil } type MediaClient struct { MinioClient minio.Client } func (m *MediaClient) Seed() ([]string, error) { var cfg config.Config if err := viper.Unmarshal(&cfg); err != nil { return nil, err } var new_buckets []string for bucket := range cfg.Server.Documents.Buckets { exists, err := m.MinioClient.BucketExists(context.Background(), bucket) if err != nil { return new_buckets, err } if exists { continue } if err = m.MinioClient.MakeBucket(context.Background(), bucket, minio.MakeBucketOptions{}); err != nil { return new_buckets, err } new_buckets = append(new_buckets, bucket) } return new_buckets, nil } func (m *MediaClient) UploadFormFiles(bucketName string, fileHeaders []*multipart.FileHeader) (statusCode int, result string) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() ok, err := m.MinioClient.BucketExists(ctx, bucketName) if err != nil { return http.StatusInternalServerError, fmt.Sprintf("Erreur lors de vérification d'existence de bucket '%s': %s", bucketName, err) } if !ok { return http.StatusBadRequest, fmt.Sprintf("Bucket '%s' n'existe pas", bucketName) } switch count := len(fileHeaders); count { case 0: return http.StatusBadRequest, "Veuillez sélectionner au moins 1 document à téléverser" case 1: result = "Téléversement de 1 fichier\n" default: result = fmt.Sprintf("Téléversement de %d fichiers\n", count) } var allowedMediaTypes = []string{"application/pdf", "text/markdown", "text/plain"} var fileNames []string for _, fileHeader := range fileHeaders { fileNames = append(fileNames, fileHeader.Filename) } var validFileHeaders []*multipart.FileHeader for i, fileHeader := range fileHeaders { // Check for conflicting file names in upload for j, fileName := range fileNames { if fileName == fileHeader.Filename && i != j { return http.StatusBadRequest, fmt.Sprintf("Doublon de nom de fichier '%s' trouvé, les noms de fichiers doivent être uniques", fileName) } } // Check media type mediaType, _, err := mime.ParseMediaType(fileHeader.Header.Get("Content-Type")) if err != nil { return http.StatusBadRequest, fmt.Sprintf("Impossible de déterminer le type de fichier pour %d '%s'.\nPlus de détails: %s", i, fileHeader.Filename, err.Error()) } var isAllowedMediaType bool for _, allowedMediaType := range allowedMediaTypes { if allowedMediaType == mediaType { isAllowedMediaType = true } } if !isAllowedMediaType { return http.StatusUnsupportedMediaType, fmt.Sprintf("Type de fichier interdit '%s' pour '%s'.\nTypes de fichiers permis: %s", mediaType, fileHeader.Filename, allowedMediaTypes) } // Check for conflicting fileNames with existing files objectInfo, err := m.MinioClient.StatObject(ctx, bucketName, fileHeader.Filename, minio.StatObjectOptions{}) if err == nil && objectInfo.Key == fileHeader.Filename { return http.StatusConflict, fmt.Sprintf("Un document au nom '%s' de catégorie '%s' existe déjà et ne peut pas être inséré de cette façon.", fileHeader.Filename, bucketName) } switch msg := err.Error(); msg { case "The specified key does not exist.": default: return http.StatusInternalServerError, fmt.Sprintf("Erreur inattendue lors de vérification de conflit de nom de fichier avec la base de données: %s", err) } validFileHeaders = append(validFileHeaders, fileHeader) } if len(validFileHeaders) == 0 { return http.StatusOK, "Aucun fichier valide envoyé au serveur, rien à faire." } for i, fileHeader := range validFileHeaders { mediaType, _, err := mime.ParseMediaType(fileHeader.Header.Get("Content-Type")) if err != nil { return http.StatusBadRequest, fmt.Sprintf("Impossible de déterminer le type de fichier pour %d '%s'.\nPlus de détails: %s", i, fileHeader.Filename, err.Error()) } // Get file content fileContent, err := fileHeader.Open() if err != nil { return http.StatusBadRequest, fmt.Sprintf("Impossible de lire le contenu de '%s': %s", fileHeader.Filename, err) } defer fileContent.Close() // Upload file info, err := m.MinioClient.PutObject(ctx, bucketName, fileHeader.Filename, fileContent, fileHeader.Size, minio.PutObjectOptions{ ContentType: mediaType, }) if err != nil { return http.StatusInternalServerError, fmt.Sprintf("Impossible d'ajouter '%s' à la base de donnée: %s", fileHeader.Filename, err) } result = fmt.Sprintf("%sDocument %d '%s' de type '%s' et de taille '%d' téléversé à '%s' avec succès\n", result, i, info.Key, mediaType, info.Size, info.Bucket) } return http.StatusCreated, result }