cortex-reaver 0.0.1

data/lib/cortex_reaver/model/photograph.rb

@@ -0,0 +1,133 @@
+module CortexReaver
+  class Photograph < Sequel::Model(:photographs)
+    def self.url
+      '/photographs'
+    end
+    
+    include CortexReaver::Model::Timestamps
+    include CortexReaver::Model::Canonical
+    include CortexReaver::Model::Attachments
+    include CortexReaver::Model::Comments
+    include CortexReaver::Model::Tags
+    include CortexReaver::Model::Sequenceable
+
+    # Target image sizes
+    SIZES = {
+      :thumbnail => '150x',
+      :grid => '150x150',
+      :small => 'x512',
+      :medium => 'x768',
+      :large => 'x1024',
+    }
+
+    many_to_many :tags, :class => 'CortexReaver::Tag'
+    belongs_to :user, :class => 'CortexReaver::User'
+    has_many :comments, :class => 'CortexReaver::Comment'
+
+    validates do
+      uniqueness_of :name
+      presence_of :name
+      length_of :name, :maximum => 255
+      presence_of :title
+    end
+
+    def self.get(id)
+      self[:name => id] || self[id]
+    end
+
+    def self.recent
+      reverse_order(:created_on).limit(16)
+    end
+
+    def atom_url
+      '/photographs/atom/' + name
+    end
+
+    # Returns the exif data for this photograph
+    def exif
+      EXIFR::JPEG.new(self.full_local_path).exif
+    end
+
+    # Gives the best guess for this photograph's date.
+    def date
+      if exif = self.exif
+        fields = [:date_time_original, :date_time_digitized, :date_time]
+        fields.each do |field|
+          begin
+            if date = exif.send(field)
+              return date
+            end
+          rescue
+          end
+        end
+      end
+
+      # Fall back on creation date
+      self.created_on
+    end
+
+    # Store an photograph on disk in the appropriate sizes.
+    def image=(file)
+      if file.blank? or file.size == 0
+        return nil
+      end
+
+      # Write file to disk
+      attachment = Attachment.new(self, 'original.jpg')
+      attachment.file = file
+
+      # Read image through ImageMagick
+      image = Magick::Image.read(attachment.local_path).first
+
+      # Write appropriate sizes to disk
+      SIZES.each do |size, geometry|
+        image.change_geometry(geometry) do |width, height|
+          attachment = Attachment.new(self, size.to_s + '.jpg')
+          image.scale(width, height).write(attachment.local_path)
+        end
+      end
+
+      true
+    end
+
+    # Sets the date from the EXIF date tag.
+    def infer_date_from_exif!
+      if exif = self.exif
+        self.created_on = self.date
+      end
+    end
+
+    # Returns the system path to the full photograph
+    def full_local_path
+      path :local, 'medium'
+    end
+
+    # Returns the path to the full photograph
+    def full_public_path
+      path :public, 'medium'
+    end
+
+    # The path to a photograph
+    def path(type = :local, size = :full)
+      attachment(size.to_s + '.jpg').path(type)
+    end
+
+    # Returns the system path to the thumbnail photograph
+    def thumbnail_local_path
+      path :local, 'thumbnail'
+    end
+
+    # Returns the path to the thumbnail photograph
+    def thumbnail_public_path
+      path :public, 'thumbnail'
+    end
+
+    def to_s
+      title || name
+    end
+
+    def url
+      '/photographs/show/' + name
+    end
+  end
+end

data/lib/cortex_reaver/model/project.rb

@@ -0,0 +1,49 @@
+module CortexReaver
+  class Project < Sequel::Model(:projects)
+    def self.url
+      '/projects'
+    end
+
+    include CortexReaver::Model::Timestamps
+    include CortexReaver::Model::CachedRendering
+    include CortexReaver::Model::Renderer
+    include CortexReaver::Model::Canonical
+    include CortexReaver::Model::Attachments
+    include CortexReaver::Model::Comments
+    include CortexReaver::Model::Tags
+    include CortexReaver::Model::Sequenceable
+
+    many_to_many :tags, :class => 'CortexReaver::Tag'
+    belongs_to :user, :class => 'CortexReaver::User'
+    has_many :comments, :class => 'CortexReaver::Comment'
+
+    validates do
+      uniqueness_of :name
+      presence_of :name
+      length_of :name, :maximum => 255
+      presence_of :title
+    end
+
+    render :body
+
+    def self.get(id)
+      self[:name => id] || self[id]
+    end
+
+    def self.recent
+      reverse_order(:updated_on).limit(16)
+    end
+
+    def atom_url
+      '/projects/atom/' + name
+    end
+
+    def url
+      '/projects/show/' + name
+    end
+
+    def to_s
+      title || name
+    end
+  end
+end

data/lib/cortex_reaver/model/tag.rb

@@ -0,0 +1,72 @@
+module CortexReaver
+  class Tag < Sequel::Model(:tags)
+    include CortexReaver::Model::Canonical
+
+    many_to_many :photographs, :class => 'CortexReaver::Photograph'
+    many_to_many :journals, :class => 'CortexReaver::Journal'
+    many_to_many :projects, :class => 'CortexReaver::Project'
+    many_to_many :pages, :class => 'CortexReaver::Page'
+
+    validates do
+      uniqueness_of :name
+      presence_of :name
+      length_of :name, :maximum => 255 
+      presence_of :title
+      length_of :title, :maximum => 255
+    end
+
+    # When we delete a tag, ensure nothing else is linked to it.
+    before_destroy(:drop_associations) do
+      remove_all_photographs
+      remove_all_journals
+      remove_all_projects
+      remove_all_pages
+    end
+
+    # Autocompletes a tag. Returns an array of matching candidates
+    def self.autocomplete(string)
+      filter(:title.like(/^#{string}/i)).limit(6).map(:title)
+    end
+
+    # Recalculates the number of children on each tag, and saves the updated values.
+    def self.refresh_counts
+      all.each do |tag|
+        tag.refresh_count
+      end
+    end
+
+    def self.get(id)
+      self[:name => id] || self[id]
+    end
+
+    def self.url
+      '/tags'
+    end
+
+    def atom_url
+      '/tags/atom/' + name
+    end
+
+    # Recalculates the number of children on this tag, and saves the update value.
+    def refresh_count
+      # Find counts
+      self[:count] = photographs_dataset.count + 
+        journals_dataset.count +
+        pages_dataset.count + 
+        projects_dataset.count
+      
+      # Save and return
+      self.skip_timestamp_update = true
+      self.save
+      self[:count]
+    end
+
+    def url
+      '/tags/show/' + name
+    end
+
+    def to_s
+      title || name
+    end
+  end
+end

data/lib/cortex_reaver/model/user.rb

@@ -0,0 +1,147 @@
+require 'digest/sha2'
+
+module CortexReaver
+  class User < Sequel::Model(:users)
+    include CortexReaver::Model::Timestamps
+    include CortexReaver::Model::Sequenceable
+
+    has_many :comments, :class => 'CortexReaver::Comment'
+    has_many :journals, :class => 'CortexReaver::Journal'
+    has_many :pages, :class => 'CortexReaver::Page'
+    has_many :photographs, :class => 'CortexReaver::Photograph'
+    has_many :projects, :class => 'CortexReaver::Project'
+
+    validates do
+      uniqueness_of :login
+      length_of     :login, :with => 5..255, :allow_blank => true
+      format_of     :login, :with => /^[A-Za-z0-9\-_]+$/
+      length_of     :name, :maximum => 255
+      length_of     :http, :allow_blank => true, :maximum => 255
+      uniqueness_of :email
+      length_of     :email, :allow_blank => true, :maximum => 255
+      format_of     :email, 
+        :with => /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/, :allow_blank => true
+      confirmation_of :password, :allow_nil => true#, :allow_false => true
+      each(:password_length, :tag => :password_length) do |object, attribute, value|
+        unless value.nil? or (8..255) === value
+          object.errors['password'] << 'must be between 8 and 255 characters.'
+        end
+      end
+    end
+
+    # Ensure an administrator is always available. TODO: This is probably
+    # subject to a race condition, especially between servers. Backup plan?
+    validates_each :admin do |object, attribute, value|
+      if User.filter(:admin => true).count == 1 and not value
+        object.errors[attribute] << "can't be unset; only one administrator left!"
+      end
+    end
+
+    self.window_size = 64
+
+    # Returns an authenticated user by login and password, or nil.
+    def self.authenticate(login, password)
+      user = self[:login => login]
+      if user and user.authenticate(password)
+        user
+      else
+        nil
+      end
+    end
+
+    # CRUD uses this to construct URLs. Even though we don't need the full
+    # power of Canonical, CRUD is pretty useful. :)
+    def self.canonical_name_attr
+      :login
+    end
+
+    # Get a user
+    def self.get(id)
+      self[:login => id] || self[id]
+    end
+
+    # Returns true if the user is an administrator.
+    def admin?
+      self.admin
+    end
+
+    # Authenticate with password
+    def authenticate(test_password)
+      if self[:password] == self.class.crypt(test_password, self.salt)
+        true
+      else
+        false
+      end
+    end
+
+    # Set user password
+    def password=(password)
+      self.salt ||= self.class.new_salt
+      self[:password] = self.class.crypt(password, self.salt)
+      @password_length = password.length
+    end
+
+    # Password confirmation
+    def password_confirmation=(password)
+      self.salt ||= self.class.new_salt
+      @password_confirmation = self.class.crypt(password, self.salt)
+    end
+
+    def password_confirmation
+      # If password_confirmation was set, use that. Otherwise, fall back
+      # to the normal password, so we don't need set the confirmation every
+      # time the password is updated programmatically.
+      @password_confirmation || self.password
+    end
+
+    # A cache for password length, so we can validate without keeping the
+    # password as plaintext.
+    def password_length
+      @password_length
+    end
+
+    def to_s
+      if name.blank?
+        login
+      else
+        name
+      end
+    end
+
+    # A URL to view this user
+    def url
+      '/users/show/' + login
+    end
+
+    private
+      # Valid characters for salt
+      SALT_CHARS = ('0'..'9').to_a + ('a'..'z').to_a + ('A'..'Z').to_a
+
+      # Returns hash of password with salt.
+      def self.crypt(password, salt)
+        Digest::SHA512.hexdigest(password.to_s + salt.to_s)
+      end
+
+      # Returns random salt
+      def self.new_salt
+        salt = ''
+        40.times do
+          salt << SALT_CHARS[rand(SALT_CHARS.size - 1).to_i]
+        end
+        salt
+      end
+
+    public
+
+    # Create default user if none exist
+    if table_exists? and count == 0
+      u = User.new(
+        :login => 'shodan',
+        :name => 'Shodan',
+        :admin => true
+      )
+      u.password = 'shodan'
+      u.save!
+    end
+  end
+end

data/lib/cortex_reaver/public/css/admin.css

@@ -0,0 +1,45 @@
+#adminbox {
+  display: none;
+  padding: 0.5em;
+  margin: 0 0 1em 0;
+  background-color: #eaeaea;
+  border: 1px solid #aaa;
+  border-top: none;
+  font-size: 80%;
+}
+
+#main #adminbox {
+  margin: -0.8em 0em 1em 0em;
+}
+
+#adminbox .actions-table {
+  width: 100%;
+}
+
+#adminbox p {
+  margin: 0;
+  padding: 0;
+}
+
+#adminbox td.title {
+  font-weight: bold;
+}
+
+#adminbox input[type=text] {
+  width: 160px;
+}
+
+#admin_section_actions {
+  text-align: center;
+}
+
+#admin_page_actions {
+}
+
+#admin_new_actions {
+  float: left;
+}
+
+#admin_user_actions {
+  float: right;
+}