client_api 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 613b6c809bbc1c8824484363e7cfc55d80e56af5
+  data.tar.gz: fa94a013a97ac14b5eefde283215ab9f882dda80
+SHA512:
+  metadata.gz: 39f2618c4436007325f036fc8152f977768be47ba8f02c38b9209ca162fbf389e1fe64e650de00162463a6bb0906f73d7c15b8ca99d804335b5500f4ecd3618e
+  data.tar.gz: d12647033ed5d4e0fdcc0553e056205af8421d43e55533ba6ba8cc390305642d852ef3894053d2c5699f1bc35adcad9ad8be7f61404c7084788b8439da2b71f4

data/.autotest

@@ -0,0 +1,2 @@
+require 'autotest/fsevent'
+require 'autotest/growl'

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+gem "autotest"
+gem "autotest-growl"
+gem "ZenTest"
+# Specify your gem's dependencies in client_api.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 fabira
+
+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,29 @@
+# ClientApi
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'client_api'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install client_api
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/client_api/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/client_api.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'client_api/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "client_api"
+  spec.version       = ClientApi::VERSION
+  spec.authors       = ["fabira && atakem "]
+  spec.email         = ["fabira90@gmail.com,atacraft@gmail.com"]
+  spec.summary       = %q{"module client-API"}
+  spec.description   = %q{"Module that interact with the API"}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 1.9"
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "redis"
+  spec.add_development_dependency "rest-client"
+  spec.add_development_dependency "rspec"
+
+end

data/lib/client_api/handler.rb

@@ -0,0 +1,183 @@
+require 'json'
+require 'rest-client'
+require_relative '../conf/conf_api'
+
+class Handler
+
+   def self.connect_app(app_params)
+    waited_keys = [:object,:option]
+    call_api(app_params,'/apps/connect','POST',waited_keys)
+  end
+
+  def self.load_data(params)
+    waited_keys = [:engine_name,:data]
+    resp = invoke('/apps/load_data','POST',params)
+    resp.code == 200 ? true : false
+  end
+
+  def self.similar_users(params)
+    waited_keys = [:engine_name,:user_id,:nb_of_similars]
+    resp = invoke('/users/similar','POST',params)
+    resp.code == 200 ? true : false
+  end
+
+  def self.similar_items(params)
+    waited_keys = [:engine_name,:item_id,:nb_of_similars]
+    resp = invoke('/items/similar','POST',params)
+    resp.code == 200 ? true : false
+  end
+
+  def self.recommend(params)
+    waited_keys = [:engine_name,:user_id,:nb_of_recommendations]
+    resp = invoke('/users/recommend','POST',params)
+    resp.code == 200 ? true : false
+  end
+
+  private #######################################
+
+  #launch a request to the api server
+  def self.get_response(request,url,param)
+      request[:post] ? response = RestClient.post(url,param) : response = RestClient.get(url, {:params => param})
+      response
+  end
+
+  #return the response's code
+  def self.get_code(response)
+    response.code
+  end
+
+  #return the correct url to the api server
+  def self.get_url(url)
+      return API_SERVER+url
+  end
+
+  #determines the restfull method
+  def self.get_request(type)
+      request = {post: false,get: false}
+      type == 'POST' ? request[:post] = true : request[:get] = true
+      request
+  end
+
+  #invoke the api et return the response
+  def self.invoke(uri,req,params)
+    request  = get_request(req)
+    url      = get_url(uri)
+    response = get_response(request,url,params)
+    return response
+  end
+
+  #determines if the passed parameter is a hash
+  def self.valid_parameter?(param)
+    param.is_a?(Hash)
+  end
+
+  #determines if the waited keys are present in the parameter
+  def self.valid_keys?(param,waited_keys)
+    waited_keys.each do |k|
+      if !(param.has_key?(k))
+        return false
+        break
+     end
+    end
+    return true
+  end
+
+  #determines if the parameter's values are not empty Hash
+  def self.valid_values?(param)
+    parameter = {object: JSON.parse(param[:object],symbolize_names: true),option: JSON.parse(param[:option],symbolize_names: true)}
+    values = parameter.values
+    values.each do |v|
+      if !(v.is_a?(Hash)) || (v.empty?)
+        return false
+        break
+      end
+    end
+    return true
+  end
+
+  #determines if the option is valid
+  def self.valid_option?(option)
+    option = JSON.parse(option,symbolize_names: true)
+    waited_keys = [:user,:app]
+    if valid_keys?(option,waited_keys)
+      values = option.values
+      values.each do |v|
+        unless (v.is_a?(TrueClass) || v.is_a?(FalseClass))
+          return false
+          break
+        end
+      end
+      if (option[:user] && option[:app]) || (!option[:user] && !option[:app])
+        return false
+      else
+        return true
+      end
+    else
+      return false
+    end
+  end
+
+  #determines if the object's keys are valid
+  def self.valid_object_keys?(keys,object_keys)
+    object_keys.each do |k|
+      unless keys.include?(k)
+        return false
+        break
+      end
+    end
+    return true
+  end
+
+  #determines if the object's values are valid
+  def self.valid_object_values?(values)
+    values.each do |v|
+      if v.nil?  || !(v.is_a?(String)) || v.empty?
+        return false
+        break
+      end
+    end
+    return true
+  end
+
+  #determines if the object is valid
+  def self.valid_param_object?(object_keys,keys,values)
+    response = true
+    if !(valid_object_keys?(keys,object_keys)) || !(valid_object_values?(values))
+      response = false
+    end
+    response
+  end
+
+  #determines if the object is valid according to the true option
+  def self.valid_object?(object,option)
+    object = JSON.parse(object,symbolize_names: true)
+    option = JSON.parse(option,symbolize_names: true)
+    keys = object.keys
+    values = object.values
+    user_keys = [:login,:password]
+    app_keys  = [:api_key]
+    if option[:user]
+      return valid_param_object?(user_keys,keys,values)
+    else
+      return valid_param_object?(app_keys,keys,values)
+    end
+  end
+
+  #validate each method's parameter
+  def self.validate(param,waited_keys)
+    valid_parameter?(param) && valid_keys?(param,waited_keys) && valid_values?(param) && valid_option?(param[:option]) && valid_object?(param[:object],param[:option])
+  end
+
+  #invoke the api and analyze the response's code
+  def self.call_api(params,short_uri,rest_req,waited_keys)
+   if validate(params,waited_keys)
+     response = invoke(short_uri,rest_req,params)
+     get_code(response) == 200 ? true : false
+   else
+     false
+   end
+   rescue
+     false
+  end
+
+end

data/lib/client_api/version.rb

@@ -0,0 +1,3 @@
+module ClientApi
+  VERSION = "0.0.3"
+end

data/lib/client_api.rb

@@ -0,0 +1,8 @@
+require "client_api/version"
+require_relative 'client_api/handler'
+
+module ClientApi
+  
+    class Handler
+    end
+end

data/lib/conf/conf_api.rb

@@ -0,0 +1 @@
+API_SERVER = 'http://localhost:9295'

data/spec/handler_spec.rb

@@ -0,0 +1,109 @@
+require_relative 'spec_helper'
+
+
+describe Handler do
+  let(:app) {{ object: {api_key: 'an api_key'}.to_json, option: {user: false,app: true}.to_json }}
+  let(:redis) { Redis.current}
+  let(:user) {{ object: {login: 'login',password: 'password'}, option: {user: true,app: false} }}
+
+   before (:each) do
+      redis.del('applications')
+      redis.del('users')
+   end
+
+
+  describe '.connect_app' do
+
+   before (:each) do
+      redis.sadd('applications',app[:object])
+      redis.sadd('users',user[:object].to_json)
+   end
+
+    context "When an application attempts to log in" do
+      it { expect(Handler.connect_app(app)).to eq true }
+    end
+
+    context "When a inexistant app attemps to log in" do
+      bad_app = {object: {api_key: '013'}.to_json,option: {user: false,app: true}.to_json}
+      it { expect(Handler.connect_app(bad_app)).to eq false }
+    end
+
+    context "When the parameter is not a hash" do
+      it { expect(Handler.connect_app("coucou")).to eq false }
+    end
+
+    context "When the parameter has not valid keys" do
+      invalid_param = {obj: {api_key: 'ap'}.to_json,opti: {user: false,app: true}.to_json}
+      it { expect(Handler.connect_app(invalid_param)).to eq false }
+    end
+
+    context "When the parameter's values are not hash" do
+      invalid_param = {object: "user",option: {user: false,app: true}.to_json}
+      it { expect(Handler.connect_app(invalid_param)).to eq false }
+    end
+
+    context "When the parameter's values nil or empty" do
+      invalid_param = {object: {}.to_json,option: {user: false,app: true}.to_json}
+      it { expect(Handler.connect_app(invalid_param)).to eq false }
+
+      invalid_param = {object: nil,option: nil}
+      it { expect(Handler.connect_app(invalid_param)).to eq false }
+    end
+
+    context "When the option is invalid" do
+      invalid_param = {object: {api_key: 'a api_key'}.to_json,option: {use: false,ap: true}.to_json}
+      it { expect(Handler.connect_app(invalid_param)).to eq false }
+
+      invalid_param = {object: {api_key: 'a api'}.to_json,option: {user: false,app: false}.to_json}
+      it { expect(Handler.connect_app(invalid_param)).to eq false }
+
+      invalid_param = {object: {api_key: 'a api'}.to_json,option: {user: true,app: true}.to_json}
+      it { expect(Handler.connect_app(invalid_param)).to eq false }
+
+      invalid_param = {object: {api_key: 'a api'}.to_json,option: {user: 'cou',app: true}.to_json}
+      it { expect(Handler.connect_app(invalid_param)).to eq false }
+
+      invalid_param = {object: {api_key: 'a api'}.to_json,option: {user: false,app: nil}.to_json}
+      it { expect(Handler.connect_app(invalid_param)).to eq false }
+    end
+
+    context "When the object is invalid" do
+      invalid_param = {object: {ap_key: 'a api'}.to_json,option: {user: false,app: true}.to_json}
+      it { expect(Handler.connect_app(invalid_param)).to eq false }
+
+      invalid_param = {object: {api_key: nil}.to_json,option: {user: false,app: true}.to_json}
+      it { expect(Handler.connect_app(invalid_param)).to eq false }
+
+      invalid_param = {object: {api_key: ''}.to_json,option: {user: false,app: true}.to_json}
+      it { expect(Handler.connect_app(invalid_param)).to eq false }
+
+      invalid_param = {object: {api_key: 1}.to_json,option: {user: false,app: true}.to_json}
+      it { expect(Handler.connect_app(invalid_param)).to eq false }
+    end
+
+  end
+
+  describe '.load_data' do
+    context "When data are successfully load" do
+      it {expect(Handler.load_data(params_to_load)).to eq true }
+    end
+  end
+
+  describe '.similar_users' do
+    context "When similar users are found" do
+      it {expect(Handler.similar_users(params_user_based)).to eq true }
+    end
+  end
+
+  describe '.similar_items' do
+    context "When similar items are found" do
+      it {expect(Handler.similar_items(params_item_based)).to eq true }
+    end
+  end
+
+  describe '.recommend' do
+    context "When recommendations are sent" do
+      it {expect(Handler.recommend(params_item_based)).to eq true }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'client_api'
+require 'redis'
+require 'json'
+
+
+
+def engine_data_sample
+  engine_data = []
+  engine_data << {customer_id: 1,item_id: 1,preference: 1}
+  100.times do
+    engine_data << {customer_id: rand(1..5),item_id: rand(1..10),preference: rand(1..5)}
+  end
+  engine_data
+end
+
+def params_user_based
+  {engine_name: 'eng869',api_key: '926eb0b0-e99d-0131-7e06-080027ab4d7b',id: 1,nb_wanted: 2}
+end
+
+def params_item_based
+  {engine_name: 'eng111',api_key: '926eb0b0-e99d-0131-7e06-080027ab4d7b',id: 1,nb_wanted: 2}
+end
+
+
+def params_to_load
+  {engine_name: 'eng111',data: engine_data_sample.to_json}
+end
+

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: client_api
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- 'fabira && atakem '
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: '"Module that interact with the API"'
+email:
+- fabira90@gmail.com,atacraft@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".autotest"
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- client_api.gemspec
+- lib/client_api.rb
+- lib/client_api/handler.rb
+- lib/client_api/version.rb
+- lib/conf/conf_api.rb
+- spec/handler_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: '"module client-API"'
+test_files:
+- spec/handler_spec.rb
+- spec/spec_helper.rb