knitkit 2.0.0

data/app/models/extensions/user.rb

@@ -0,0 +1,5 @@
+User.class_eval do
+  has_many :comments, :dependent => :nullify
+
+  alias :approved_comments :comments
+end

data/app/models/published_element.rb

@@ -0,0 +1,9 @@
+class PublishedElement < ActiveRecord::Base
+  belongs_to :published_website
+  belongs_to :published_element_record, :polymorphic => true
+  belongs_to :published_by, :class_name => "User"
+
+  def published_by_username
+    self.published_by.username rescue ''
+  end
+end

data/app/models/published_website.rb

@@ -0,0 +1,118 @@
+class PublishedWebsite < ActiveRecord::Base
+  belongs_to :website
+  belongs_to :published_by, :class_name => "User"
+  has_many   :published_elements, :dependent => :destroy
+
+  def published_by_username
+    self.published_by.username rescue ''
+  end
+
+  def self.activate(website, version, current_user)
+    published_websites = self.where('website_id = ?', website.id).all
+    published_websites.each do |published_website|
+      if published_website.version == version
+        published_website.active = true
+        published_website.published_by = current_user
+      else
+        published_website.active = false
+      end
+      published_website.save
+    end
+  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|
+      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
+
+      elements = elements | website_section.contents
+    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
+      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
+  end
+
+  def publish_element(comment, element, version, current_user)
+    new_publication = clone_publication(0.1, comment, 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
+
+  private
+
+  def clone_publication(version_increment, 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.published_by = current_user
+    published_website.comment = comment
+    published_website.save
+
+    #create new PublishedWebsiteElements
+    published_elements.each do |published_element|
+      new_published_element = PublishedElement.new
+      new_published_element.published_website = published_website
+      new_published_element.published_element_record = published_element.published_element_record
+      new_published_element.version = published_element.version
+      new_published_element.published_by = current_user
+      new_published_element.save
+    end
+
+    published_website
+  end
+end

data/app/models/theme.rb

@@ -0,0 +1,239 @@
+require 'yaml'
+require 'fileutils'
+
+class Theme < ActiveRecord::Base
+  THEME_STRUCTURE = ['stylesheets', 'javascripts', 'images', 'templates']
+  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_IMAGES_PATH = "#{Knitkit::Engine.root.to_s}/public/images/knitkit"
+
+  has_file_assets
+
+  class << self
+    def root_dir
+      @@root_dir ||= "#{Rails.root}/public"
+    end
+
+    def base_dir(website)
+      "#{root_dir}/sites/site-#{website.id}/themes"
+    end
+
+    def import(file, website)
+      name_and_id = file.original_filename.to_s.gsub(/(^.*(\\|\/))|(\.zip$)/, '')
+      theme_name = name_and_id.split('[').first
+      theme_id = name_and_id.split('[').last.gsub(']','')
+      return false unless valid_theme?(file)
+      Theme.create(:name => theme_name, :theme_id => theme_id, :website => website).tap do |theme|
+        theme.import(file)
+      end
+    end
+
+    def make_tmp_dir
+      random = Time.now.to_i.to_s.split('').sort_by { rand }
+      Pathname.new(Rails.root.to_s + "/tmp/themes/tmp_#{random}/").tap do |dir|
+        FileUtils.mkdir_p(dir) unless dir.exist?
+      end
+    end
+
+    def valid_theme?(file)
+      valid = false
+      Zip::ZipFile.open(file.path) do |zip|
+        zip.sort.each do |entry|
+          entry.name.split('/').each do |file|
+            valid = true if THEME_STRUCTURE.include?(file)
+          end
+        end
+      end
+      valid
+    end
+  end
+  
+  belongs_to :website
+
+  has_permalink :name, :theme_id, :scope => :website_id,
+    :only_when_blank => false, :sync_url => true
+
+  validates :name, :presence => {:message => 'Name cannot be blank'}
+  validates_uniqueness_of :theme_id, :scope => :website_id
+  
+  before_destroy :delete_theme_files!
+  
+  def path
+    "#{self.class.base_dir(website)}/#{theme_id}"
+  end
+
+  def url
+    "sites/site-#{website.id}/themes/#{theme_id}"
+  end
+  
+  def activate!
+    update_attributes! :active => true
+  end
+
+  def deactivate!
+    update_attributes! :active => false
+  end
+
+  def themed_widgets
+    widgets = []
+    ErpApp::Widgets::Base.installed_widgets.each do |widget_name|
+      widgets << widget_name unless self.files.where("directory like '/#{File.join(self.url, 'widgets', widget_name)}%'").empty?
+    end
+    widgets
+  end
+
+  def non_themed_widgets
+    already_themed_widgets = self.themed_widgets
+    widgets = []
+    ErpApp::Widgets::Base.installed_widgets.each do |widget_name|
+      widgets << widget_name unless already_themed_widgets.include?(widget_name)
+    end
+    widgets
+  end
+
+  def create_layouts_for_widget(widget)
+    file_support = ErpTechSvcs::FileSupport::Base.new
+    views_location = "::Widgets::#{widget.camelize}::Base".constantize.views_location
+    create_theme_files_for_directory_node(file_support.build_tree(views_location, :preload => true), :widgets, :path_to_replace => views_location, :widget_name => widget)
+  end
+
+  def about
+    %w(name author version homepage summary).inject({}) do |result, key|
+      result[key] = send(key)
+      result
+    end
+  end
+  
+  def import(file)
+    file_support = ErpTechSvcs::FileSupport::Base.new(:storage => ErpTechSvcs::FileSupport.options[:storage])
+    file = ActionController::UploadedTempfile.new("uploaded-theme").tap do |f|
+      f.puts file.read
+      f.original_filename = file.original_filename
+      f.read # no idea why we need this here, otherwise the zip can't be opened
+    end unless file.path
+
+    theme_root = Theme.find_theme_root(file)
+
+    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?
+          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(entry.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
+  end
+
+  def export
+    file_support = ErpTechSvcs::FileSupport::Base.new(:storage => ErpTechSvcs::FileSupport.options[:storage])
+    tmp_dir = Theme.make_tmp_dir
+    (tmp_dir + "#{name}[#{theme_id}].zip").tap do |file_name|
+      file_name.unlink if file_name.exist?
+      Zip::ZipFile.open(file_name, Zip::ZipFile::CREATE) do |zip|
+        files.each {|file|
+          contents = file_support.get_contents(File.join(file_support.root,file.directory,file.name))
+          relative_path = file.directory.sub("/#{url}",'')
+          path = FileUtils.mkdir_p(File.join(tmp_dir,relative_path))
+          full_path = File.join(path,file.name)
+          File.open(full_path, 'w+') {|f| f.puts(contents) }
+          zip.add(File.join(relative_path[1..relative_path.length],file.name), full_path) if ::File.exists?(full_path)
+        }
+        ::File.open(tmp_dir + 'about.yml', 'w') { |f| f.puts(about.to_yaml) }
+        zip.add('about.yml', tmp_dir + 'about.yml')
+      end
+    end
+  end
+
+  def has_template?(directory, name)
+    self.templates.find{|item| item.directory == File.join(path,directory).gsub(Rails.root.to_s, '') and item.name == name}
+  end
+
+  class << self
+    def find_theme_root(file)
+      theme_root = ''
+      Zip::ZipFile.open(file.path) 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_in_path(path)
+      root_found = false
+      theme_root = ''
+      path.split('/').each do |piece|
+        if piece == 'about.yml' || THEME_STRUCTURE.include?(piece)
+          root_found = true
+        else
+          theme_root += piece + '/' if !piece.match('\.') && !root_found
+        end
+      end
+      root_found ? theme_root : false
+    end
+
+    def strip_path(file_name, path)
+      file_name.sub(path, '')
+    end
+  end
+
+  def delete_theme_files!
+    file_support = ErpTechSvcs::FileSupport::Base.new(:storage => ErpTechSvcs::FileSupport.options[:storage])
+    file_support.delete_file(File.join(file_support.root,self.url), :force => true)
+  end
+
+  def create_theme_files!
+    file_support = ErpTechSvcs::FileSupport::Base.new
+    create_theme_files_for_directory_node(file_support.build_tree(BASE_LAYOUTS_VIEWS_PATH, :preload => true), :templates, :path_to_replace => BASE_LAYOUTS_VIEWS_PATH)
+    create_theme_files_for_directory_node(file_support.build_tree(KNITKIT_WEBSITE_STYLESHEETS_PATH, :preload => true), :stylesheets, :path_to_replace => KNITKIT_WEBSITE_STYLESHEETS_PATH)
+    create_theme_files_for_directory_node(file_support.build_tree(KNITKIT_WEBSITE_IMAGES_PATH, :preload => true), :images, :path_to_replace => KNITKIT_WEBSITE_IMAGES_PATH)
+  end
+
+  private
+
+  def create_theme_files_for_directory_node(node, type, options={})
+    node[:children].each do |child_node|
+      child_node[:leaf] ? save_theme_file(child_node[:id], type, options) : create_theme_files_for_directory_node(child_node, type, options)
+    end
+  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}")
+    end
+
+    self.add_file(contents, path)
+  end
+  
+end

data/app/models/website.rb

@@ -0,0 +1,457 @@
+class Website < ActiveRecord::Base
+  after_destroy :remove_sites_directory, :remove_website_role
+  after_create  :setup_website
+  
+  has_file_assets
+  
+  has_many :published_websites, :dependent => :destroy
+  has_many :website_hosts, :dependent => :destroy
+  has_many :website_navs, :dependent => :destroy
+  has_many :website_inquiries, :dependent => :destroy
+
+  alias :hosts :website_hosts
+
+  has_many :website_sections, :dependent => :destroy, :order => :lft do
+    def paths
+      collect{|website_section| website_section.paths}.flatten
+    end
+
+    #have to do a sort by to override what awesome nested set does for the order by (lft)
+    def positioned
+      where('parent_id is null').sort_by!(&:position)
+    end
+    
+    def update_paths!
+      all.each{|section| section.self_and_descendants.each{|_section| _section.update_path!}}
+    end
+  end
+  alias :sections :website_sections
+  
+  has_many :themes, :dependent => :destroy do
+    def active
+      where('active = 1')
+    end
+  end
+
+  def all_section_paths
+    ActiveRecord::Base.connection.execute("select path from website_sections where website_id = #{self.id}").collect{|row| row['path']}
+  end
+
+  def self.find_by_host(host)
+    website = nil
+    website_host = WebsiteHost.find_by_host(host)
+    website = website_host.website unless website_host.nil?
+    website
+  end
+
+  def deactivate_themes!
+    themes.each do |theme|
+      theme.deactivate!
+    end
+  end
+
+  def publish_element(comment, element, version, current_user)
+    self.published_websites.last.publish_element(comment, element, version, current_user)
+  end
+
+  def publish(comment, current_user)
+    self.published_websites.last.publish(comment, current_user)
+  end
+
+  def set_publication_version(version, current_user)
+    PublishedWebsite.activate(self, version, current_user)
+  end
+
+  def active_publication
+    self.published_websites.all.find{|item| item.active}
+  end
+
+  def role
+    Role.iid(website_role_iid)
+  end
+
+  def setup_website
+    PublishedWebsite.create(:website => self, :version => 0, :active => true, :comment => 'New Site Created')
+    Role.create(:description => "Website #{self.title}", :internal_identifier => website_role_iid)
+  end
+
+  def remove_sites_directory
+    file_support = ErpTechSvcs::FileSupport::Base.new(:storage => ErpTechSvcs::FileSupport.options[:storage])
+    begin
+      file_support.delete_file(File.join(file_support.root,"sites/site-#{self.id}"), :force => true)
+    rescue
+      #do nothing it may not exist
+    end
+  end
+
+  def remove_website_role
+    role.destroy if role
+  end
+  
+  def setup_default_pages
+    # create default sections for each widget using widget layout
+    widget_classes = [
+      ::Widgets::ContactUs::Base, 
+      ::Widgets::Search::Base, 
+      ::Widgets::ManageProfile::Base,
+      ::Widgets::Login::Base,
+      ::Widgets::Signup::Base,
+      ::Widgets::ResetPassword::Base
+    ] 
+    widget_classes.each do |widget_class|
+      website_section = WebsiteSection.new
+      website_section.title = widget_class.title
+      website_section.in_menu = true unless ["Login", "Sign Up", "Reset Password"].include?(widget_class.title)
+      website_section.layout = widget_class.base_layout
+      website_section.save
+      #make manage profile secured
+      website_section.add_role(self.role) if widget_class.title == 'Manage Profile'
+      self.website_sections << website_section
+    end
+    self.save
+    self.website_sections.update_paths!
+  end
+
+  def export_setup
+    setup_hash = {
+      :name => name,
+      :hosts => hosts.collect(&:host),
+      :title => title,
+      :subtitle => subtitle,
+      :email => email,
+      :auto_activate_publication => auto_activate_publication,
+      :email_inquiries => email_inquiries,
+      :sections => [],
+      :images => [],
+      :files => [],
+      :website_navs => []
+    }
+
+    setup_hash[:sections] = sections.positioned.collect do |website_section|
+      build_section_hash(website_section)
+    end
+
+    setup_hash[:website_navs] = website_navs.collect do |website_nav|
+      {
+        :name => website_nav.name,
+        :items => website_nav.items.positioned.map{|website_nav_item| build_menu_item_hash(website_nav_item)}
+      }
+    end
+
+    self.files.where("directory like '%/sites/site-#{self.id}/images%'").all.each do |image_asset|
+      setup_hash[:images] << {:path => image_asset.directory, :name => image_asset.name}
+    end
+
+    self.files.where("directory like '%/sites/site-#{self.id}/file_assets%'").all.each do |file_asset|
+      setup_hash[:files] << {:path => file_asset.directory, :name => file_asset.name}
+    end
+
+    setup_hash
+  end
+
+  def export
+    tmp_dir = Website.make_tmp_dir
+    file_support = ErpTechSvcs::FileSupport::Base.new(:storage => ErpTechSvcs::FileSupport.options[:storage])
+    
+    sections_path = Pathname.new(File.join(tmp_dir,'sections'))
+    FileUtils.mkdir_p(sections_path) unless sections_path.exist?
+
+    articles_path = Pathname.new(File.join(tmp_dir,'articles'))
+    FileUtils.mkdir_p(articles_path) unless articles_path.exist?
+
+    excerpts_path = Pathname.new(File.join(tmp_dir,'excerpts'))
+    FileUtils.mkdir_p(excerpts_path) unless excerpts_path.exist?
+
+    image_assets_path = Pathname.new(File.join(tmp_dir,'images'))
+    FileUtils.mkdir_p(image_assets_path) unless image_assets_path.exist?
+
+    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.title}.rhtml"), 'w+') {|f| f.puts(website_section.layout) }
+      end
+    end
+
+    contents = sections.collect(&:contents).flatten.uniq
+    contents.each do |content|
+      File.open(File.join(articles_path,"#{content.title}.html"), 'w+') {|f| f.puts(content.body_html) }
+      unless content.excerpt_html.blank?
+        File.open(File.join(excerpts_path,"#{content.title}.html"), 'w+') {|f| f.puts(content.excerpt_html) }
+      end
+    end
+
+    self.files.where("directory like '%/sites/site-#{self.id}/images%'").all.each do |image_asset|
+      contents = file_support.get_contents(File.join(file_support.root,image_asset.directory,image_asset.name))
+      File.open(File.join(image_assets_path,image_asset.name), 'w+') {|f| f.puts(contents) }
+    end
+
+    self.files.where("directory like '%/sites/site-#{self.id}/file_assets%'").all.each do |file_asset|
+      contents = file_support.get_contents(File.join(file_support.root,file_asset.directory,file_asset.name))
+      File.open(File.join(file_assets_path,file_asset.name), 'w+') {|f| f.puts(contents) }
+    end
+
+    files = []
+
+    Dir.entries(sections_path).each do |entry|
+      next if entry =~ /^\./
+      files << {:path => File.join(sections_path,entry), :name => File.join('sections/',File.basename(entry))}
+    end
+
+    Dir.entries(articles_path).each do |entry|
+      next if entry =~ /^\./
+      files << {:path => File.join(articles_path,entry), :name => File.join('articles/',File.basename(entry))}
+    end
+
+    Dir.entries(excerpts_path).each do |entry|
+      next if entry =~ /^\./
+      files << {:path => File.join(excerpts_path,entry), :name => File.join('excerpts/',File.basename(entry))}
+    end
+
+    Dir.entries(image_assets_path).each do |entry|
+      next if entry =~ /^\./
+      files << {:path => File.join(image_assets_path,entry), :name => File.join('images/',File.basename(entry))}
+    end
+
+    Dir.entries(file_assets_path).each do |entry|
+      next if entry =~ /^\./
+      files << {:path => File.join(file_assets_path,entry), :name => File.join('files/',File.basename(entry))}
+    end
+
+    files.uniq!
+
+    (tmp_dir + "#{name}.zip").tap do |file_name|
+      file_name.unlink if file_name.exist?
+      Zip::ZipFile.open(file_name, Zip::ZipFile::CREATE) do |zip|
+        files.each { |file| zip.add(file[:name], file[:path]) if File.exists?(file[:path]) }
+        File.open(tmp_dir + 'setup.yml', 'w') { |f| f.puts(export_setup.to_yaml) }
+        zip.add('setup.yml', tmp_dir + 'setup.yml')
+      end
+    end
+  end
+
+  class << self
+    def make_tmp_dir
+      random = Time.now.to_i.to_s.split('').sort_by { rand }
+      Pathname.new(Rails.root + "/tmp/website_export/tmp_#{random}/").tap do |dir|
+        FileUtils.mkdir_p(dir) unless dir.exist?
+      end
+    end
+
+    def import(file, current_user)
+      file_support = ErpTechSvcs::FileSupport::Base.new(:storage => ErpTechSvcs::FileSupport.options[:storage])
+      message = ''
+      success = true
+
+      file = ActionController::UploadedTempfile.new("uploaded-theme").tap do |f|
+        f.puts file.read
+        f.original_filename = file.original_filename
+        f.read # no idea why we need this here, otherwise the zip can't be opened
+      end unless file.path
+      
+      entries = []
+      setup_hash = nil
+
+      Zip::ZipFile.open(file.path) do |zip|
+        zip.each do |entry|
+          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('/')[(entry.name.split('/').count - 2)]
+            name = entry.name.split('/').last
+            next if name.nil?
+            data = ''
+            entry_hash = {:type => type, :name => name}
+            entries << entry_hash unless name == 'sections' || name == 'articles' || name == 'excerpts'
+            entries.uniq!
+            data = entry.get_input_stream.read
+            entry_hash[:data] = data
+          end
+        end
+      end
+
+      if Website.find_by_name(setup_hash[:name]).nil?
+        website = Website.create(
+          :name => setup_hash[:name],
+          :title => setup_hash[:title],
+          :subtitle => setup_hash[:subtitle],
+          :email => setup_hash[:email],
+          :email_inquiries => setup_hash[:email_inquiries],
+          :auto_activate_publication => setup_hash[:auto_activate_publication]
+        )
+        
+        #set default publication published by user
+        first_publication = website.published_websites.first
+        first_publication.published_by = current_user
+        first_publication.save
+        
+        begin
+
+          #handle images
+          setup_hash[:images].each do |image_asset|
+            content = entries.find{|entry| entry[:type] == 'images' and entry[:name] == image_asset[:name]}[:data]
+            website.add_file(content, File.join(file_support.root, image_asset[:path].sub(/site-[0-9][0-9]*/, "site-#{website.id}"), image_asset[:name]))
+          end
+
+          #handle files
+          setup_hash[:files].each do |file_asset|
+            content = entries.find{|entry| entry[:type] == 'files' and entry[:name] == file_asset[:name]}[:data]
+            website.add_file(content, File.join(file_support.root, file_asset[:path].sub(/site-[0-9][0-9]*/, "site-#{website.id}"), file_asset[:name]))
+          end
+
+          #handle hosts
+          setup_hash[:hosts].each do |host|
+            website.hosts << WebsiteHost.create(:host => host)
+            website.save
+          end
+
+          #handle sections
+          setup_hash[:sections].each do |section_hash|
+            build_section(section_hash, entries, website)
+          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
+          website.destroy unless website.nil?
+          raise ex
+        end
+
+        website.save
+        success = true
+      else
+        message = 'Website already exists with that name'
+        success = false
+      end
+
+      return success, message
+    end
+
+    protected
+
+    def build_menu_item(hash)
+      website_item = WebsiteNavItem.new(
+        :title => hash[:title],
+        :url => hash[:url],
+        :position => hash[:position]
+      )
+      unless hash[:linked_to_item_type].blank?
+        website_item.linked_to_item = WebsiteSection.find_by_path(hash[:linked_to_item_path])
+      end
+      website_item.save
+      hash[:items].each do |item|
+        child_website_item = build_menu_item(item)
+        child_website_item.move_to_child_of(website_item)
+      end
+      unless hash[:roles].empty?
+        hash[:roles].each do |role|
+          website_item.add_role(Role.find_by_internal_identifier(role)) rescue nil #do nothing if the role does not exist
+        end
+      end
+      website_item
+    end
+
+    def build_section(hash, entries, website)
+      klass = hash[:type].constantize
+      section = klass.new(:title => hash[:name], :in_menu => hash[:in_menu], :position => hash[:position])
+      section.permalink = hash[:permalink]
+      section.path = hash[:path]
+      unless entries.find{|entry| entry[:type] == 'sections' and entry[:name] == "#{hash[:name]}.rhtml"}.nil?
+        section.layout = entries.find{|entry| entry[:type] == 'sections' and entry[:name] == "#{hash[:name]}.rhtml"}[:data]
+      end
+      hash[:articles].each do |article_hash|
+        article = Article.find_by_title(article_hash[:name])
+        if article.nil?
+          article = Article.new(:title => article_hash[:name], :display_title => article_hash[:display_title])
+          article.tag_list = article_hash[:tag_list].split(',').collect{|t| t.strip() } unless article_hash[:tag_list].blank?
+          article.body_html = entries.find{|entry| entry[:type] == 'articles' and entry[:name] == "#{article_hash[:name]}.html"}[:data]
+          unless entries.find{|entry| entry[:type] == 'excerpts' and entry[:name] == "#{article_hash[:name]}.html"}.nil?
+            article.excerpt_html = entries.find{|entry| entry[:type] == 'excerpts' and entry[:name] == "#{article_hash[:name]}.html"}[:data]
+          end
+        end
+        section.contents << article
+        section.save
+        article.update_content_area_and_position_by_section(section, article_hash[:content_area], article_hash[:position])
+      end
+      website.website_sections << section
+      section.save
+      hash[:sections].each do |section_hash|
+        child_section = build_section(section_hash, entries, website)
+        child_section.move_to_child_of(section)
+      end
+      unless hash[:roles].empty?
+        hash[:roles].each do |role|
+          section.add_role(Role.find_by_internal_identifier(role)) rescue nil #do nothing if the role does not exist
+        end
+      end
+      section
+    end
+    
+  end
+
+  private
+  
+  def website_role_iid
+    "website_#{self.name.underscore.gsub("'","").gsub(",","")}_access"
+  end
+  
+  def build_section_hash(section)
+    section_hash = {
+      :name => section.title,
+      :has_layout => !section.layout.blank?,
+      :type => section.class.to_s,
+      :in_menu => section.in_menu,
+      :articles => [],
+      :roles => section.roles.collect{|role| role.internal_identifier},
+      :path => section.path,
+      :permalink => section.permalink,
+      :internal_identifier => section.internal_identifier,
+      :position => section.position,
+      :sections => section.children.each.map{|child| build_section_hash(child)}
+    }
+
+    section.contents.each do |content|
+      content_area = content.content_area_by_website_section(section)
+      position = content.position_by_website_section(section)
+      section_hash[:articles] << {
+        :name => content.title,
+        :tag_list => content.tag_list.join(', '),
+        :content_area => content_area,
+        :position => position,
+        :display_title => content.display_title,
+        :internal_identifier => content.internal_identifier
+      }
+    end
+
+    section_hash
+  end
+
+
+  def build_menu_item_hash(menu_item)
+    {
+      :title => menu_item.title,
+      :url => menu_item.url,
+      :roles => menu_item.roles.collect{|role| role.internal_identifier},
+      :linked_to_item_type => menu_item.linked_to_item_type,
+      :linked_to_item_path => menu_item.linked_to_item.nil? ? nil : menu_item.linked_to_item.path,
+      :position => menu_item.position,
+      :items => menu_item.children.collect{|child| build_menu_item_hash(child)}
+    }
+  end
+
+end