multi_video_streaming 1.0.0.beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0c1ae1d10ba98cf2adfd9db15e18956c5ec601e0afdd47f4857c5313d5b5661c
+  data.tar.gz: e972c5a015cb6e813c9423d21a0993646aacc807b549797f6db638f3686823c4
+SHA512:
+  metadata.gz: 1feb06fa08e5ec6775c208ea859371083956b99d95c71b419b040823cfa307156c1acaeb110ae012bf12c6d573636ef800752d3fb3ed3ed74415ecb6db1bac2f
+  data.tar.gz: a4cf1f7c854d9b3b4838e459c75417441078fccc2ac2b09ff02751855d29579126529a701efc7303da03ea5a96604da6ca8d746e2b5158b7da75a610b1c99982

data/lib/multi_video_streaming/drivers/bunny.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  module Drivers
+    class Bunny < MultiVideoStreaming::Protocols::Platform
+      PARAMS_EQUIVALENT = {
+        "guid" => :video_id,
+        "title" => :title,
+        "status" => :status,
+        "files" => :files,
+        "availableResolutions" => :available_resolutions,
+        "directPlay" => :direct_play,
+        "dateUploaded" => :date_uploaded
+      }
+
+      STATUS_EQUIVALENT = {
+        "0" => "processing",
+        "1" => "processing",
+        "2" => "transcoding",
+        "3" => "processing",
+        "4" => "available",
+        "5" => "failed"
+      }
+
+      BASE_URL = "https://video.bunnycdn.com"
+
+      def upload_video(url:)
+        begin
+          library_id, api_key = self.dependency_params.values_at(:library_id, :api_key)
+          @original_status_code = nil
+
+          self.required_fields_validator_instance.validate(library_id: library_id, api_key: api_key)
+
+          title = MultiVideoStreaming::Helpers::TitleFromUrl.get(url: url)
+          create_video_response = self.https_service_instance.post(uri: "#{BASE_URL}/library/#{library_id}/videos", headers: { :AccessKey => api_key }, body: { :title => title })
+
+          if create_video_response["status_code"] != 200
+            @original_status_code = create_video_response["status_code"]
+            raise create_video_response["Message"] || create_video_response["message"] || MultiVideoStreaming::Helpers::GetDefaultErrorMessage.by_method(method: :upload)
+          end
+
+          video_id = create_video_response["guid"]
+          upload_response = self.https_service_instance.post(uri: "#{BASE_URL}/library/#{library_id}/videos/#{video_id}/fetch", body: { url: url }, headers: { :AccessKey => api_key })
+
+          @original_status_code = upload_response["status_code"]
+
+          if upload_response["status_code"] != 200
+            self.https_service_instance.delete(uri: "#{BASE_URL}/library/#{library_id}/videos/#{video_id}", headers: { :AccessKey => api_key })
+            raise upload_response["Message"] || upload_response["message"] || MultiVideoStreaming::Helpers::GetDefaultErrorMessage.by_method(method: :upload)
+          end
+
+          create_video_response["availableResolutions"] = []
+          create_video_response["status"] = STATUS_EQUIVALENT[create_video_response["status"].to_s]
+          create_video_response["directPlay"] = "https://video.bunnycdn.com/play/#{library_id}/#{video_id}"
+          create_video_response["files"] = []
+
+          return self.response_instance.add_response(
+            platform_name: "bunny",
+            status: "success",
+            original_status_code: @original_status_code,
+            data: create_video_response,
+            params_equivalent: PARAMS_EQUIVALENT,
+            message: "Video uploaded successfully."
+          )
+
+        rescue => exception
+          return self.response_instance.add_response(
+            platform_name: "bunny",
+            status: "error",
+            original_status_code: @original_status_code,
+            data: {},
+            message: exception.message
+          )
+        end
+      end
+
+      def get_video
+        begin
+          video_id, library_id, pull_zone, api_key = self.dependency_params.values_at(:video_id, :library_id, :pull_zone, :api_key)
+          @original_status_code = nil
+
+          self.required_fields_validator_instance.validate(
+            library_id: library_id,
+            video_id: video_id,
+            pull_zone: pull_zone,
+            api_key: api_key
+          )
+
+          response = self.https_service_instance.get(uri: "#{BASE_URL}/library/#{library_id}/videos/#{video_id}", headers: { :AccessKey => api_key })
+
+          @original_status_code = response["status_code"]
+
+          if response["status_code"] != 200
+            if response["status_code"] == 404
+              raise MultiVideoStreaming::Helpers::GetDefaultErrorMessage.not_found(video_id: video_id)
+            end
+
+            raise response["Message"] || response["message"] || MultiVideoStreaming::Helpers::GetDefaultErrorMessage.by_method(method: :get)
+          end
+
+          response["directPlay"] = "https://video.bunnycdn.com/play/#{library_id}/#{video_id}"
+          response["availableResolutions"] = response["availableResolutions"].split(",")
+
+          files = []
+          response["availableResolutions"].map do |available_resolution|
+            files << 
+            {
+              file: "https://#{pull_zone}.b-cdn.net/#{response["guid"]}/play_#{available_resolution}.mp4",
+              label: available_resolution
+            }
+          end
+
+          response["files"] = files
+          status = STATUS_EQUIVALENT[response["status"].to_s]
+
+          response["status"] = STATUS_EQUIVALENT[response["status"].to_s]
+
+          return self.response_instance.add_response(
+            platform_name: "bunny",
+            status: "success",
+            original_status_code: @original_status_code,
+            data: response,
+            params_equivalent: PARAMS_EQUIVALENT,
+            message:  "Video found successfully."
+          )
+        rescue => exception
+          return self.response_instance.add_response(
+            platform_name: "bunny",
+            status: "error",
+            original_status_code: @original_status_code,
+            data: {},
+            message: exception.message
+          )
+        end
+      end
+
+      def delete_video
+        begin
+          video_id, library_id, api_key = self.dependency_params.values_at(:video_id, :library_id, :api_key)
+          @original_status_code = nil
+
+          self.required_fields_validator_instance.validate(library_id: library_id, video_id: video_id, api_key: api_key)
+
+          response = self.https_service_instance.delete(uri: "#{BASE_URL}/library/#{library_id}/videos/#{video_id}", headers: { :AccessKey => api_key })
+
+          @original_status_code = response["status_code"]
+
+          if response["status_code"] != 200
+            if response["status_code"] == 404
+              raise MultiVideoStreaming::Helpers::GetDefaultErrorMessage.not_found(video_id: video_id)              
+            end
+
+            raise response["Message"] || response["message"] || MultiVideoStreaming::Helpers::GetDefaultErrorMessage.by_method(method: :delete)
+          end
+
+          return self.response_instance.add_response(
+            platform_name: "bunny",
+            status: "success",
+            original_status_code: @original_status_code,
+            data: {},
+            message:  "Video deleted successfully."
+          )
+        rescue => exception
+          return self.response_instance.add_response(
+            platform_name: "bunny",
+            status: "error",
+            original_status_code: @original_status_code,
+            data: {},
+            message: exception.message
+          )
+        end
+      end
+    end
+  end
+end

data/lib/multi_video_streaming/drivers/s3.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  module Drivers
+    class S3 < MultiVideoStreaming::Protocols::Platform
+      PARAMS_EQUIVALENT = {
+        "key" => :video_id,
+        "title" => :title,
+        "status" => :status,
+        "files" => :files,
+        "available_resolutions" => :available_resolutions,
+        "direct_play" => :direct_play,
+        "date_uploaded" => :date_uploaded
+      }
+
+      STATUS_EQUIVALENT = {
+        :true => "available",
+        :false => "failed"
+      }
+
+      def get_video()
+        begin
+          video_id, bucket = self.dependency_params.values_at(:video_id, :bucket)
+
+          self.required_fields_validator_instance.validate(bucket: bucket)
+
+          configure_credentials
+
+          response = Aws::S3::Resource.new().bucket(bucket).object(video_id)
+          video_url = response.public_url
+
+          data = {
+            "key": response.key,
+            "title": response.key,
+            "status":  STATUS_EQUIVALENT[:true],
+            "files": [
+              {
+                file: video_url
+              }
+            ],
+            "available_resolutions": [],
+            "direct_play": video_url,
+            "date_uploaded": response.data.last_modified
+          }
+
+          return self.response_instance.add_response(
+            platform_name: "s3",
+            status: "success",
+            original_status_code: 200,
+            data: data,
+            params_equivalent: PARAMS_EQUIVALENT,
+            message:  "Video found successfully."
+          )
+
+        rescue Aws::Errors::MissingCredentialsError => exception
+          return self.response_instance.add_response(
+            platform_name: "s3",
+            status: "error",
+            original_status_code: 401,
+            data: {},
+            message: exception.message
+          )
+        rescue Aws::S3::Errors::NotFound => e
+          return self.response_instance.add_response(
+            platform_name: "s3",
+            status: "error",
+            original_status_code: 404,
+            data: {},
+            message: "Video or bucket does not exist."
+          )
+        rescue => exception
+          return self.response_instance.add_response(
+            platform_name: "s3",
+            status: "error",
+            original_status_code: 500,
+            data: {},
+            message: exception.message || MultiVideoStreaming::Helpers::GetDefaultErrorMessage.by_method(method: :get)
+          )
+        end
+      end
+
+      def delete_video()
+        begin
+          video_id, bucket = self.dependency_params.values_at(:video_id, :bucket)
+          self.required_fields_validator_instance.validate(bucket: bucket)
+
+          configure_credentials
+        
+          response = Aws::S3::Resource.new().bucket(bucket).object(video_id)
+          response.data
+          response.delete
+
+          return self.response_instance.add_response(
+            platform_name: "s3",
+            status: "success",
+            original_status_code: 200,
+            data: {},
+            message:  "Video deleted successfully."
+          )
+
+        rescue Aws::Errors::MissingCredentialsError => exception
+          return self.response_instance.add_response(
+            platform_name: "s3",
+            status: "error",
+            original_status_code: 401,
+            data: {},
+            message: exception.message
+          )
+        rescue Aws::S3::Errors::NotFound
+          return self.response_instance.add_response(
+            platform_name: "s3",
+            status: "error",
+            original_status_code: 404,
+            data: {},
+            message: "Video or bucket does not exist."
+          )
+        rescue => exception
+          return self.response_instance.add_response(
+            platform_name: "s3",
+            status: "error",
+            original_status_code: 500,
+            data: {},
+            message: exception.message || MultiVideoStreaming::Helpers::GetDefaultErrorMessage.by_method(method: :delete)
+          )
+        end
+      end
+
+      private 
+
+      def configure_credentials
+        access_key_id, secret_access_key, region, is_local = self.dependency_params.values_at(:access_key_id, :secret_access_key, :region, :is_local)
+        self.required_fields_validator_instance.validate(access_key_id: access_key_id, secret_access_key: secret_access_key, region: region)
+
+        credentials = Aws::Credentials.new(access_key_id, secret_access_key)
+
+        if is_local
+          Aws.config.update(endpoint: "http://localstack:4566", credentials: credentials, region: region, force_path_style: true)
+        else 
+          Aws.config.update(credentials: credentials, region: region, force_path_style: true)
+        end
+      end
+    end
+  end
+end

data/lib/multi_video_streaming/drivers/vimeo.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  module Drivers
+    class Vimeo < MultiVideoStreaming::Protocols::Platform
+      PARAMS_EQUIVALENT = {
+        "vimeo_id" => :video_id,
+        "name" => :title,
+        "status" => :status,
+        "files" => :files,
+        "available_resolutions" => :available_resolutions,
+        "player_embed_url" => :direct_play,
+        "created_time" => :date_uploaded
+      }
+
+      STATUS_EQUIVALENT = {
+        "available" => "available",
+        "quota_exceeded" => "failed",
+        "total_cap_exceeded" => "failed",
+        "transcode_starting" => "transcoding",
+        "transcoding" => "transcoding",
+        "transcoding_error" => "failed",
+        "unavailable" => "failed",
+        "uploading" => "processing",
+        "uploading_error" => "failed"
+      }
+
+      VIMEO_URL = "https://api.vimeo.com"
+
+      def upload_video(url:)
+        begin
+          token = self.dependency_params[:token]
+          title = MultiVideoStreaming::Helpers::TitleFromUrl.get(url: url)
+          @original_status_code = nil
+
+          self.required_fields_validator_instance.validate(token: token)
+          response = self.https_service_instance.post(
+            uri: "#{VIMEO_URL}/me/videos",
+            headers: { :Authorization => "Bearer #{token}", :Accept => "application/vnd.vimeo.*+json;version=3.4" },
+            body: {
+              :name => title,
+              :upload => {
+                :approach => "pull",
+                :link => url
+              },
+              :privacy => {
+                :download => false,
+                :embed => "private",
+                :view => "nobody"
+              }
+            }
+          )
+
+          @original_status_code = response["status_code"]
+
+          if response["status_code"] != 201
+            raise response["developer_message"] || response["error"] || MultiVideoStreaming::Helpers::GetDefaultErrorMessage.by_method(method: :upload)
+          end
+
+          response["vimeo_id"] = response["uri"].split("/videos/")[1]
+          response["files"] = []
+          response["available_resolutions"] = []
+          response["status"] = STATUS_EQUIVALENT[response["status"]]
+
+          return self.response_instance.add_response(
+            platform_name: "vimeo",
+            status: "success",
+            original_status_code: @original_status_code,
+            data: response,
+            params_equivalent: PARAMS_EQUIVALENT,
+            message:  "Video uploaded successfully."
+          )
+
+        rescue => exception
+          return self.response_instance.add_response(
+            platform_name: "vimeo",
+            status: "error",
+            original_status_code: @original_status_code,
+            data: {},
+            message: exception.message
+          )
+        end
+
+      end
+
+      def get_video()
+        begin
+          video_id, token = self.dependency_params.values_at(:video_id, :token)
+          @original_status_code = nil
+
+          self.required_fields_validator_instance.validate(token: token, video_id: video_id)
+
+          response = self.https_service_instance.get(uri: "#{VIMEO_URL}/videos/#{video_id}", headers: { :Authorization => "Bearer #{token}" })
+
+          @original_status_code = response["status_code"]
+          if response["status_code"] != 200
+            if response["status_code"] == 404
+              raise MultiVideoStreaming::Helpers::GetDefaultErrorMessage.not_found(video_id: video_id)
+            end
+
+            raise response["developer_message"] || response["error"] || MultiVideoStreaming::Helpers::GetDefaultErrorMessage.by_method(method: :get)
+          end
+
+          response["vimeo_id"] = response["uri"].split("/videos/")[1]
+
+          available_resolutions = []
+          files = []
+          response["files"].each do |file|
+            if file["rendition"] != "adaptive"
+              available_resolutions << file["rendition"]
+              files << { file: file["link"], label: file["rendition"] }
+            end
+          end
+
+          response["files"] = files
+          response["available_resolutions"] = available_resolutions
+          response["status"] = STATUS_EQUIVALENT[response["status"]]
+          return self.response_instance.add_response(
+            platform_name: "vimeo",
+            status: "success",
+            original_status_code: @original_status_code,
+            data: response,
+            params_equivalent: PARAMS_EQUIVALENT,
+            message:  "Video found successfully."
+          )
+        rescue => exception
+          return self.response_instance.add_response(
+            platform_name: "vimeo",
+            status: "error",
+            original_status_code: @original_status_code,
+            data: {},
+            message: exception.message
+          )
+        end
+      end
+
+      def delete_video()
+        begin
+          video_id, token = self.dependency_params.values_at(:video_id, :token)
+          self.required_fields_validator_instance.validate(video_id: video_id, token: token)
+          @original_status_code = nil
+
+          response = self.https_service_instance.delete(uri: "#{VIMEO_URL}/videos/#{video_id}", headers: { :Authorization => "Bearer #{token}" })
+
+          @original_status_code = response["status_code"]
+
+          if response["status_code"] != 204
+            if response["status_code"] == 404
+              raise MultiVideoStreaming::Helpers::GetDefaultErrorMessage.not_found(video_id: video_id)
+            end
+
+            raise response["developer_message"] || response["error"] || MultiVideoStreaming::Helpers::GetDefaultErrorMessage.by_method(method: :delete)
+          end
+
+          return self.response_instance.add_response(
+            platform_name: "vimeo",
+            status: "success",
+            original_status_code: @original_status_code,
+            data: {},
+            message:  "Video deleted successfully."
+          )
+        rescue => exception
+          return self.response_instance.add_response(
+            platform_name: "vimeo",
+            status: "error",
+            original_status_code: @original_status_code,
+            data: {},
+            message: exception.message
+          )
+        end
+      end
+    end
+  end
+end

data/lib/multi_video_streaming/drivers.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "multi_video_streaming/drivers/bunny"
+require "multi_video_streaming/drivers/s3"
+require "multi_video_streaming/drivers/vimeo"

data/lib/multi_video_streaming/errors/duplicated_platform_name.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  module Errors
+    class DuplicatedPlatformName < StandardError
+      def initialize()
+        super("Duplicate name platform")
+      end
+    end
+  end
+end

data/lib/multi_video_streaming/errors/invalid_platform_name.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  module Errors
+    class InvalidPlatformName < StandardError
+      def initialize(name)
+        super("Platform name #{name} is invalid")
+      end
+    end
+  end
+end

data/lib/multi_video_streaming/errors/invalid_platforms_param.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  module Errors
+    class InvalidPlatformsParam < StandardError
+      def initialize()
+        super("Platforms param is invalid")
+      end
+    end
+  end
+end

data/lib/multi_video_streaming/errors/missing_param.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  module Errors
+    class MissingParam < StandardError
+      def initialize(param_name)
+        super("The #{param_name} dependency param is missing")
+      end
+    end
+  end
+end

data/lib/multi_video_streaming/errors/s3_is_not_valid_to_upload.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  module Errors
+    class S3IsNotValidToUpload < StandardError
+      def initialize()
+        super("S3 is not a valid platform to upload a video through MultiVideoStreaming")
+      end
+    end
+  end
+end

data/lib/multi_video_streaming/errors.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "multi_video_streaming/errors/duplicated_platform_name"
+require "multi_video_streaming/errors/invalid_platform_name"
+require "multi_video_streaming/errors/invalid_platforms_param"
+require "multi_video_streaming/errors/missing_param"
+require "multi_video_streaming/errors/s3_is_not_valid_to_upload"

data/lib/multi_video_streaming/factories/drive.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  module Factories
+    class Drive
+      PLATFORM_DRIVERS = {}
+      MultiVideoStreaming::PLATFORMS_SUPPORT.each do |platform|
+        platform_sym = platform.capitalize().to_sym
+        PLATFORM_DRIVERS[platform] = MultiVideoStreaming::Drivers.const_get(platform_sym)
+      end
+
+      def self.get_platform_instance(platform_name:, dependency_params:, response_instance:, required_fields_validator_instance:, https_service_instance:)
+        PLATFORM_DRIVERS[platform_name].new(
+          dependency_params: dependency_params,
+          response_instance: response_instance,
+          required_fields_validator_instance: required_fields_validator_instance,
+          https_service_instance: https_service_instance
+        )
+      end
+    end
+  end
+end
+

data/lib/multi_video_streaming/factories.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "multi_video_streaming/factories/drive"

data/lib/multi_video_streaming/helpers/get_default_error_message.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  module Helpers
+    class GetDefaultErrorMessage
+      def self.by_method(method:)
+        methods = {
+          :upload => "upload",
+          :get => "get",
+          :delete => "delete"
+        }
+
+        current_method = methods[method]
+        if current_method.nil?
+          raise MultiVideoStreaming::Errors::MissingParam.new("method")
+        end
+
+        "An error occurred when trying to #{current_method} a video."
+      end
+
+      def self.not_found(video_id:)
+        "The video with id: #{video_id} does not exist."
+      end
+    end
+  end
+end

data/lib/multi_video_streaming/helpers/title_from_url.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  module Helpers
+    class TitleFromUrl
+      def self.get(url:)
+        URI(url.to_s).path.split('/').last
+      end
+    end
+  end
+end

data/lib/multi_video_streaming/helpers.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "multi_video_streaming/helpers/title_from_url.rb"
+require "multi_video_streaming/helpers/get_default_error_message.rb"

data/lib/multi_video_streaming/platforms_support.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  PLATFORMS_SUPPORT = ["vimeo", "bunny", "s3"]
+end

data/lib/multi_video_streaming/protocols/https.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  module Protocols
+    class Https
+      extend MultiVideoStreaming::Protocols::Interface
+
+      method :get
+      method :post
+      method :put
+      method :patch
+      method :delete
+    end
+  end
+end

data/lib/multi_video_streaming/protocols/interface.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  module Protocols
+    module Interface
+      def method(name)
+        define_method(name) { |*args|
+          raise "interface method #{name} not implemented"
+        }
+      end
+    end
+  end
+end

data/lib/multi_video_streaming/protocols/platform.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  module Protocols
+    class Platform
+      extend MultiVideoStreaming::Protocols::Interface
+
+      attr_accessor :dependency_params
+      private :dependency_params=
+
+      attr_accessor :response_instance
+      private :response_instance=
+
+      attr_accessor :required_fields_validator_instance
+      private :required_fields_validator_instance=
+
+      attr_accessor :https_service_instance
+      private :https_service_instance=
+
+      def initialize(dependency_params:, response_instance:, required_fields_validator_instance:, https_service_instance:)
+        self.dependency_params = dependency_params
+        self.response_instance = response_instance
+        self.required_fields_validator_instance = required_fields_validator_instance
+        self.https_service_instance = https_service_instance
+      end
+
+      method :upload_video
+      method :get_video
+      method :delete_video
+    end
+  end
+end

data/lib/multi_video_streaming/protocols.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "multi_video_streaming/protocols/interface"
+require "multi_video_streaming/protocols/platform"
+require "multi_video_streaming/protocols/https"

data/lib/multi_video_streaming/response.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  class DriverResponse
+    attr_accessor :platform_name
+    private :platform_name=
+
+    attr_accessor :status
+    private :status=
+
+    attr_accessor :original_status_code
+    private :original_status_code=
+
+    attr_accessor :data
+    private :data=
+
+    attr_accessor :message
+    private :message=
+
+    def initialize(platform_name:, status:, original_status_code:, data:, message:)
+      self.platform_name = platform_name
+      self.status = status
+      self.original_status_code = original_status_code
+      self.data = data
+      self.message = message
+    end
+  end
+
+  class FinalResponse
+    attr_accessor :response
+    private :response=
+
+    attr_accessor :has_error
+    private :has_error=
+
+    def initialize(has_error:, response:)
+      @has_error = has_error
+      @response = format_response(response: response)
+    end
+
+    def has_error?
+      @has_error
+    end
+
+    def response
+      @response
+    end
+
+    private
+    def format_response(response: )
+      if response.is_a?(Array)
+        if (response.length > 1)
+          return response.map { |response| DriverResponse.new(platform_name: response[:platform_name], status: response[:status], original_status_code: response[:original_status_code], data: response[:data], message: response[:message]) }
+        else
+          return DriverResponse.new(
+            platform_name: response[0][:platform_name],
+            status: response[0][:status],
+            original_status_code: response[0][:original_status_code],
+            data: response[0][:data],
+            message: response[0][:message]
+          )
+        end
+      end
+
+      DriverResponse.new(
+        platform_name: response[:platform_name],
+        status: response[:status],
+        original_status_code: response[:original_status_code],
+        data: response[:data],
+        message: response[:message]
+      )
+    end
+  end
+
+  class Response
+    attr_accessor :response
+    private :response=
+
+    attr_accessor :has_error
+    private :has_error=
+
+    def initialize()
+      @response = []
+      @has_error = false
+    end
+
+    def add_response(platform_name:, status:, original_status_code:, data:, params_equivalent: nil, message:)
+      if params_equivalent
+        response_data = format_data(data: data, params_equivalent: params_equivalent)
+      else
+        response_data = data
+      end
+
+      @response.push({ platform_name: platform_name, status: status, original_status_code: original_status_code, data: response_data, message: message })
+      if status == "error"
+        @has_error = true
+      end
+
+      status
+    end
+
+    def get_this_response
+      MultiVideoStreaming::FinalResponse.new(has_error: has_error, response: @response.last)
+    end
+
+    def get_all_response
+      MultiVideoStreaming::FinalResponse.new(has_error: has_error, response: @response)
+    end
+
+    private
+
+    def format_data(data:, params_equivalent:)
+      data_formatted = {}
+      data.map do |key_value|
+        key = key_value.first.to_s
+        equivalent_key = params_equivalent[key]
+        if equivalent_key
+          data_formatted[equivalent_key] = key_value.last
+        end
+      end
+      data_formatted
+    end
+  end
+end

data/lib/multi_video_streaming/services/https.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  module Services
+    class Https < MultiVideoStreaming::Protocols::Https
+      def get(uri:, headers:)
+        config_http(uri: uri)
+        request = build_request(method: :get, headers: headers)
+        formatt_response(response: request!)
+      end
+
+      def post(uri:, body:, headers:)
+        config_http(uri: uri)
+        request = build_request(method: :post, headers: headers)
+        request.body = body.to_json
+        formatt_response(response: request!)
+      end
+
+      def put(uri:, body:, headers:)
+        config_http(uri: uri)
+        request = build_request(method: :put, headers: headers)
+        request.body = body
+        formatt_response(response: request!)
+      end
+
+      def patch(uri:, body:, headers:)
+        config_http(uri: uri)
+        request = build_request(method: :patch, headers: headers)
+        request.body = body
+        formatt_response(response: request!)
+      end
+
+      def delete(uri:, headers:)
+        config_http(uri: uri)
+        request = build_request(method: :delete, headers: headers)
+        formatt_response(response: request!)
+      end
+
+      private
+      def config_http(uri:)
+        @url = URI(uri)
+        @http = Net::HTTP.new(@url.host, @url.port)
+        @http.use_ssl = true
+      end
+
+      def build_request(method:, headers:)
+        methods = {
+          :post => Net::HTTP::Post.new(@url),
+          :get => Net::HTTP::Get.new(@url),
+          :put => Net::HTTP::Put.new(@url),
+          :patch => Net::HTTP::Patch.new(@url),
+          :delete => Net::HTTP::Delete.new(@url)
+        }
+
+        @request = methods[method]
+        @request["Accept"] = "application/json"
+        @request["Content-Type"] = "application/json"
+        build_headers(headers: headers)
+        @request
+      end
+
+      def build_headers(headers:)
+        headers_keys = headers.keys
+        headers_keys.each do |key|
+          @request[key] = headers[key]
+        end
+        @request
+      end
+
+      def request!
+        @http.request(@request)
+      end
+
+      def formatt_response(response:)
+        response_formatted = {}
+        if !response.body.nil? && !response.read_body&.empty?
+          response_formatted = JSON.parse(response.read_body)
+        end
+
+        response_formatted["status_code"] = response.code.to_i
+        response_formatted
+      end
+    end
+  end
+end

data/lib/multi_video_streaming/services.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "multi_video_streaming/services/https"

data/lib/multi_video_streaming/validators/platform_name_validator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  module Validators
+    class PlatformNameValidator
+      def self.validate(name:)
+        if !MultiVideoStreaming::PLATFORMS_SUPPORT.include?(name)
+          raise MultiVideoStreaming::Errors::InvalidPlatformName.new(name)
+        end
+      end
+    end
+  end
+end

data/lib/multi_video_streaming/validators/platforms_array_validator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  module Validators
+    class PlatformsArrayValidator
+      def self.validate(platforms_array:)
+        if !(platforms_array.is_a?(Array))
+          raise MultiVideoStreaming::Errors::MissingParam.new('platforms')
+        end
+
+        if platforms_array.length == 0
+          raise MultiVideoStreaming::Errors::MissingParam.new('platforms')
+        end  
+      end
+    end
+  end
+end

data/lib/multi_video_streaming/validators/platforms_hash_validator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  module Validators
+    class PlatformsHashValidator
+      def self.validate(platforms_hash: [], method:, number_of_platforms: 0)
+        platform_names = []
+        platforms_hash.each do |platform_hash|
+          if (platform_hash.nil? || platform_hash[:platform_name].nil?)
+            raise MultiVideoStreaming::Errors::MissingParam.new('platform_name')
+          end
+  
+          if (platform_hash[:dependency_params].nil?)
+            raise MultiVideoStreaming::Errors::MissingParam.new('dependency_params')
+          end
+  
+          if method == :create && platform_hash[:platform_name] == "s3"
+            if number_of_platforms > 1
+              return
+            else
+              raise MultiVideoStreaming::Errors::S3IsNotValidToUpload.new
+            end
+          end
+  
+          MultiVideoStreaming::Validators::PlatformNameValidator.validate(name: platform_hash[:platform_name])
+
+          if platform_names.include?(platform_hash[:platform_name])
+            raise MultiVideoStreaming::Errors::DuplicatedPlatformName.new
+          else
+            platform_names << platform_hash[:platform_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/multi_video_streaming/validators/platforms_position_validator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  module Validators
+    class PlatformsPositionValidator
+      def self.validate(platforms:)
+        primary_platform = platforms.first
+        if primary_platform[:platform_name] == "s3"
+          platforms.delete_at(0)
+          platforms << primary_platform
+        end
+
+        platforms
+      end
+    end
+  end
+end

data/lib/multi_video_streaming/validators/required_fields_validator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  module Validators
+    class RequiredFieldsValidator
+      def self.validate(params)
+        params.each do |param_name, param_value|
+          if param_value.nil?
+            raise MultiVideoStreaming::Errors::MissingParam.new(param_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/multi_video_streaming/validators.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "multi_video_streaming/validators/platforms_hash_validator"
+require "multi_video_streaming/validators/required_fields_validator"
+require "multi_video_streaming/validators/platforms_array_validator"
+require "multi_video_streaming/validators/platform_name_validator"
+require "multi_video_streaming/validators/platforms_position_validator"

data/lib/multi_video_streaming/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MultiVideoStreaming
+  VERSION = "1.0.0.beta"
+end

data/lib/multi_video_streaming.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'thread'
+require 'thwait'
+require "uri"
+require "net/http"
+require "openssl"
+require "json"
+require "aws-sdk-s3"
+
+require "multi_video_streaming/platforms_support"
+require "multi_video_streaming/protocols"
+require "multi_video_streaming/services"
+require "multi_video_streaming/drivers"
+require "multi_video_streaming/factories"
+require "multi_video_streaming/errors"
+require "multi_video_streaming/response"
+require "multi_video_streaming/helpers"
+require "multi_video_streaming/version"
+require "multi_video_streaming/validators"
+
+module MultiVideoStreaming
+  def self.upload(url, *platforms)
+    threads = []
+
+    MultiVideoStreaming::Validators::PlatformsArrayValidator.validate(platforms_array: platforms)
+    MultiVideoStreaming::Validators::PlatformsHashValidator.validate(platforms_hash: platforms, method: :create, number_of_platforms: platforms.length)
+
+    response_instance = MultiVideoStreaming::Response.new
+    required_fields_validator_instance = MultiVideoStreaming::Validators::RequiredFieldsValidator
+    https_service_instance = MultiVideoStreaming::Services::Https.new
+
+    platforms.each do |platform|
+      threads << Thread.new {
+        platform_instance = MultiVideoStreaming::Factories::Drive.get_platform_instance(
+          platform_name: platform[:platform_name],
+          dependency_params: platform[:dependency_params],
+          response_instance: response_instance,
+          required_fields_validator_instance: required_fields_validator_instance,
+          https_service_instance: https_service_instance
+        )
+        platform_instance.upload_video(url: url)
+      }
+    end
+
+    ThreadsWait.all_waits(*threads)
+    response_instance.get_all_response
+  end
+
+  def self.get(*platforms)
+    MultiVideoStreaming::Validators::PlatformsArrayValidator.validate(platforms_array: platforms)
+    MultiVideoStreaming::Validators::PlatformsHashValidator.validate(platforms_hash: platforms, method: :get, number_of_platforms: platforms.length)
+
+    response_instance = MultiVideoStreaming::Response.new
+    required_fields_validator_instance = MultiVideoStreaming::Validators::RequiredFieldsValidator
+    https_service_instance = MultiVideoStreaming::Services::Https.new
+
+    platforms_in_the_correct_order = MultiVideoStreaming::Validators::PlatformsPositionValidator.validate(platforms: platforms)
+
+    platforms_in_the_correct_order.each do |platform|
+      platform_instance = MultiVideoStreaming::Factories::Drive.get_platform_instance(
+        platform_name: platform[:platform_name],
+        dependency_params: platform[:dependency_params],
+        response_instance: response_instance,
+        required_fields_validator_instance: required_fields_validator_instance,
+        https_service_instance: https_service_instance
+      )
+      platform_response = platform_instance.get_video
+
+      if platform_response == "success"
+        return response_instance.get_this_response
+      end
+    end
+
+    response_instance.get_all_response
+  end
+
+  def self.delete(*platforms)
+    threads = []
+
+    MultiVideoStreaming::Validators::PlatformsArrayValidator.validate(platforms_array: platforms)
+    MultiVideoStreaming::Validators::PlatformsHashValidator.validate(platforms_hash: platforms, method: :get, number_of_platforms: platforms.length)
+
+    response_instance = MultiVideoStreaming::Response.new
+    required_fields_validator_instance = MultiVideoStreaming::Validators::RequiredFieldsValidator
+    https_service_instance = MultiVideoStreaming::Services::Https.new
+
+    platforms.each do |platform|
+      threads << Thread.new {
+        platform_instance = MultiVideoStreaming::Factories::Drive.get_platform_instance(
+          platform_name: platform[:platform_name],
+          dependency_params: platform[:dependency_params],
+          response_instance: response_instance,
+          required_fields_validator_instance: required_fields_validator_instance,
+          https_service_instance: https_service_instance
+        )
+        platform_instance.delete_video    
+      }
+    end
+
+    ThreadsWait.all_waits(*threads)
+    response_instance.get_all_response
+  end
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: multi_video_streaming
+version: !ruby/object:Gem::Version
+  version: 1.0.0.beta
+platform: ruby
+authors:
+- Henrique Schmeller
+- Gustavo Voigt
+- Matheus Mazepa
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-08-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.12'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-s3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.96.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.96.2
+description: A ruby gem for multiples streaming video services
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/multi_video_streaming.rb
+- lib/multi_video_streaming/drivers.rb
+- lib/multi_video_streaming/drivers/bunny.rb
+- lib/multi_video_streaming/drivers/s3.rb
+- lib/multi_video_streaming/drivers/vimeo.rb
+- lib/multi_video_streaming/errors.rb
+- lib/multi_video_streaming/errors/duplicated_platform_name.rb
+- lib/multi_video_streaming/errors/invalid_platform_name.rb
+- lib/multi_video_streaming/errors/invalid_platforms_param.rb
+- lib/multi_video_streaming/errors/missing_param.rb
+- lib/multi_video_streaming/errors/s3_is_not_valid_to_upload.rb
+- lib/multi_video_streaming/factories.rb
+- lib/multi_video_streaming/factories/drive.rb
+- lib/multi_video_streaming/helpers.rb
+- lib/multi_video_streaming/helpers/get_default_error_message.rb
+- lib/multi_video_streaming/helpers/title_from_url.rb
+- lib/multi_video_streaming/platforms_support.rb
+- lib/multi_video_streaming/protocols.rb
+- lib/multi_video_streaming/protocols/https.rb
+- lib/multi_video_streaming/protocols/interface.rb
+- lib/multi_video_streaming/protocols/platform.rb
+- lib/multi_video_streaming/response.rb
+- lib/multi_video_streaming/services.rb
+- lib/multi_video_streaming/services/https.rb
+- lib/multi_video_streaming/validators.rb
+- lib/multi_video_streaming/validators/platform_name_validator.rb
+- lib/multi_video_streaming/validators/platforms_array_validator.rb
+- lib/multi_video_streaming/validators/platforms_hash_validator.rb
+- lib/multi_video_streaming/validators/platforms_position_validator.rb
+- lib/multi_video_streaming/validators/required_fields_validator.rb
+- lib/multi_video_streaming/version.rb
+homepage: https://rubygems.org/gems/multi_video_streaming
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: multi_video_streaming
+test_files: []