eivid 1.0.0

data/app/jobs/eivid/get_vimeo_urls_job.rb

@@ -0,0 +1,62 @@
+module Eivid
+  class GetVimeoUrlsJob < ApplicationJob
+
+    retry_on VideoUrlsUnavailableError, wait: 10.seconds, attempts: 50
+
+    def perform(video_record:, vimeo_id:)
+      @video_record = video_record
+      @vimeo_id     = vimeo_id
+
+      set_response
+      set_url_sd
+      set_url_hd
+      set_url_thumbnail
+      
+      validate_url_presence
+      validate_url_thumbnail
+
+      update_record
+      notify_front
+    end
+
+    private
+
+    def set_response
+      @response = Eivid::RequestService.get_video @vimeo_id
+    end
+
+    def set_url_sd
+      @url_sd = dig_video_url :sd
+    end
+
+    def set_url_hd
+      @url_hd = dig_video_url :hd
+    end
+
+    def dig_video_url(definition)
+      @response[:files]&.find { |video| video[:quality] == definition.to_s }&.dig(:link)
+    end
+
+    def set_url_thumbnail
+      @url_thumbnail = @response&.dig(:pictures, :sizes)&.find { |url| url[:width] == 640 && url[:height] == 360 }&.dig(:link_with_play_button)
+    end
+
+    def validate_url_presence
+      raise Eivid::VideoUrlsUnavailableError unless (@url_sd && @url_hd && @url_thumbnail)
+    end
+
+    def validate_url_thumbnail
+      raise Eivid::VideoUrlsUnavailableError if @url_thumbnail.include? 'video%2Fdefault'
+    end
+
+    def update_record
+      @video_record.update(uploaded: true, url_sd: @url_sd, url_hd: @url_hd, url_thumbnail: @url_thumbnail)
+    end
+
+    def notify_front
+      data = { video: @video_record.slice(:id, :user_id), progress: { percentage: 100, step: "All video versions are available on Vimeo." } }
+      NotifyFrontService.progress('notify_method_on_versions_available', data)
+    end
+
+  end
+end

data/app/jobs/eivid/upload_vimeo_job.rb

@@ -0,0 +1,55 @@
+module Eivid
+  class UploadVimeoJob < ApplicationJob
+
+    def perform(video_record:, video_path:)
+      @video_record = video_record
+      @video_path   = video_path
+      @video_file   = File.open(video_path).read
+
+      upload_to_vimeo
+      set_attributes
+      update_record
+      add_to_folder
+      
+      notify_front
+      check_status
+    end
+
+    private
+
+    def upload_to_vimeo      
+      @response = Eivid::RequestService.upload_video(video_path: @video_path)
+    end
+
+    def set_attributes
+      set_vimeo_url
+      set_vimeo_id
+    end
+
+    def set_vimeo_url
+      @vimeo_url = @response.dig(:link)
+    end
+
+    def set_vimeo_id
+      @vimeo_id = @vimeo_url.split('/').last
+    end
+
+    def update_record
+      @video_record.update(url_embedded: @vimeo_url, vimeo_id: @vimeo_id)
+    end
+
+    def add_to_folder
+      Eivid::RequestService.add_video_to_folder(video_record: @video_record)
+    end
+
+    def check_status
+      CheckVimeoStatusJob.perform_later(video_record: @video_record)
+    end
+
+    def notify_front
+      data = { video: @video_record.slice(:id, :user_id), progress: { percentage: 33, step: "The video has been uploaded to Vimeo." } }
+      NotifyFrontService.progress('notify_method_on_upload', data)
+    end
+
+  end
+end

data/app/mailers/eivid/application_mailer.rb

@@ -0,0 +1,6 @@
+module Eivid
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/eivid/application_record.rb

@@ -0,0 +1,5 @@
+module Eivid
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/eivid/concerns/main_app/owner.rb

@@ -0,0 +1,17 @@
+module Eivid::Concerns::MainApp::Owner
+  extend ActiveSupport::Concern
+  included do
+  
+    has_one  :video_owner, class_name: 'Eivid::Owner', foreign_key: 'external_id'
+    has_many :videos, class_name: 'Eivid::Video', source: :video_owner, foreign_key: 'owner_id'
+
+    include Eivid::Concerns::MainApp::VideoConcerns
+
+    after_create :create_eivid_owner
+
+    def create_eivid_owner
+      Eivid::Owner.create(external_id: self.id)
+    end
+  
+  end
+end

data/app/models/eivid/concerns/main_app/user.rb

@@ -0,0 +1,11 @@
+module Eivid::Concerns::MainApp::User
+  extend ActiveSupport::Concern
+  included do
+  
+    has_many :videos, class_name: 'Eivid::Video'
+    has_many :video_resources, class_name: 'Eivid::VideoResource', through: :videos
+
+    include Eivid::Concerns::MainApp::VideoConcerns
+    
+  end
+end

data/app/models/eivid/concerns/main_app/video_concerns.rb

@@ -0,0 +1,16 @@
+module Eivid::Concerns::MainApp::VideoConcerns
+  extend ActiveSupport::Concern
+  included do
+  
+    scope :has_video,             -> { joins(:videos).distinct }
+    scope :has_not_video,         -> { joins(:videos).where('eivid_videos.id' => nil) }
+
+    scope :has_pending_video,     -> { joins(:videos).where('eivid_videos.uploaded' => false) }
+    scope :has_not_pending_video, -> { where(id: [ids - has_pending_video.ids]) }
+    
+    # caution: due to the has_many with .distinct, the condition only has to be satisfied once
+    scope :has_processed_video,   -> { joins(:videos).where('eivid_videos.uploaded': true).distinct }
+    scope :has_unprocessed_video, -> { joins(:videos).where('eivid_videos.uploaded' => false).distinct }
+
+  end
+end

data/app/models/eivid/concerns/main_app/video_resource.rb

@@ -0,0 +1,11 @@
+module Eivid::Concerns::MainApp::VideoResource
+  extend ActiveSupport::Concern
+  included do
+  
+    has_many :video_resources, class_name: 'Eivid::VideoResource', as: :resource
+    has_many :videos, class_name: 'Eivid::Video', through: :video_resources, source: :video
+
+    include Eivid::Concerns::MainApp::VideoConcerns
+    
+  end
+end

data/app/models/eivid/concerns/request_service/delete_video.rb

@@ -0,0 +1,17 @@
+module Eivid::Concerns::RequestService::DeleteVideo
+  extend ActiveSupport::Concern
+
+  def destroy(video:)
+    @video = video
+    delete_from_vimeo
+    video.destroy
+  end
+
+  private
+
+  def delete_from_vimeo
+    return unless @video.uploaded
+    HTTParty.delete "#{Eivid::RequestService::PLAIN_VIDEO_URL}/#{@video.vimeo_id}", headers: default_headers
+  end
+  
+end

data/app/models/eivid/concerns/request_service/get_video.rb

@@ -0,0 +1,9 @@
+module Eivid::Concerns::RequestService::GetVideo
+  extend ActiveSupport::Concern
+
+  def get_video(vimeo_id)
+    response = HTTParty.get "#{Eivid::RequestService::PLAIN_VIDEO_URL}/#{vimeo_id}", headers: default_headers
+    JSON.parse(response.body).deep_symbolize_keys
+  end
+
+end

data/app/models/eivid/concerns/request_service/manage_folder.rb

@@ -0,0 +1,29 @@
+module Eivid::Concerns::RequestService::ManageFolder
+  extend ActiveSupport::Concern
+  
+  def get_all_folders
+    HTTParty.get Eivid::RequestService::FOLDER_URL, headers: default_headers
+  end
+
+  def create_folder(namespace:, id:)
+    body = { "name" => "#{Rails.env}_#{namespace}_#{id}" }
+    
+    @response = HTTParty.post Eivid::RequestService::FOLDER_URL, body: body.to_json, headers: default_headers
+    get_folder_id
+  end
+
+  def add_video_to_folder(video_record:)
+    video_id  = video_record.vimeo_id
+    folder_id = video_record.owner.folder_id
+    endpoint  = Eivid::RequestService::ADD_TO_FOLDER_URL.call(folder_id, video_id)
+    
+    HTTParty.put endpoint, headers: default_headers
+  end
+
+  private
+
+  def get_folder_id
+    @response["uri"].split('/').last
+  end
+  
+end

data/app/models/eivid/concerns/request_service/poll_status.rb

@@ -0,0 +1,9 @@
+module Eivid::Concerns::RequestService::PollStatus
+  extend ActiveSupport::Concern
+
+  def get_status(vimeo_id:)
+    response = HTTParty.get "#{Eivid::RequestService::BASE_URL}/videos/#{vimeo_id}?fields=uri,status", headers: default_headers
+    JSON.parse(response)
+  end
+  
+end

data/app/models/eivid/concerns/request_service/testing_methods.rb

@@ -0,0 +1,38 @@
+module Eivid::Concerns::RequestService::TestingMethods
+  extend ActiveSupport::Concern
+
+    def delete_all_videos
+      puts "are you sure you want to delete ALL videos from Vimeo? Confirm by typing: 'yup brah'"
+      confirmation = gets
+      return "operation cancelled" unless confirmation.chomp == "yup brah"
+      delete_all_videos_from_vimeo
+    end
+
+    private
+
+    def get_all_video_ids
+      get_all_pages.map { |page| get_single_page_video_ids(page) }.flatten
+    end
+
+    def delete_all_videos_from_vimeo
+      get_all_video_ids.map { |id| delete_single_video_from_vimeo(id) }
+    end
+
+    def delete_single_video_from_vimeo(vimeo_id)
+      HTTParty.delete "#{Eivid::RequestService::PLAIN_VIDEO_URL}/#{vimeo_id}", headers: default_headers
+      puts "deleted #{vimeo_id}"
+    end
+
+    def get_single_page_video_ids(url)
+      response = HTTParty.get url, headers: default_headers
+      JSON.parse(response)["data"].map { |record| record["link"].split('/').last }
+    end
+
+    def get_all_pages
+      response   = HTTParty.get Eivid::RequestService::VIDEOS_URL, headers: default_headers
+      page_count = (JSON.parse(response)["total"] / 25.to_f).ceil
+
+      (1..page_count).map { |cnt| "#{Eivid::RequestService::VIDEOS_URL}?page=#{cnt}" }
+    end
+
+end

data/app/models/eivid/concerns/request_service/upload_video.rb

@@ -0,0 +1,31 @@
+module Eivid::Concerns::RequestService::UploadVideo
+  extend ActiveSupport::Concern
+
+  def upload_video(video_path:)
+    @file        = File.open(video_path) 
+    @request     = HTTParty.post Eivid::RequestService::VIDEOS_URL, **upload_params
+    @response    = JSON.parse(@request).deep_symbolize_keys
+    @upload_link = @response.dig(:upload, :upload_link)
+
+    tus_upload_to_vimeo
+    @response
+  end
+
+  private
+
+  def tus_upload_to_vimeo
+    HTTParty.patch @upload_link, body: @file.read, headers: tus_headers
+  end
+
+  def upload_params
+    body = {
+      "upload" => {
+        "approach" => "tus",
+        "size"     => @file.size.to_s,
+      }
+    }
+
+    { body: body.to_json, headers: default_headers }
+  end
+
+end

data/app/models/eivid/owner.rb

@@ -0,0 +1,21 @@
+module Eivid
+  class Owner < ApplicationRecord
+
+    has_many :videos
+
+    validates :external_id, presence: true #, uniqueness: true # comment out for dev only
+
+    before_create :get_folder_id
+
+    belongs_to :"#{Eivid.owner_model}", foreign_key: "external_id"
+
+    def external_owner
+      send Eivid.owner_model
+    end
+
+    def get_folder_id
+      self.folder_id = RequestService.create_folder(namespace: Eivid.owner_model, id: self.external_id)
+    end
+
+  end
+end

data/app/models/eivid/video.rb

@@ -0,0 +1,21 @@
+module Eivid
+  class Video < ApplicationRecord
+
+    belongs_to :owner
+    belongs_to :user, optional: true
+    has_many   :video_resources
+
+    def owner_id # required for aliassing :owner_id
+      super
+    end
+
+    def external_owner
+      owner.send Eivid.owner_model
+    end
+
+    alias_method :"#{Eivid.owner_model}_id", :owner_id
+    alias_method :"#{Eivid.owner_model}", :external_owner
+    scope        :"of_#{Eivid.owner_model}", -> (owner_id) { where(owner_id: owner_id) }
+
+  end
+end

data/app/models/eivid/video_resource.rb

@@ -0,0 +1,8 @@
+module Eivid
+  class VideoResource < ApplicationRecord
+
+    belongs_to :video
+    belongs_to :resource, polymorphic: true
+
+  end
+end

data/app/services/eivid/notify_front_service.rb

@@ -0,0 +1,14 @@
+module Eivid::NotifyFrontService   
+  class << self
+
+    def progress(progress_method, progress_hash)
+      return unless Eivid.notify_front_enabled
+      
+      main_app_proc = Eivid.send progress_method
+      main_app_meth = main_app_proc.call progress_hash.deep_symbolize_keys
+
+      eval main_app_meth
+    end
+
+  end
+end

data/app/services/eivid/request_service.rb

@@ -0,0 +1,42 @@
+# vimeo docs:   https://developer.vimeo.com/api/guides/start
+# wrapper docs: https://github.com/bo-oz/vimeo_me2
+
+module Eivid::RequestService   
+  
+  VIMEO_ID          = "136419353"
+  BASE_URL          = "https://api.vimeo.com"
+  VIDEOS_URL        = "#{BASE_URL}/me/videos"
+  FOLDER_URL        = "#{BASE_URL}/me/projects"
+  PLAIN_VIDEO_URL   = "#{BASE_URL}/videos"
+  ADD_TO_FOLDER_URL = -> (folder_id, video_id) { "#{FOLDER_URL}/#{folder_id}/videos/#{video_id}" }
+
+  class << self
+
+    include Eivid::Concerns::RequestService::ManageFolder
+    include Eivid::Concerns::RequestService::PollStatus
+    include Eivid::Concerns::RequestService::GetVideo
+    include Eivid::Concerns::RequestService::UploadVideo
+    include Eivid::Concerns::RequestService::DeleteVideo
+    include Eivid::Concerns::RequestService::TestingMethods
+
+    private
+
+    def default_headers
+      {
+        "Authorization" => "bearer #{Figaro.env.VIMEO_ACCESS_TOKEN}",
+        "Content-Type"  => "application/json",
+        "Accept"        => "application/vnd.vimeo.*+json;version=3.4" 
+      }    
+    end
+
+    def tus_headers
+      {
+        "Tus-Resumable" => "1.0.0",
+        "Upload-Offset" => "0",
+        "Content-Type"  => "application/offset+octet-stream",
+        "Accept"        => "application/vnd.vimeo.*+json;version=3.4"   
+      }
+    end
+
+  end
+end