graph_starter 0.0.1

data/app/assets/stylesheets/graph_starter/application.scss

@@ -0,0 +1,9 @@
+/*
+ *= require_self
+ */
+
+@import "semantic-ui";
+
+#menu {
+  margin-top: 0;
+}

data/app/controllers/graph_starter/application_controller.rb

@@ -0,0 +1,11 @@
+module GraphStarter
+  class ApplicationController < ::ApplicationController
+
+    protected
+
+    def model_class
+      @model_slug = params[:model_slug]
+      @model_slug.classify.constantize
+    end    
+  end
+end

data/app/controllers/graph_starter/assets_controller.rb

@@ -0,0 +1,76 @@
+module GraphStarter
+  class AssetsController < ::GraphStarter::ApplicationController
+    def home
+    end
+
+    def index
+      @assets = asset_set
+    end
+
+    def search
+      regexp = Regexp.new('.*' + params[:query].gsub(/\s+/, '.*') + '.*', 'i')
+      assets = asset_set { |scope| scope.where(title: regexp) }
+      results_data = assets.map do |asset|
+        {
+          title: asset.title,
+          url: asset_path(id: asset, model_slug: asset.class.model_slug),
+          image: images? && asset.first_image_source && asset.first_image_source.url || nil
+        }.reject {|_, v| v.nil? }
+      end
+
+      render json: {results: results_data}.to_json
+    end
+
+    def asset_set
+      associations = []
+      associations << :images if images?
+      associations << model_class.category_association if model_class.category_association
+
+      scope = model_class_scope
+      scope = yield scope if block_given?
+
+      scope = scope.limit(50)
+
+      if associations.present?
+        scope.query_as(:s).with(:s).proxy_as(model_class_scope.model, :s).with_associations(*associations)
+      else
+        scope
+      end
+    end
+
+    def show
+      @asset = asset
+
+      render file: 'public/404.html', status: :not_found, layout: false if !@asset
+    end
+
+    def edit
+      @asset = asset
+
+      render file: 'public/404.html', status: :not_found, layout: false if !@asset
+    end
+
+    def update
+      @asset = asset
+      @asset.update(params[:book])
+
+      redirect_to action: :edit
+    end
+
+    def asset
+      model_class_scope.find(params[:id])
+    end
+
+    def images?
+      model_class_scope.has_images?
+    end
+
+    def model_class_scope
+      @model_class_scope = if defined?(current_user)
+        model_class.authorized_for(current_user)
+      else
+        model_class.all
+      end
+    end
+  end
+end

data/app/controllers/graph_starter/authorizables_controller.rb

@@ -0,0 +1,47 @@
+module GraphStarter
+  class AuthorizablesController < ApplicationController
+    before_action :require_admin
+
+    before_action :set_object, only: [:show, :update]
+
+    def show
+    end
+
+    def update
+      @object.update_attribute(:private, params[:private])
+
+      @object.set_access_levels User,
+                                access_levels_from_permissions(params[:user_permissions], :user)
+
+      @object.set_access_levels Group,
+                                access_levels_from_permissions(params[:group_permissions], :group)
+
+      render :show
+    end
+
+    def access_levels_from_permissions(permissions, type)
+      (permissions || []).each_with_object({}) do |permission, result|
+        result[permission[type][:id]] = permission[:level]
+      end
+    end
+
+    def user_and_group_search
+      @users, @groups = if params[:query].present?
+
+                          [User.for_query(params[:query]), Group.for_query(params[:query])]
+                        else
+                          [[], []]
+                        end
+    end
+
+    def change_permissions_modal
+      render layout: false
+    end
+
+    private
+
+    def set_object
+      @object = model_class.find(params[:id])
+    end
+  end
+end

data/app/controllers/graph_starter/categories_controller.rb

@@ -0,0 +1,79 @@
+module GraphStarter
+  class CategoriesController < ApplicationController
+    before_action :set_category, only: [:show, :edit, :update, :destroy]
+
+    # GET /categories
+    # GET /categories.json
+    def index
+      @categories = Category.all
+    end
+
+    # GET /categories/1
+    # GET /categories/1.json
+    def show
+    end
+
+    # GET /categories/new
+    def new
+      @category = Category.new
+    end
+
+    # GET /categories/1/edit
+    def edit
+    end
+
+    # POST /categories
+    # POST /categories.json
+    def create
+      @category = Category.new(category_params)
+
+      respond_to do |format|
+        if @category.save
+          format.html { redirect_to @category, notice: 'Category was successfully created.' }
+          format.json { render :show, status: :created, location: @category }
+        else
+          format.html { render :new }
+          format.json { render json: @category.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # PATCH/PUT /categories/1
+    # PATCH/PUT /categories/1.json
+    def update
+      respond_to do |format|
+        if @category.update(category_params)
+          format.html { redirect_to @category, notice: 'Category was successfully updated.' }
+          format.json { render :show, status: :ok, location: @category }
+        else
+          format.html { render :edit }
+          format.json { render json: @category.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # DELETE /categories/1
+    # DELETE /categories/1.json
+    def destroy
+      @category.destroy
+      respond_to do |format|
+        format.html do
+          redirect_to categories_url, notice: 'Category was successfully destroyed.'
+        end
+        format.json { head :no_content }
+      end
+    end
+
+    private
+
+    # Use callbacks to share common setup or constraints between actions.
+    def set_category
+      @category = Category.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def category_params
+      params[:category]
+    end
+  end
+end

data/app/controllers/graph_starter/groups_controller.rb

@@ -0,0 +1,85 @@
+module GraphStarter
+  class GroupsController < ApplicationController
+    before_action :require_admin
+
+    before_action :set_group, only: [:show, :edit, :update, :destroy, :users_to_add]
+
+    # GET /groups
+    # GET /groups.json
+    def index
+      @groups = Group.roots
+    end
+
+    # GET /groups/1
+    # GET /groups/1.json
+    def show
+    end
+
+    # GET /groups/new
+    def new
+      @group = Group.new
+    end
+
+    # GET /groups/1/edit
+    def edit
+    end
+
+    # POST /groups
+    # POST /groups.json
+    def create
+      @group = Group.new(group_params)
+
+      respond_to do |format|
+        if @group.save
+          format.html { redirect_to @group, notice: 'Group was successfully created.' }
+          format.json { render :show, status: :created, location: @group }
+        else
+          format.html { render :new }
+          format.json { render json: @group.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # PATCH/PUT /groups/1
+    # PATCH/PUT /groups/1.json
+    def update
+      respond_to do |format|
+        if @group.update(group_params)
+          format.html { redirect_to @group, notice: 'Group was successfully updated.' }
+          format.json { render :show, status: :ok, location: @group }
+        else
+          format.html { render :edit }
+          format.json { render json: @group.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # DELETE /groups/1
+    # DELETE /groups/1.json
+    def destroy
+      @group.destroy
+      respond_to do |format|
+        format.html { redirect_to groups_url, notice: 'Group was successfully destroyed.' }
+        format.json { head :no_content }
+      end
+    end
+
+    def users_to_add
+      render json: @group.addable_users
+    end
+
+    private
+
+    # Use callbacks to share common setup or constraints between actions.
+    def set_group
+      @group = Group.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def group_params
+      params[:group][:member_ids].reject!(&:blank?)
+
+      params[:group]
+    end
+  end
+end

data/app/controllers/graph_starter/models_controller.rb

@@ -0,0 +1,11 @@
+module GraphStarter
+  class ModelsController < ApplicationController
+    def index
+      @models = Model.all
+    end
+
+    def show
+      @model = Model.find_by(name: params[:name])
+    end
+  end
+end

data/app/controllers/graph_starter/properties_controller.rb

@@ -0,0 +1,11 @@
+module GraphStarter
+  class PropertiesController < ApplicationController
+    def index
+      @properties = Property.all
+    end
+
+    def show
+      @property = Property.find(params[:id])
+    end
+  end
+end

data/app/helpers/graph_starter/application_helper.rb

@@ -0,0 +1,11 @@
+module GraphStarter
+  module ApplicationHelper
+    def asset_path(asset)
+      super(id: asset, model_slug: asset.class.model_slug)
+    end
+
+    def engine_view(&b)
+       yield eval("__FILE__.gsub(Rails.root.to_s, GraphStarter::Engine.root.to_s)",b.binding) 
+    end    
+  end
+end

data/app/models/concerns/graph_starter/authorizable.rb

@@ -0,0 +1,30 @@
+module GraphStarter
+  module Authorizable
+    extend ActiveSupport::Concern
+
+    included do
+      property :private, type: ActiveAttr::Typecasting::Boolean, default: false
+      validates :private, inclusion: {in: [true, false]}
+
+      has_many :in, :allowed_users, rel_class: :CanAccess, model_class: :User
+      has_many :in, :allowed_groups, rel_class: :CanAccess, model_class: :Group
+    end
+
+    def set_access_levels(model, access_levels)
+      records_by_id = model.where(id: access_levels.keys).index_by(&:id)
+
+      model.where_not(id: records_by_id.keys)
+        .query_as(:r)
+        .match_nodes(this: self)
+        .match('r-[rel:CAN_ACCESS]->(this)')
+        .delete(:rel).exec
+
+      access_levels.each do |id, level|
+        CanAccess.create(from_node: records_by_id[id], to_node: self, level: level)
+      end
+    end
+
+    module ClassMethods
+    end
+  end
+end

data/app/models/graph_starter/asset.rb

@@ -0,0 +1,161 @@
+require 'graph_starter/query_authorizer'
+
+module GraphStarter
+  class Asset
+    include Neo4j::ActiveNode
+    self.mapped_label_name = 'Asset'
+
+    include Neo4j::Timestamps
+
+    include Authorizable
+
+    property :title
+    validates :title, presence: true
+
+    property :summary
+
+    property :view_count, type: Integer
+
+    property :private, type: Boolean, default: false
+
+    #has_many :in, :creators, type: :CREATED, model_class: :User
+
+    has_many :in, :viewers, rel_class: :View, model_class: :User
+
+    SecretSauceRecommendation = Struct.new(:asset, :score)
+
+    def body
+    end
+
+    IMAGE_MODELS = []
+    def self.has_images
+      GraphStarter::Asset::IMAGE_MODELS << self
+      has_many :out, :images, type: :HAS_IMAGE, model_class: '::GraphStarter::Image'
+    end
+
+    def self.has_images?
+      GraphStarter::Asset::IMAGE_MODELS.include?(self)
+    end
+
+    def first_image_source
+      images.first && images.first.source
+    end 
+
+    def self.category_association
+      @category_association
+    end
+
+    def self.category_association=(association_name)
+      @category_association = association_name
+    end
+
+    def categories
+      if self.class.category_association
+        send(self.class.category_association)
+      else
+        []
+      end
+    end
+
+
+    def self.for_query(query)
+      all.where(title: /.*#{query}.*/i)
+    end
+
+    def secret_sauce_recommendations
+      query_as(:source)
+        .match('source-[:HAS_CATEGORY]->(category:Category)<-[:HAS_CATEGORY]-(asset:Asset)')
+        .break
+        .optional_match('source<-[:CREATED]-(creator:User)-[:CREATED]->asset')
+        .break
+        .optional_match('source<-[:VIEWED]-(viewer:User)-[:VIEWED]->asset')
+        .limit(5)
+        .order('score DESC')
+        .pluck(
+          :asset,
+          '(count(category) * 2) +
+           (count(creator) * 4) +
+           (count(viewer) * 0.1) AS score').map do |other_asset, score|
+        SecretSauceRecommendation.new(other_asset, score)
+      end
+    end
+
+    def name
+      title
+    end
+
+    def as_json(_options = {})
+      {self.class.model_slug =>
+        {id: id,
+         title: title,
+         name: title,
+         images: images.map {|image| image.source.url },
+         model_slug: self.class.model_slug}
+       }
+    end
+
+    def self.descendants
+      Rails.application.eager_load! if Rails.env == 'development'
+      Neo4j::ActiveNode::Labels._wrapped_classes.select { |klass| klass < self }
+    end
+
+    def self.model_slug
+      name.tableize
+    end
+
+    def self.properties
+      attributes.keys - Asset.attributes.keys
+    end
+
+    def self.authorized_for(user)
+      require 'graph_starter/query_authorizer'
+
+      ::GraphStarter::QueryAuthorizer.new(all(:asset).categories(:category, nil, optional: true))
+        .authorized_query([:asset, :category], user)
+        .with('DISTINCT asset AS asset')
+        .proxy_as(self, :asset)
+    end
+
+    def self.authorized_properties(user)
+      authorized_properties_query(user).pluck(:property)
+    end
+
+    def self.authorized_properties_and_levels(user)
+      authorized_properties_query(user).pluck(:property, :level)
+    end
+
+    def self.authorized_properties_query(user)
+      query = property_name_and_uuid_and_ruby_type_query
+              .merge(model: {Model: {name: name}})
+              .on_create_set(model: {private: false})
+              .break
+              .merge('model-[:HAS_PROPERTY]->(property:Property {name: property_name})')
+              .on_create_set(property: {private: false})
+              .on_create_set('property.uuid = uuid, property.ruby_type = ruby_type')
+              .with(:property)
+
+      ::GraphStarter::Property # rubocop:disable Lint/Void
+      QueryAuthorizer.new(query).authorized_query(:property, user)
+    end
+
+    def self.property_name_and_uuid_and_ruby_type_query
+      properties_and_uuids_and_ruby_types = properties.map do |property|
+        [property, SecureRandom.uuid, self.attributes[property][:type]]
+      end
+
+      Neo4j::Session.current.query
+        .with('{array} AS array')
+        .unwind('array AS row')
+        .params(array: properties_and_uuids_and_ruby_types)
+        .with('row[0] AS property_name, row[1] AS uuid, row[2] AS ruby_type')
+    end
+
+    def self.authorized_associations
+      associations.except(*Asset.associations.keys + [:images])
+    end
+
+    def self.icon_class
+      'bookmark'
+    end
+  end
+end