koda 0.0.8

data/lib/helpers/app_helper.rb

@@ -0,0 +1,40 @@
+require 'sinatra'
+
+#
+# Application Helpers
+#
+#  The last line of a method is always the return value
+#
+#  here you can define any helper methods that are available to your routes and your views
+#  
+#  -----------------------------------------------------
+#  To create a helper method that returns something
+#
+#  def my_method
+#    'something'
+#  end
+#
+#  def my_method(param1, param2)
+#     # remember to use doublequotes. single quotes will force a string
+#     "using variables in strings #{param1}, #{param2}"
+#  end
+#  
+#  use other helpers
+#  
+#  def is_user_logged_in?  
+#    # there are loads of helpers in /koda/helpers that you could use
+#    logged_in?
+#  end
+#
+
+helpers do
+  
+  def style_link(path)
+    "<link rel=\"StyleSheet\" href=\"#{path}\" type=\"text/css\">"
+  end
+  
+  def script_link(path)
+    "<script src=\"#{path}\"></script>"
+  end
+  
+end

data/lib/helpers/koda_helper.rb

@@ -0,0 +1,105 @@
+require 'sinatra'
+
+require 'json'
+require 'dalli'
+require 'uri'
+require 'net/https'
+
+helpers do
+    
+  def fetch_linked_docs doc
+    if(doc)
+
+      koda_doc_links = doc['_koda_doc_links']
+      if(doc && koda_doc_links && koda_doc_links != '')
+  
+        doc_links = koda_doc_links.split(',')
+        doc['includes'] = []
+
+        doc_links.each do |doc_link|
+          begin
+            if(doc_link.include? 'http')
+              doc_to_include = JSON.parse(get_raw_from_external URI(doc_link))
+            else
+              if(doc_link.include? '/search/')
+                doc_to_include = JSON.parse(get_raw "#{doc_link}")
+              else
+                doc_to_include = JSON.parse(get_raw "#{doc_link}?include=false")
+              end
+            end
+            rescue Exception => e  
+              doc_to_include = {'failed' => e.message}
+            end
+
+          key = doc.stripped_document.select{|k,v| v==doc_link}.map{|k,v| k}.first()
+          
+          if(doc_to_include)
+            linked_doc_item = {
+              'ref' => key,
+              'document' => doc_to_include
+            }
+            doc['includes'].push linked_doc_item
+          end
+        end
+
+      end
+
+    end
+  end
+  
+  def current_user 
+    UserContext.current_user
+  end
+  
+  def logged_in?
+    @uap.logged_in?
+  end
+  
+  def is_admin?
+    @uap.is_admin?
+  end
+  
+  def is_allowed?(action, collection_name)
+    @uap.is_allowed? action, collection_name
+  end
+  
+  def is_public_read? collection_name
+    @uap.is_public_read? collection_name
+  end
+  
+  def log_out
+    @uap.log_out
+  end
+  
+  def is_allowed_in_console?
+    @uap.is_allowed_in_console?
+  end
+  
+  def is_allowed_in_explorer?
+    @uap.is_allowed_in_explorer?
+  end
+  
+  def sign_in_return_url
+    if settings.environment == :development
+      "#{request.host}:#{request.port}"
+    else
+      "#{request.host}"
+    end
+  end
+  
+  def get_raw(url)     
+      http = Net::HTTP.new(request.host, request.port)
+      request = Net::HTTP::Get.new(url)
+      response = http.request(request)
+      response.body
+  end
+  
+  def get_raw_from_external(uri)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true if uri.to_s.include? 'https'
+      request = Net::HTTP::Get.new("#{uri.path}?#{uri.query}")
+      response = http.request(request)
+      response.body
+  end
+  
+end

data/lib/helpers/view_helper.rb

@@ -0,0 +1,146 @@
+require 'json'
+require 'dalli'
+require 'uri'
+require 'rest_client'
+
+def show_koda(template, locals={})
+  content_type :html
+  options = {:layout => false}.merge(settings.view_options)
+  template = template_for "koda/views/#{template}.#{settings.view_format}"
+  render(settings.view_format, template, options, locals)
+end
+
+def show_system(template, locals={})
+  content_type :html
+  options = {:layout => false}.merge(settings.view_options)
+  template = system_view "#{template}.#{settings.view_format}"
+  render(settings.view_format, template, options, locals)
+end
+
+def show(template, locals={})
+  content_type :html
+  options = {:layout => true}.merge(settings.view_options)
+  
+  @content = get_from_cache
+  
+  template = template_for "views/#{template}.#{settings.view_format}"
+  render(settings.view_format, template, settings.view_options, locals)
+end
+
+def render_partial(template, locals={})
+  template = template_for "views/#{template}.#{settings.view_format}"
+  options = {:layout => false}.merge(settings.view_options)
+
+  @content = get_from_cache
+
+  content_type :html
+  render(settings.view_format, template, settings.view_options, locals)
+end
+
+def render_doc(doc)
+  return "<p>No content has yet been added...</p>\n" if(doc == nil)
+  result = "<dl id='#{doc.alias}'>\n" 
+  doc.delete 'alias'
+
+  doc.each do |k,v|
+    if(v.to_s.include? '_koda_media')
+      result += "<img src='#{v}' title='#{k}' \>\n"
+    else
+      result += "<dt>#{k}</dt><dd>#{v}</dd>\n"
+    end
+  end  
+  
+  result += "</dl>"
+  result
+end
+
+def model
+  @content
+end
+
+def safe(fallback='')
+  begin
+    return yield
+  rescue
+    fallback
+  end
+end
+
+def create_content
+
+  content = @db_wrapper.flat_file
+  
+  if(content)
+
+    content.each do |collection|
+
+      collection_obj = {}
+
+      collection['docs'].each do |doc|
+        k = doc['alias'].gsub(/-/,'_')
+        v = doc.to_obj
+
+        collection_obj.instance_variable_set("@#{k}", v)
+        collection_obj.class.send(:define_method, k, proc{self.instance_variable_get("@#{k}")})
+      end
+    
+      collection_obj.class.send(:define_method, "all", proc{self.instance_variables.map {|name| instance_variable_get name }})
+      collection_obj.class.send(:define_method, "where", proc{|&block| self.instance_variables.map {|name| instance_variable_get name }.select{ |o| block.call o}})
+      collection_obj.class.send(:define_method, "single", proc{|&block| self.instance_variables.map {|name| instance_variable_get name }.select{ |o| block.call o}.first})
+      collection_obj.class.send(:define_method, "by_ref", proc{|ref| self.instance_variables.map {|name| instance_variable_get name }.select{ |o| ref.include? o.alias}.first})
+    
+      collection_k = collection['collection']
+      collection_v = collection_obj
+    
+      content.instance_variable_set("@#{collection_k}", collection_v)
+      content.class.send(:define_method, collection_k, proc{self.instance_variable_get("@#{collection_k}")})
+    
+    end  
+  
+    return content
+  
+  end
+  
+  {}
+
+end
+
+def refresh_cache(time_to_live=settings.long_ttl)
+  key = "full_cache"
+
+  if(settings.enable_cache)
+    settings.cache.delete key
+    settings.cache.set(key, create_content, ttl=time_to_live+rand(100))
+  end
+end
+
+def get_from_cache(time_to_live=settings.long_ttl)
+
+  key = "full_cache"
+
+  if(!settings.enable_cache)
+    return create_content
+  end
+
+  if(settings.cache.get(key) == nil)
+    settings.cache.set(key, create_content, ttl=time_to_live+rand(100))
+  end
+
+  return settings.cache.get(key)
+
+end
+
+private
+
+def template_for(path)
+  return nil  unless File.exists?(path)
+  File.open(path) { |f| f.read }
+end
+
+alias user_view template_for
+
+
+def system_view(path)
+  path = File.dirname(__FILE__)+ '/../views/' + path.to_s
+  template_for path
+end

data/lib/koda.rb

@@ -0,0 +1,123 @@
+require 'mongo'
+require 'sinatra'
+require 'json'
+require 'sinatra/jsonp'
+require 'rack-methodoverride-with-params'
+require 'erb'
+require 'net/http'
+require 'rest_client'
+require 'dalli'
+
+#
+#  Register all models
+#
+Dir[File.dirname(__FILE__) + "/models/*.rb"].each {|file| require file }
+
+#
+#  Register Routes (don't fiddle with the order)
+#
+require File.join(File.dirname(__FILE__), %w[/routes/koda_api.rb])
+require File.join(File.dirname(__FILE__), %w[/routes/koda_site.rb])
+
+#
+#   Register other helpers and routes
+#
+Dir[File.dirname(__FILE__) + "/helpers/*.rb"].each {|file| require file }
+
+
+#
+#   Main Sinatra Application Class
+#
+class KodaApp
+
+  use Rack::MethodOverrideWithParams
+
+  configure do
+    class << Sinatra::Base
+      def options(path, opts={}, &block)
+        route 'OPTIONS', path, opts, &block
+      end
+    end
+    Sinatra::Delegator.delegate :options
+  end
+
+  before do
+    content_type :json
+    response['Access-Control-Allow-Origin'] = '*'
+    response['Access-Control-Allow-Methods'] = 'PUT, DELETE, GET, POST, HEADER, OPTIONS'
+    response['Access-Control-Allow-Headers'] = 'content-type'
+
+    if (@env['HTTP_CACHE_CONTROL'] == 'no-cache')
+      response['Cache-Control'] = 'no-cache'
+      response['Pragma'] = 'no-cache'
+      expires = -1
+    end
+
+    #
+    #  If you need to add database configuration other than local or mongolab
+    #  Edit the MongoConfig class
+    #
+    db = MongoConfig::GetMongoDatabase()
+    @db_wrapper = MongoDatabase.new db
+    @grid_wrapper = MongoGrid.new(MongoConfig::GetGridFS(), @db_wrapper.collection('_koda_meta'))
+
+    #
+    #   Initialise the Usercontext and set the default UserAccessProvider
+    #
+    UserContext.user_bag = session
+    @uap = UserAccessProvider.new(@db_wrapper)
+
+  end
+
+end
+
+
+
+set :protection, :except => [:remote_token, :frame_options, :json_csrf]
+set :public_folder, File.dirname(__FILE__) + '/public'
+
+# --------------------------------------------------------------------------
+# Sinatra View Options (don't modify)
+# --------------------------------------------------------------------------
+set :view_format, :erb
+set :view_options, { :escape_html => true }
+
+# --------------------------------------------------------------------------
+# This is a workaround for Cedar apps where production ENV var not being set
+# Please create an environment var on Heroku and set it to production
+# --------------------------------------------------------------------------
+if ENV['ENVIRONMENT']
+  set :environment, ENV['ENVIRONMENT']
+end
+
+# --------------------------------------------------------------------------
+# Cache documents until they are changed (recommended for production)
+# To Use, set this env var to true
+# --------------------------------------------------------------------------
+if ENV['ENABLE_CACHE']
+  set :enable_cache, ENV['ENABLE_CACHE']
+else
+  set :enable_cache, false
+end
+
+# --------------------------------------------------------------------------
+# Sign up to Janrain Engage and paste your api key here
+# --------------------------------------------------------------------------
+set :janrain_api_key, "6c7c4318166d62ad9416231aedca6385e7d7978f"
+
+# --------------------------------------------------------------------------
+# Dalli (memcache) settings
+# --------------------------------------------------------------------------
+set :cache, Dalli::Client.new
+set :short_ttl, 400
+set :long_ttl, 4600
+
+# --------------------------------------------------------------------------
+# This is needed for janrain auth
+# --------------------------------------------------------------------------
+set :sessions, true
+
+# --------------------------------------------------------------------------
+# This is so shotgun keeps session vars
+# --------------------------------------------------------------------------
+set :session_secret, "something"

data/lib/models/hash.rb

@@ -0,0 +1,29 @@
+class ::Hash
+
+  # add keys to hash
+  def to_obj
+    self.each do |k,v|
+      if v.kind_of? Hash
+        v.to_obj
+      end
+      k=k.gsub(/\.|\s|-|\/|\'/, '_').downcase.to_sym
+
+      ## create and initialize an instance variable for this key/value pair
+      self.instance_variable_set("@#{k}", v)
+
+      ## create the getter that returns the instance variable
+      self.class.send(:define_method, k, proc{self.instance_variable_get("@#{k}")})
+
+      ## create the setter that sets the instance variable
+      self.class.send(:define_method, "#{k}=", proc{|v| self.instance_variable_set("@#{k}", v)})
+    end
+    return self
+  end
+  
+  def method_missing(name)
+    return self[name] if key? name
+    self.each { |k,v| return v if k.to_s.to_sym == name }
+    super.method_missing name
+  end
+  
+end

data/lib/models/mongo_collection.rb

@@ -0,0 +1,144 @@
+require File.join(File.dirname(__FILE__), %w[mongo_document])
+require 'time'
+
+class MongoCollection
+  def initialize collection
+    @collection = collection
+  end
+
+  def resource_urls
+    @collection.find.map{|doc| (create_document_wrapper doc).url}
+  end
+
+  def resource_links take=nil, skip=nil, sort=nil
+    resource_links_from_docs @collection.find({},build_options(take, skip, sort)).map
+  end
+  
+  def resource_links_no_hidden take=nil, skip=nil, sort=nil
+    resource_links_from_docs @collection.find({ '$or'=> [{'_koda_hidden_file'=>nil},{'_koda_hidden_file'=>false}] },build_options(take, skip, sort)).map
+  end
+  
+  def content_links take=nil, skip=nil, sort=nil
+    content_links_from_docs @collection.find({ '$or'=> [{'_koda_hidden_file'=>nil},{'_koda_hidden_file'=>false}] },build_options(take, skip, sort)).map
+  end
+
+  def find_document doc_ref
+    doc = create_document_wrapper @collection.find_one("alias"=>doc_ref)
+    if (doc == nil)
+      begin
+        bsonid = BSON::ObjectId.from_string doc_ref
+        doc = create_document_wrapper @collection.find_one(bsonid)
+      rescue
+      end
+    end
+
+    doc
+  end
+
+  def query query_map, take=nil, skip=nil, sort=nil
+    content_links_from_docs @collection.find(query_map, build_options(take, skip, sort))
+  end
+
+  def save_document raw_resource, ref=nil
+
+    if(raw_resource['linked_documents'] != nil)
+      raw_resource.delete 'linked_documents'
+    end
+
+    if !(ref==nil)
+      existing_doc = find_document(ref)
+    end
+
+    if !(existing_doc == nil)      
+      updated_doc = MongoDocument.new raw_resource, @collection.name, existing_doc.id, Time.now.httpdate
+      @collection.save(updated_doc.raw_document)
+    else
+      new_id = @collection.insert(raw_resource)
+      
+      if(raw_resource['_koda_indexes'] && raw_resource['_koda_indexes'] != '')
+        indexes = raw_resource['_koda_indexes'].split(',')
+        index_collection = []
+        indexes.each do |index|
+          index_collection.push [index, Mongo::ASCENDING]
+        end
+        @collection.ensure_index index_collection 
+      end
+      
+      updated_doc = MongoDocument.new raw_resource, @collection.name, new_id, Time.now.httpdate
+
+      if(ref and updated_doc.ref != ref)
+        updated_doc.ref = ref
+        @collection.save(raw_resource)
+      end
+
+      updated_doc.is_new = true
+    end
+
+    updated_doc
+  end
+
+  def delete_document ref
+    existing_doc = find_document(ref)
+
+    if (existing_doc)
+      @collection.remove('_id' => existing_doc.id)
+    end
+  end
+
+  def delete
+    @collection.drop
+  end
+
+  private
+
+  def resource_links_from_docs docs
+    docs.map do |doc|
+      doc_wrapper = create_document_wrapper doc
+      { 
+        'href' => doc_wrapper.url, 
+        '_koda_type' => doc_wrapper.type, 
+        'rel' => 'full', 
+        'title' => doc_wrapper.title, 
+        "alias" => doc_wrapper.ref, 
+        '_koda_hidden' => doc_wrapper.hidden, 
+        'date_created' => doc_wrapper.date_created 
+      }
+    end
+  end
+  
+  def content_links_from_docs docs
+    docs.map do |doc|
+      doc_wrapper = create_document_wrapper doc
+      {
+        'href' => doc_wrapper.url.gsub(/api/, "content"), 
+        'title' => doc_wrapper.title, 
+        'alias' => doc_wrapper.ref, 
+        'date_created' => doc_wrapper.date_created 
+      }
+    end
+  end
+
+  def build_options take, skip, sort
+    options = {}
+    options[:limit] = take.to_i if take != nil
+    options[:skip] = skip.to_i if skip != nil
+
+    if (sort != nil)
+      sort_array = sort.to_a
+      sort_expression = sort_array[0][0]
+      sort_order = sort_array[0][1] == "desc" ? Mongo::DESCENDING : Mongo::ASCENDING
+
+      options[:sort] = [sort_expression, sort_order]
+    end
+
+    options
+  end
+
+  def create_document_wrapper(doc)
+    if !(doc==nil)
+      doc_wrapper=MongoDocument.new doc, @collection.name
+    end
+    doc_wrapper
+  end
+
+end