breeze_cms 0.9.5

data/app/models/breeze/image.rb

@@ -0,0 +1,104 @@
+require "mini_magick"
+require "fileutils"
+
+module Breeze
+  class Image < ActiveBase
+
+    set_root_path Rails.root
+
+    fields  :name , :tags , :type , :size ,  :height , :width
+
+    def change_name
+      name
+    end
+
+    def aspect_ratio
+      ratio = self.ratio
+      ratios = (1..9).collect{ |i|  ((ratio * i) - (ratio * i).round(0)).abs }
+      min , min_index = ratios.each_with_index.min
+      [(ratio *  (min_index + 1) ).round(0).to_i , (min_index + 1) ]
+    end
+
+    def ratio
+      return 0 unless self.height
+      self.width.to_f / self.height
+    end
+
+    def copy()
+      image = Image.new_image_for( name: "#{name}_copy" , type: type ,
+                    tags: (tags || "") , width: width ,
+                    height: height, size: size )
+      FileUtils.cp full_filename , image.full_filename
+      image
+    end
+
+    def scale( new_size )
+      mini = MiniMagick::Image.new( full_filename)
+      mini.resize( new_size.to_s + "%")
+      init_file_size
+    end
+
+    def crop( to_size )
+      mini = MiniMagick::Image.new(full_filename)
+      mini.crop( to_size )
+      init_file_size
+    end
+    #save an io as new image. The filename is the id, type taken from io
+    def self.create_new(name , tags,  io)
+      original , end_ = io.original_filename.split("/").last.split(".")
+      magick_image = MiniMagick::Image.read(io).auto_orient
+      ending = magick_image.type.downcase
+      ending = "jpg" if ending == "jpeg"
+      name = original if( name.blank? )
+      image = self.new_image_for( name: name , type: ending , tags: (tags || "") ,
+                width: magick_image.width, height: magick_image.height ,
+                size: (magick_image.size/1024).to_i )
+      magick_image.write(image.full_filename)
+      image
+    end
+
+    def self.new_image_for( image_data )
+      new_id = Image.append(image_data)
+      Image.new(image_data)
+    end
+    def destroy(editor)
+      File.delete self.full_filename
+      delete_save!(editor)
+    end
+
+    def asset_name
+      Breeze.images_dir + "/" + self.id.to_s + "." + self.type
+    end
+
+    def full_filename
+      full_filename = self.id.to_s + "." + self.type
+      Rails.root.join(Image.asset_root, full_filename)
+    end
+
+    def self.transform
+      Image.all.each do |image|
+        last = image.name.split.last
+        image.tags = ""
+        ["wide", "small" , "big" , "room"].each do |tag|
+          if(last == tag)
+            image.name = image.name.gsub(last,"").strip
+            image.tags = last
+          end
+        end
+        image.save
+      end
+    end
+
+    def init_file_size
+      magick_image = MiniMagick::Image.open(full_filename)
+      self.width = magick_image.width
+      self.height = magick_image.height
+      self.size = (magick_image.size/1024).to_i
+    end
+
+    def self.asset_root
+      "app/assets/images/" + Breeze.images_dir
+    end
+
+  end
+end

data/app/models/breeze/option_definition.rb

@@ -0,0 +1,43 @@
+module Breeze
+
+  # Quite simple mapping from name to usually  a selection of values.
+  # Options have type that can be set but usually is inferred from
+  # wether there is one values (select) other wise text.
+  # date is also supported.
+  #
+  # a corresponding ./app/views/breeze/sections/_option_form_TYPE.haml
+  # nust exist to render the type.
+  #
+  # Also values may be provided by a module function/attribute on Breeze.
+  # eg option text_color (also shade_color) have a Breeze.text_color that return a
+  # hash. In this case so it is easy to customize the colors of the app.
+  #
+  class OptionDefinition < SharedBase
+
+    set_root_path Rails.root.join(Breeze.data_dir)
+
+    fields :name , :default , :description , :values , :type
+
+    def type
+      return data[:type] unless data[:type].blank?
+      if has_values?
+        "select"
+      else
+        "text"
+      end
+    end
+
+    def has_values?
+      return true if Breeze.respond_to?( name.to_sym )
+      return false if data[:values].nil?
+      ! data[:values].empty?
+    end
+
+    def values
+      return Breeze.send(name.to_sym).keys if Breeze.respond_to?( name.to_sym )
+      return [] unless has_values?
+      data[:values].split(" ")
+    end
+
+  end
+end

data/app/models/breeze/page.rb

@@ -0,0 +1,97 @@
+module Breeze
+  class Page < ViewBase
+    set_root_path Rails.root.join(Breeze.data_dir)
+
+    fields :name , :type , :options, :redirects , :section_template
+
+    alias :template :section_template
+
+    def change_name
+      self.name
+    end
+
+    def set_name new_name
+      new_name = Page.fix_name(new_name)
+      olds = self.redirects.to_s.split(" ")
+      olds << self.name unless olds.include?(self.name)
+      self.redirects = olds.join(" ")
+      self.name = new_name
+    end
+
+    def missing_translations
+      sum = 0
+      sections.collect{ |s | sum += s.missing_translations }
+      sum
+    end
+
+    def sections
+      Section.find_all(:page_id, id).sort_by{|obj| obj.index }
+    end
+
+    def sections_update
+      last_update_for( sections )
+    end
+
+    def template_style
+      PageStyle.find_by_type( type )
+    end
+
+    def new_section(section_template = nil)
+      section_template = "section_spacer" if section_template.blank?
+      section = Section.new_section(section_template, self.id , sections.length + 1)
+      section
+    end
+
+    def remove_section(section)
+      from_index = section.index
+      @sections.delete_at(from_index)
+      @content.delete_at(from_index)
+      @sections.each_with_index do |section, index|
+        section.set_index(index)
+      end
+    end
+
+    def first_template
+      return "none" unless @content[0]
+      @content[0]["template"]
+    end
+
+    def reset_index
+      sections.each_with_index{|section, index| section.index = index + 1}
+    end
+
+    def delete(editor)
+      sections.each {|section| section.delete(editor) }
+      delete_save!(editor)
+    end
+
+    def save(editor)
+      olds = self.redirects.to_s.split(" ")
+      olds.delete( self.name.to_s )
+      self.redirects = olds.join(" ")
+      super
+    end
+
+    def previous_page
+      return Page.all.last if(self.id == 1)
+      Page.all[self.id - 2]
+    end
+
+    def next_page
+      all = Page.all
+      return all.first if(self.id == all.length)
+      all[self.id]
+    end
+
+    def self.fix_name(name)
+      name.gsub(" ", "_").downcase
+    end
+
+    def self.new_page(name , type)
+      data = { name: self.fix_name(name) , updated_at: Time.now , type: type}
+      new_id = Page.append(data)
+      Page.new(data)
+    end
+
+  end
+end

data/app/models/breeze/page_style.rb

@@ -0,0 +1,12 @@
+module Breeze
+  class PageStyle < Style
+    set_root_path Rails.root.join(Breeze.data_dir)
+
+    fields  :type , :description , :section_template
+
+    def section_preview
+      "breeze/section_preview/" + section_template
+    end
+
+  end
+end

data/app/models/breeze/section.rb

@@ -0,0 +1,137 @@
+module Breeze
+  class Section < ViewBase
+
+    set_root_path Rails.root.join(Breeze.data_dir)
+
+    fields :id , :page_id , :index
+    fields :template , :card_template
+    fields :header, :text , :image_name
+
+    def page_name
+      page ? page.name : "missing page"
+    end
+
+    def change_name
+      "#{page_name}:#{header}"
+    end
+
+    def index_name
+      "#{self.index}"
+    end
+
+    def object_type
+      "Section"
+    end
+
+    def missing_translations
+      sum = 0
+      cards.collect{ |s | sum += s.missing_translations }
+      Breeze.language_strings.each do |lang|
+        sum += 1 if get_translation(lang)&.is_old?
+      end
+      sum
+    end
+
+    def cards
+      Card.find_all(:section_id, id).sort_by{|obj| obj.index }
+    end
+
+    def cards_update
+      last_update_for( cards )
+    end
+
+    def template_style
+      SectionStyle.find_by_template( template )
+    end
+
+    def card_template_style
+      CardStyle.find_by_template( card_template )
+    end
+
+    def set_template(new_template)
+      self.template = new_template
+      new_style = template_style
+      if(new_style.has_cards?)
+        if card_template.blank?
+          self.card_template = CardStyle.first.template
+        end
+      end
+    end
+
+    def allowed_fields
+      super + [:page_id]
+    end
+
+    def has_cards?
+      template_style.has_cards?
+    end
+
+    def move_up
+      swap_index_with(previous_section)
+    end
+
+    def move_down
+      swap_index_with(next_section)
+    end
+
+    def previous_section
+      page.sections.find{|s|  s.index == index - 1 }
+    end
+
+    def next_section
+      page.sections.find{|s|  s.index == index + 1 }
+    end
+
+    def new_card
+      card = Card.new_card(card_template, self.id , cards.length + 1)
+      card
+    end
+
+    def reset_index
+      cards.each_with_index{|card, index| card.index = index + 1}
+    end
+
+    def delete(editor)
+      cards.each {|card| card.delete(editor) }
+      delete_translations(editor)
+      delete_save!(editor)
+    end
+
+    def delete_and_reset_index(editor)
+      delete(editor)
+      Page.find(page_id).reset_index
+      Section.save_all
+    end
+
+    def self.new_section(template , page_id , index)
+      data = { template: template , index: index , page_id: page_id}
+      style = SectionStyle.find_by_template( template)
+      style.fields.each do |key|
+        data[key.to_sym] = key.upcase
+      end unless style.fields.blank?
+      if(style.has_cards?)
+        data[:card_template] = CardStyle.first.template
+      end
+      new_id = Section.append(data)
+      s = Section.new(data)
+      s.add_default_options
+      s
+    end
+
+    def self.fix_cards
+      Section.all.each do |section|
+        next if section.template_style.has_cards?
+        puts "#{section.id}: #{section.card_template}"
+        section.card_template = nil if section.card_template
+      end
+      Section.save_all
+      nil
+    end
+
+    def self.reload
+      res = super()
+      self.fix_translations
+    end
+
+  end
+end

data/app/models/breeze/section_style.rb

@@ -0,0 +1,17 @@
+module Breeze
+  class SectionStyle < Style
+
+    set_root_path Rails.root.join(Breeze.data_dir)
+
+    fields  :template , :text , :header, :fields , :cards
+
+    def has_cards?
+      cards
+    end
+
+    def section_preview
+      "breeze/section_preview/" + template
+    end
+
+  end
+end

data/app/models/breeze/shared_base.rb

@@ -0,0 +1,20 @@
+module Breeze
+  # shared data across engine and app
+  # takes a little footwork, as seen below
+  # and does not work with saving anymore.
+
+  class SharedBase < ActiveYaml
+
+    def self.load_file
+      # does super work ? Copied, wet wet wet
+      mod , filename = self.name.split("::").collect{|p| p.underscore}
+      fullname = mod + "/" + filename.tableize + ".yml"
+      res = YAML.load(File.read(File.join(self.path , fullname )))
+
+      breeze_path = Breeze::Engine.root.join("config")
+      breeze_res = YAML.load(File.read(File.join(breeze_path , fullname )))
+
+      res + breeze_res
+    end
+  end
+end

data/app/models/breeze/style.rb

@@ -0,0 +1,17 @@
+module Breeze
+  class Style < SharedBase
+
+    fields  :options
+
+    def options_definitions
+      option_defs = []
+      options.each do |name|
+        option = OptionDefinition.find_by_name(name)
+        raise "no option for #{name}:#{name.class}" if option.blank?
+        option_defs << option
+      end if options
+      option_defs
+    end
+
+  end
+end

data/app/models/breeze/translation.rb

@@ -0,0 +1,83 @@
+module Breeze
+  class Translation < ActiveBase
+
+    set_root_path Rails.root.join(Breeze.data_dir)
+
+    fields :id
+    fields :objectid , :object_type # poly: card or section (id without _, no association)
+    fields :language # the language for which the is a translation
+    fields :text , :header, :sub_header #actual text fields
+
+    def initialize(data)
+      super(data)
+      raise "no object type" unless self.object_type
+      raise "no object id" unless lang = self.objectid
+      raise "no language" unless lang = self.language
+      raise "not configured language #{lang}" unless Breeze.has_language(lang)
+    end
+
+    def object
+      clazz = "Breeze::#{object_type}".constantize
+      clazz.find( objectid )
+    end
+
+    def is_old?
+      return true unless self.updated_at
+      object.updated_at > self.updated_at
+    end
+
+    def change_name
+      "Translation: #{object.change_name}"
+    end
+
+    def update(hash , user)
+      return unless hash
+      [:text , :header ].each do |key|
+        data[key] = hash[key] if hash.has_key?(key)
+      end
+      add_save(user)
+    end
+
+    class << self
+
+      def fill_data(object, data = {})
+        data[:text] = object.text
+        data[:header] = object.header
+        data[:objectid] = object.id
+        data[:object_type] = object.object_type
+        data
+      end
+
+      def find_translation(objectid , object_type, language)
+        find_all(:objectid, objectid).each do |o|
+          return o if (objectid == o.objectid    ) &&
+                    (object_type == o.object_type) &&
+                    (language == o.language)
+        end
+        nil
+      end
+
+      def ensure_translation(object , language)
+        found = self.find_translation(object.id , object.object_type , language)
+        return nil if found
+        data = fill_data(object)
+        data[:updated_at] = object.updated_at - 1.day
+        data[:language] = language
+        data[:id] = "#{object.object_type}_#{object.id}"
+        data
+      end
+
+      def new_object_translation(object, data)
+        self.fill_data(object,data)
+        self.new_translation(data)
+      end
+
+      # append data and create new object.
+      def new_translation( data )
+        new_id = Translation.append(data)
+        Translation.new(data)
+      end
+
+    end
+  end
+end

data/app/models/breeze/view_base.rb

@@ -0,0 +1,134 @@
+module Breeze
+
+  # base class for viewable elements: ie page, section and casrd
+  # they share the template idea, options , change tracking,
+  # and the fact that they persist in ActiveYaml
+
+  class ViewBase < ActiveBase
+
+    fields :options ,  :image_id
+
+    def header_text(lang)
+      return self.header if lang.blank?
+      get_translation(lang).header
+    end
+
+    def text_text(lang)
+      return self.text if lang.blank?
+      get_translation(lang).text
+    end
+
+    def type_id
+      "#{object_type}_#{self.id}"
+    end
+
+    def last_update_for(elements)
+      last = Time.now
+      last_section = nil
+      elements.each do |section|
+        if( section.updated_at < last )
+          last = section.updated_at
+          last_section = section
+        end
+      end
+      last_section
+    end
+
+    def has_option?(option)
+      safe_options.has_key?(option) and !safe_options[option].blank?
+    end
+
+    def option_definitions
+      template_style.options_definitions
+    end
+
+    def option(name)
+      opts = safe_options
+      opts[name]
+    end
+
+    def safe_options
+      return data[:options] unless data[:options].blank?
+      data[:options] = {}
+    end
+
+    def set_option( option , value)
+      if( option.ends_with?"_date" )
+        puts "date is #{value}"
+        year = value[:year] || Time.new.year
+        value = Time.new( year.to_i , value[:month] , value[:day]).to_date
+      end
+      safe_options[option] = value
+    end
+
+    def add_default_options( definitions = nil )
+      definitions = option_definitions if definitions.nil?
+      definitions.each do |option|
+        next unless option.default
+        set_option( option.name , option.default)
+      end
+    end
+
+    def update(hash)
+      return unless hash
+      hash.each do |key , value|
+        value = value.to_i if key.to_s.include?("_id")
+        key = key.to_sym
+        raise "unsuported field :#{key} for #{template}:#{allowed_fields}" unless allowed_fields.include?(key)
+        if(! data[key].nil? ) # first setting ok, types not (yet?) specified
+          if( data[key].class != value.class )
+            raise "Type mismatch #{key} #{data[key].class}!=#{value.class}"
+          end
+        end
+        data[key] = value
+      end
+    end
+
+    def update_options( options )
+      return unless options
+      option_definitions.each do |option|
+        set_option(option.name,  options[option.name])
+      end
+    end
+    #other may be nil
+    def swap_index_with(other)
+      return unless other
+      old_index = self.index
+      self.index = other.index
+      other.index = old_index
+    end
+
+    def allowed_fields
+      template_style.fields.collect{|f| f.to_sym}
+    end
+
+    def image_old
+      Image.find_by_name(self.image_name)
+    end
+
+    def get_translation(lang)
+      Translation.find_translation(self.id , self.object_type , lang)
+    end
+
+    def delete_translations(editor)
+      Breeze.language_strings.each do |lang|
+        trans = Translation.find_translation(self.id, self.object_type , lang)
+        trans.delete_save!(editor) if trans
+      end
+    end
+
+    def self.fix_translations
+      create = []
+      Breeze.language_strings.each do |lang|
+        self.all.each do |object|
+          data = Translation.ensure_translation(object , lang)
+          (create << data) unless data.nil?
+        end
+      end
+      #puts "#{self.name} create #{create.length} Translations"
+      create.each{ |data| Translation.new_translation(data) }
+      Translation.save_all
+    end
+
+  end
+end