knitkit 2.1.15 → 3.0.0

data/app/models/published_website.rb

@@ -3,7 +3,7 @@ class PublishedWebsite < ActiveRecord::Base
 
   belongs_to :website
   belongs_to :published_by, :class_name => "User"
-  has_many :published_elements, :dependent => :destroy
+  has_many :published_elements, :dependent => :delete_all
 
   def published_by_username
     self.published_by.username rescue ''
@@ -25,91 +25,128 @@ class PublishedWebsite < ActiveRecord::Base
   end
 
   def publish(comment, current_user)
-    new_publication = clone_publication(1, comment, current_user)
-    elements = []
-
-    #get a publish sections
-    website_sections = new_publication.website.website_sections
-    website_sections = website_sections | website_sections.collect { |section| section.descendants }.flatten
-    website_sections.each do |website_section|
-      #get nested elements too
-      website_section.self_and_descendants.each do |website_section|
-        if new_publication.published_elements.where('published_element_record_id = ? and (published_element_record_type = ? or published_element_record_type = ?)', website_section.id, website_section.class.to_s, website_section.class.superclass.to_s).first.nil?
+    # if the site is currently being published we need to wait
+    # we want to sleep for 2 seconds and only try 3 times then give up
+    try_count = 0
+    while website.reload.publishing? and try_count < 2
+      sleep(2.seconds)
+      try_count += 1
+    end
+
+    # lock website for publishing
+    website.publishing = true
+    website.save
+
+    # wrap in transaction so if something fails it rolls back
+    ActiveRecord::Base.transaction do
+      new_publication = clone_publication(comment, current_user)
+      elements = []
+
+      #get a publish sections
+      website_sections = new_publication.website.website_sections
+      website_sections = website_sections | website_sections.collect { |section| section.descendants }.flatten
+      website_sections.each do |website_section|
+        #get nested elements too
+        website_section.self_and_descendants.each do |website_section|
+          if new_publication.published_elements.where('published_element_record_id = ? and (published_element_record_type = ? or published_element_record_type = ?)', website_section.id, website_section.class.to_s, website_section.class.superclass.to_s).first.nil?
+            published_element = PublishedElement.new
+            published_element.published_website = new_publication
+            published_element.published_element_record = website_section
+            published_element.version = website_section.version
+            published_element.published_by = current_user
+            published_element.save
+          end
+        end
+
+        if website_section.is_a?(OnlineDocumentSection)
+          elements = elements | [website_section.documented_item.content]
+        else
+          elements = elements | website_section.contents
+        end
+      end
+
+      #make sure all elements have published_element objects
+      elements.each do |element|
+        if new_publication.published_elements.where('published_element_record_id = ? and (published_element_record_type = ? or published_element_record_type = ?)', element.id, element.class.to_s, element.class.superclass.to_s).first.nil?
           published_element = PublishedElement.new
           published_element.published_website = new_publication
-          published_element.published_element_record = website_section
-          published_element.version = website_section.version
+          published_element.published_element_record = element
+          published_element.version = element.version
           published_element.published_by = current_user
           published_element.save
         end
       end
 
-      if website_section.is_a?(OnlineDocumentSection)
-        elements = elements | [website_section.documented_item.content]
-      else
-        elements = elements | website_section.contents
+      #get latest version for all elements
+      new_publication.published_elements.each do |published_element|
+        published_element.version = published_element.published_element_record.version
+        published_element.save
       end
-    end
 
-    #make sure all elements have published_element objects
-    elements.each do |element|
-      if new_publication.published_elements.where('published_element_record_id = ? and (published_element_record_type = ? or published_element_record_type = ?)', element.id, element.class.to_s, element.class.superclass.to_s).first.nil?
-        published_element = PublishedElement.new
-        published_element.published_website = new_publication
-        published_element.published_element_record = element
-        published_element.version = element.version
-        published_element.published_by = current_user
-        published_element.save
+      #check if we want to auto active this publication
+      if new_publication.website.auto_activate_publication?
+        PublishedWebsite.activate(new_publication.website, new_publication.version, current_user)
       end
-    end
 
-    #get latest version for all elements
-    new_publication.published_elements.each do |published_element|
-      published_element.version = published_element.published_element_record.version
-      published_element.save
     end
 
-    #check if we want to auto active this publication
-    if new_publication.website.auto_activate_publication?
-      PublishedWebsite.activate(new_publication.website, new_publication.version, current_user)
-    end
+    # unlock website for publishing
+    website.publishing = false
+    website.save
   end
 
   def publish_element(comment, element, version, current_user)
-    new_publication = clone_publication(0.1, comment, current_user)
+    # if the site is currently being published we need to wait
+    # we want to sleep for 2 seconds and only try 3 times then give up
+    try_count = 0
+    while website.reload.publishing? and try_count < 2
+      sleep(2.seconds)
+      try_count += 1
+    end
 
-    published_element = new_publication.published_elements.where('published_element_record_id = ? and (published_element_record_type = ? or published_element_record_type = ?)', element.id, element.class.to_s, element.class.superclass.to_s).first
+    # lock website for publishing
+    website.publishing = true
+    website.save
 
-    unless published_element.nil?
-      published_element.version = version
-      published_element.published_by = current_user
-      published_element.save
-    else
-      new_published_element = PublishedElement.new
-      new_published_element.published_website = new_publication
-      new_published_element.published_element_record = element
-      new_published_element.version = version
-      new_published_element.published_by = current_user
-      new_published_element.save
-    end
+    # wrap in transaction so if something fails it rolls back
+    ActiveRecord::Base.transaction do
+      new_publication = clone_publication(comment, current_user)
 
-    #check if we want to auto active this publication
-    if new_publication.website.auto_activate_publication?
-      PublishedWebsite.activate(new_publication.website, new_publication.version, current_user)
+      published_element = new_publication.published_elements.where('published_element_record_id = ? and (published_element_record_type = ? or published_element_record_type = ?)', element.id, element.class.to_s, element.class.superclass.to_s).first
+
+      unless published_element.nil?
+        published_element.version = version
+        published_element.published_by = current_user
+        published_element.save
+      else
+        new_published_element = PublishedElement.new
+        new_published_element.published_website = new_publication
+        new_published_element.published_element_record = element
+        new_published_element.version = version
+        new_published_element.published_by = current_user
+        new_published_element.save
+      end
+
+      #check if we want to auto active this publication
+      if new_publication.website.auto_activate_publication?
+        PublishedWebsite.activate(new_publication.website, new_publication.version, current_user)
+      end
     end
+
+    # unlock website for publishing
+    website.publishing = false
+    website.save
   end
 
   private
 
-  def clone_publication(version_increment, comment, current_user)
+  def clone_publication(comment, current_user)
     #create new PublishedWebsite with comment
     published_website = PublishedWebsite.new
     published_website.website = self.website
-    if version_increment == 1
-      published_website.version = (self.version.to_i + version_increment)
-    else
-      published_website.version = (self.version + version_increment).round(6)
-    end
+
+    published_website.version = (self.version.to_i + 1)
+
     published_website.published_by = current_user
     published_website.comment = comment
     published_website.save

data/app/models/theme.rb

@@ -5,15 +5,79 @@ class Theme < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
   THEME_STRUCTURE = ['stylesheets', 'javascripts', 'images', 'templates']
-  class << self; attr_accessor :base_layouts_views_path, :knitkit_website_stylesheets_path, :knitkit_website_images_path  end
+  class << self
+    attr_accessor :base_layouts_views_path, :knitkit_website_stylesheets_path,
+                  :knitkit_website_images_path, :knitkit_website_javascripts_path
+  end
   @base_layouts_views_path = "#{Knitkit::Engine.root.to_s}/app/views"
   @knitkit_website_stylesheets_path = "#{Knitkit::Engine.root.to_s}/public/stylesheets/knitkit"
+  @knitkit_website_javascripts_path = "#{Knitkit::Engine.root.to_s}/public/javascripts/knitkit"
   @knitkit_website_images_path = "#{Knitkit::Engine.root.to_s}/public/images/knitkit"
 
   protected_with_capabilities
   has_file_assets
 
+  def import_download_item_file(file)
+    file_support = ErpTechSvcs::FileSupport::Base.new(:storage => Rails.application.config.erp_tech_svcs.file_storage)
+
+    theme_root = Theme.find_theme_root_from_file(file)
+
+    Zip::ZipFile.open(file) do |zip|
+      zip.each do |entry|
+        if entry.name == 'about.yml'
+          data = ''
+          entry.get_input_stream { |io| data = io.read }
+          data = StringIO.new(data) if data.present?
+          about = YAML.load(data)
+          self.author = about['author'] if about['author']
+          self.version = about['version'] if about['version']
+          self.homepage = about['homepage'] if about['homepage']
+          self.summary = about['summary'] if about['summary']
+        else
+          name = entry.name.sub(/__MACOSX\//, '')
+          name = Theme.strip_path(name, theme_root)
+          data = ''
+          entry.get_input_stream { |io| data = io.read }
+          data = StringIO.new(data) if data.present?
+          theme_file = self.files.where("name = ? and directory = ?", File.basename(name), File.join(self.url,File.dirname(name))).first
+          unless theme_file.nil?
+            theme_file.data = data
+            theme_file.save
+          else
+            self.add_file(data, File.join(file_support.root, self.url,name)) rescue next
+          end
+        end
+      end
+    end
+    activate!
+  end
+
   class << self
+    def import_download_item(tempfile, website)
+          name_and_id = tempfile.gsub(/(^.*(\\|\/))|(\.zip$)/, '')
+          theme_name = name_and_id.split('[').first
+          theme_id = name_and_id.split('[').last.gsub(']','')
+          Theme.create(:name => theme_name.sub(/-theme/, ''), :theme_id => theme_id, :website_id => website.id).tap do |theme|
+            theme.import_download_item_file(tempfile)
+          end
+    end
+
+
+    def find_theme_root_from_file(file)
+      theme_root = ''
+      Zip::ZipFile.open(file) do |zip|
+        zip.each do |entry|
+          entry.name.sub!(/__MACOSX\//, '')
+          if theme_root == root_in_path(entry.name)
+            break
+          end
+        end
+      end
+      theme_root
+    end
+
+
+
     def root_dir
       @@root_dir ||= "#{Rails.root}/public"
     end
@@ -120,8 +184,6 @@ class Theme < ActiveRecord::Base
     Zip::ZipFile.open(file.path) do |zip|
       zip.each do |entry|
         if entry.name == 'about.yml'
-          #TODO
-          #FIXME this does not work for some reason
           data = ''
           entry.get_input_stream { |io| data = io.read }
           data = StringIO.new(data) if data.present?
@@ -146,6 +208,7 @@ class Theme < ActiveRecord::Base
         end
       end
     end
+
   end
 
   def export
@@ -213,6 +276,7 @@ class Theme < ActiveRecord::Base
     file_support = ErpTechSvcs::FileSupport::Base.new
     create_theme_files_for_directory_node(file_support.build_tree(Theme.base_layouts_views_path, :preload => true), :templates, :path_to_replace => Theme.base_layouts_views_path)
     create_theme_files_for_directory_node(file_support.build_tree(Theme.knitkit_website_stylesheets_path, :preload => true), :stylesheets, :path_to_replace => Theme.knitkit_website_stylesheets_path)
+    create_theme_files_for_directory_node(file_support.build_tree(Theme.knitkit_website_javascripts_path, :preload => true), :javascripts, :path_to_replace => Theme.knitkit_website_javascripts_path)
     create_theme_files_for_directory_node(file_support.build_tree(Theme.knitkit_website_images_path, :preload => true), :images, :path_to_replace => Theme.knitkit_website_images_path)
   end
 
@@ -225,18 +289,40 @@ class Theme < ActiveRecord::Base
   end
 
   def save_theme_file(path, type, options)
-    contents = IO.read(path)
-    contents.gsub!("../../images/knitkit","../images") unless path.scan('style.css').empty?
-    contents.gsub!("<%= static_stylesheet_link_tag('knitkit/style.css') %>","<%= theme_stylesheet_link_tag('#{self.theme_id}','style.css') %>") unless path.scan('base.html.erb').empty?
-
-    path = case type
-    when :widgets
-      path.gsub(options[:path_to_replace], "#{self.url}/widgets/#{options[:widget_name]}")
-    else
-      path.gsub(options[:path_to_replace], "#{self.url}/#{type.to_s}")
+    ignored_css = [
+        'bootstrap.min.css',
+        'bootstrap-responsive.min.css',
+        'datepicker.css',
+        'inline_editing.css',
+    ]
+
+    ignored_js = [
+        'bootstrap.min.js',
+        'bootstrap-datepicker.js',
+        'confirm-bootstrap.js',
+        'inline_editing.js',
+        'jquery.maskedinput.min.js',
+        'Main.js',
+        'View.js'
+    ]
+
+    ignored_files = (ignored_css | ignored_js).flatten
+
+    unless ignored_files.any? { |w| path =~ /#{w}/ }
+      contents = IO.read(path)
+      contents.gsub!("<%= static_stylesheet_link_tag 'knitkit/custom.css' %>","<%= theme_stylesheet_link_tag '#{self.theme_id}','custom.css' %>") unless path.scan('base.html.erb').empty?
+      contents.gsub!("<%= static_javascript_include_tag 'knitkit/theme.js' %>","<%= theme_javascript_include_tag '#{self.theme_id}','theme.js' %>") unless path.scan('base.html.erb').empty?
+
+      path = case type
+               when :widgets
+                 path.gsub(options[:path_to_replace], "#{self.url}/widgets/#{options[:widget_name]}")
+               else
+                 path.gsub(options[:path_to_replace], "#{self.url}/#{type.to_s}")
+             end
+
+      self.add_file(contents, path)
     end
 
-    self.add_file(contents, path)
   end
-
 end
+

data/app/models/website.rb

@@ -1,9 +1,9 @@
 class Website < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
-  after_destroy  :remove_sites_directory, :remove_website_role
+  after_destroy :remove_sites_directory, :remove_website_role
   before_destroy :destroy_sections
-  after_create   :setup_website
+  after_create :setup_website
 
   protected_with_capabilities
   has_file_assets
@@ -54,7 +54,7 @@ class Website < ActiveRecord::Base
 
   alias :sections :website_sections
   alias :hosts :website_hosts
-  
+
   #We only want to destroy parent sections as better nested set will destroy children for us
   def destroy_sections
     parents = []
@@ -63,8 +63,12 @@ class Website < ActiveRecord::Base
         parents << section
       end
     end
-    
-    parents.each {|parent| parent.destroy}
+
+    parents.each { |parent| parent.destroy }
+  end
+
+  def publishing?
+    self.publishing
   end
 
   def to_label
@@ -150,9 +154,7 @@ class Website < ActiveRecord::Base
   def setup_website
     PublishedWebsite.create(:website => self, :version => 0, :active => true, :comment => 'New Site Created')
     SecurityRole.create(:description => "Website #{self.title}", :internal_identifier => website_role_iid) if self.role.nil?
-    configuration = ::Configuration.find_template('default_website_configuration').clone(true)
-    configuration.description = "Website #{self.name} Configuration"
-    configuration.internal_identifier = configuration.description.underscore
+    configuration = ::Configuration.find_template('default_website_configuration').clone(true, "Website #{self.title} Configuration", "Website #{self.title} Configuration".underscore)
     configuration.update_configuration_item(ConfigurationItemType.find_by_internal_identifier('login_url'), '/login')
     configuration.update_configuration_item(ConfigurationItemType.find_by_internal_identifier('homepage_url'), '/home')
     self.configurations << configuration
@@ -230,7 +232,7 @@ class Website < ActiveRecord::Base
     end
 
     self.files.where("directory like '%/#{Rails.application.config.erp_tech_svcs.file_assets_location}/sites/#{self.iid}%'").all.each do |file_asset|
-      setup_hash[:files] << {:path => file_asset.directory, :name => file_asset.name, :roles => file_asset.roles.uniq.collect{|r| r.internal_identifier}}
+      setup_hash[:files] << {:path => file_asset.directory, :name => file_asset.name, :roles => file_asset.roles.uniq.collect { |r| r.internal_identifier }}
     end
 
     setup_hash
@@ -258,10 +260,8 @@ class Website < ActiveRecord::Base
     file_assets_path = Pathname.new(File.join(tmp_dir, 'files'))
     FileUtils.mkdir_p(file_assets_path) unless file_assets_path.exist?
 
-    sections.each do |website_section|
-      unless website_section.layout.blank?
-        File.open(File.join(sections_path, "#{website_section.internal_identifier}.rhtml"), 'wb+') { |f| f.puts(website_section.layout) }
-      end
+    sections.where('parent_id is null').each do |website_section|
+      save_section_layout_to_file(sections_path, website_section)
     end
 
     contents = sections.collect(&:contents).flatten.uniq
@@ -307,11 +307,49 @@ class Website < ActiveRecord::Base
         zip.add('setup.yml', tmp_dir + 'setup.yml')
       end
     end
+
+  end
+
+  def save_section_layout_to_file(sections_path, website_section)
+    unless website_section.layout.blank?
+      File.open(File.join(sections_path, "#{website_section.permalink}.rhtml"), 'wb+') { |f| f.puts(website_section.layout) }
+    end
+
+    # we need to handle child sections because internal identifier uniqueness is scoped by parent_id and website_id
+    # get all children of this section
+    unless website_section.children.empty?
+      sections_path = Pathname.new(File.join(sections_path, website_section.permalink))
+      FileUtils.mkdir_p(sections_path) unless sections_path.exist?
+
+      website_section.children.each do |website_section_child|
+        save_section_layout_to_file(sections_path, website_section_child)
+      end
+    end
+  end
+
+  def export_template
+    tmp_dir = Website.make_tmp_dir
+    template_zip_path = export
+
+    if !themes.active.first.is_a?(Theme)
+      return false
+    end
+
+    theme_zip_path = themes.active.first.export
+
+    zip_file_name = File.join(tmp_dir, self.iid + '-composite.zip')
+
+    Zip::ZipFile.open(zip_file_name, Zip::ZipFile::CREATE) do |zip_file|
+      zip_file.add(File.basename(template_zip_path, '.zip') + '-template.zip', template_zip_path)
+      zip_file.add(File.basename(theme_zip_path, '.zip') + '-theme.zip', theme_zip_path)
+    end
+
+    File.join(tmp_dir, self.iid + '-composite.zip')
   end
 
   class << self
     def make_tmp_dir
-      Pathname.new(Rails.root + "/tmp/website_export/tmp_#{Time.now.to_i.to_s}/").tap do |dir|
+      Pathname.new(File.join(Rails.root, "/tmp/website_export/tmp_#{Time.now.to_i.to_s}")).tap do |dir|
         FileUtils.mkdir_p(dir) unless dir.exist?
       end
     end
@@ -319,7 +357,7 @@ class Website < ActiveRecord::Base
     def import(file, current_user)
       file_support = ErpTechSvcs::FileSupport::Base.new(:storage => Rails.application.config.erp_tech_svcs.file_storage)
       message = ''
-      success = true
+      website = nil
 
       file = ActionController::UploadedTempfile.new("uploaded-theme").tap do |f|
         f.puts file.read
@@ -404,7 +442,7 @@ class Website < ActiveRecord::Base
               file = website.add_file(content[:data], File.join(file_support.root, file_asset[:path], file_asset[:name]))
 
               #handle security
-              unless file_asset[:roles].empty? 
+              unless file_asset[:roles].empty?
                 capability = file.add_capability(:download)
                 file_asset[:roles].each do |role_iid|
                   role = SecurityRole.find_by_internal_identifier(role_iid)
@@ -443,6 +481,173 @@ class Website < ActiveRecord::Base
 
           website.publish("Website Imported", current_user)
 
+        rescue => ex
+          Rails.logger.error "#{ex.inspect} #{ex.backtrace}"
+          website.destroy unless website.nil?
+          raise ex
+        end
+
+        website.save
+      else
+        message = 'Website already exists with that internal_identifier'
+      end
+
+      return website, message
+    end
+
+    def import_template_director(file, current_user)
+      file_object = file.tempfile
+      file_path = file_object.path
+
+      entries = []
+      begin
+        Zip::ZipFile.open(file_path) { |zip_file|
+          zip_file.each { |f|
+            f_path=File.join('public/waste', f.name)
+            FileUtils.mkdir_p(File.dirname(f_path))
+            zip_file.extract(f, f_path) unless File.exist?(f_path)
+            entries << f.name
+          }
+        }
+
+        entries.each do |entry|
+          if entry.match(/-template.zip/)
+            @website_result = import_template('public/waste/' + entry, current_user)
+          end
+        end
+        entries.each do |entry|
+          if entry.match(/-theme.zip/)
+            Theme.import_download_item('public/waste/' + entry, @website_result[0])
+          end
+        end
+        return @website_result[0], @website_result[1]
+      rescue Exception => e
+        return false, "Error"
+      end
+    end
+
+    def import_template(file, current_user)
+      file_support = ErpTechSvcs::FileSupport::Base.new(:storage => Rails.application.config.erp_tech_svcs.file_storage)
+      message = ''
+      website = nil
+
+      entries = []
+      setup_hash = nil
+
+      tmp_dir = Website.make_tmp_dir
+
+      Zip::ZipFile.open(file) do |zip|#passing in a file
+        #Zip::ZipFile.open(file.path) do |zip|
+        zip.each do |entry|
+          f_path = File.join(tmp_dir.to_s, entry.name)
+          FileUtils.mkdir_p(File.dirname(f_path))
+          zip.extract(entry, f_path) unless File.exist?(f_path)
+
+          next if entry.name =~ /__MACOSX\//
+          if entry.name =~ /setup.yml/
+            data = ''
+            entry.get_input_stream { |io| data = io.read }
+            data = StringIO.new(data) if data.present?
+            setup_hash = YAML.load(data)
+          else
+            type = entry.name.split('/')[0]
+            name = entry.name.split('/').last
+            next if name.nil?
+
+            if File.exist?(f_path) and !File.directory?(f_path)
+              entry_hash = {:type => type, :name => name, :path => entry.name}
+              entries << entry_hash unless name == 'sections' || name == 'articles' || name == 'excerpts' || name == 'documented contents'
+              entry_hash[:data] = File.open(f_path, "rb") { |io| io.read }
+            end
+          end
+
+        end
+      end
+      entries.uniq!
+      FileUtils.rm_rf(tmp_dir.to_s)
+
+      if Website.find_by_internal_identifier(setup_hash[:internal_identifier]).nil?
+        website = Website.new(
+            :name => setup_hash[:name],
+            :title => setup_hash[:title],
+            :subtitle => setup_hash[:subtitle],
+            :internal_identifier => setup_hash[:internal_identifier]
+        )
+
+        #TODO update to handle configurations
+
+        website.save!
+
+        #set default publication published by user
+        first_publication = website.published_websites.first
+        first_publication.published_by = current_user
+        first_publication.save
+
+        begin
+          #handle images
+          # entries.each do |entry|
+          #   puts "entry type '#{entry[:type]}'"
+          #   puts "entry name '#{entry[:name]}'"
+          #   puts "entry path '#{entry[:path]}'"
+          #   puts "entry data #{!entry[:data].blank?}"
+          # end
+          # puts "------------------"
+          setup_hash[:images].each do |image_asset|
+            filename = 'images' + image_asset[:path] + '/' + image_asset[:name]
+            #puts "image_asset '#{filename}'"
+            content = entries.find { |entry| entry[:type] == 'images' and entry[:path] == filename }
+            unless content.nil?
+              website.add_file(content[:data], File.join(file_support.root, image_asset[:path], image_asset[:name]))
+            end
+          end
+
+          #handle files
+          setup_hash[:files].each do |file_asset|
+            filename = 'files' + file_asset[:path] + '/' + file_asset[:name]
+            #puts "file_asset '#{filename}'"
+            content = entries.find { |entry| entry[:type] == 'files' and entry[:path] == filename }
+            unless content.nil?
+              file = website.add_file(content[:data], File.join(file_support.root, file_asset[:path], file_asset[:name]))
+
+              #handle security
+              unless file_asset[:roles].empty?
+                capability = file.add_capability(:download)
+                file_asset[:roles].each do |role_iid|
+                  role = SecurityRole.find_by_internal_identifier(role_iid)
+                  role.add_capability(capability)
+                end
+              end
+            end
+          end
+
+          #handle hosts
+          if WebsiteHost.last
+          setup_hash.merge(:hosts => 'localhost:3000')
+          end
+
+          if !setup_hash[:hosts].blank? and !setup_hash[:hosts].empty?
+            #set first host as primary host in configuration
+            website.configurations.first.update_configuration_item(ConfigurationItemType.find_by_internal_identifier('primary_host'), 'localhost:3000')
+            website.save
+          end
+
+          #handle sections
+          setup_hash[:sections].each do |section_hash|
+            build_section(section_hash, entries, website, current_user)
+          end
+          website.website_sections.update_paths!
+
+          #handle website_navs
+          setup_hash[:website_navs].each do |website_nav_hash|
+            website_nav = WebsiteNav.new(:name => website_nav_hash[:name])
+            website_nav_hash[:items].each do |item|
+              website_nav.website_nav_items << build_menu_item(item)
+            end
+            website.website_navs << website_nav
+          end
+
+          website.publish("Website Imported", current_user)
+
         rescue Exception => ex
           Rails.logger.error "#{ex.inspect} #{ex.backtrace}"
           website.destroy unless website.nil?
@@ -450,17 +655,38 @@ class Website < ActiveRecord::Base
         end
 
         website.save
-        success = true
       else
         message = 'Website already exists with that internal_identifier'
-        success = false
       end
 
-      return success, message
+      return website, message
+    end
+
+
+    def find_site_entry_in_zip(file)
+      zf = Zip::ZipFile.open(file)
+      zf.each_with_index {  |entry, index|
+        if entry.name.match(/-template.zip/) && !entry.name.match(/_./)
+          return entry
+        end
+      }
+    end
+
+    def find_theme_entries_in_zip(file)
+      entries = []
+      zf = Zip::ZipFile.new(file)
+      zf.each_with_index {  |entry, index|
+        if entry.name.match(/-theme.zip/) && !entry.name.match(/_./)
+          entries << entry
+        end
+      }
+      entries
     end
 
+
     protected
 
+
     def build_menu_item(hash)
       website_item = WebsiteNavItem.new(
           :title => hash[:title],
@@ -475,16 +701,16 @@ class Website < ActiveRecord::Base
         child_website_item = build_menu_item(item)
         child_website_item.move_to_child_of(website_item)
       end
-      
+
       #handle security
-      unless hash[:roles].empty? 
+      unless hash[:roles].empty?
         capability = website_item.add_capability(:view)
         hash[:roles].each do |role_iid|
           role = SecurityRole.find_by_internal_identifier(role_iid)
           role.add_capability(capability)
         end
       end
-      
+
       website_item
     end
 
@@ -498,7 +724,9 @@ class Website < ActiveRecord::Base
       section.internal_identifier = hash[:internal_identifier]
       section.permalink = hash[:permalink]
       section.path = hash[:path]
-      content = entries.find { |entry| entry[:type] == 'sections' and entry[:name] == "#{hash[:internal_identifier]}.rhtml" }
+      content = entries.find do |entry|
+        entry[:type] == 'sections' and entry[:name] == "#{hash[:permalink]}.rhtml" and entry[:path].split('.')[0] == "sections#{hash[:path]}"
+      end
 
       section.layout = content[:data] unless content.nil?
 
@@ -529,7 +757,7 @@ class Website < ActiveRecord::Base
       if section.is_a? OnlineDocumentSection
         section.use_markdown = hash[:use_markdown]
         section.save
-        extension_type =  hash[:use_markdown] ? 'md' : 'html'
+        extension_type = hash[:use_markdown] ? 'md' : 'html'
         entry_data = entries.find { |entry| entry[:type] == 'documented contents' and entry[:name] == "#{section.internal_identifier}.#{extension_type}" }[:data]
         documented_content = DocumentedContent.create(:title => section.title, :body_html => entry_data)
         DocumentedItem.create(:documented_content_id => documented_content.id, :online_document_section_id => section.id)
@@ -541,27 +769,31 @@ class Website < ActiveRecord::Base
           child_section.save
           child_section.move_to_child_of(section)
           # CREATE THE DOCUMENTED CONTENT HERE
-          extension_type =  section_hash[:use_markdown] ? 'md' : 'html'
+          extension_type = section_hash[:use_markdown] ? 'md' : 'html'
           entry_data = entries.find { |entry| entry[:type] == 'documented contents' and entry[:name] == "#{child_section.internal_identifier}.#{extension_type}" }[:data]
           documented_content = DocumentedContent.create(:title => child_section.title, :body_html => entry_data)
           DocumentedItem.create(:documented_content_id => documented_content.id, :online_document_section_id => child_section.id)
         end
       end
-      
+
       #handle security
       if hash[:roles] #if this is a OnlineDocumentSection will not have roles
-        unless hash[:roles].empty? 
+        unless hash[:roles].empty?
           capability = section.add_capability(:view)
           hash[:roles].each do |role_iid|
             role = SecurityRole.find_by_internal_identifier(role_iid)
+            if role.nil?
+              role = SecurityRole.create(internal_identifier: role_iid, description: role_iid.humanize)
+            end
             role.add_capability(capability)
           end
         end
       end
-      
+
       section
     end
 
+
   end
 
   def website_role_iid