tentd 0.0.1

data/lib/tentd/datamapper/query.rb

@@ -0,0 +1,19 @@
+require 'dm-core/query'
+
+module DataMapper
+  class Query
+    private
+
+    def get_relative_position(offset, limit)
+      self_offset = self.offset
+      self_limit  = self.limit
+      new_offset  = self_offset + offset
+
+      if limit < 0 || offset < 0
+        raise RangeError, "offset #{offset} and limit #{limit} are outside allowed range"
+      end
+
+      return new_offset, limit
+    end
+  end
+end

data/lib/tentd/json_patch.rb

@@ -0,0 +1,181 @@
+module TentD
+  class JsonPatch
+    OPERATIONS = %w( add remove replace move copy test )
+
+    class HashPointer
+      class Error < ::StandardError
+      end
+
+      class InvalidPointer < Error
+      end
+
+      def initialize(hash, pointer)
+        @hash, @pointer = hash, pointer
+      end
+
+      def value
+        keys.inject(@hash) do |obj, key|
+          if obj.kind_of?(Array)
+            raise InvalidPointer if key.to_i >= obj.size
+            obj[key.to_i]
+          elsif obj.kind_of?(Hash)
+            raise InvalidPointer unless obj.has_key?(key)
+            obj[key]
+          else
+            raise InvalidPointer
+          end
+        end
+      end
+
+      def value=(value)
+        if exists? && value_class == Array && keys.last !~ /^\d+$/
+          raise InvalidPointer
+        end
+        obj = keys[0..-2].inject(@hash) do |obj, key|
+          obj[key] = {} unless [Hash, Array].include?(obj[key].class)
+          obj[key]
+        end
+        if obj.kind_of?(Array)
+          obj.insert(keys.last.to_i, value)
+        else
+          obj[keys.last] = value
+        end
+      end
+
+      def delete
+        obj = keys[0..-2].inject(@hash) do |obj, key|
+          obj[key]
+        end
+        if obj.kind_of?(Array)
+          raise InvalidPointer if keys.last.to_i >= obj.size
+          obj.delete_at(keys.last.to_i)
+        else
+          raise InvalidPointer unless obj.has_key?(keys.last)
+          obj.delete(keys.last)
+        end
+      end
+
+      def move_to(pointer)
+        _value = value
+        to_pointer = self.class.new(@hash, pointer)
+        if value_class == Array && to_pointer.value_class == Array && to_pointer.keys.last !~ /^\d+$/
+          raise InvalidPointer
+        end
+        delete
+        to_pointer.value = _value
+      end
+
+      def exists?
+        i = 0
+        keys.inject(@hash) do |obj, key|
+          # points to a key that doesn't exist
+          break unless obj
+
+          if obj.kind_of?(Array)
+            return key.to_i < obj.size
+          end
+
+          return true if obj.kind_of?(Hash) && i == keys.size-1 && obj.has_key?(key)
+
+          return false if obj[key].nil?
+
+          return true if ![Hash, Array].include?(obj[key].class)
+
+          i += 1
+          obj[key]
+        end
+        false
+      end
+
+      def value_class
+        i = 0
+        keys.inject(@hash) do |obj, key|
+          return unless obj
+
+          return Array if obj.kind_of?(Array)
+          return Hash if i == keys.size-1 && obj[key].kind_of?(Hash)
+
+          i += 1
+          obj[key]
+        end
+      end
+
+      def keys
+        @pointer.sub(%r{^/}, '').split("/").map do |key|
+          unescape_key(key)
+        end
+      end
+
+      def unescape_key(key)
+        key.gsub(/~1/, '/').gsub(/~0/, '~')
+      end
+    end
+
+    class Error < ::StandardError
+    end
+
+    class ObjectExists < Error
+    end
+
+    class ObjectNotFound < Error
+    end
+
+    class << self
+      def merge(object, patch)
+        patch.each do |patch_object|
+          operation = OPERATIONS.find { |key| !patch_object[key].nil? }
+          send(operation, object, patch_object)
+        end
+        object
+      end
+
+      def add(object, patch_object)
+        pointer = HashPointer.new(object, patch_object["add"])
+        if pointer.exists?
+          raise ObjectExists unless pointer.value_class == Array
+        end
+        pointer.value = patch_object["value"]
+        object
+      rescue HashPointer::InvalidPointer => e
+        raise ObjectExists
+      end
+
+      def remove(object, patch_object)
+        pointer = HashPointer.new(object, patch_object["remove"])
+        pointer.delete
+        object
+      rescue HashPointer::InvalidPointer => e
+        raise ObjectNotFound
+      end
+
+      def replace(object, patch_object)
+        pointer = HashPointer.new(object, patch_object["replace"])
+        pointer.delete
+        pointer.value = patch_object["value"]
+        object
+      rescue HashPointer::InvalidPointer => e
+        raise ObjectNotFound
+      end
+
+      def move(object, patch_object)
+        pointer = HashPointer.new(object, patch_object["move"])
+        pointer.move_to patch_object["to"]
+      rescue HashPointer::InvalidPointer => e
+        raise ObjectNotFound
+      end
+
+      def copy(object, patch_object)
+        from_pointer = HashPointer.new(object, patch_object["copy"])
+        add(object, { "add" => patch_object["to"], "value" => from_pointer.value })
+      rescue HashPointer::InvalidPointer => e
+        raise ObjectNotFound
+      end
+
+      def test(object, patch_object)
+        pointer = HashPointer.new(object, patch_object["test"])
+        raise ObjectNotFound unless pointer.exists?
+        raise ObjectNotFound unless pointer.value == patch_object["value"]
+      end
+    end
+  end
+end

data/lib/tentd/model.rb

@@ -0,0 +1,30 @@
+require 'jdbc/postgres' if RUBY_ENGINE == 'jruby'
+require 'data_mapper'
+require 'dm-ar-finders'
+require 'tentd/datamapper/array_property'
+require 'tentd/datamapper/query'
+
+module TentD
+  module Model
+    require 'tentd/model/permissible'
+    require 'tentd/model/serializable'
+    require 'tentd/model/random_public_id'
+    require 'tentd/model/type_properties'
+    require 'tentd/model/user_scoped'
+    require 'tentd/model/mention'
+    require 'tentd/model/post'
+    require 'tentd/model/post_version'
+    require 'tentd/model/post_attachment'
+    require 'tentd/model/follower'
+    require 'tentd/model/following'
+    require 'tentd/model/app'
+    require 'tentd/model/app_authorization'
+    require 'tentd/model/notification_subscription'
+    require 'tentd/model/profile_info'
+    require 'tentd/model/group'
+    require 'tentd/model/permission'
+    require 'tentd/model/user'
+  end
+end
+
+DataMapper.finalize

data/lib/tentd/model/app.rb

@@ -0,0 +1,68 @@
+require 'securerandom'
+require 'tentd/core_ext/hash/slice'
+
+module TentD
+  module Model
+    class App
+      include DataMapper::Resource
+      include RandomPublicId
+      include Serializable
+      include UserScoped
+
+      storage_names[:default] = 'apps'
+
+      property :id, Serial
+      property :name, Text, :required => true, :lazy => false
+      property :description, Text, :lazy => false
+      property :url, Text, :required => true, :lazy => false
+      property :icon, Text, :lazy => false
+      property :redirect_uris, Array, :lazy => false, :default => []
+      property :scopes, Json, :default => {}, :lazy => false
+      property :mac_key_id, String, :default => lambda { |*args| 'a:' + SecureRandom.hex(4) }, :unique => true
+      property :mac_key, String, :default => lambda { |*args| SecureRandom.hex(16) }
+      property :mac_algorithm, String, :default => 'hmac-sha-256'
+      property :mac_timestamp_delta, Integer
+      property :created_at, DateTime
+      property :updated_at, DateTime
+      property :deleted_at, ParanoidDateTime
+
+      has n, :authorizations, 'TentD::Model::AppAuthorization', :constraint => :destroy
+      has n, :posts, 'TentD::Model::Post', :constraint => :set_nil
+      has n, :post_versions, 'TentD::Model::PostVersion', :constraint => :set_nil
+
+      def self.create_from_params(params)
+        create(params.slice(:name, :description, :url, :icon, :redirect_uris, :scopes))
+      end
+
+      def self.update_from_params(id, params)
+        app = first(:id => id)
+        return unless app
+        app.update(params.slice(:name, :description, :url, :icon, :redirect_uris, :scopes))
+        app
+      end
+
+      def self.public_attributes
+        [:name, :description, :url, :icon, :scopes, :redirect_uris]
+      end
+
+      def auth_details
+        attributes.slice(:mac_key_id, :mac_key, :mac_algorithm)
+      end
+
+      def as_json(options = {})
+        attributes = super
+
+        if options[:mac]
+          [:mac_key, :mac_key_id, :mac_algorithm].each { |key|
+            attributes[key] = send(key)
+          }
+        end
+
+        attributes[:authorizations] = authorizations.all.map { |a| a.as_json(options.merge(:self => nil)) }
+
+        Array(options[:exclude]).each { |k| attributes.delete(k) if k }
+        attributes
+      end
+    end
+  end
+end

data/lib/tentd/model/app_authorization.rb

@@ -0,0 +1,113 @@
+require 'securerandom'
+require 'tentd/core_ext/hash/slice'
+
+module TentD
+  module Model
+    class AppAuthorization
+      include DataMapper::Resource
+      include RandomPublicId
+      include Serializable
+
+      storage_names[:default] = 'app_authorizations'
+
+      property :id, Serial
+      property :post_types, Array, :lazy => false, :default => []
+      property :profile_info_types, Array, :default => [], :lazy => false
+      property :scopes, Array, :default => [], :lazy => false
+      property :token_code, String, :default => lambda { |*args| SecureRandom.hex(16) }, :unique => true
+      property :mac_key_id, String, :default => lambda { |*args| 'u:' + SecureRandom.hex(4) }, :unique => true
+      property :mac_key, String, :default => lambda { |*args| SecureRandom.hex(16) }
+      property :mac_algorithm, String, :default => 'hmac-sha-256'
+      property :mac_timestamp_delta, Integer
+      property :notification_url, Text, :lazy => false
+      property :follow_url, Text, :lazy => false
+      property :created_at, DateTime
+      property :updated_at, DateTime
+
+      belongs_to :app, 'TentD::Model::App'
+      has n, :notification_subscriptions, 'TentD::Model::NotificationSubscription', :constraint => :destroy
+
+      before :save do
+        if scopes.to_a.map(&:to_s).include?('follow_ui') && follow_url
+          _auths = self.class.all(:follow_url.not => nil, :id.not => id)
+          _auths.each { |a| a.update(:scopes => a.scopes - ['follow_ui']) }
+        end
+        self.notification_url = nil if notification_url.to_s == ''
+      end
+
+      def auth_details
+        attributes.slice(:mac_key_id, :mac_key, :mac_algorithm)
+      end
+
+      def notification_servers
+        nil
+      end
+
+      def notification_path
+        notification_url
+      end
+
+      def self.public_attributes
+        [:post_types, :profile_info_types, :scopes, :notification_url]
+      end
+
+      def self.create_from_params(data)
+        authorization = create(data)
+
+        if data[:notification_url]
+          data[:post_types].each do |type|
+            authorization.notification_subscriptions.create(:type => type)
+          end
+        end
+
+        authorization
+      end
+
+      def self.follow_url(entity)
+        app_auth = all(:follow_url.not => nil).find { |a| a.scopes.map(&:to_sym).include?(:follow_ui) }
+        return unless app_auth
+        uri = URI(app_auth.follow_url)
+        query = "entity=#{URI.encode_www_form_component(entity)}"
+        uri.query ? uri.query += "&#{query}" : uri.query = query
+        uri.to_s
+      end
+
+      def update_from_params(data)
+        _post_types = post_types
+
+        saved = update(data.slice(:post_types, :profile_info_types, :scopes, :notification_url))
+
+        if saved && data[:post_types] && data[:post_types] != _post_types
+          notification_subscriptions.all(:type_base.not => post_types.map { |t| TentType.new(t).base }).destroy
+
+          data[:post_types].map { |t| TentType.new(t) }.each do |type|
+            next if notification_subscriptions.first(:type_base => type.base)
+            notification_subscriptions.create(:type_base => type.base, :type_version => type.version, :type_view => type.view)
+          end
+        end
+
+        saved
+      end
+
+      def token_exchange!
+        update(:token_code => SecureRandom.hex(16))
+        {
+          :access_token => mac_key_id,
+          :mac_key => mac_key,
+          :mac_algorithm => mac_algorithm,
+          :token_type => 'mac'
+        }
+      end
+
+      def as_json(options = {})
+        attributes = super
+
+        if options[:authorization_token]
+          attributes[:token_code] = token_code
+        end
+
+        attributes
+      end
+    end
+  end
+end

data/lib/tentd/model/follower.rb

@@ -0,0 +1,105 @@
+require 'tentd/core_ext/hash/slice'
+require 'securerandom'
+
+module TentD
+  module Model
+    class Follower
+      include DataMapper::Resource
+      include Permissible
+      include RandomPublicId
+      include Serializable
+      include UserScoped
+
+      storage_names[:default] = 'followers'
+
+      property :id, Serial
+      property :groups, Array, :lazy => false, :default => []
+      property :entity, Text, :required => true, :lazy => false
+      property :public, Boolean, :default => true
+      property :profile, Json, :default => {}
+      property :licenses, Array, :lazy => false, :default => []
+      property :notification_path, Text, :lazy => false, :required => true
+      property :mac_key_id, String, :default => lambda { |*args| 's:' + SecureRandom.hex(4) }, :unique => true
+      property :mac_key, String, :default => lambda { |*args| SecureRandom.hex(16) }
+      property :mac_algorithm, String, :default => 'hmac-sha-256'
+      property :mac_timestamp_delta, Integer
+      property :created_at, DateTime
+      property :updated_at, DateTime
+      property :deleted_at, ParanoidDateTime
+
+      has n, :notification_subscriptions, 'TentD::Model::NotificationSubscription', :constraint => :destroy
+
+      # permissions describing who can see them
+      has n, :visibility_permissions, 'TentD::Model::Permission', :child_key => [ :follower_visibility_id ], :constraint => :destroy
+
+      # permissions describing what they have access to
+      has n, :access_permissions, 'TentD::Model::Permission', :child_key => [ :follower_access_id ], :constraint => :destroy
+
+      def self.create_follower(data, authorized_scopes = [])
+        if authorized_scopes.include?(:write_followers) && authorized_scopes.include?(:write_secrets)
+          follower = create(data.slice(:entity, :groups, :public, :profile, :licenses, :notification_path, :mac_key_id, :mac_key, :mac_algorithm, :mac_timestamp_delta))
+        else
+          follower = create(data.slice('entity', 'licenses', 'profile', 'notification_path'))
+        end
+        (data.types || ['all']).each do |type_url|
+          follower.notification_subscriptions.create(:type => type_url)
+        end
+        follower
+      end
+
+      def self.update_follower(id, data, authorized_scopes = [])
+        follower = first(:id => id)
+        return unless follower
+        whitelist = ['licenses']
+        if authorized_scopes.include?(:write_followers)
+          whitelist.concat(['entity', 'profile', 'public', 'groups'])
+
+          if authorized_scopes.include?(:write_secrets)
+            whitelist.concat(['mac_key_id', 'mac_key', 'mac_algorithm', 'mac_timestamp_delta'])
+          end
+        end
+        follower.update(data.slice(*whitelist))
+        if data['types']
+          follower.notification_subscriptions.destroy
+          data['types'].each do |type_url|
+            follower.notification_subscriptions.create(:type => type_url)
+          end
+        end
+        follower
+      end
+
+      def self.public_attributes
+        [:entity]
+      end
+
+      def permissible_foreign_key
+        :follower_access_id
+      end
+
+      def core_profile
+        API::CoreProfileData.new(profile)
+      end
+
+      def notification_servers
+        core_profile.servers
+      end
+
+      def auth_details
+        attributes.slice(:mac_key_id, :mac_key, :mac_algorithm)
+      end
+
+      def as_json(options = {})
+        attributes = super
+
+        attributes.merge!(:profile => profile) if options[:app]
+
+        if options[:app] || options[:self]
+          types = notification_subscriptions.all.map { |s| s.type.uri }
+          attributes.merge!(:licenses => licenses, :types => types)
+        end
+
+        attributes
+      end
+    end
+  end
+end