ubiquity-wiredrive 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4ccd5f3318034434414e3b07000317126d2e6d1f4bf30f2cdfc5f8680911f011
+  data.tar.gz: cc92e7e91a7cedaea4e2f4aa48477c1f9b0fa12b8557cd8033eb05f8811b829b
+SHA512:
+  metadata.gz: 99bfad05b74cfd9194b19a3b6966fc7565aa98bd103b81d45300726b928536a868a4624bf95897dfe1d195b0c063bce5e10cbd471eb6e25a43fd6b983e3be309
+  data.tar.gz: 1291cb4b05760c751152837b1556257c84e2d94a20808d390c5878e8bdf2a6acd6deb82ad61f2dcada727ca5daf5fef16b96986f3a930176505f5b3dc534aab2

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.gems/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/dev/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rbenv-gemsets

@@ -0,0 +1,3 @@
+.gems
+ubiquity-wiredrive
+-global

data/.ruby-version

@@ -0,0 +1 @@
+2.3.3

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'json', :platforms => :mri_18
+
+# Specify your gem's dependencies in ubiquity-mediasilo-api-v3.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 John Whitson
+
+MIT License
+
+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,31 @@
+# Ubiquity::Wiredrive
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ubiquity-wiredrive'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ubiquity-wiredrive
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/XPlatform-Consulting/ubiquity-wiredrive/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/console

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'ubiquity-wiredrive'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+begin
+  require 'pry'
+  Pry.start
+rescue LoadError => e
+  require 'irb'
+  IRB.start(__FILE__)
+end
+

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/ubiquity/wiredrive.rb

@@ -0,0 +1,7 @@
+require 'ubiquity/wiredrive/version'
+
+module Ubiquity
+  module Wiredrive
+
+  end
+end

data/lib/ubiquity/wiredrive/api.rb

@@ -0,0 +1,7 @@
+module Ubiquity
+  module Wiredrive
+    module API
+
+    end
+  end
+end

data/lib/ubiquity/wiredrive/api/client.rb

@@ -0,0 +1,35 @@
+# require 'ubiquity/wiredrive/api/v2'
+
+module Ubiquity
+  module Wiredrive
+    module API
+      class Client
+
+        def self.new(args = { })
+          new_v2(args)
+        end
+
+        def self.new_v2(args)
+          version = '2'
+          require "ubiquity/wiredrive/api/v#{version}"
+          Ubiquity::Wiredrive::API::V2::Client.new(args)
+        end
+
+        def self.new_v3(args)
+          version = '3'
+          require "ubiquity/wiredrive/api/v#{version}"
+          Ubiquity::Wiredrive::API::V3::Client.new(args)
+        end
+
+      end
+    end
+  end
+end
+# class Ubiquity::Wiredrive::API::Client
+#
+#   # def self.new(args = { })
+#   #   # Ubiquity::Wiredrive::API::V2::Client.new(args)
+#   # end
+#
+#
+# end

data/lib/ubiquity/wiredrive/api/utilities.rb

@@ -0,0 +1,25 @@
+# require 'ubiquity/wiredrive/api/v2'
+
+module Ubiquity
+  module Wiredrive
+    module API
+      class Utilities
+
+        def self.new(args = { })
+          version = '2'
+          require "ubiquity/wiredrive/api/v#{version}"
+          Ubiquity::Wiredrive::API::V2::Utilities.new(args)
+        end
+
+      end
+    end
+  end
+end
+# class Ubiquity::Wiredrive::API::Client
+#
+#   # def self.new(args = { })
+#   #   # Ubiquity::Wiredrive::API::V2::Client.new(args)
+#   # end
+#
+#
+# end

data/lib/ubiquity/wiredrive/api/v2.rb

@@ -0,0 +1,12 @@
+require 'ubiquity/wiredrive/api/v2/client'
+require 'ubiquity/wiredrive/api/v2/utilities'
+
+module Ubiquity
+  module Wiredrive
+    module API
+      module V2
+
+      end
+    end
+  end
+end

data/lib/ubiquity/wiredrive/api/v2/client.rb

@@ -0,0 +1,301 @@
+require 'ubiquity/wiredrive/api/v2/http_client'
+
+class Ubiquity::Wiredrive::API::V2::Client
+
+  attr_accessor :logger
+
+  attr_accessor :http_client, :request, :response, :http_response
+
+  def initialize(args = { })
+    require 'ubiquity/wiredrive/api/v2/client/requests'
+
+    initialize_logger(args)
+    initialize_http_client(args)
+  end
+
+  def initialize_logger(args = { })
+    @logger = args[:logger] ||= Logger.new(args[:log_to] || STDOUT)
+    log_level = args[:log_level]
+    if log_level
+      @logger.level = log_level
+      args[:logger] = @logger
+    end
+    @logger
+  end
+
+  def initialize_http_client(args = { })
+    @http_client = Ubiquity::Wiredrive::API::V2::HTTPClient.new(args)
+  end
+
+  # @param [Requests::BaseRequest] request
+  # @param [Hash, nil] options
+  # @option options [Boolean] :execute_request (true) Will execute the request
+  # @option options [Boolean] :return_request (true) Will return the request instance instead of nil. Only applies if
+  #   execute_request is false.
+  def process_request(request, options = nil)
+    # @paginator = nil
+    @response = nil
+    @request = request
+    logger.warn { "Request is Missing Required Arguments: #{request.missing_required_arguments.inspect}" } unless request.missing_required_arguments.empty?
+
+    # if ([:all, 'all'].include?(request.arguments[:_page]))
+    #   request.arguments[:_page] = 1
+    #   include_remaining_pages = true
+    # else
+    #   include_remaining_pages = false
+    # end
+
+    request.client = self unless request.client
+    options ||= request.options
+
+    return (options.fetch(:return_request, true) ? request : nil) unless options.fetch(:execute_request, true)
+
+    #@response = http_client.call_method(request.http_method, { :path => request.path, :query => request.query, :body => request.body }, options)
+    @response = request.execute
+
+    # if include_remaining_pages
+    #   return paginator.include_remaining_pages
+    # end
+
+    if @response.is_a?(Hash)
+      _results = @response['results']
+      return _results if _results
+    end
+
+    @response
+  end
+
+  # def paginator
+  #   @paginator ||= Paginator.new(self) if @response
+  # end
+
+  def process_request_using_class(request_class, args = { }, options = { })
+    @response = nil
+    @request = request_class.new(args, options)
+    process_request(request, options)
+  end
+
+  def error
+    _error = errors.first
+    return _error.inspect if _error.is_a?(Hash)
+    _error
+  end
+
+  def error_message
+    _error = error
+    _error.is_a?(Hash) ? (_error['message'] || _error) : _error
+  end
+
+  def errors
+    return (response['errors'] || [ ]) if response.is_a?(Hash)
+    [ ]
+  end
+
+  def success?
+    return unless request
+    return request.success? if request.respond_to?(:success?)
+
+    _code = http_client.response.code
+    _code and _code.start_with?('2')
+  end
+
+  # ################################################################################################################## #
+  # @!group API METHODS
+
+  def asset_create(args = { }, options = { })
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'assets',
+        :http_method => :post,
+        :default_parameter_send_in_value => :body,
+        :parameters => [
+          :name,
+          :description,
+          :workflow,
+          :is_folder,
+          { :name => :parent, :aliases => [ :parentid ] },
+          { :name => :project, :aliases => [ :projectid ] },
+        ]
+      }
+    )
+    # http_client.get('assets')
+    _response = process_request(_request, options)
+
+    _response.first if _response.is_a?(Array)
+  end
+
+  def asset_primary_file_init(args = { }, options = { })
+    args = { :id => args } if args.is_a?(String)
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'assets/#{arguments[:id]}/primary_file',
+        :http_success_code => 202,
+        :http_method => :post,
+        :parameters => [
+          { :name => :id, :aliases => [ :assetid ], :send_in => :path }
+        ]
+      }
+    )
+    process_request(_request, options)
+    http_client.response['location']
+  end
+  alias :asset_upload_session_get :asset_primary_file_init
+
+  def asset_delete(args = { }, options = { })
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'assets/#{arguments[:id]}',
+        :http_method => :delete,
+        :parameters => [
+          { :name => :id, :aliases => [ :assetid ], :send_in => :path },
+        ]
+      }
+    )
+    response = process_request(_request, options)
+    response
+  end
+
+  def asset_get(args = { }, options = { })
+
+  end
+
+  def assets_get(args = { }, options = { })
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'assets',
+        :parameters => [
+          :limit,
+          :offset,
+          :id,
+          :name,
+          :workflow,
+          :is_folder,
+          :is_active,
+          :has_default_thumbs,
+          :date_created,
+          :date_modified,
+          :created_by,
+          { :name => :parent, :aliases => [ :parentid ] },
+          { :name => :project, :aliases => [ :projectid ] },
+          :height,
+          :width,
+          :mime_type,
+          :include
+        ]
+      }
+    )
+
+    name = _request.arguments[:name]
+    _request.arguments[:name] = CGI.escapeHTML(name) if name
+
+    # http_client.get('assets')
+    response = process_request(_request, options)
+    response
+  end
+
+  def file_upload(args = { }, options = { })
+    file_path = args[:file_path]
+    file_name = args[:file_name] || File.basename(file_path)
+
+    uri = args[:destination_uri]
+    uri = URI(uri) if uri.is_a?(String)
+
+    res = nil
+    File.open(file_path) do |file|
+      req = Net::HTTP::Post::Multipart.new uri.path,
+                                           'file' => UploadIO.new(file, 'application/octet-stream', file_name)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      res = http.request(req)
+    end
+
+    res ? res.code.start_with?('2') : false
+  end
+
+  def project_create(args = { }, options = { })
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'projects',
+        :http_method => :post,
+        :default_parameter_send_in_value => :body,
+        :parameters => [
+          :name,
+          :description,
+          :code,
+          :manager,
+          :notify_manager,
+          :is_active,
+        ]
+      }
+    )
+    _response = process_request(_request, options)
+
+    _response.first if _response.is_a?(Array)
+  end
+
+  def project_delete(args = { }, options = { })
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'projects/#{arguments[:id]}',
+        :http_method => :delete,
+        :parameters => [
+          { :name => :id, :aliases => [ :projectid ], :send_in => :path },
+        ]
+      }
+    )
+    response = process_request(_request, options)
+    response
+  end
+
+  def project_get(args = { }, options = { })
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'projects/#{arguments[:id]}',
+        :parameters => [
+          { :name => :id, :send_in => :path },
+          :q,
+          :include
+        ]
+      }
+    )
+    response = process_request(_request, options)
+    response
+  end
+
+  def projects_get(args = { }, options = { })
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'projects',
+        :parameters => [
+          :id,
+          :name,
+          :code,
+          :notify_manager,
+          :is_active,
+          :date_last_accessed,
+          :date_created,
+          :date_modified,
+          :date_deleted,
+          :manager
+        ]
+      }
+    )
+
+    name = _request.arguments[:name]
+    _request.arguments[:name] = CGI.escapeHTML(name) if name
+
+    response = process_request(_request, options)
+    response
+  end
+
+  # @!endgroup API METHODS
+
+end