tentd 0.0.1

data/lib/tentd/model/post.rb

@@ -0,0 +1,178 @@
+require 'securerandom'
+
+module TentD
+  module Model
+    class Post
+      include DataMapper::Resource
+      include Permissible
+      include RandomPublicId
+      include Serializable
+      include TypeProperties
+      include UserScoped
+
+      storage_names[:default] = "posts"
+
+      property :id, Serial
+      property :entity, Text, :lazy => false, :unique_index => :upublic_id
+      property :public, Boolean, :default => false
+      property :licenses, Array, :default => []
+      property :content, Json, :default => {}
+      property :views, Json, :default => {}
+      property :published_at, DateTime, :default => lambda { |*args| Time.now }
+      property :received_at, DateTime, :default => lambda { |*args| Time.now }
+      property :updated_at, DateTime
+      property :deleted_at, ParanoidDateTime
+      property :app_name, Text, :lazy => false
+      property :app_url, Text, :lazy => false
+      property :original, Boolean, :default => false
+
+      has n, :permissions, 'TentD::Model::Permission', :constraint => :destroy
+      has n, :attachments, 'TentD::Model::PostAttachment', :constraint => :destroy
+      has n, :mentions, 'TentD::Model::Mention', :constraint => :destroy
+      belongs_to :app, 'TentD::Model::App', :required => false
+      belongs_to :following, 'TentD::Model::Following', :required => false
+
+      has n, :versions, 'TentD::Model::PostVersion', :constraint => :destroy
+
+      after :create, :create_version!
+
+      def create_version!(post = self)
+        attrs = post.attributes
+        attrs.delete(:id)
+        latest = post.versions.all(:order => :version.desc, :fields => [:version]).first
+        attrs[:version] = latest ? latest.version + 1 : 1
+        version = post.versions.create(attrs)
+      end
+
+      def latest_version(options = {})
+        versions.all({ :order => :version.desc }.merge(options)).first
+      end
+
+      def update(data)
+        mentions = data.delete(:mentions)
+        last_version = latest_version(:fields => [:id])
+        res = super(data)
+
+        create_version! # after update hook doe not fire
+
+        current_version = latest_version(:fields => [:id])
+
+        if mentions.to_a.any?
+          Mention.all(:post_id => self.id).update(:post_id => nil, :post_version_id => last_version.id)
+          mentions.each do |mention|
+            next unless mention[:entity]
+            self.mentions.create(:entity => mention[:entity], :mentioned_post_id => mention[:post], :post_version_id => current_version.id)
+          end
+        end
+
+        res
+      end
+
+      def self.create(data)
+        mentions = data.delete(:mentions)
+        post = super(data)
+
+        mentions.to_a.each do |mention|
+          next unless mention[:entity]
+          post.mentions.create(:entity => mention[:entity], :mentioned_post_id => mention[:post], :post_version_id => post.latest_version(:fields => [:id]).id)
+        end
+
+        if post.mentions.to_a.any? && post.original
+          post.mentions.each do |mention|
+            follower = Follower.first(:entity => mention.entity)
+            next if follower && NotificationSubscription.first(:follower => follower, :type_base => post.type.base)
+
+            Notifications.notify_entity(:entity => mention.entity, :post_id => post.id)
+          end
+        end
+
+        post
+      end
+
+      def self.fetch_with_permissions(params, current_auth)
+        super do |params, query, query_bindings|
+          if params.since_time
+            query << "AND posts.published_at > ?"
+            query_bindings << Time.at(params.since_time.to_i)
+          end
+
+          if params.before_time
+            query << "AND posts.published_at < ?"
+            query_bindings << Time.at(params.before_time.to_i)
+          end
+
+          if params.post_types
+            params.post_types = params.post_types.split(',').map { |url| URI.unescape(url) }
+            if params.post_types.any?
+              query << "AND posts.type_base IN ?"
+              query_bindings << params.post_types.map { |t| TentType.new(t).base }
+            end
+          end
+
+          if params.mentioned_post && params.mentioned_entity
+            select = query.shift
+            query.unshift "INNER JOIN mentions ON mentions.post_id = posts.id"
+            query.unshift select
+
+            query << "AND mentions.entity = ? AND mentions.mentioned_post_id = ?"
+            query_bindings << params.mentioned_entity
+            query_bindings << params.mentioned_post
+          end
+
+          unless params.return_count
+            query << "ORDER BY posts.published_at DESC"
+          end
+        end
+      end
+
+      def self.public_attributes
+        [:app_name, :app_url, :entity, :type, :licenses, :content, :published_at]
+      end
+
+      def self.write_attributes
+        public_attributes + [:following_id, :original, :public, :mentions, :views]
+      end
+
+      def can_notify?(app_or_follow)
+        return true if public && original
+        case app_or_follow
+        when AppAuthorization
+          app_or_follow.scopes && app_or_follow.scopes.map(&:to_sym).include?(:read_posts) ||
+          app_or_follow.post_types && app_or_follow.post_types.include?(type.base)
+        when Follower
+          return false unless original
+          q = permissions.all(:follower_access_id => app_or_follow.id)
+          q += permissions.all(:group_public_id => app_or_follow.groups) if app_or_follow.groups.any?
+          q.any?
+        when Following
+          return false unless original
+          q = permissions.all(:following => app_or_follow)
+          q += permissions.all(:group_public_id => app_or_follow.groups) if app_or_follow.groups.any?
+          q.any?
+        else
+          false
+        end
+      end
+
+      def as_json(options = {})
+        attributes = super
+        attributes[:type] = type.uri
+        attributes[:version] = latest_version(:fields => [:version]).version
+        attributes[:app] = { :url => attributes.delete(:app_url), :name => attributes.delete(:app_name) }
+
+        attributes[:mentions] = mentions.map do |mention|
+          h = { :entity => mention.entity }
+          h[:post] = mention.mentioned_post_id if mention.mentioned_post_id
+          h
+        end
+
+        if options[:app]
+          attributes[:following_id] = following.public_id if following
+        end
+
+        Array(options[:exclude]).each { |k| attributes.delete(k) if k }
+        attributes
+      end
+    end
+  end
+end

data/lib/tentd/model/post_attachment.rb

@@ -0,0 +1,27 @@
+module TentD
+  module Model
+    class PostAttachment
+      include DataMapper::Resource
+
+      storage_names[:default] = "post_attachments"
+
+      property :id, Serial
+      property :type, Text, :required => true, :lazy => false
+      property :category, Text, :required => true, :lazy => false
+      property :name, Text, :required => true, :lazy => false
+      property :data, Text, :required => true
+      property :size, Integer, :required => true
+      timestamps :at
+
+      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? }
+
+      def as_json(options = {})
+        super({ :exclude => [:id, :data, :post_id, :created_at, :updated_at] }.merge(options))
+      end
+    end
+  end
+end

data/lib/tentd/model/post_version.rb

@@ -0,0 +1,64 @@
+module TentD
+  module Model
+    class PostVersion
+      include DataMapper::Resource
+      include Permissible
+      include Serializable
+      include TypeProperties
+      include UserScoped
+
+      storage_names[:default] = "post_versions"
+
+      belongs_to :post, 'TentD::Model::Post', :required => true
+      property :version, Integer, :required => true
+
+      property :id, Serial
+      property :entity, Text, :lazy => false
+      property :public_id, String, :required => true
+      property :public, Boolean, :default => false
+      property :licenses, Array, :default => []
+      property :content, Json, :default => {}
+      property :views, Json, :default => {}
+      property :published_at, DateTime, :default => lambda { |*args| Time.now }
+      property :received_at, DateTime, :default => lambda { |*args| Time.now }
+      property :updated_at, DateTime
+      property :deleted_at, ParanoidDateTime
+      property :app_name, Text, :lazy => false
+      property :app_url, Text, :lazy => false
+      property :original, Boolean, :default => false
+
+      has n, :attachments, 'TentD::Model::PostAttachment', :constraint => :destroy
+      has n, :mentions, 'TentD::Model::Mention', :constraint => :destroy
+      belongs_to :app, 'TentD::Model::App', :required => false
+      belongs_to :following, 'TentD::Model::Following', :required => false
+
+      def self.public_attributes
+        Post.public_attributes
+      end
+
+      def as_json(options = {})
+        attributes = super
+        post_attrs = post.as_json(options)
+
+        attributes[:type] = type.uri
+        attributes[:version] = version
+        attributes[:app] = { :url => attributes.delete(:app_url), :name => attributes.delete(:app_name) }
+
+        attributes[:mentions] = mentions.map do |mention|
+          h = { :entity => mention.entity }
+          h[:post] = mention.mentioned_post_id if mention.mentioned_post_id
+          h
+        end
+
+        if options[:app]
+          attributes[:following_id] = following.public_id if following
+        end
+
+        attributes[:permissions] = post_attrs[:permissions]
+
+        Array(options[:exclude]).each { |k| attributes.delete(k) if k }
+        attributes
+      end
+    end
+  end
+end

data/lib/tentd/model/profile_info.rb

@@ -0,0 +1,80 @@
+require 'hashie'
+
+module TentD
+  module Model
+    class ProfileInfo
+      include DataMapper::Resource
+      include TypeProperties
+      include UserScoped
+      include Permissible
+
+      TENT_PROFILE_TYPE_URI = 'https://tent.io/types/info/core/v0.1.0'
+      TENT_PROFILE_TYPE = TentType.new(TENT_PROFILE_TYPE_URI)
+
+      self.raise_on_save_failure = true
+
+      storage_names[:default] = 'profile_info'
+
+      property :id, Serial
+      property :public, Boolean, :default => false
+      property :content, Json, :default => {}, :lazy => false
+      property :created_at, DateTime
+      property :updated_at, DateTime
+      property :deleted_at, ParanoidDateTime
+
+      has n, :permissions, 'TentD::Model::Permission'
+
+
+      def self.tent_info
+        first(:type_base => TENT_PROFILE_TYPE.base, :order => :type_version.desc) || Hashie::Mash.new
+      end
+
+      def self.get_profile(authorized_scopes = [], current_auth = nil)
+        h = if (authorized_scopes.include?(:read_profile) || authorized_scopes.include?(:write_profile)) && current_auth.respond_to?(:profile_info_types)
+          current_auth.profile_info_types.include?('all') ? all : all(:type_base => current_auth.profile_info_types.map { |t| TentType.new(t).base }) + all(:public => true)
+        else
+          fetch_with_permissions({}, current_auth)
+        end.inject({}) do |memo, info|
+          memo[info.type.uri] = info.content.merge(:permissions => info.permissions_json(authorized_scopes.include?(:read_permissions)))
+          memo
+        end
+        h
+      end
+
+      def self.update_profile(type, data)
+        data = Hashie::Mash.new(data) unless data.kind_of?(Hashie::Mash)
+        type = TentType.new(type)
+        perms = data.delete(:permissions)
+        if (infos = all(:type_base => type.base)) && (info = infos.pop)
+          infos.to_a.each(&:destroy)
+          info.type = type
+          info.public = data.delete(:public)
+          info.content = data
+          info.save
+        else
+          info = create(:type => type, :public => data.delete(:public), :content => data)
+        end
+        info.assign_permissions(perms)
+        info
+      end
+
+      def self.create_update_post(id)
+        first(:id => id).create_update_post
+      end
+
+      def create_update_post
+        post = user.posts.create(
+          :type => 'https://tent.io/types/post/profile/v0.1.0',
+          :entity => user.profile_entity,
+          :original => true,
+          :content => {
+            :action => 'update',
+            :types => [self.type.uri],
+          }
+        )
+        Permission.copy(self, post)
+        Notifications.trigger(:type => post.type.uri, :post_id => post.id)
+      end
+    end
+  end
+end

data/lib/tentd/model/random_public_id.rb

@@ -0,0 +1,46 @@
+module TentD
+  module Model
+    module RandomPublicId
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.class_eval do
+          property :public_id, String, :required => true, :unique_index => :upublic_id, :default => lambda { |*args| random_id }
+          self.raise_on_save_failure = true
+        end
+      end
+
+      module ClassMethods
+        def random_id
+          rand(36 ** 6).to_s(36)
+        end
+      end
+
+      private
+
+#      TODO: Debug DataMapper state issue
+#      # catch unique public_id validation and generate a new one
+#      def assert_save_successful(*args)
+#        super
+#      rescue DataMapper::SaveFailureError
+#        if self.class.all(:public_id => self.public_id).any?
+#          self.public_id = self.class.random_id
+#          save
+#        else
+#          raise
+#        end
+#      end
+#
+#      # catch db unique constraint on public_id and generate a new one
+#      def _persist
+#        super
+#      rescue DataObjects::IntegrityError
+#        if self.class.all(:public_id => self.public_id).any?
+#          self.public_id = self.class.random_id
+#          save
+#        else
+#          raise
+#        end
+#      end
+    end
+  end
+end

data/lib/tentd/model/serializable.rb

@@ -0,0 +1,58 @@
+module TentD
+  module Model
+    module Serializable
+      def as_json(options = {})
+        attributes = super(:only => self.class.public_attributes)
+        attributes.merge!(:permissions => permissions_json(options[:permissions])) if respond_to?(:permissions_json)
+        attributes[:id] = respond_to?(:public_id) ? public_id : id
+
+        if options[:app]
+          [:created_at, :updated_at, :published_at, :received_at].each { |key|
+            attributes[key] = send(key) if respond_to?(key)
+          }
+        end
+
+        [:published_at, :updated_at, :created_at, :received_at].each do |key|
+          attributes[key] = attributes[key].to_time.to_i if attributes[key].respond_to?(:to_time)
+        end
+
+        mac_fields = [:mac_key_id, :mac_key, :mac_algorithm]
+        if options[:mac] && mac_fields.select { |k| respond_to?(k) }.size == mac_fields.size
+          mac_fields.each { |k| attributes[k] = send(k) }
+        end
+
+        if options[:groups] && respond_to?(:groups)
+          attributes[:groups] = groups.to_a.uniq
+        end
+
+        if relationships.map(&:name).include?(:attachments)
+          if options[:view] && respond_to?(:views) && (conditions = (views[options[:view]] || {})['attachments'])
+            conditions.map! { |c| c.slice('category', 'name', 'type') }.reject! { |c| c.empty? }
+            attributes[:attachments] = conditions.inject(nil) { |memo, c|
+              q = attachments.all(c)
+              memo ? memo += q : q
+            }
+          else
+            attributes[:attachments] = attachments.all.map { |a| a.as_json } unless options[:view] == 'meta'
+          end
+        end
+
+        if options[:view] && respond_to?(:views) && respond_to?(:content)
+          if keypaths = (views[options[:view]] || {})['content']
+            attributes[:content] = keypaths.inject({}) do |memo, keypath|
+              pointer = JsonPatch::HashPointer.new(content, keypath)
+              memo[pointer.keys.last] = pointer.exists? ? pointer.value : nil
+              memo
+            end
+          elsif options[:view] == 'meta'
+            attributes.delete(:content)
+          elsif options[:view] != 'full'
+            attributes[:content] = {}
+          end
+        end
+
+        attributes
+      end
+    end
+  end
+end