wolas_channel 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8f14856471b65c461e0f74f8305a2e0af55bd35d
-  data.tar.gz: a06f9887cbd0c3e170650e4b85d0ac05b16044d6
+  metadata.gz: 55de7197e5d2e624f3972aef8e06e325a6357348
+  data.tar.gz: de983cb3a62ea09cb43665e0c2db6223b4f6bd50
 SHA512:
-  metadata.gz: 3c4cfb2ecd0fdb89d32c9b5650267184299aac3e48b562ff0c7fdaffe2921106dcea1a908676d86c0348c930954a19cbbfbd9d78c762ad80477c0487e35302a1
-  data.tar.gz: 0f9fff9a385468d4fd99c5b1578de207bc32b95f1d3b0d83f904b97ea933d46ecfc202891aab21cf555c2948121f923cebc9c2246a80b5643fe5e61087025c07
+  metadata.gz: afc89a3a1262dbd2716b27124c4ad9217255a14131cbdbc7f69750076bbc139199af2c9057a6ec75a9f5103858cf4a293cd90e12ad66269770413da97d9ae29e
+  data.tar.gz: 938e14b4bc6f7920a12c7e47ecd2ce4947e483c89b67d2255c3daf1e077be4d788d260ee6fa07a1a4fa88f40247f1d8a7b2182275b00aac6444f96b8ab421b1f

data/lib/wolas_channel/version.rb

@@ -1,3 +1,3 @@
 class WolasChannel
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/wolas_channel.rb

@@ -8,6 +8,11 @@ module ErrorHandling
   # This error is raised when a tenant requests a channel that does not belong
   # to their tenant id
   class PermissionFailure < StandardError; end
+  # This error is thrown when an insert request is made on an object without an
+  # identifiable body field
+  class InvalidObject < StandardError; end
+  # This error is thrown when attempting to access a channel that doesn't exist
+  class InvalidChannel < StandardError; end
 end
 
 # This class handles mapping the channel items from and to the database
@@ -26,13 +31,14 @@ class WolasChannel
     begin
       # Connect to the database
       connect = Connection.new.open(@database, @host, @user, @pw)
-      # Generate a UUID for the new channel
-      channel_id = SecureRandom.uuid
 
-      insert = "INSERT INTO `channel`.`channels` (`channel_id`, `tenant_id`, `type`) VALUES (?, ?, ?)"
+      insert = "INSERT INTO `channel`.`channels` (`tenant_id`, `type`) VALUES (?, ?)"
       # This method performs the insert. Mysql2 does not return an object on a successful
       # insert
-      prepare_exe(connect, insert, channel_id, @tenant_id, type)
+      prepare_exe(connect, insert, @tenant_id, type)
+
+      # Return the last id from mysql2 object
+      channel_id = connect.last_id
 
       return { channel_created: channel_id, channel_type: type }
     ensure
@@ -50,11 +56,10 @@ class WolasChannel
       # Determine if the tenant is able to view this entity based off the
       # channel and return the type of the entity
       check = tenant_entity(entity_id)
-      type = check[0]
       return nil if check == [nil, nil]
       
       # Now the entity is requested
-      entity = entity_construct(entity_id, type)
+      entity = entity_construct(entity_id)
       return entity
     ensure
       @connect.close
@@ -74,46 +79,203 @@ class WolasChannel
       return nil if type == nil
       
       # Now the entities are requested
-      ent_q = "SELECT * FROM `channel`.`data` WHERE `data`.`channel_id` = ?"
+      ent_q = "SELECT `entities`.`entity_id`, `entities`.`body`, `entities`.`created`, `entities`.`type` FROM `channel`.`entities` \
+      INNER JOIN `channel`.`channel_entities` on `entities`.`entity_id` = `channel_entities`.`entity_id` \
+      INNER JOIN `channel`.`channels` on `channel_entities`.`channel_id` = `channels`.`channel_id` \
+      WHERE `channels`.`channel_id` = ?"
       ent = prepare_exe(@connect, ent_q, channel_id)
 
-      # Return nil if nothing is returned from the select
+      # And their metadata
+      data_q = "SELECT `data`.`entity_id`, `data`.`key`, `data`.`value` FROM `channel`.`data` \
+      INNER JOIN `channel`.`channel_entities` on `data`.`entity_id` = `channel_entities`.`entity_id` \
+      INNER JOIN `channel`.`channels` on `channel_entities`.`channel_id` = `channels`.`channel_id` \
+      WHERE `channels`.`channel_id` = ?"
+      data = prepare_exe(@connect, data_q, channel_id)
+      # Return nil if nothing is returned from the select from the entities table
       return nil if ent.count == 0
 
       # Construct the object requested using the generic method
-      entitys = object_constructor(ent)
+      entitys = object_constructor(ent, data)
+
+      return entitys
+    ensure
+      @connect.close
+    end
+  end
+
+  # This method returns the 20 most recent entries for a channel
+  def get_channel_recent(channel_id)
+    begin
+      # Connect to the database. Instance variable used to pass connection to
+      # private methods
+      @connect = Connection.new.open(@database, @host, @user, @pw)
+      # Determine if this channel is valid for the tenant and returns its type
+      type = tenant_channel(channel_id)
+      return nil if type == nil
+      
+      # Now the 20 most recent entities are requested 
+      ent_q = "SELECT `entities`.`entity_id`, `entities`.`body`, `entities`.`created`, `entities`.`type` FROM `channel`.`entities` \
+      INNER JOIN `channel`.`channel_entities` on `entities`.`entity_id` = `channel_entities`.`entity_id` \
+      INNER JOIN `channel`.`channels` on `channel_entities`.`channel_id` = `channels`.`channel_id` \
+      WHERE `channels`.`channel_id` = ? \
+      ORDER BY `entities`.`created` DESC LIMIT 20"
+      ent = prepare_exe(@connect, ent_q, channel_id)
+
+      # All meta data is selected for the channel as the entity_ids are unknown.
+      # However any data that does not match an entity id from the query above will
+      # not be inserted anywhere.
+      data_q = "SELECT `data`.`entity_id`, `data`.`key`, `data`.`value` FROM `channel`.`data` \
+      INNER JOIN `channel`.`channel_entities` on `data`.`entity_id` = `channel_entities`.`entity_id` \
+      INNER JOIN `channel`.`channels` on `channel_entities`.`channel_id` = `channels`.`channel_id` \
+      WHERE `channels`.`channel_id` = ?"
+      data = prepare_exe(@connect, data_q, channel_id)
+      # Return nil if nothing is returned from the select from the entities table
+      return nil if ent.count == 0
+
+      # Construct the object requested using the generic method
+      entitys = object_constructor(ent, data)
+
+      return entitys
+    ensure
+      @connect.close
+    end
+  end
+
+  # This method allows an entity to be received by a channel and key/value match
+  def get_channel_kv(channel_id, *kv)
+    begin
+      # Connect to the database. Instance variable used to pass the connection to
+      # private methods
+      @connect = Connection.new.open(@database, @host, @user, @pw)
+      # Determine if the tenant is able to view this entity based off the
+      # channel and return the type of the entity
+      type = tenant_channel(channel_id)
+      return nil if type == nil
+      return nil if kv.length == 0
+      byebug
+
+      # This count determines the number of key / value matches that exist per
+      # entity. If the number of matches equals the number of kvs passed to the 
+      # method, then the search criteria is met and the entity is returned.
+      match_q = "SELECT `entities`.`entity_id`, count(*) AS `matches` FROM `channel`.`entities` \
+      INNER JOIN `channel`.`data` ON `entities`.`entity_id` = `data`.`entity_id` \
+      INNER JOIN `channel`.`channel_entities` ON `data`.`entity_id` = `channel_entities`.`entity_id` \
+      INNER JOIN `channel`.`channels` ON `channel_entities`.`channel_id` = `channels`.`channel_id` \
+      WHERE `channels`.`channel_id` = ? AND ("
+      kv_arr = []
+      kv.each_with_index do |hash, index|
+        if index != kv.length - 1
+          match_q = match_q + "(`data`.`key` = ? AND `data`.`value` = ?) OR "
+        else
+          match_q = match_q + "(`data`.`key` = ? AND `data`.`value` = ?))"
+        end
+        # Push the key followed by the value into the array to match ?s
+        hash[:key] ? kv_arr << hash[:key] : kv_arr << hash['key'] 
+        hash[:value] ? kv_arr << hash[:value] : kv_arr << hash['value'] 
+      end
+      match_q = match_q + "GROUP BY `entities`.`entity_id`"
+      match = prepare_exe(@connect, match_q, channel_id, *kv_arr)
 
-      # Apply the type to each object constructed
-      entitys.each do |ents|
-        ents[:type] = type
+      match_raw = match.map{ |e| e }
+      entity_ids = []
+      # The entity id is only push into the array if the matches count is equal to
+      # the number of key / values used in the search
+      match_raw.each do |hash|
+        if hash['matches'] == kv.length
+          entity_ids << hash['entity_id']
+        end
       end
+
+      # Return nil if nothing is pushed into the entity_ids array 
+      return nil if entity_ids.count == 0
+
+      # Determine the number of question marks required for the in statements,
+      # based of the number of entity_ids 
+      q_marks = in_prepare(entity_ids)
+
+      # Now the entities are requested
+      ent_q = "SELECT `entities`.`entity_id`, `entities`.`body`, `entities`.`created`, `entities`.`type` FROM `channel`.`entities` \
+      INNER JOIN `channel`.`channel_entities` on `entities`.`entity_id` = `channel_entities`.`entity_id` \
+      INNER JOIN `channel`.`channels` on `channel_entities`.`channel_id` = `channels`.`channel_id` \
+      WHERE `channels`.`channel_id` = ? AND `entities`.`entity_id` IN (#{q_marks})"
+      ent = prepare_exe(@connect, ent_q, channel_id, *entity_ids)
+
+      # And their metadata
+      data_q = "SELECT `data`.`entity_id`, `data`.`key`, `data`.`value` FROM `channel`.`data` \
+      INNER JOIN `channel`.`channel_entities` on `data`.`entity_id` = `channel_entities`.`entity_id` \
+      INNER JOIN `channel`.`channels` on `channel_entities`.`channel_id` = `channels`.`channel_id` \
+      WHERE `channels`.`channel_id` = ? AND `data`.`entity_id` IN (#{q_marks})"
+      data = prepare_exe(@connect, data_q, channel_id, *entity_ids)
+
+      # Construct the object requested using the generic method
+      entitys = object_constructor(ent, data)
+
       return entitys
     ensure
       @connect.close
     end
   end
 
-  # This method allows the creation of a new entity against a channel. The tenant
-  # id must match the id of the channel passed or an error is raised
-  def insert_entity(channel_id, obj)
+  # This method allows the creation of a new entity against a channel / channels. 
+  # The tenant id must match the id of the channel passed or an error is raised
+  def insert_entity(obj, *channel_ids)
     begin
       # Connect to the database. Instance variable used to pass connection to
       # private methods
       @connect = Connection.new.open(@database, @host, @user, @pw)
-      # Determine if the tenant has access to the channel requested
-      tenant_channel(channel_id)
+      # Determine if the tenant has access to all channels requested
+      channel_ids.each do |channel_id|
+        tenant_channel(channel_id)
+      end
 
-      # Assign a UUID for the new entity
-      entity_id = SecureRandom.uuid
-      # Now we construct the key / value insert for each pair in the object
-      # passed to the method
+      # Scan object for type, if it doesn't exist, make it equal to default
+      type = obj[:type] || obj['type']
+      unless type
+        type = 'Text'
+      end
+
+      # Throw errors if Video and Image types do not have required field
+      if type == 'Video' || type == 'Image'
+        bucket_key = obj[:bucket_key] || obj['bucket_key']
+        unless bucket_key
+          message = 'A video or image entity object must include an S3 bucketkey'
+          raise ErrorHandling::InvalidObject, message
+        end
+      end
+
+      # Define body and created
+      created = Time.now.utc
+      body = obj[:body] || obj['body']
+      unless body
+        raise ErrorHandling::InvalidObject, 'The entity object must include a body field'
+      end
+
+      insert = "INSERT INTO `channel`.`entities` (`body`, `created`, `type`) VALUES (?, ?, ?)"
+      insert_sql = prepare_exe(@connect, insert, body, created, type)
+      # The last_id mysql2 method provides direct access to the last id inserted
+      entity_id = @connect.last_id
+
+      # Delete body key from object in preparation for k/v insert
+      obj['body'] ? obj.delete('body') : obj.delete(:body)
+
+      # Insert remaining as k/vs, with entity id from above
       obj.each do |key, value|
-        insert = "INSERT INTO `channel`.`data` (`channel_id`, `key`, `value`, `entity_id`)\ 
-        VALUES (?, ?, ?, ?)"
+        insert = "INSERT INTO `channel`.`data` (`key`, `value`, `entity_id`)\ 
+        VALUES (?, ?, ?)"
         # This method performs the insert. Mysql2 does not return an object on a successful
         # insert
-        prepare_exe(@connect, insert, channel_id, key.to_s, value, entity_id)
+        prepare_exe(@connect, insert, key.to_s, value, entity_id)
       end
+
+      # Insert link entries based on channel_ids passed to method
+      channel_ids.each do |channel_id|
+        insert = "INSERT INTO `channel`.`channel_entities` (`channel_id`, `entity_id`)\ 
+        VALUES (?, ?)"
+        # This method performs the insert. Mysql2 does not return an object on a successful
+        # insert
+        prepare_exe(@connect, insert, channel_id, entity_id)
+      end
+
       return { entity_id: entity_id, insert: 'SUCCESS' }
     ensure
       @connect.close
@@ -128,31 +290,39 @@ class WolasChannel
       @connect = Connection.new.open(@database, @host, @user, @pw)
       # Determine if the tenant has access to the entity requested
       check = tenant_entity(entity_id)
-      type = check[0]
-      channel_id = check[1]
-
-      # Lookup the key to be changed on the entity, insert it if it doesn't exist
-      ent_q = "SELECT * FROM `channel`.`data` WHERE `data`.`entity_id` = ? AND `data`.`key` = ?"
-      ent = prepare_exe(@connect, ent_q, entity_id, key)
-
-      if ent.count != 0
-        # update the existing key value
-        update = "UPDATE `channel`.`data` SET `data`.`value`= ? \
-        WHERE `data`.`entity_id` = ? AND `data`.`key` = ?"
-        prepare_exe(@connect, update, value, entity_id, key.to_s)
-
-        # Now that the insert has been completed, the entire object is returned
-        # from the database and constructed to return to the user
-        entity = entity_construct(entity_id, type)
+
+      # If the key requested for the update is the body, the entity itself is updated.
+      # If it is not, the key is searched for in the data table and either updated or
+      # inserted
+      if key == 'body' || key == :body
+        # update the existing entity body
+        update = "UPDATE `channel`.`entities` SET `entities`.`body` = ? WHERE `entities`.`entity_id` = ?"
+        prepare_exe(@connect, update, value, entity_id)
+
+        # Return the updated entity to the
+        entity = entity_construct(entity_id)
       else
-        # insert the new key as it does not exist for the entity
-        insert = "INSERT INTO `channel`.`data` (`channel_id`, `key`, `value`, `entity_id`)\
-        VALUES (?, ?, ?, ?)"
-        prepare_exe(@connect, insert, key.to_s, value, entity_id)
+        # Lookup the key to be changed on the entity, insert it if it doesn't exist
+        ent_q = "SELECT * FROM `channel`.`data` WHERE `data`.`entity_id` = ? AND `data`.`key` = ?"
+        ent = prepare_exe(@connect, ent_q, entity_id, key)
+
+        if ent.count != 0
+          # update the existing key value
+          update = "UPDATE `channel`.`data` SET `data`.`value`= ? \
+          WHERE `data`.`entity_id` = ? AND `data`.`key` = ?"
+          prepare_exe(@connect, update, value, entity_id, key.to_s)
 
-        # Now that the insert has been completed, the entire object is returned
-        # from the database and constructed to return to the user
-        entity = entity_construct(entity_id, type)
+          # Return the updated entity to the
+          entity = entity_construct(entity_id)
+        else
+          # insert the new key as it does not exist for the entity
+          insert = "INSERT INTO `channel`.`data` (`key`, `value`, `entity_id`)\
+          VALUES (?, ?, ?)"
+          prepare_exe(@connect, insert, key.to_s, value, entity_id)
+
+          # Return the updated entity to the
+          entity = entity_construct(entity_id)
+        end
       end
 
       return entity
@@ -161,49 +331,39 @@ class WolasChannel
     end
   end
 
+
   private
   # This method constructs a single object from key-values returned from a 
   # query
-  def object_constructor(ent)
-    # ent is a mysql2 object. This generic map returns an array of the rows
-    entity_raw = ent.map{ |e| e }
-    entity = []
-    @init = false
-    entity_h = {}
-    # This method identifies when the entity id changes, pushes the built hash
-    # to the array and starts a new hash for the new entity id
-    entity_raw.each do |hash|
-      if hash['entity_id'] != @init && @init != false
-        entity_h[:channel_id] = @channel_id
-        entity_h[:entity_id] = @init
-        entity << entity_h
-        entity_h = {}
+  def object_constructor(ent, data)
+    # Build the entity objects from the entity table. Each row will always represent
+    # one entity
+    entity = ent.map{ |e| e }
+    # For each metadata entry, match it to an entity by id and add the key and value
+    data_raw = data.map{ |e| e }
+    data_raw = data_raw.sort_by{ |k| k['entity_id'] }
+    # This method scans the entity array to match on entity id, and then pushed the
+    # key and value to that hash
+    data_raw.each do |hash|
+      match = entity.find {|e| e['entity_id'] == hash['entity_id']}
+      if match
+        match[hash['key']] = hash['value']
       end
-      entity_h[hash['key'].to_sym] = hash['value']
-      # Init is used to determine when to push to the array
-      @init = hash['entity_id']
-      # The resource_id for the current hash is stored and added to the entity
-      # hash before it is finalised and pushed to an array
-      @channel_id = hash['channel_id']
     end
-    # Push the last built hash to the array
-    entity_h[:channel_id] = @channel_id
-    entity_h[:entity_id] = @init
-    entity << entity_h
     return entity
   end
 
   # This method determines the if the channel on an entity is availble to the tenant
   # and returns the type of channel
   def tenant_entity(entity_id)
-    res_q = "SELECT * FROM `channel`.`channels` \
-    INNER JOIN `channel`.`data` ON `channels`.`channel_id` = `data`.`channel_id` \
-    WHERE `data`.`entity_id` = ?"
+    res_q = "SELECT `channels`.`tenant_id`, `channels`.`channel_id`, `channels`.`type` FROM `channel`.`channels` \
+    INNER JOIN `channel`.`channel_entities` ON `channels`.`channel_id` = `channel_entities`.`channel_id` \
+    INNER JOIN `channel`.`entities` ON `channel_entities`.`entity_id` = `entities`.`entity_id` \
+    WHERE `entities`.`entity_id` = ?"
     res = prepare_exe(@connect, res_q, entity_id)
     return [nil, nil] if res.count == 0
 
-    # Check the tenant_id on each row returned. They should all be the same as they
-    # will all join to the same row on the channels table
+    # Check the tenant_id on each row returned
     channels = res.map{ |a| a }
     channels.each do |check|
       unless check['tenant_id'] == @tenant_id
@@ -220,7 +380,9 @@ class WolasChannel
   def tenant_channel(channel_id)
     res_q = "SELECT * FROM `channel`.`channels` WHERE `channels`.`channel_id` = ?"
     res = prepare_exe(@connect, res_q, channel_id)
-    return nil if res.count == 0
+    if res.count == 0
+      raise ErrorHandling::InvalidChannel, 'The channel requested is invalid'
+    end
 
     # Check the tenant_id on each row returned. They should all be the same, and in this
     # instance their should only be one row.
@@ -230,24 +392,23 @@ class WolasChannel
         raise ErrorHandling::PermissionFailure, 'You do not have permission to access information for this tenant'
       end
       @type = check['type']
-      @channel_id = check['channel_id']
     end
     return @type
   end
 
   # This method returns a constructed entity from an entity id
-  def entity_construct(entity_id, type)
-    ent_q = "SELECT * FROM `channel`.`data` WHERE `entity_id` = ?"
+  def entity_construct(entity_id)
+    ent_q = "SELECT * FROM `channel`.`entities` WHERE `entity_id` = ?"
     ent = prepare_exe(@connect, ent_q, entity_id)
 
+    data_q = "SELECT * FROM `channel`.`data` WHERE `entity_id` = ?"
+    data = prepare_exe(@connect, data_q, entity_id)
+
     # Return nil if nothing is returned from the select
     return nil if ent.count == 0
 
     # Construct the object requested using the generic method. 
-    entity = object_constructor(ent)[0]
-
-    # Apply the type to the entity
-    entity[:type] = type
+    entity = object_constructor(ent, data)[0]
     return entity
   end
 
@@ -258,5 +419,20 @@ class WolasChannel
     result = sqlobj.execute(*inputs)
     return result
   end
+
+  # This operation determines the number of question marks to be used for an
+  # IN (), in the SQL prepare statement.
+  def in_prepare(ids)
+    ins = ids.length
+    q_marks = []
+    x = 0
+    while x < ins
+      q_marks << '?'
+      x += 1
+    end
+    # convert ?s array to comma delimited string for IN query
+    q_marks = q_marks.join(',')
+    return q_marks
+  end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wolas_channel
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - WOLAS
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-09-30 00:00:00.000000000 Z
+date: 2015-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -99,7 +99,6 @@ files:
 - lib/connection.rb
 - lib/wolas_channel.rb
 - lib/wolas_channel/version.rb
-- wolas_channel-0.1.0.gem
 - wolas_channel.gemspec
 homepage: https://bitbucket.org/wolas-revolution/srvc-channel
 licenses: []