eivid 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 98674e7ecdf813a76dda68ec8f37ad5a1ba3bee64c3c480d50b8f4d5f2cee8b1
+  data.tar.gz: 3371b018b813ad3abde17f2ec6e5843d71227c98b1eff1fc8606bdd77863979e
+SHA512:
+  metadata.gz: c631a4883bd2318cd4ee1da40344e45e9b30158225f69187ca5bb14c3389d2fca39f1481ed0911ed35acc9a3892ec9058ae33b88a27213fbe6c41e9f43fca1f8
+  data.tar.gz: f2f2d8e6ffcdec2242614f2cf86ac9f1ef45738d525912f919757b3a9d99b222c6c8a26e7c2a5d25404b13e04be8dd17ad7704bf49f45c6e2620f3681a85d03b

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2021 Jurriaan Schrofer
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,215 @@
+# Eivid
+
+Never stops streaming awesome videos, yay!
+
+
+
+## Installation
+
+Add the following to your application's Gemfile and run $bundle:
+
+```ruby
+
+gem 'eivid', git: 'https://github.com/eitje-app/eivid_engine', branch: 'production'
+
+```
+Or, for development purposes, add instead:
+
+```ruby
+local_eivid_path = "/Users/jurriaanschrofer/Documents/eivid"
+if ENV["RAILS_ENV"] == 'development' && Dir.glob(local_eivid_path).any?
+  gem 'eivid', path: local_eivid_path
+else
+  gem 'eivid', git: 'https://github.com/eitje-app/eivid_engine', branch: 'production'
+end
+```
+
+Add the following file to your app's config/initializers directory:
+
+```ruby
+
+# eivid.rb
+
+Eivid.set_mattr_accessors do |config|
+  config.owner_model = "owner"
+end
+
+```
+
+In this file, set the {owner_model} to your apps owner of videos, which generates the following methods (in this example config.owner_model is set to "organisation"):
+
+```ruby
+
+# retrieves the owner_id from a record
+Eivid::Video.first.organisation_id
+
+# returns the owner record of your application
+Eivid::Video.first.organisation 
+
+# scope, which returns all records for your application's organisation
+Eivid::Video.of_organisation(id)
+
+# returns the owner record of your application
+Eivid::Owner.organisation
+
+```
+
+
+
+## Setup
+
+Create and run the required migrations:
+
+```bash
+
+$ rails eivid:install:migrations
+$ rails db:migrate
+
+```
+
+For your application's owner model (in this example Organisation), run the following command, which creates all dedicated folders within Vimeo:
+
+```ruby
+
+Organisation.find_each { |owner| Eivid::Owner.create(external_id: owner.id) }
+
+```
+
+Add the following to your routes.rb:
+
+```ruby
+
+mount Eivid::Engine => "/eivid"
+
+```
+
+Set the following environment variables in your application:
+
+```ruby
+
+VIMEO_ACCESS_TOKEN
+
+```
+
+
+
+## Include Owner
+
+Witin your application's owner model (in this example Organisation), add to following:
+
+```ruby
+
+eivid_owner
+
+```
+
+Which runs an after_create effect, which creates an Eivid::Owner for every new Organisation record, and generates the following methods within your application:
+
+```ruby
+
+# returns a single Eivid::Owner record for the owner, which includes a Vimeo folder_id
+Organisation.first.video_owner
+
+#returns all Eivid::Video records, which each contain an url to the video and vimeo_id
+Organisation.first.videos
+
+```
+
+
+
+## Include VideoResource
+
+Besides an owner, an Eivid::Video can belongs to many resources of your main application, e.g. a Post, Manual or Message. This functionality is provided through a join table Eivid::VideoResource, which enables any model of your application to has_many Eivid::VideoResource. In order to create this association, paste the following code in your application's resource holder:
+
+```ruby
+
+eivid_video_resource
+
+```
+
+Which generates the following methods within your application (in this example for a Post model):
+
+```ruby
+
+# returns join table records
+Post.first.video_resources
+
+# returns video records
+Post.first.videos
+
+# scope which returns all records (here Post instances) which have a video
+Post.has_video
+
+# scope which returns all records (here Post instances) which do not have a video
+Post.has_not_video
+
+```
+
+
+
+## Include User
+
+An Eivid::Video can optionally belong to your application's User model. If you want to hook up your User with Eivid::Video, include the following in your user.rb file.
+
+Note: for the user_id to be added to a Eivid::Video record, your main application should provide an User instance @user within your controllers. 
+
+```ruby
+
+eivid_user
+
+```
+
+Which generates the following methods within your application:
+
+```ruby
+
+# returns video records
+User.first.videos
+
+# returns join table records
+User.first.video_resources
+
+# returns an User instance
+Eivid::Video.first.user
+
+```
+
+
+
+
+
+## Optional Config: Set Controller before_action
+
+Before each controller action, the the @owner variable is set through through ```params['external_owner_id']```. If you want to overwrite this logic, because your main application already has some kind of standardized before hooks, you can do that by setting the following in your config/initializers/eivid.rb file. This code will be evaluated, instead of ```params['external_owner_id']```.
+
+```ruby
+
+Eivid.set_mattr_accessors do |config|
+  config.infer_external_owner_id = "@env.organisation.id"
+end
+
+```
+
+
+
+## Optional Config: Set Front End Notifications
+
+If you want your front end to be notified on the progress of the videos being uploaded to vimeo, you can add the following to your eivid.rb config file. The method fields should be any proc and accept a single positional hash as argument, which stores all the progress information. This proc will be called on any progress change, thus enabbles you to set which method in your main application should handle the change.
+
+```ruby
+
+# eivid.rb
+
+Eivid.set_mattr_accessors do |config|
+  config.notify_front_enabled                = true
+  config.notify_method_on_upload             = -> (data) { "NotifyFrontOnVimeoService.progress(#{data})" }
+  config.notify_method_on_video_available    = -> (data) { "NotifyFrontOnVimeoService.progress(#{data})" }
+  config.notify_method_on_versions_available = -> (data) { "NotifyFrontOnVimeoService.progress(#{data})" }
+end
+
+```
+
+
+
+
+

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/controllers/eivid/application_controller.rb

@@ -0,0 +1,20 @@
+module Eivid
+  class ApplicationController < API::BaseController
+
+    include Concerns::VideoValidations
+
+    private
+
+    def set_owner
+      @owner = Owner.find_by(external_id: eval(Eivid.infer_external_owner_id)) || report_record_not_found
+    end
+
+    def report_record_not_found
+      raise MainAppRecordNotFoundError.new( 
+        "The given external_owner_id could not be mapped to your application's owner records. 
+        Beware: if you have overwritten the Eivid.infer_external_owner_id setting, the error is dependant on your main application."
+      )
+    end
+
+  end
+end

data/app/controllers/eivid/concerns/video_validations.rb

@@ -0,0 +1,42 @@
+module Eivid::Concerns::VideoValidations
+  extend ActiveSupport::Concern
+  included do
+
+    MAX_MB_VIDEO = 100
+
+    private
+  
+    def validate_video_file
+      validate_video_file_presence
+      validate_video_file_format
+      validate_video_file_size
+    end
+
+    def validate_video_file_presence
+      unless params["video_file"]
+        raise Eivid::VideoFileNotPresentError.new(
+          "you forgot to add a required 'video_file' to your request"
+        )
+      end
+    end
+
+    def validate_video_file_format
+      mime = params["video_file"]&.original_filename&.split('.')&.last&.downcase     
+      unless Eivid::VideoMimeDump::DATA.include?(mime)
+        raise Eivid::IncorrectVideoMimeTypeError.new(
+          "the 'video_file' you tried to upload, is of an invalid mime type"
+        )
+      end
+    end
+
+    def validate_video_file_size
+      megabytes = params["video_file"].tempfile.size / 1.0.megabyte
+      unless MAX_MB_VIDEO >= megabytes
+        raise VideoFileSizeTooBigError.new(
+          "the 'video_file' size (#{megabytes.round(2)} mb) you tried to upload exceeds the maximum file size (#{MAX_MB_VIDEO} mb)"
+        )
+      end
+    end
+  
+  end
+end

data/app/controllers/eivid/videos_controller.rb

@@ -0,0 +1,48 @@
+require_dependency "eivid/application_controller"
+require 'tempfile'
+
+# for local development, run: 
+  # QUEUE=* rake resque:work
+  # rake environment resque:scheduler
+
+module Eivid
+  class VideosController < ApplicationController
+
+    before_action :set_owner, only: [:upload_video, :owner_videos]
+    before_action :set_video, only: [:show, :destroy]
+    before_action :validate_video_file, only: [:upload_video]
+
+    def upload_video
+      record = UploadService.upload(owner: @owner, user: @user, video_file: video_params["video_file"])   
+      render json: record
+    end
+
+    def owner_videos
+      render json: @owner.videos
+    end
+
+    def index
+      render json: Video.all
+    end
+
+    def show
+      render json: @video
+    end
+
+    def destroy
+      record = RequestService.destroy(video: @video)
+      render json: record
+    end
+
+    private
+
+    def set_video
+      @video = Video.find params["id"]
+    end
+
+    def video_params
+      params.permit("video_file")
+    end
+
+  end
+end

data/app/dump/eivid/video_mime_dump.rb

@@ -0,0 +1,9 @@
+module Eivid::VideoMimeDump
+
+  DATA = %w$
+    wemb mkv flv vob ogv ogg drc gif gifv mng avi mts m2ts ts mov qt wmv yuv rm rmvb
+    viv asf amv mp4 m4p m4v mpg mp2 mmpeg mpe mpv m2v m4v svi 3gp 3g2 mxf roq nsv flv
+    f4v f4p f4a f4b 
+  $
+
+end

data/app/errors/eivid/incorrect_video_mime_type_error.rb

@@ -0,0 +1,4 @@
+module Eivid
+  class IncorrectVideoMimeTypeError < StandardError
+  end
+end

data/app/errors/eivid/main_app_record_not_found_error.rb

@@ -0,0 +1,4 @@
+module Eivid
+  class MainAppRecordNotFoundError < StandardError
+  end
+end

data/app/errors/eivid/maximum_vimeo_poll_reached_error.rb

@@ -0,0 +1,4 @@
+module Eivid
+  class MaximumVimeoPollReachedError < StandardError
+  end
+end

data/app/errors/eivid/video_file_not_present_error.rb

@@ -0,0 +1,4 @@
+module Eivid
+  class VideoFileNotPresentError < StandardError
+  end
+end

data/app/errors/eivid/video_file_size_too_big_error.rb

@@ -0,0 +1,4 @@
+module Eivid
+  class VideoFileSizeTooBigError < StandardError
+  end
+end

data/app/errors/eivid/video_unavailable_error.rb

@@ -0,0 +1,4 @@
+module Eivid
+  class VideoUnavailableError < StandardError
+  end
+end

data/app/errors/eivid/video_urls_unavailable_error.rb

@@ -0,0 +1,4 @@
+module Eivid
+  class VideoUrlsUnavailableError < StandardError
+  end
+end

data/app/jobs/eivid/application_job.rb

@@ -0,0 +1,4 @@
+module Eivid
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/jobs/eivid/check_vimeo_status_job.rb

@@ -0,0 +1,46 @@
+module Eivid
+  class CheckVimeoStatusJob < ApplicationJob
+
+    retry_on VideoUnavailableError, wait: 10.seconds, attempts: 50
+    after_perform :poll_vimeo_urls
+
+    def perform(video_record:)
+      @video_record = video_record
+
+      set_vimeo_id
+      set_video_status
+      
+      upload_completed ? notify_front : (raise Eivid::VideoUnavailableError)
+    end
+
+    private
+
+    def set_vimeo_id
+      @vimeo_id ||= @video_record.url_embedded.split('/').last
+    end
+
+    def set_video_status
+      @video_status = Eivid::RequestService.get_status(vimeo_id: @vimeo_id)["status"]
+    end
+
+    def upload_completed
+      @video_status == "available"
+    end
+
+    def notify_front
+      data = { video: @video_record.slice(:id, :user_id), progress: { percentage: 66, step: "The video is available on Vimeo." } }
+      NotifyFrontService.progress('notify_method_on_video_available', data)
+    end
+
+    def report_max_poll
+      raise MaximumVimeoPollReachedError.new (
+        "the maximum amount of polling Vimeo (#{@@maximum_vimeo_polls} times) for the status of Eivid::Video ##{@video_record&.id} is reached."
+      )
+    end
+
+    def poll_vimeo_urls
+      GetVimeoUrlsJob.perform_later(video_record: @video_record, vimeo_id: @vimeo_id)
+    end
+
+  end
+end