Media

Media is a Golang library that supports the upload of files/images/videos to a filesystem or cloud storage as well as linked videos (i.e. YouTube, Vimeo, etc.). The plugin includes:

  • cropping and resizing features for images.
  • optional multiple sizes for each media resource.
  • Accessibility helpers.

GoDoc

File Types

Media accepts any and every file type, yet it associates certain file types as images or videos so as to provide helpers supporting those media's specific needs.

Images: .jpg, .jpeg, .png, .tif, .tiff, .bmp, .gif

Videos: .mp4, .m4p, .m4v, .m4v, .mov, .mpeg, .webm, .avi, .ogg, .ogv

Usage

Media depends on GORM models as it is using GORM's callbacks to handle file processing, so you will need to register callbacks first:

  import (
    "github.com/jinzhu/gorm"
    "github.com/qor/media"
  )

  DB, err = gorm.Open("sqlite3", "demo_db") // [gorm](https://github.com/jinzhu/gorm)

  media.RegisterCallbacks(&DB)

Then add OSS(Object Storage Service) to your model:

  import (
    "github.com/jinzhu/gorm"
    "github.com/qor/media/oss"
  )

  type Product struct {
    gorm.Model
    Image oss.OSS
  }

Last, configure the storage. The default value is storage := filesystem.New("public"). Here we configure S3 as storage.

  import (
    // "github.com/oss/filesystem"
    "github.com/oss/s3"
  )

  storage := s3.New(s3.Config{AccessID: "access_id", AccessKey: "access_key", Region: "region", Bucket: "bucket", Endpoint: "cdn.getqor.com", ACL: aws.BucketCannedACLPublicRead})
  // Default configuration `storage := filesystem.New("public")`

Operate stored files

The OSS(Object Storage Service) provides a pretty simple API

  type StorageInterface interface {
      Get(path string) (*os.File, error)
      Put(path string, reader io.Reader) (*Object, error)
      Delete(path string) error
      List(path string) ([]*Object, error)
      GetEndpoint() string
  }

So once you finished the setting, you could operate saved files like this:

  storage := s3.New(s3.Config{AccessID: "access_id", AccessKey: "access_key", Region: "region", Bucket: "bucket", Endpoint: "cdn.getqor.com", ACL: aws.BucketCannedACLPublicRead})
  // storage := filesystem.New("public")

  // Save a reader interface into storage
  storage.Put("/sample.txt", reader)

  // Get file with path
  storage.Get("/sample.txt")

  // Delete file with path
  storage.Delete("/sample.txt")

  // List all objects under path
  storage.List("/")

Predefine common image size

You can implement the GetSizes function to predefine image sizes. The size name can be used to fetch image of corresponding size.

  import (
    "github.com/qor/media/oss"
    "github.com/jinzhu/gorm"
  )

  type Product struct {
    gorm.Model
    Image ProductIconImageStorage
  }

  type ProductIconImageStorage struct{
    oss.OSS
  }

  func (ProductIconImageStorage) GetSizes() map[string]media.Size {
    return map[string]media.Size{
      "small":    {Width: 60 * 2, Height: 60 * 2},
      "small@ld": {Width: 60, Height: 60},

      "middle":    {Width: 108 * 2, Height: 108 * 2},
      "middle@ld": {Width: 108, Height: 108},

      "big":    {Width: 144 * 2, Height: 144 * 2},
      "big@ld": {Width: 144, Height: 144},
    }
  }

  // Get image's url with style
  product.Image.URL("small")
  product.Image.URL("big@ld")

Set file storage path in the file system

The default size and path for Image. The default size is 4294967295 and default path is {repo_path}/public/system/{{class}}/{{primary_key}}/{{column}}.{{extension}}.

You can set the path and size manually by adding tag to the field like this:

type Product struct {
  gorm.Model
  Image oss.OSS `sql:"size:4294967295;" media:"url:/backend/{{class}}/{{primary_key}}/{{column}}.{{extension}};path:./private"`
}

The media takes two parameters, url and path. the url set the relative file path and the path set the prefix path. So suppose we uploaded a image called demo.png. The file will be stored at {repo_path}/private/backend/products/1/demo.png.

Be careful when using http.FileServer

The http.FileServer not only serves the files, but also shows the directory contents. This is very dangerous when you do things like

for _, path := range []string{"system", "javascripts", "stylesheets", "images"} {
  mux.Handle(fmt.Sprintf("/%s/", path), http.FileServer(http.Dir("public")))
}

The files under public will be exposed to public(especially the search engine!), Imagine someone upload a illegal or sensitive file to your server. The directory is fully visible to everyone and its indexable by search engines and boom!

To avoid this problem, we made a safer FileServer function here. This function serves file only. So the previous code now turned into:

for _, path := range []string{"system", "javascripts", "stylesheets", "images"} {
  mux.Handle(fmt.Sprintf("/%s/", path), utils.FileServer(http.Dir("public")))
}

Accessibility helpers

Media Library has some features aimed at helping achieve Accessibile frontends:

  • capture of a textual description for images, videos, and linked videos to aid with Accessibility.
  • capture of textual transcript for videos and linked videos to aid with Accessibility.

The values captured are fed into the sub-templates for each media type to be used if/where necessary. For example, an image's HTML output (an img tag) manifests the textual description within an alt attribute while a video's HTML (an iframe tag) manifests the textual description within a title attribute.

results matching ""

    No results matching ""