tentd 0.0.1

data/lib/tentd/model/following.rb

@@ -0,0 +1,100 @@
+require 'tentd/core_ext/hash/slice'
+
+module TentD
+  module Model
+    class Following
+      include DataMapper::Resource
+      include Permissible
+      include RandomPublicId
+      include Serializable
+      include UserScoped
+
+      storage_names[:default] = 'followings'
+
+      property :id, Serial
+      property :remote_id, String
+      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 :mac_key_id, String
+      property :mac_key, String
+      property :mac_algorithm, String
+      property :mac_timestamp_delta, Integer
+      property :created_at, DateTime
+      property :updated_at, DateTime
+      property :deleted_at, ParanoidDateTime
+      property :confirmed, Boolean, :default => true
+
+      has n, :permissions, 'TentD::Model::Permission', :constraint => :destroy
+
+      def confirm_from_params(params)
+        update(
+          :remote_id => params.id,
+          :profile => params.profile || {},
+          :mac_key_id => params.mac_key_id,
+          :mac_key => params.mac_key,
+          :mac_algorithm => params.mac_algorithm,
+          :confirmed => true
+        )
+      end
+
+      def self.public_attributes
+        [:remote_id, :entity]
+      end
+
+      def self.update_profile(id)
+        first(:id => id).update_profile
+      end
+
+      def update_profile
+        client = TentClient.new(core_profile.servers, auth_details.merge(:faraday_adapter => TentD.faraday_adapter))
+        res = client.profile.get
+        if res.status == 200
+          self.profile = res.body
+          self.licenses = core_profile.licenses
+          self.entity = core_profile.entity
+        end
+        save
+        profile
+      end
+
+      def core_profile
+        API::CoreProfileData.new(profile)
+      end
+
+      def notification_path
+        'posts'
+      end
+
+      def notification_servers
+        core_profile.servers
+      end
+
+      def auth_details
+        attributes.slice(:mac_key_id, :mac_key, :mac_algorithm)
+      end
+
+      def update_from_params(params, authorized_scopes = [])
+        whitelist = [:remote_id, :entity, :groups, :public, :licenses, :profile]
+        if authorized_scopes.include?(:write_secrets)
+          whitelist.concat([:mac_key_id, :mac_key, :mac_algorithm, :mac_timestamp_delta])
+        end
+        attributes = params.slice(*whitelist)
+        update(attributes)
+      end
+
+      def as_json(options = {})
+        attributes = super
+
+        if options[:app]
+          attributes[:profile] = profile
+          attributes[:licenses] = licenses
+        end
+
+        attributes
+      end
+    end
+  end
+end

data/lib/tentd/model/group.rb

@@ -0,0 +1,24 @@
+module TentD
+  module Model
+    class Group
+      include DataMapper::Resource
+      include RandomPublicId
+      include Serializable
+      include UserScoped
+
+      storage_names[:default] = "groups"
+
+      property :id, Serial
+      property :name, Text, :required => true, :lazy => false
+      property :created_at, DateTime
+      property :updated_at, DateTime
+      property :deleted_at, ParanoidDateTime
+
+      has n, :permissions, 'TentD::Model::Permission', :constraint => :destroy, :parent_key => :public_id
+
+      def self.public_attributes
+        [:name]
+      end
+    end
+  end
+end

data/lib/tentd/model/mention.rb

@@ -0,0 +1,19 @@
+module TentD
+  module Model
+    class Mention
+      include DataMapper::Resource
+
+      storage_names[:default] = "mentions"
+
+      property :id, Serial
+      property :entity, Text, :lazy => false, :required => true
+      property :mentioned_post_id, String
+
+      belongs_to :post, 'TentD::Model::Post', :required => false
+      belongs_to :post_version, 'TentD::Model::PostVersion', :required => false
+
+      validates_presence_of :post_id, :if => lambda { |m| m.post_version_id.nil? }
+      validates_presence_of :post_version_id, :if => lambda { |m| m.post_id.nil? }
+    end
+  end
+end

data/lib/tentd/model/notification_subscription.rb

@@ -0,0 +1,56 @@
+module TentD
+  module Model
+    class NotificationSubscription
+      include DataMapper::Resource
+      include TypeProperties
+      include UserScoped
+
+      storage_names[:default] = 'notification_subscriptions'
+
+      property :id, Serial
+      property :created_at, DateTime
+      property :updated_at, DateTime
+
+      belongs_to :app_authorization, 'TentD::Model::AppAuthorization', :required => false
+      belongs_to :follower, 'TentD::Model::Follower', :required => false
+
+      def subject
+        app_authorization || follower
+      end
+
+      def self.notify_all(type, post_id)
+        post = Post.first(:id => post_id, :fields => [:id, :original, :public])
+        post.user.notification_subscriptions.all(:type_base => [TentType.new(type).base, 'all'],
+                                                 :fields => [:id, :app_authorization_id, :follower_id]).each do |subscription|
+          next unless post.can_notify?(subscription.subject)
+          Notifications.notify(:subscription_id => subscription.id, :post_id => post_id, :view => subscription.type_view)
+        end
+      end
+
+      def self.notify_entity(entity, post_id, view='full')
+        post = Post.first(:id => post_id)
+        return if post.entity == entity
+        if follow = post.user.followers.first(:entity => entity) || post.user.followings.first(:entity => entity)
+          return unless post.can_notify?(follow)
+          client = TentClient.new(follow.notification_servers, follow.auth_details.merge(:faraday_adapter => TentD.faraday_adapter))
+          path = follow.notification_path
+        else
+          return unless post.public
+          profile, server_url = TentClient.new(nil, :faraday_adapter => TentD.faraday_adapter).discover(entity).get_profile
+          server_urls = API::CoreProfileData.new(profile).servers
+          client = TentClient.new(server_urls, :faraday_adapter => TentD.faraday_adapter)
+          path = 'posts'
+        end
+        client.post.create(post.as_json(:view => view), :url => path)
+      end
+
+      def notify_about(post_id, view='full')
+        post = Post.first(:id => post_id)
+        client = TentClient.new(subject.notification_servers, subject.auth_details.merge(:faraday_adapter => TentD.faraday_adapter))
+        permissions = subject.respond_to?(:scopes) && subject.scopes.include?(:read_permissions)
+        client.post.create(post.as_json(:app => !!app_authorization, :permissions => permissions, :view => view), :url => subject.notification_path)
+      rescue Faraday::Error::ConnectionFailed
+      end
+    end
+  end
+end

data/lib/tentd/model/permissible.rb

@@ -0,0 +1,227 @@
+require 'hashie'
+
+module TentD
+  module Model
+    module Permissible
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def permissions_json(extended = false)
+        if extended
+          groups = []
+          entities = []
+          send(respond_to?(:permissions) ? :permissions : :visibility_permissions).each do |permission|
+            groups << permission.group.public_id if permission.group
+            entities << permission.follower_access.entity if permission.follower_access
+          end
+
+          {
+            :groups => groups.uniq,
+            :entities => Hash[entities.uniq.map { |e| [e, true] }],
+            :public => self.public
+          }
+        else
+          { :public => self.public }
+        end
+      end
+
+      def assign_permissions(permissions)
+        return unless permissions.kind_of?(Hash)
+
+        if permissions.groups && permissions.groups.kind_of?(Array)
+          permissions.groups.each do |g|
+            next unless g.id
+            group = Model::Group.first(:public_id => g.id, :fields => [:id])
+            self.permissions.create(:group => group) if group
+          end
+        end
+
+        if permissions.entities && permissions.entities.kind_of?(Hash)
+          permissions.entities.each do |entity,visible|
+            next unless visible
+            followers = Model::Follower.all(:entity => entity, :fields => [:id])
+            followers.each do |follower|
+              self.permissions.create(:follower_access => follower)
+            end
+            followings = Model::Following.all(:entity => entity, :fields => [:id])
+            followings.each do |following|
+              self.permissions.create(:following => following)
+            end
+          end
+        end
+
+        self.public = permissions.public unless permissions.public.nil?
+      end
+
+      module ClassMethods
+        def query_with_permissions(current_auth, params=Hashie::Mash.new)
+          query = []
+          query_bindings = []
+
+          if params.return_count
+            query << "SELECT COUNT(#{table_name}.*) FROM #{table_name}"
+          else
+            query << "SELECT #{table_name}.* FROM #{table_name}"
+          end
+
+          if current_auth && current_auth.respond_to?(:permissible_foreign_key)
+            query << "LEFT OUTER JOIN permissions ON permissions.#{visibility_permissions_relationship_foreign_key} = #{table_name}.id"
+            query << "AND (permissions.#{current_auth.permissible_foreign_key} = ?"
+            query_bindings << current_auth.id
+            if current_auth.respond_to?(:groups) && current_auth.groups.to_a.any?
+              query << "OR permissions.group_public_id IN ?)"
+              query_bindings << current_auth.groups
+            else
+              query << ")"
+            end
+            query << "WHERE (public = ? OR permissions.#{visibility_permissions_relationship_foreign_key} = #{table_name}.id)"
+            query_bindings << true
+          else
+            query << "WHERE public = ?"
+            query_bindings << true
+          end
+
+          query << "AND user_id = ?"
+          query_bindings << User.current.id
+
+          query << "AND #{table_name}.deleted_at IS NULL"
+
+          if properties[:original]
+            query << "AND original = ?"
+            query_bindings << true
+          end
+
+          if block_given?
+            yield query, query_bindings
+          end
+        end
+
+        def find_with_permissions(id, current_auth)
+          query_with_permissions(current_auth) do |query, query_bindings|
+            query << "AND #{table_name}.id = ?"
+            query_bindings << id
+
+            query << "LIMIT 1"
+
+            records = find_by_sql([query.join(' '), *query_bindings])
+            records.first
+          end
+        end
+
+        def fetch_all(params)
+          params = Hashie::Mash.new(params) unless params.kind_of?(Hashie::Mash)
+
+          query = []
+          query_conditions = []
+          query_bindings = []
+
+          if params.return_count
+            query << "SELECT COUNT(#{table_name}.*) FROM #{table_name}"
+          else
+            query << "SELECT #{table_name}.* FROM #{table_name}"
+          end
+
+          if params.since_id
+            query_conditions << "#{table_name}.id > ?"
+            query_bindings << params.since_id.to_i
+          end
+
+          if params.before_id
+            query_conditions << "#{table_name}.id < ?"
+            query_bindings << params.before_id.to_i
+          end
+
+          if params.entity
+            query_conditions << "#{table_name}.entity IN ?"
+            query_bindings << Array(params.entity)
+          end
+
+          if block_given?
+            yield params, query_conditions, query_bindings
+          end
+
+          query_conditions << "#{table_name}.user_id = ?"
+          query_bindings << User.current.id
+
+          query_conditions << "#{table_name}.deleted_at IS NULL"
+
+          query << "WHERE #{query_conditions.join(' AND ')}"
+
+          unless params.return_count
+            query << "ORDER BY id DESC" unless query.find { |q| q =~ /^order/i }
+
+            query << "LIMIT ?"
+            query_bindings << [(params.limit ? params.limit.to_i : TentD::API::PER_PAGE), TentD::API::MAX_PER_PAGE].min
+          end
+
+          if params.return_count
+            DataMapper.repository(:default).adapter.send(:with_connection) do |connection|
+              connection.create_command(query.join(' ')).execute_reader(*query_bindings).to_a.first['count']
+            end
+          else
+            find_by_sql([query.join(' '), *query_bindings])
+          end
+        end
+
+        def fetch_with_permissions(params, current_auth, &block)
+          params = Hashie::Mash.new(params) unless params.kind_of?(Hashie::Mash)
+
+          query_with_permissions(current_auth, params) do |query, query_bindings|
+            if params.since_id
+              query << "AND #{table_name}.id > ?"
+              query_bindings << params.since_id.to_i
+            end
+
+            if params.before_id
+              query << "AND #{table_name}.id < ?"
+              query_bindings << params.before_id.to_i
+            end
+
+            if params.entity
+              query << "AND #{table_name}.entity IN ?"
+              query_bindings << Array(params.entity)
+            end
+
+            if block_given?
+              yield params, query, query_bindings
+            end
+
+            unless params.return_count
+              query << "ORDER BY id DESC" unless query.find { |q| q =~ /^order/i }
+
+              query << "LIMIT ?"
+              query_bindings << [(params.limit ? params.limit.to_i : TentD::API::PER_PAGE), TentD::API::MAX_PER_PAGE].min
+            end
+
+            if params.return_count
+              DataMapper.repository(:default).adapter.send(:with_connection) do |connection|
+                connection.create_command(query.join(' ')).execute_reader(*query_bindings).to_a.first['count']
+              end
+            else
+              find_by_sql([query.join(' '), *query_bindings])
+            end
+          end
+        end
+
+        protected
+
+        def table_name
+          storage_names[repository_name]
+        end
+
+        def permissions_relationship_name
+          relationships.map(&:name).include?(:access_permissions) ? :access_permissions : :permissions
+        end
+
+        def permissions_relationship_foreign_key
+          send(permissions_relationship_name).relationships.first.child_key.first.name
+        end
+
+        def visibility_permissions_relationship_foreign_key
+          relationships.map(&:name).include?(:visibility_permissions) ? visibility_permissions.relationships.first.child_key.first.name : permissions_relationship_foreign_key
+        end
+      end
+    end
+  end
+end

data/lib/tentd/model/permission.rb

@@ -0,0 +1,28 @@
+module TentD
+  module Model
+    class Permission
+      include DataMapper::Resource
+
+      storage_names[:default] = "permissions"
+
+      belongs_to :post, 'TentD::Model::Post', :required => false
+      belongs_to :group, 'TentD::Model::Group', :required => false, :parent_key => :public_id
+      belongs_to :following, 'TentD::Model::Following', :required => false
+      belongs_to :follower_visibility, 'TentD::Model::Follower', :required => false
+      belongs_to :follower_access, 'TentD::Model::Follower', :required => false
+      belongs_to :profile_info, 'TentD::Model::ProfileInfo', :required => false
+
+      property :id, Serial
+      property :visible, Boolean, :default => true
+
+      def self.copy(from, to)
+        from.permissions.each do |permission|
+          attrs = permission.attributes
+          attrs.delete(:id)
+          to.permissions.create(attrs)
+        end
+        to.update(:public => from.public)
+      end
+    end
+  end
+end