pwb 1.2.0 → 1.3.0

data/app/helpers/pwb/css_helper.rb

@@ -1,7 +1,21 @@
 module Pwb
   module CssHelper
+    def element_classes(*identifiers)
+      classes = ""
+      identifiers.each do |identifier|
+        classes += @current_website.get_element_class(identifier) + " "
+      end
+      classes
+    end
 
     def custom_styles(theme_name)
+      @bg_style_vars = ["primary-color-light", "primary-color-dark",
+                     "primary-color",
+                     "accent-color", "divider-color",
+                     "primary-background-dark"]
+      @text_color_style_vars = ["primary-color-text",
+                     "primary-text-color","secondary-text-color",
+                     ]
       render :partial => "pwb/custom_css/#{theme_name}", :locals => {}, formats: :css
     end
 

data/app/helpers/pwb/navigation_helper.rb

@@ -0,0 +1,82 @@
+module Pwb
+  module NavigationHelper
+
+    def render_top_navigation_links
+      html = ""
+      @tn_links ||= Pwb::Link.ordered_visible_top_nav
+      @tn_links.each do |page|
+        unless page.slug == "top_nav_admin"
+          html += (top_nav_link_for page) || ""
+        end
+      end
+      html.html_safe
+    end
+
+    def render_footer_links
+      html = ""
+      @ftr_links ||= Pwb::Link.ordered_visible_footer
+      @ftr_links.each do |page|
+        html += (footer_link_for page) || ""
+      end
+      html.html_safe
+    end
+
+    def footer_link_for(page)
+      html = ""
+      begin
+        if page[:link_path].present?
+          # link_path should be valid - below checks that
+          target_path = self.pwb.send(page[:link_path], [page[:link_path_params]], {locale: locale})
+          # below works in most routes but had to change to above to support devise routes
+          # target_path = send(page[:link_path], {locale: locale})
+          # else
+          #   target_path = self.pwb.send("show_page_path", page[:slug], {locale: locale})
+        elsif page[:link_url].present?
+          target_path = page[:link_url]
+        end
+      rescue NoMethodError
+        # target_path = '/'
+        # rescue Exception => e
+      end
+      if target_path
+        html = <<-HTML
+        #{ link_to page.link_title, target_path}.
+        HTML
+      end
+      html
+    end
+
+    def top_nav_link_for(page)
+      html = ""
+      begin
+        if page[:link_path].present?
+          # link_path should be valid - below checks that
+          target_path = self.pwb.send(page[:link_path], [page[:link_path_params]], {locale: locale})
+          # below works in most routes but had to change to above to support devise routes
+          # target_path = send(page[:link_path], {locale: locale})
+          # else
+          #   target_path = self.pwb.send("show_page_path", page[:slug], {locale: locale})
+        elsif page[:link_url].present?
+          target_path = page[:link_url]
+        end
+      rescue NoMethodError
+        # target_path = '/'
+        # rescue Exception => e
+      end
+      if target_path
+        style_class = 'selected active' if current_page?( target_path )
+        if current_page?("/") && (page[:link_path] == "home_path")
+          # so correct tab is higlighted when at root path
+          style_class = 'selected active'
+        end
+        html = <<-HTML
+        <li class="#{style_class}">
+        #{link_to page.link_title, target_path, target: page[:href_target]}
+        </li>
+        HTML
+      end
+      html
+    end
+
+  end
+end

data/app/models/pwb/contact.rb

@@ -0,0 +1,25 @@
+module Pwb
+  class Contact < ApplicationRecord
+    has_many :messages
+    belongs_to :primary_address, optional: true, class_name: "Address", foreign_key: 'primary_address_id'
+    belongs_to :secondary_address, optional: true, class_name: "Address", foreign_key: 'secondary_address_id'
+    belongs_to :user, optional: true
+
+    # enum title: [ :mr, :mrs ]
+    # above method of declaring less flexible than below:
+    enum title: { mr: 0, mrs: 1 }
+
+    def street_number
+      primary_address.present? ? primary_address.street_number : nil
+    end
+    def street_address
+      primary_address.present? ? primary_address.street_address : nil
+    end
+    def city
+      primary_address.present? ? primary_address.city : nil
+    end
+    def postal_code
+      primary_address.present? ? primary_address.postal_code : nil
+    end
+  end
+end

data/app/models/pwb/content.rb

@@ -1,23 +1,41 @@
 module Pwb
   class Content < ApplicationRecord
     has_many :content_photos, dependent: :destroy
-    belongs_to :section, optional: true, foreign_key: "section_key", primary_key: "link_path"
+    # belongs_to :section, optional: true, foreign_key: "section_key", primary_key: "link_path"
+    has_many :page_contents
+    has_many :pages, :through => :page_contents
+    # , :uniq => true
 
     translates :raw, fallbacks_for_empty_translations: true
     globalize_accessors locales: I18n.available_locales
     # globalize_accessors locales: [:en, :ca, :es, :fr, :ar, :de, :ru, :pt]
 
+    attribute :raw
+
+    def as_json(options = nil)
+      super({only: [
+               "key","page_part_key", "visible_on_page"
+             ],
+             methods: admin_attribute_names
+             }.merge(options || {}))
+    end
+
+    def admin_attribute_names
+      self.globalize_attribute_names.push :content_photos
+    end
+
+
     def default_photo
       content_photos.first
     end
 
-    # def default_photo_url
-    #   if content_photos.first
-    #     content_photos.first.image_url
-    #   else
-    #     'https://placeholdit.imgix.net/~text?txtsize=38&txt=&w=550&h=300&txttrack=0'
-    #   end
-    # end
+    def default_photo_url
+      if content_photos.first
+        content_photos.first.image_url
+      else
+        'https://placeholdit.imgix.net/~text?txtsize=38&txt=&w=550&h=300&txttrack=0'
+      end
+    end
 
     class << self
       def import(file)

data/app/models/pwb/content_photo.rb

@@ -2,10 +2,28 @@ module Pwb
   class ContentPhoto < ApplicationRecord
     mount_uploader :image, ContentPhotoUploader
     belongs_to :content, optional: true
+    # I use block_key col to indicate if there is a fragment block associated
+    # with this photo 
 
     # validates_processing_of :image
     # validate :image_size_validation
 
+    def optimized_image_url
+      unless self.image.url.present?
+        # if this method is called too soon after an image is 
+        # uploaded, might need to reload the record to
+        # have the url available
+        self.reload
+      end
+      if Rails.application.config.use_cloudinary
+        options = {height: 800, crop: "scale", quality: "auto"}
+        image_url = Cloudinary::Utils.cloudinary_url self.image, options
+      else
+        image_url = self.image.url
+      end
+      image_url
+    end
+
     # private
     # def image_size_validation
     #   errors[:image] << "should be less than 500KB" if image.size > 0.5.megabytes

data/app/models/pwb/link.rb

@@ -0,0 +1,41 @@
+module Pwb
+# added July 2017
+  class Link < ApplicationRecord
+    translates :link_title, fallbacks_for_empty_translations: true
+    # globalize_accessors locales: [:en, :ca, :es, :fr, :ar, :de, :ru, :pt]
+    globalize_accessors locales: I18n.available_locales
+
+    belongs_to :page, optional: true, foreign_key: "page_slug", primary_key: "slug"
+
+    # below needed to avoid "... is not an attribute known to Active Record" warnings
+    attribute :link_title
+
+
+    # enum placement: [ :top_nav, :footer ]
+    # above method of declaring less flexible than below:
+    enum placement: { top_nav: 0, footer: 1, social_media: 2, admin: 3}
+
+    scope :ordered_visible_admin, -> () { where(visible: true, placement: :admin).order('sort_order asc')  }
+    scope :ordered_visible_top_nav, -> () { where(visible: true, placement: :top_nav).order('sort_order asc')  }
+    scope :ordered_visible_footer, -> () { where(visible: true, placement: :footer).order('sort_order asc')  }
+    scope :ordered_top_nav, -> () { where(placement: :top_nav).order('sort_order asc')  }
+    scope :ordered_footer, -> () { where(placement: :footer).order('sort_order asc')  }
+
+
+    def as_json(options = nil)
+      super({only: [
+               "sort_order", "placement",
+               "href_class", "is_deletable",
+               "slug", "link_path","visible",
+               "link_title", "page_slug"
+             ],
+             methods: admin_attribute_names}.merge(options || {}))
+    end
+
+    def admin_attribute_names
+      self.globalize_attribute_names
+      # self.globalize_attribute_names.push :content_photos
+    end
+
+  end
+end

data/app/models/pwb/message.rb

@@ -1,5 +1,5 @@
 module Pwb
   class Message < ApplicationRecord
-    belongs_to :client, optional: true
+    belongs_to :contact, optional: true
   end
 end

data/app/models/pwb/page.rb

@@ -0,0 +1,227 @@
+module Pwb
+  # added July 2017
+  # has details json col where page_fragment info is stored
+  class Page < ApplicationRecord
+    extend ActiveHash::Associations::ActiveRecordExtensions
+    # belongs_to_active_hash :page_setup, optional: true, foreign_key: "setup_id", class_name: "Pwb::PageSetup", shortcuts: [:friendly_name], primary_key: "id"
+
+    has_many :links, foreign_key: "page_slug", primary_key: "slug"
+    has_one :main_link, -> { where(placement: :top_nav) }, foreign_key: "page_slug", primary_key: "slug", class_name: "Pwb::Link"
+    # , :conditions => ['placement = ?', :admin]
+
+    has_many :page_parts, foreign_key: "page_slug", primary_key: "slug"
+
+    has_many :page_contents
+    has_many :contents, :through => :page_contents
+    # https://stackoverflow.com/questions/5856838/scope-with-join-on-has-many-through-association
+    has_many :ordered_visible_page_contents, -> { ordered_visible }, :class_name => 'PageContent'
+    # below would get me the correct items but the order gets lost:
+    # has_many :ordered_visible_contents, :source => :content, :through => :ordered_visible_page_contents
+    # note, even where ordered_visible_contents exist,
+    # @page.ordered_visible_contents.first will return nill
+    # @page.ordered_visible_contents.all.first will return content
+
+    translates :raw_html, fallbacks_for_empty_translations: true
+    translates :page_title, fallbacks_for_empty_translations: true
+    translates :link_title, fallbacks_for_empty_translations: true
+    # globalize_accessors locales: [:en, :ca, :es, :fr, :ar, :de, :ru, :pt]
+    globalize_accessors locales: I18n.available_locales
+
+    # Pwb::Page.has_attribute?("raw_html")
+    # below needed so above returns true
+    attribute :link_title
+    attribute :page_title
+    attribute :raw_html
+    # without above, Rails 5.1 will give deprecation warnings in my specs
+
+    # scope :visible_in_admin, -> () { where visible: true  }
+
+    # def get_fragment_html label, locale
+    #   content_key = slug + "_" + label
+    #   content = self.contents.find_by_key content_key
+    #   if content.present?
+    #     content.raw
+    #   else
+    #     nil
+    #   end
+    # end
+
+    # used by page_controller to create a photo (from upload) that can
+    # later be used in fragment html
+    def create_fragment_photo page_part_key, block_label, photo_file
+      # content_key = self.slug + "_" + page_part_key
+      # get content model associated with page and fragment
+      page_fragment_content = contents.find_or_create_by(page_part_key: page_part_key)
+
+      if ENV["RAILS_ENV"] == "test"
+        # don't create photos for tests
+        return nil
+      end
+      begin
+        photo = page_fragment_content.content_photos.create(block_key: block_label)
+        photo.image = photo_file
+        # photo.image = Pwb::Engine.root.join(photo_file).open
+        photo.save!
+      rescue Exception => e
+        # log exception to console
+        print e
+        # if photo
+        #   photo.destroy!
+        # end
+      end
+      return photo
+    end
+
+
+    # when seeding I only need to ensure that a photo exists for the fragment
+    # so will return existing photo if it can be found
+    def seed_fragment_photo page_part_key, block_label, photo_file
+      # content_key = self.slug + "_" + page_part_key
+      # get in content model associated with page and fragment
+      page_fragment_content = contents.find_or_create_by(page_part_key: page_part_key)
+      photo = page_fragment_content.content_photos.find_by_block_key(block_label)
+
+      if photo.present?
+        return photo
+      else
+        photo = page_fragment_content.content_photos.create(block_key: block_label)
+      end
+
+      if ENV["RAILS_ENV"] == "test"
+        # don't create photos for tests
+        return nil
+      end
+      begin
+        # if photo_file.is_a?(String)
+        # photo.image = photo_file
+        photo.image = Pwb::Engine.root.join(photo_file).open
+        photo.save!
+        print "#{self.slug}--#{page_part_key} image created: #{photo.optimized_image_url}\n"
+        # reload the record to ensure that url is available
+        photo.reload
+        print "#{self.slug}--#{page_part_key} image created: #{photo.optimized_image_url}(after reload..)"
+      rescue Exception => e
+        # log exception to console
+        print e
+      end
+      return photo
+    end
+
+    def set_fragment_sort_order page_part_key, sort_order
+      page_fragment_content = contents.find_by_page_part_key page_part_key
+      # using join model for sorting and visibility as it
+      # will allow use of same content by different pages
+      # with different settings for sorting and visibility
+      page_content_join_model = page_fragment_content.page_contents.find_by_page_id self.id
+      page_content_join_model.sort_order = sort_order
+      page_content_join_model.save!
+    end
+
+    def set_fragment_visibility page_part_key, visible_on_page
+      page_fragment_content = contents.find_by_page_part_key page_part_key
+      page_content_join_model = page_fragment_content.page_contents.find_by_page_id self.id
+      page_content_join_model.visible_on_page = visible_on_page
+      page_content_join_model.save!
+    end
+
+    # currently only used in
+    # /pwb/spec/controllers/pwb/welcome_controller_spec.rb
+    def set_fragment_html page_part_key, locale, new_fragment_html
+      # content_key = slug + "_" + page_part_key
+      # save in content model associated with page
+      page_fragment_content = contents.find_or_create_by(page_part_key: page_part_key)
+      content_html_col = "raw_" + locale + "="
+      # above is the col used by globalize gem to store localized data
+      # page_fragment_content[content_html_col] = fragment_html
+      page_fragment_content.send content_html_col, new_fragment_html
+      page_fragment_content.save!
+
+      return page_fragment_content
+    end
+
+    # def parse_page_part page_part_key, content_for_pf_locale
+
+    #   page_part = self.page_parts.find_by_page_part_key page_part_key
+
+    #   if page_part.present?
+    #     l_template = Liquid::Template.parse(page_part.template)
+    #     fragment_html = l_template.render('page_part' => content_for_pf_locale["blocks"] )
+    #     p "#{page_part_key} content for #{self.slug} page parsed."
+
+    #   else
+    #     fragment_html = ""
+    #   end
+
+    #   # fragment_html = l_template.render('page_part' => content_for_pf_locale["blocks"] )
+    #   # ac = ActionController::Base.new()
+    #   # # render html for fragment with associated partial
+    #   # fragment_html = ac.render_to_string :partial => "pwb/fragments/#{page_part_key}",  :locals => { page_part: content_for_pf_locale["blocks"]}
+    #   return fragment_html
+    # end
+
+    # Will retrieve saved page_part blocks and use that along with template
+    # to rebuild page_content html
+    def rebuild_page_content page_part_key, locale
+      page_part = self.page_parts.find_by_page_part_key page_part_key
+
+      if page_part.present?
+        l_template = Liquid::Template.parse(page_part.template)
+        new_fragment_html = l_template.render('page_part' => page_part.block_contents[locale]["blocks"] )
+        # p "#{page_part_key} content for #{self.slug} page parsed."
+        # save in content model associated with page
+        page_fragment_content = contents.find_or_create_by(page_part_key: page_part_key)
+        content_html_col = "raw_" + locale + "="
+        # above is the col used by globalize gem to store localized data
+        # page_fragment_content[content_html_col] = new_fragment_html
+        page_fragment_content.send content_html_col, new_fragment_html
+        page_fragment_content.save!
+
+      else
+        new_fragment_html = ""
+      end
+
+      return new_fragment_html
+    end
+
+    def set_page_part_block_contents page_part_key, locale, fragment_details
+      page_part = self.page_parts.find_by_page_part_key page_part_key
+      if page_part.present?
+        page_part.block_contents[locale] = fragment_details
+        page_part.save!
+        # fragment_details passed in might be a params object
+        # - retrieving what has just been saved will return it as JSON
+        fragment_details = page_part.block_contents[locale]
+      end
+      return fragment_details
+    end
+
+
+    # def as_json(options = nil)
+    #   super({only: ["sort_order_top_nav", "show_in_top_nav"],
+    #          methods: ["link_title_en","link_title_es"
+    #   ]}.merge(options || {}))
+    # end
+    # above can be called on a result set from a query like so:
+    # Page.all.as_json
+    # Below can only be called on a single record like so:
+    # Page.first.as_json
+    def as_json_for_admin(options = nil)
+      as_json({only: [
+                 "sort_order_top_nav", "show_in_top_nav",
+                 "sort_order_footer", "show_in_footer",
+                 "slug", "link_path","visible"
+               ],
+               methods: admin_attribute_names}.merge(options || {}))
+    end
+
+    def admin_attribute_names
+
+      self.globalize_attribute_names.push :page_contents, :page_parts
+      # return "link_title_en","link_title_es", "link_title_de",
+    end
+
+    # def page_fragment_blocks
+    #   return details["fragments"]
+    # end
+  end
+end