dbAccessor 0.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7779c4a2bb87572cd744bc3fb1f6a7ec72104936
+  data.tar.gz: ead38bab42b71e9df42c7539c57024ba298673ad
+SHA512:
+  metadata.gz: 7d9f4826add8a051d3258e64817b88a84153184982c1b091fddd542c1cb07a20cb3fa84713b4d78fb25d32583347387fff02007d20b6105ab4b107bd759e18f9
+  data.tar.gz: 740af56e79f80c311ca395cfb0bb8b46766bba327003dbd22f7edacf3bfbc3e04c2b4fe3270988cfc86dc3ac4706555890fc6d0364f58a1698a6d2bf694f5ed3

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,2 @@
+--format nested
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in dbAccessor.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 @@
+# DbAccessor
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'dbAccessor'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dbAccessor
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/dbAccessor/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/dbAccessor.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dbAccessor/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dbAccessor"
+  spec.version       = DbAccessor::VERSION
+  spec.authors       = ["fabira"]
+  spec.email         = ["fabira90@gmail.com"]
+  spec.summary       = %q{"Module dbAccessor"}
+  spec.description   = %q{"Module d'acces a la base de donnees "}
+  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"]
+
+   # Declare that the Gem is compatible with
+  # version 2.0 or greater
+  spec.required_ruby_version = ">= 2.0"
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "autotest", "~> 4.4", ">= 4.4.6"
+  spec.add_development_dependency "uuid", "~> 2.3", ">= 2.3.7"
+  spec.add_development_dependency "autotest-fsevent", "~> 0.2", ">= 0.2.9"
+  spec.add_development_dependency "autotest-growl", "~> 0.2", ">= 0.2.16"
+  spec.add_development_dependency "ZenTest", "~> 4.10", ">= 4.10.0"
+  spec.add_development_dependency "rspec", "~> 2.6"
+  spec.add_development_dependency "activerecord", "~> 4.1", ">= 4.1.1"
+  spec.add_development_dependency "rake", "~> 10.3", ">= 10.3.2"
+  spec.add_development_dependency "pg", "~> 0.17", ">= 0.17.1"
+end

data/lib/dbAccessor/base.rb

@@ -0,0 +1,100 @@
+module Db_Accessor
+  
+  class Base
+    USER_MODEL = 'User'
+    APP_MODEL  = 'Application'
+    app_columns  = [:id,:name,:api_key,:url,:user_id]
+    user_columns = [:id,:login,:password,:firstname,:lastname,:gender,:email]
+    
+    def self.validate_argument(given_param)
+      resp = nil
+      given_param.values.each do |v|
+        if v.nil? 
+          resp = true
+          break
+        elsif v.is_a?(String) && v.empty?
+          resp = true
+          break
+        else
+          resp = false
+        end
+    end
+      return resp
+    end
+
+    def self.return_response(code,msg)
+      {code: code,message: msg}
+    end
+
+    def self.get_model_name(object_param)
+      Object.const_get(object_param[:model_name])
+    end
+
+    def self.is_model?(param)
+      param == USER_MODEL || param == APP_MODEL 
+    end
+
+    def self.valid_hash?(param)
+      param.is_a?(Hash)
+    end
+
+   
+  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
+
+  def self.verify_keys(keys,attributes)
+     keys.each do |k|
+      if !(attributes.include?(k))
+        return false
+        break
+      end
+    end
+    return true
+  end
+
+  def self.valid_object_columns?(model_name,content)
+    keys = content.keys
+    user_attributes = [:id,:login,:password,:firstname,:lastname,:gender,:email]
+    app_attributes  = [:id,:api_key,:name,:url,:user_id]
+    model_name == "User" ? attributes = user_attributes : attributes = app_attributes
+    verify_keys(keys,attributes)
+  end
+
+   def self.valid_class?(keys,columns,attributes)
+     keys.each do |k|
+      if columns.include?(k)
+        if !(attributes[k].is_a?(String))
+          return false
+          break
+        end
+      else
+        if !(attributes[k].is_a?(Fixnum))
+          return false
+          break
+        end
+      end
+    end
+    return true
+  end
+
+  def self.valid_attributes_values?(attributes)
+    string_columns = [:login,:password,:firstname,:lastname,:gender,:email,:api_key,:name,:url]
+    fixnum_columns = [:user_id,:id]
+    keys = attributes.keys
+    valid_class?(keys,string_columns,attributes)
+  end
+
+
+
+
+
+  end
+
+end

data/lib/dbAccessor/dbConnector.rb

@@ -0,0 +1,14 @@
+require 'active_record'
+require 'pg'
+
+ActiveRecord::Base.establish_connection(
+  adapter: 'postgresql',
+  host: 'localhost',
+  username: 'vagrant',
+  password: 'vagrant',
+  encoding: 'utf8',
+  pool: 5,
+  port: 5432,
+  database: 'nelam_recommend'
+)
+

data/lib/dbAccessor/deleter/deleter.rb

@@ -0,0 +1,73 @@
+require_relative '../../../spec/feed/resources/environment'
+require_relative '../base'
+
+
+class DbAccessor::Deleter < Db_Accessor::Base
+
+  
+  def self.delete_all(given_object)
+    waited_keys = [:model_name,:condition]
+    if validate(given_object,waited_keys) && valid_condition?(given_object)
+	  model = get_model_name(given_object)
+      condition = given_object[:condition]
+      condition == {} ? model.update_all("deleted = true") : model.where(condition).update_all("deleted = true") 
+	  return_response(200,"success")
+    else
+      return_response(400,"Not deleted")
+    end
+  end
+
+  
+  def self.delete_by_id(given_param)
+    waited_keys = [:model_name,:id]
+    if validate(given_param,waited_keys) && validate_id(given_param[:id])
+	  model_name = get_model_name(given_param)
+	  objects = model_name.find(given_param[:id])
+	  objects.each do |o|
+        o.deleted=true
+	    o.save
+	  end
+	  return_response(200,"success")
+    else
+      return_response(400,"Not deleted")
+    end
+  end
+
+  def self.validate(param,waited_keys)
+      param.is_a?(Hash) && valid_keys?(param,waited_keys) && !validate_argument(param) && is_model?(param[:model_name])  
+  end
+
+  def self.validate_id(param)
+    if param.is_a?(Array)
+      param.each do |v|
+        if !(v.is_a?(Fixnum))
+          return false
+          break
+        end
+      end
+    else
+      return false
+    end
+    return true
+  end
+  
+  def self.valid_condition?(param)
+    condition = param[:condition]
+    model_name = param[:model_name]
+    if condition.is_a?(Hash)
+      if !(condition.empty?) 
+        keys = condition.keys
+        values = condition.values
+        if !(valid_object_columns?(model_name,condition)) || validate_argument(condition) || !(valid_attributes_values?(condition)) 
+          return false
+        end
+      else
+          return true
+      end
+    else
+        return false
+    end
+    return true
+  end
+ 
+end

data/lib/dbAccessor/reader/reader.rb

@@ -0,0 +1,81 @@
+require_relative '../../../spec/feed/resources/environment'
+require_relative '../base'
+
+class DbAccessor::Reader < Db_Accessor::Base
+
+  
+  def self.simple_select(given_param)
+    waited_keys = [:model_name,:action_on]
+    if validate(given_param,waited_keys)
+     result = get_model_name(given_param).where(deleted: false).send(given_param[:action_on])
+	 result.nil? ?  return_response(404,"Not found") : return_response(200,result)
+    else
+        return_response(404,"Not found")
+    end
+    rescue ActiveRecord::RecordNotFound => e
+	 return_response(404,"Not found")
+  end
+	
+ 
+  def self.condition_select(given_param)
+    waited_keys = [:model_name,:condition]
+    if validate(given_param,waited_keys) 
+     result = get_model_name(given_param).where(given_param[:condition],deleted: false)
+     ( result.nil? || result == []) ? return_response(404,"Not found") : return_response(200,result)
+    else
+      return_response(404,"Not found")
+    end
+    rescue ActiveRecord::RecordNotFound => e
+	 return_response(400,"Not found")
+  end
+
+
+  def self.select_by_id(given_param)
+    waited_keys = [:model_name,:identifiers]
+    if validate(given_param,waited_keys) && validate_id(given_param[:identifiers])
+      model_name = get_model_name(given_param)
+      result     = model_name.where(deleted: false).find(given_param[:identifiers]) 
+      result.nil? ? return_response(404,"Not found") : return_response(200,result)
+    else
+      return_response(404,"Not found")
+    end
+    rescue ActiveRecord::RecordNotFound => e
+	 return_response(404,"Not found")
+  end
+
+
+
+  def self.linked_models_select(given_param)
+    waited_keys = [:model_name,:condition,:models]
+    if validate(given_param,waited_keys)
+      model_name = get_model_name(given_param)
+      condition  = given_param[:condition]
+      models     = given_param[:models]
+      result     = model_name.where(condition,deleted: false).first
+      result.nil? ? return_response(404,"Not found") : return_response(200,result.send(models)) 
+    else
+      return_response(404,"Not found")
+    end
+    rescue ActiveRecord::RecordNotFound => e
+	 return_response(400,"Not found")
+  end 
+private ##################################################################
+
+  def self.validate(param,waited_keys)
+    valid_hash?(param) && valid_keys?(param,waited_keys) && !validate_argument(param) && is_model?(param[:model_name]) 
+  end
+ 
+  def self.validate_id(param)
+       test_id = lambda do |param|
+                   param.each do |i| 
+                     if !(i.is_a?(Fixnum))
+                       return false
+                       break
+                     end
+                   end
+                   return true
+                 end
+       param.is_a?(Array) && test_id.call(param)
+  end
+
+  end

data/lib/dbAccessor/updater/updater.rb

@@ -0,0 +1,83 @@
+require_relative '../../../spec/feed/resources/environment'
+require_relative '../base'
+
+class DbAccessor::Updater < Db_Accessor::Base 
+
+  #updates given object(s) with given attributes using object's identifier named 'id'
+  def self.update_by_id(given_object)
+    waited_keys = [:model_name,:attributes]
+    if validate(given_object,waited_keys) && valid_attributes_pattern?(given_object[:model_name],given_object[:attributes])
+	   get_model_name(given_object).update(get_attributes(given_object).keys,get_attributes(given_object).values)
+	  return_response(200,"Succesfully updated")
+	else
+      return_response(400,"Not updated")
+    end
+    rescue ActiveRecord::RecordNotFound => e
+	 return_response(400,"Not updated")
+  end
+
+  #updates all model's objects or model's objects that satisfy the given condition with given attributes 
+  def self.update_all_objects(given_param,condition="")
+    waited_keys = [:model_name,:attributes]
+    if validate(given_param,waited_keys) && valid_object_columns?(given_param[:model_name],given_param[:attributes]) && valid_attributes_values?(given_param[:attributes])
+
+
+	  model_name=Object.const_get(given_param[:model_name])
+	  model_name.update_all(given_param[:attributes]) if condition.empty?
+	  model_name.update_all(given_param[:attributes],condition) if condition.is_a?(String) && !condition.empty?
+	 
+	  return_response(200,"Successfully updated")
+    else 
+  	  return_response(400,"Not updated")
+    end
+  end
+
+  private ###################################################################
+
+  def self.get_attributes(given_param)
+    given_param[:attributes]
+  end
+
+  def self.validate_attributes(given_param)
+    given_param.is_a?(Hash) && !given_param.empty?
+  end
+  
+ 
+  def self.valid_fixnum_keys?(keys)
+    keys.each do |k|
+      if !(k.is_a?(Fixnum))
+        return false
+        break
+      end
+    end
+    return true
+  end
+
+  def self.valid_values_pattern?(values,model_name)
+    values.each do |v|
+       if !(v.nil?)  
+         if v.empty? || !(v.is_a?(Hash)) || !valid_object_columns?(model_name,v) || !valid_attributes_values?(v)
+         return false
+         break
+         end
+       else
+         return false
+         break
+       end
+    end
+    return true
+  end
+
+  def self.valid_attributes_pattern?(model_name,attributes)
+    keys = attributes.keys
+    values = attributes.values
+    if valid_fixnum_keys?(keys) && valid_values_pattern?(values,model_name)
+      return true
+    end
+  end
+
+  def self.validate(param,waited_keys)
+    param.is_a?(Hash) && valid_keys?(param,waited_keys) && is_model?(param[:model_name]) && validate_attributes(param[:attributes]) && !validate_argument(param) 
+  end
+
+end

data/lib/dbAccessor/version.rb

@@ -0,0 +1,3 @@
+module DbAccessor
+  VERSION = "0.0.7"
+end

data/lib/dbAccessor/writer/writer.rb

@@ -0,0 +1,70 @@
+require_relative '../../../spec/feed/resources/environment'
+require_relative '../base'
+
+class DbAccessor::Writer < Db_Accessor::Base
+
+  USER_MODEL = 'User'
+  APP_MODEL  = 'Application'
+
+  def self.write_object(object_param)
+    waited_keys =[:model_name,:content]
+    if validate(object_param,waited_keys)
+      @given_object = get_object(object_param)
+      @given_object.save
+      !@given_object.new_record? ? code = 201 : code = 400
+      return_response(code,"Success") 
+    else
+       return_response(400,"Failed")
+    end
+  end
+
+private ######################################################################
+
+  def self.get_content(object_param)
+    object_param[:content]
+  end
+
+  def self.get_object(object_param)
+    get_model_name(object_param).new(get_content(object_param))
+  end
+ 
+  def self.validate_required_params(param)
+      content = param[:content]
+      model_name = param[:model_name]
+      if model_name == 'User'
+      email_pattern = /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i
+      content[:login].is_a?(String) && content[:password].is_a?(String) && content[:email].is_a?(String) && !(email_pattern.match(content[:email])).nil? 
+      elsif model_name == 'Application'
+          content[:name].is_a?(String) && content[:api_key].is_a?(String) && content[:url].is_a?(String)
+      else
+          false
+      end
+  end
+
+   
+  def self.validate(param,waited_keys)
+     valid_hash?(param) && valid_keys?(param,waited_keys) && is_model?(param[:model_name]) && valid_object_columns?(param[:model_name],param[:content]) && !validate_argument(param) && !validate_argument(param[:content]) && validate_required_params(param)
+  end
+
+
+
+ end 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/lib/dbAccessor.rb

@@ -0,0 +1,20 @@
+require "dbAccessor/version"
+require "dbAccessor/writer/writer"
+require "dbAccessor/reader/reader"
+require "dbAccessor/updater/updater"
+require "dbAccessor/deleter/deleter"
+
+module DbAccessor
+  
+    class Writer
+    end
+
+    class Reader
+    end
+
+    class Updater
+    end
+
+    class Deleter
+    end
+end

data/spec/deleter_spec.rb

@@ -0,0 +1,90 @@
+require_relative 'spec_helper'
+
+describe DbAccessor::Deleter do	
+
+  describe ".delete_all" do
+	given_param = { model_name: "User",condition: {id: 5}}
+    context "when the object is deleted" do
+		it {expect((DbAccessor::Deleter.delete_all(given_param))[:code]).to eq 200 }
+
+		it {expect((DbAccessor::Deleter.delete_all({model_name: "Application",condition: {name: 'Wikia'}}))[:code]).to eq 200 }
+      
+		it {expect((DbAccessor::Deleter.delete_all({model_name: "User",condition: {login: 'fabira',password: 'passera'}}))[:code]).to eq 200 }
+	end
+
+    context "when the conditon format is not valid" do
+        param = {model_name: "User",condition: {ta: 1}}
+
+		it {expect((DbAccessor::Deleter.delete_all(param))[:code]).to eq 400 }
+
+        param[:condition] = "coucou"
+		it {expect((DbAccessor::Deleter.delete_all(param))[:code]).to eq 400 }
+
+        param[:condition] = nil
+		it {expect((DbAccessor::Deleter.delete_all(param))[:code]).to eq 400 }
+
+        param[:condition] = {login: 1}
+		it {expect((DbAccessor::Deleter.delete_all(param))[:code]).to eq 400 }
+
+        param[:model_name] = "Application"
+        param[:condition] = {login: 'fabi'}
+		it {expect((DbAccessor::Deleter.delete_all(param))[:code]).to eq 400 }
+	end
+
+    context "when model name is invalid" do
+		it {expect((DbAccessor::Deleter.delete_all({model_name: "A",condition: {}}))[:code]).to eq 400 }
+	end
+
+    context "when one of the parameter's keys is invalid" do
+		it {expect((DbAccessor::Deleter.delete_all({model: "User",condition: {}}))[:code]).to eq 400 }
+	end
+
+	context "when the object which satisfy the given condition is deleted" do
+		it {expect((DbAccessor::Deleter.delete_all({model_name: "User",condition: {id: 4}}))[:code]).to eq 200 }
+
+		it {expect((DbAccessor::Deleter.delete_all({model_name: "Application",condition: {id: 4}}))[:code]).to eq 200 }	
+	end
+  
+    context "when one or many parameters are empty or nil" do
+        it {expect((DbAccessor::Deleter.delete_all({model_name: nil,condition: {id: 3}}))[:code]).to eq 400 }
+    end
+
+  end
+
+  describe ".delete_by_id" do
+      context "when the object find by id is deleted" do
+      given_param={model_name: "Application", id: [4]}
+	  it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 200 }
+
+      given_param={model_name: "User", id: [4]}
+	  it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 200 }
+	end 
+
+    context "when the id's format is invalid" do
+      given_param={model_name: "User", id: "coucou"}
+	  it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 400 }
+	end 
+
+
+    context "when one or many parameters are empty or nil" do 
+        given_param={model_name: "User", id: nil}
+        it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 400 }
+    end
+
+    context "when the model name is invalid" do 
+        given_param={model_name: "U3466", id: [1,2,3]}
+        it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 400 }
+    end
+
+    context "when parameter's keys are invalid" do 
+        given_param={model_name: "User", i: [1,2] }
+        it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 400 }
+        given_param = {model: "Application",id: [5]} 
+        it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 400 }
+    end
+
+    context "when the parameter is nil" do  
+        it {expect((DbAccessor::Deleter.delete_by_id(nil))[:code]).to eq 400 }
+    end
+  end
+end

data/spec/feed/dbTest/migration/add_deleted_to_utilisateur.rb

@@ -0,0 +1 @@
+ActiveRecord::Migration.add_column :utilisateurs, :deleted, :boolean, default: false

data/spec/feed/dbTest/migration/create_table_actions.rb

@@ -0,0 +1,6 @@
+ActiveRecord::Migration.create_table :actions do |t|
+  t.belongs_to :utilisateur
+  t.belongs_to :item
+  t.string :name
+  t.timestamps
+end