class ZeroFetcher

Public Class Methods

cleanUpFolder(path, files) click to toggle source
# File lib/zerofetcher.rb, line 823
def self.cleanUpFolder(path, files)
    self.log('Clean up Path ' + path)
    existing_files = Dir.glob(File.join(path, "*"))
    
    existing_files.each do |file|
        file_basename = Pathname.new(file).basename.to_s
        
        if !files.include?( file_basename )
            self.log(' - ' + file)
            FileUtils.rm(file)
        end
    end
end
cleanUpPages( path, pages ) click to toggle source
# File lib/zerofetcher.rb, line 837
def self.cleanUpPages( path, pages )
    # clean up this folder
    self.cleanUpPagesFolder( path, pages )

    ignore_dirs = ['assets','node_modules','nbproject']
    ignore_starts = ['.','_']
    dirs = Dir.entries( path ).select {|entry| File.directory? File.join(path,entry) and !(ignore_dirs.include?(entry) || ignore_starts.include?( entry[0] )) }

    dirs.each do |dir|
        this_dir = path + '/' + dir
        if !File.exist?( this_dir + '/.keep' )
            #puts "Clean Dir " + dir
            self.cleanUpPagesFolder( this_dir, pages )
        end
    end
end
cleanUpPagesFolder( path, pages ) click to toggle source
# File lib/zerofetcher.rb, line 854
def self.cleanUpPagesFolder( path, pages )
    existing_pages_files = Dir.glob(File.join(path, "*.md"))

    existing_pages_files.each do |file|
        #puts " - FILE " + file
        file_basename = Pathname.new(file).basename.to_s
        #puts " - BSF["+file_basename+"] FILE " + file
        if 'README.md' != file_basename
            if !pages.include?( file.downcase )
                #puts " - Deleting " + file
                self.log(" - Deleting:"+file)
                FileUtils.rm(file)
            end
        end
    end
end
getAndSaveFile(source, dest) click to toggle source
# File lib/zerofetcher.rb, line 738
def self.getAndSaveFile(source, dest)
    if !Pathname.new(dest).file?
        self.log('Get/Save ' + dest)
        uri = URI.encode(source)
        
        begin
            open(dest, 'wb') do |file|
                begin
                    file << open(uri).read
                rescue
                    puts uri + " could not be read"
                    return false
                end
            end                
        rescue
            puts 'source ['+source+'] Could not be opened to save'
            self.log('source ['+source+'] Could not be opened to save')
            return false
        end
    end
end
getAndSaveImages(source, dest) click to toggle source
# File lib/zerofetcher.rb, line 766
def self.getAndSaveImages(source, dest)
    images = {
        'original' => File.basename( dest )
    }
          
    # Save Original
    if !File.file?( dest )
        if self.getAndSaveFile( source, dest )
            self.optimizeImage( dest )
        end
    end
    
    # Save Variants
    if @@image_variants
        @@image_variants.each do |variant|
            v_source = self.getImageVariantSource(source, variant)
            v_dest = self.getImageVariantDestination(dest, variant)
            
            if !File.file?( v_dest )
                if self.getAndSaveFile( v_source, v_dest )
                    self.optimizeImage( v_dest )
                end
            end
            
            images[ variant['key'] ] = File.basename( v_dest )
        end
    end
    
    return images
end
getImageVariantDestination(source, variant) click to toggle source
# File lib/zerofetcher.rb, line 815
def self.getImageVariantDestination(source, variant)
    ext = File.extname( source )
    basename  = File.basename( source, ext )
    dirname  = File.dirname( source )
            
    return dirname + '/' + basename + '_' + variant['key'] + ext
end
getImageVariantSource(source, variant) click to toggle source
# File lib/zerofetcher.rb, line 797
def self.getImageVariantSource(source, variant)        
    qs = {}
    
    if variant['width']
        qs['w'] = variant['width']
    end
    if variant['height']
        qs['h'] = variant['height']
    end
    if variant['crop']
        qs['zoomfit'] = "1"
    end
    
    new_source = source + "?" + URI.encode_www_form(qs)
    
    return new_source  
end
loadDataFromApi(end_point, api_key, site_id) click to toggle source
# File lib/zerofetcher.rb, line 721
def self.loadDataFromApi(end_point, api_key, site_id)
    uri = URI(end_point+'/api/Sites/allcontent')
    params = { :key => api_key, :site_id => site_id }
    uri.query = URI.encode_www_form(params)

    res = Net::HTTP.get_response(uri)
    
    begin  
        json_data = JSON.parse(res.body)
    rescue
        puts "Server did not return JSON data. Check to make sure your endpoint is valid ["+end_point+"]"
        return false
    end  
    
    return json_data['data']
end
log(data) click to toggle source
# File lib/zerofetcher.rb, line 704
def self.log(data)
    @@logger.debug { data }
end
optimizeImage(dest) click to toggle source
# File lib/zerofetcher.rb, line 760
def self.optimizeImage(dest)
    # disabled optimize here only
    return true
    #ImageOptimizer.new(dest, quality: 90, quiet: true).optimize
end
readFile(file) click to toggle source
# File lib/zerofetcher.rb, line 708
def self.readFile(file)
    file = File.open(file, "r")
    data = file.read
    file.close
    return data
end
run() click to toggle source
# File lib/zerofetcher.rb, line 21
    def self.run        
        # Paths
        app_path = File.dirname(__FILE__)
        jekyll_path = Dir.pwd
        @@jekyll_path = jekyll_path
        
        gitignores = [
            '_logs',
            '_posts',
            '_includes/pages',
            '_includes/content_blocks',
        ]

        # App Requires
        FileUtils::mkdir_p jekyll_path+'/_logs'         
        FileUtils::mkdir_p jekyll_path+'/_data'
        FileUtils::mkdir_p jekyll_path+'/_posts'
        FileUtils::mkdir_p jekyll_path+'/assets'
        FileUtils::mkdir_p jekyll_path+'/assets/images'
        FileUtils::mkdir_p jekyll_path+'/assets/images/pages'
        FileUtils::mkdir_p jekyll_path+'/assets/files'
        FileUtils::mkdir_p jekyll_path+'/assets/images/tax-images'
        FileUtils::mkdir_p jekyll_path+'/_includes'
        FileUtils::mkdir_p jekyll_path+'/_includes/pages'
        FileUtils::mkdir_p jekyll_path+'/_includes/content_blocks'
        
        # Setup Logger
        @@logger = Logger.new(jekyll_path + '/_logs/logfile.log', 10, 1024000)

        if !Pathname.new(jekyll_path+"/_config.yml").file?
            self.log('_config.yml not found')
            abort('_config.yml not found')
        end

        config = YAML.load_file(jekyll_path+"/_config.yml")

        if !config.has_key?('fetcher')
            self.log('No Fetcher Info Found')
            abort('No Fetcher Info Found')
        end

        end_point = config['fetcher']['end_point']
        @@end_point = end_point 
        site_id = config['fetcher']['site_id'].to_s
        @@site_id = site_id;

        # Load data from API
        data = self.loadDataFromApi(end_point, config['fetcher']['api_key'], site_id)
        
        if data == false
            return
        end
        
        # Create empty collection hash
        collection_config = {};

        # Site Info
        if data.key?("site")
            self.writeFile( jekyll_path+'/_data/site.json', JSON.pretty_generate(data['site']) )
            self.log('Writing File /_data/site.json')
        end
        
        # write .htaccess file
        htaccess = '<IfModule mod_headers.c>
  <FilesMatch "\.(ttf|ttc|otf|eot|woff|woff2|font.css|css|js)$">
    Header set Access-Control-Allow-Origin "*"
  </FilesMatch>
</IfModule>
RewriteEngine On
Redirect 301 /d3panel '+end_point+'/d3panel?sitekey='+data['site']['key']+'
ErrorDocument 404 /404/index.html'

        if data['site']['site_down'] == "1"
            htaccess = 'Redirect 302 / https://d3corp.com/site-down/?status=closed'
        end

        self.writeFile( jekyll_path+'/.htaccess', htaccess )
        
        # Image Variants
        @@image_variants = data['image_variants']

        # Pages
        if data.key?("pages")
            pages_files_saved = Array.new
            content_files_saved = Array.new

            pages_folder = jekyll_path+'/_includes/pages'

            puts 'Pages - ' + data['pages'].length.to_s
            self.log('Pages - ' + data['pages'].length.to_s)

            # array to store hash info on all pages
            pages = Array.new

            # Loop through each page
            data['pages'].each do |page|
                puts ' - ' + page['name']
                self.log(' - ' + page['name'])

                jpage = JekyllFile.new(jekyll_path, page, 'page')

                content_file = jpage.saveContentFile(pages_folder, page['url']+'.md', page['content'])
                content_files_saved.push( content_file.downcase )
                jpage.savePageFile

                #pages_files_saved.push(jpage.getFileName)
                #pages_files_saved.push( Pathname.new( jpage.getFileName ).basename.to_s )
                pages_files_saved.push( jpage.getFileName.downcase )

                self.log(" - Saved:"+jpage.getFileName)

                # Add to pages array
                page_info = {
                    'id' => page['id'],
                    'name' => page['name'],
                    'slug' => page['slug'],
                    'url' => page['url'],
                    'sitemap' => (page['ignore_sitemap']) ? false : true,
                    'layout' => page['layout'],
                    'meta_title' => (page['meta_title']) ? page['meta_title'] : page['name'],
                    'meta_description' => page['meta_description'],
                    'short_description' => page['short_description'],
                    'parent_id' => page['parent_id'],
                }
                if page['image']
                    page_info['image'] = 'images/pages/' + page['image']
                end
                pages.push(page_info)
                
                # save image
                if page['image']
                    page['image'] = self.getAndSaveImages(end_point + '/media/images/'+site_id+'/pages/' + page['image'], jekyll_path+'/assets/images/pages/' + page['image'])
                end
            end

            self.writeFile( jekyll_path+'/_data/pages.json', JSON.pretty_generate(pages) )
            self.log("Writing File /_data/pages.json")

            #puts "pages_files_saved"
            #puts pages_files_saved

            # Clean Unused Pages
            self.cleanUpPages( jekyll_path, pages_files_saved )

            # Clean up content files
            self.cleanUpPages( pages_folder, content_files_saved )
        end      

        # Variables
        if data.key?("variables")
            self.writeFile( jekyll_path+'/_data/vars.json', JSON.pretty_generate(data['variables']) )
            self.log("Writing File /_data/vars.json")
        end

        # Content Blocks v2
        if data.key?("content_blocks")
            puts 'Content Blocks - ' + data['content_blocks'].length.to_s
            self.log('Content Blocks - ' + data['content_blocks'].length.to_s)
            cb_folder = jekyll_path+'/_includes/content_blocks'

            # Save original .md files
            data['content_blocks'].each do |content_block|
                self.log('writing File /_includes/content_blocks/'+content_block['key']+'.md')
                self.writeFile( cb_folder+'/'+content_block['key']+'.md' , content_block['content'].to_s );
            end

            # Save json data file
            self.writeFile( jekyll_path+'/_data/content_blocks.json', JSON.pretty_generate(data['content_blocks']) )
            self.log('Writing file /_data/galleries.json')
        end
        
        # Content Images
        if data.key?("content_images")
            FileUtils::mkdir_p jekyll_path+'/assets/images/content'
          
            puts 'Content Images - ' + data['content_images'].length.to_s
            self.log('Content Images - ' + data['content_images'].length.to_s)

            data['content_images'].each do |image|
                image = self.getAndSaveImages(end_point + '/media/images/'+site_id+'/content-blocks/' + image, jekyll_path+'/assets/images/content/' + image)
            end
            
            self.writeFile( jekyll_path+'/_data/content_images.json', JSON.pretty_generate(data['content_images']) )
        end
        
        # Taxonomy
        if data.key?("taxonomy")
            data['taxonomy'].each do |taxonomy_data_type|
                taxonomy_data_type['taxonomies'].each do |taxonomy|
                    if '1' == taxonomy['enable_images']
                        FileUtils::mkdir_p jekyll_path+'/assets/images/tax-images/' + taxonomy['id']

                        if taxonomy.key?("terms")
                            taxonomy['terms'].each do |term|
                                if term['image']
                                    image_path = jekyll_path+'/assets/images/tax-images/' + term['taxonomy_id'] 
                                    src_image = end_point + '/media/images/'+site_id+'/taxonomies/' + term["image"]

                                    #puts 'A: ' + src_image + ' -> ' + image_path + '/' + term["image"]

                                    term['image'] = self.getAndSaveImages(src_image, image_path + '/' + term["image"])
                                end
                            end
                        end
                    end
                end
            end
            
            self.writeFile( jekyll_path+'/_data/taxonomy.json', JSON.pretty_generate(data['taxonomy']) );
            self.log("Writing File /_data/taxonomy.json")
        end
        
        # Nav Menus
        if data.key?("nav_menus")
            puts "Make Dir" + jekyll_path+'/assets/images/nav-items'
            FileUtils::mkdir_p jekyll_path+'/assets/images/nav-items'

            puts 'Nav menus - ' + data['nav_menus'].length.to_s
            self.log('Nav Menus - ' + data['nav_menus'].length.to_s)

            data['nav_menus'].each do |nav_menu|
                puts "Nav Menus"
                if nav_menu['items']
                    puts "Nav Menu Items"
                    nav_menu['items'].each do |nav_menu_item|
                        if nav_menu_item['icon_image']
                            puts "Nav Item Image"
                            image_path = jekyll_path+'/assets/images/nav-items' 
                            src_image = end_point + '/media/images/'+site_id+'/nav_items/' +nav_menu_item['icon_image']
                            nav_menu_item['icon_image'] = self.getAndSaveImages(src_image, image_path + '/' + nav_menu_item['icon_image'])
                        end
                    end
                end
            end

            self.writeFile( jekyll_path+'/_data/nav_menus.json', JSON.pretty_generate(data['nav_menus']) )
        end
        
        # Posts
        existing_post_files = Dir.glob(File.join(jekyll_path+'/_posts', "*"))

        # Remove all post files
        existing_post_files.each do |file|
            self.log('Deleting Post File ' + file)
            FileUtils.rm(file)
        end

        # Post files
        if data.key?("posts")
            FileUtils::mkdir_p jekyll_path+'/assets/images/posts'
            
            puts "Posts - " + data['posts'].length.to_s
            data['posts'].each do |post|
                self.log('Saving Post File ' + post['date']+'-'+post['slug']+'.md')
                
                # Do Tax
                self.taxonomyImages(post)
                
                # save image
                if post['image']
                    post['image'] = self.getAndSaveImages(end_point + '/media/images/'+site_id+'/posts/' + post['image'], jekyll_path+'/assets/images/posts/' + post['image'])
                end
                
                jpost = JekyllPost.new(jekyll_path+'/_posts', post)
                jpost.savePageFile
            end
        end


        # Galleries
        if data.key?("galleries")
            FileUtils::mkdir_p jekyll_path+'/assets/images/galleries'

            puts "Galleries - " + data['galleries'].length.to_s
            self.log("Galleries - " + data['galleries'].length.to_s)

            # Create files saved array
            gallery_files_saved = Array.new

            # set collection path
            gallery_collection_path = jekyll_path+'/_gallery'

            if data['site'].key?('gallery_make_detail_pages') && data['site']['gallery_make_detail_pages'] == "1"
                FileUtils::mkdir_p gallery_collection_path
                collection_config[ 'gallery' ] = {'output' => true}
            end

            # Save Photos
            data['galleries'].each_with_index do |gallery,idx|
                FileUtils::mkdir_p jekyll_path+'/assets/images/galleries/' + gallery['id']

                puts " - " + gallery['name'] + ' has ' + gallery['photos'].length.to_s + ' photos'
                self.log(" - " + gallery['name'] + ' has ' + gallery['photos'].length.to_s + ' photos')

                gallery['photos'].each_with_index do |photo,pidx|
                    photo['image'] = self.getAndSaveImages(end_point + '/media/images/'+site_id+'/galleries/photos/' + photo['image'], jekyll_path+'/assets/images/galleries/' + gallery['id'] + '/' + photo['image'])
                end

                # Detail Pages
                if data['site'].key?('gallery_make_detail_pages') && data['site']['gallery_make_detail_pages'] == "1"
                
                    self.log('Saving Event File ' + gallery['slug']+'.md')

                    if data['site'].key?('gallery_detail_layout') && data['site']['gallery_detail_layout'] != ""
                        gallery['layout'] = data['site']['gallery_detail_layout']
                    end

                    gallery_data = gallery.clone
                    gallery_data.delete('id')
                    gallery_data[ 'gallery_id' ] = gallery['id']

                    jfile = JekyllFile.new(gallery_collection_path, gallery_data, 'collection', gallery['slug'])
                    jfile.savePageFile

                    gallery_files_saved.push( Pathname.new( jfile.getFileName ).basename.to_s )
                end
            end
            
            # Save Json Data
            self.writeFile( jekyll_path+'/_data/galleries.json', JSON.pretty_generate(data['galleries']) )
            self.log('Writing file /_data/galleries.json')
        end

        # Calendar
        if data.key?("calendar")
            FileUtils::mkdir_p jekyll_path+'/assets/images/calendar'
            FileUtils::mkdir_p jekyll_path+'/assets/files/calendar'

            puts "Calendar - " + data['calendar'].length.to_s
            self.log("Calendar - " + data['calendar'].length.to_s)

            # Create files saved array
            event_files_saved = Array.new

            event_collection_path = jekyll_path+'/_event'

            # Save Photos / Files / event pages
            if data['calendar'].key?("events")
                data['calendar']['events'].each do |event|
                    if event['image']
                        event['image'] = self.getAndSaveImages(end_point + '/media/images/'+site_id+'/calendar/' + event['image'], jekyll_path+'/assets/images/calendar/' + event['image'])
                    end

                    if event['file']
                        self.getAndSaveFile(end_point + '/media/files/'+site_id+'/calendar/' + event['file'], jekyll_path+'/assets/files/calendar/' + event['file'])
                    end

                    # Detail Pages
                    if data['site'].key?('calendar_make_detail_pages') && data['site']['calendar_make_detail_pages'] == "1"
                        FileUtils::mkdir_p event_collection_path

                        event['dates'].each do |event_date|
                            event_data = event.clone
                            event_date.each do |key,value|
                                if 'date' == key
                                    key = 'event_date'
                                end
                                event_data[ key ] = value
                            end

                            if data['site'].key?('calendar_detail_layout') && data['site']['calendar_detail_layout'] != ""
                                event_data['layout'] = data['site']['calendar_detail_layout']
                            end

                            self.log('Saving Event File ' + event_data['slug']+'-'+event_date['date']+'.md')

                            event_data[ 'event_id' ] = event_data['id']
                            event_data.delete('id')

                            jfile = JekyllFile.new(event_collection_path, event_data, 'collection', event_data['slug']+'-'+event_date['date'])
                            jfile.savePageFile

                            event_files_saved.push( Pathname.new( jfile.getFileName ).basename.to_s )
                        end
                    end
                end
            end

            # Clean up unused collection files
            self.cleanUpFolder(event_collection_path, event_files_saved)
            
            # Save Json Data
            self.writeFile( jekyll_path+'/_data/calendar.json', JSON.pretty_generate(data['calendar']) )
            self.log('Writing File /_data/calendar.json')
        end

        if data['site'].key?('calendar_make_detail_pages') && data['site']['calendar_make_detail_pages'] == "1"
            collection_config[ 'event' ] = {'output' => true}
        end
        
        # Menus  (as json data and images)
        if data.key?("menus")
            # Save Json Data
            
            # Save Images
            FileUtils::mkdir_p jekyll_path+'/assets/images/menus'
            FileUtils::mkdir_p jekyll_path+'/assets/images/menus/items'
            
            data['menus'].each_with_index do |menu,idx|
                if menu['image']
                    menu_image_path = jekyll_path+'/assets/images/menus'
                    
                    src_image = end_point + '/media/images/'+site_id+'/menus/' + menu['image']
                    
                    menu['image'] = self.getAndSaveImages(src_image, menu_image_path + '/' + menu['image']) 
                end
                if menu['download']
                    menu_download_path = jekyll_path+'/assets/files/menus'
                    
                    src_image = end_point + '/media/files/'+site_id+'/menu_downloads/' + menu['download']
                    
                    self.getAndSaveFile(src_image, menu_download_path + '/' + menu['download']) 
                end
              
                menu['items'].each_with_index do |item,iidx|
                    if item['image']
                        image_path = jekyll_path+'/assets/images/menus/items/'+menu['id']
                        FileUtils::mkdir_p image_path
                        
                        src_image = end_point + '/media/images/'+site_id+'/menus/items/' + item['image']
                        
                        item['image'] = self.getAndSaveImages(src_image, image_path+'/' + item['image'])
                    end 
                end
            end
            
            self.writeFile( jekyll_path+'/_data/menus.json', JSON.pretty_generate(data['menus']) )
            
            self.log('Writing File /_data/menus.json')
        end
        
        # Downloads
        if data.key?("downloads")
            # Save Json Data
            self.writeFile( jekyll_path+'/_data/downloads.json', JSON.pretty_generate(data['downloads']) )
            
            # Make Dir
            FileUtils::mkdir_p jekyll_path+'/assets/files/downloads'
            
            # Download Files
            data['downloads'].each do |download|
                self.taxonomyImages(download)
                
                download_path = jekyll_path+'/assets/files/downloads'
                
                src_file = end_point + '/media/files/'+site_id+'/downloads/' + download['file']
                
                self.getAndSaveFile(src_file, download_path + '/' + download['file']) 
            end
        end
        
        # Properties
        if data.key?("properties")            
            # Make Dir
            FileUtils::mkdir_p jekyll_path+'/assets/images/properties'
            
            # Directory Check
            option_file_path = jekyll_path+'/assets/files/property_files'
            FileUtils::mkdir_p option_file_path
            
            option_image_path = jekyll_path+'/assets/images/property_images'
            FileUtils::mkdir_p option_image_path
            
            # Save Collection Info
            collection_config[ 'properties' ] = {'output' => true}
            
            # Directory Check
            collection_path = jekyll_path+'/_properties'
            FileUtils::mkdir_p collection_path

            # Create files saved array
            files_saved = Array.new
            
            # Save Individual Collection Files
            data['properties']['data'].each_with_index do |row,pidx|
                row_data = row.clone;
                row_data.delete('id')
                id_key = 'property_id'
                row_data[ id_key ] = row['id']
                
                # process taxonomies
                self.taxonomyImages(data['properties']['data'][pidx])
              
                # Save Images
                if row.key?("galleries")
                    row['galleries'].each_with_index do |gallery,gidx|
                        # Directory Check
                        image_path = jekyll_path+'/assets/images/properties/'+row['id']
                        FileUtils::mkdir_p image_path
                        
                        if gallery.key?("images")                            
                            # save images
                            gallery['images'].each_with_index do |image,idx|
                                src_image = end_point + '/media/images/'+site_id+'/properties/'+row['id']+'/' + image['image']
                                
                                data['properties']['data'][pidx]['galleries'][gidx]['images'][idx]['image'] = self.getAndSaveImages(src_image, image_path+'/' + image['image'])
                            end
                        end
                    end
                end
                
                if row.key?("images")
                    # Directory Check
                    image_path = jekyll_path+'/assets/images/properties/'+row['id']
                    FileUtils::mkdir_p image_path
                    
                    # save images
                    row['images'].each_with_index do |image,idx|
                        
                        src_image = end_point + '/media/images/'+site_id+'/properties/'+row['id']+'/' + image['image']
                        
                        data['properties']['data'][pidx]['images'][idx]['image'] = self.getAndSaveImages(src_image, image_path+'/' + image['image'])
                    end
                end
                
                # image/file option fields
                data['properties']['options'].each do |option|
                    if row[ option['key'] ]
                        case option['input_type']
                            when 'file'
                                src_file = end_point + '/media/files/'+site_id+'/property_files/' + row[ option['key'] ]
                                
                                self.getAndSaveFile(src_file, option_file_path+'/' + row[ option['key'] ])
                            when 'image'
                                src_image = end_point + '/media/images/'+site_id+'/property_images/' + row[ option['key'] ]
                                
                                
                                data['properties']['data'][pidx][ option['key'] ] = self.getAndSaveImages(src_image, option_image_path+'/' + row[ option['key'] ])
                        end
                    end
                end
              
                jfile = JekyllFile.new(collection_path, row_data, 'collection')
                jfile.savePageFile

                files_saved.push( Pathname.new( jfile.getFileName ).basename.to_s )
                
                self.log('Saving Property File ' + jfile.getFileName)
            end
            
            # Save Json Data
            self.writeFile( jekyll_path+'/_data/properties.json', JSON.pretty_generate(data['properties']['data']) )
            self.writeFile( jekyll_path+'/_data/properties_options.json', JSON.pretty_generate(data['properties']['options']) )

            # Clean up unused collection files
            self.cleanUpFolder(collection_path, files_saved)
        end
        
        # Custom Collections
        if data.key?("collections")
            data['collections'].each do |collection_type,collection_data|
                puts "Collection - " + collection_type + ' - ' + collection_data.length.to_s
                self.log("Collection - " + collection_type + ' - ' + collection_data.length.to_s)

                # Save Images / Files
                collection_data['data'].each_with_index do |row,cidx|
                    collection_data['fields'].each do |fld_key,fld_info|
                        row.each do |key,val|
                            #puts 'Row ['+key+']:['+val.to_s+']'
                            if fld_key == key && val
                                case fld_info['type']
                                    when 'image'
                                        # Directory Check
                                        image_path = jekyll_path+'/assets/images/'+collection_type
                                        FileUtils::mkdir_p image_path
                                        
                                        src_image = end_point + '/media/images/'+site_id+'/'+collection_type+'/' + val
                                        
                                        collection_data['data'][cidx][fld_key] = self.getAndSaveImages(src_image, image_path+'/' + val)
                                    when 'file'
                                        # Directory Check
                                        file_path = jekyll_path+'/assets/files/'+collection_type
                                        FileUtils::mkdir_p file_path
                                        
                                        src_file = end_point + '/media/files/'+site_id+'/'+collection_type+'/' + val
                                        
                                        self.getAndSaveFile(src_file, file_path+'/' + val)
                                end
                            end
                        end
                    end
                    
                    #hasmany data
                    if row.key?("hasmany_data")
                        row['hasmany_data'].each do |hasmany_type,hasmany_data|
                            #puts " - hasmany : " + hasmany_type + " - " + hasmany_data['data'].length.to_s
                            hasmany_data['fields'].each do |fld_key,fld_info|
                                hasmany_data['data'].each_with_index do |hsrow,hsidx|
                                    hsrow.each do |key,val|
                                        if fld_key == key && val
                                            case fld_info['type']
                                                when 'image'
                                                    # Directory Check
                                                    image_path = jekyll_path+'/assets/images/'+collection_type+'/'+hasmany_type+'/'+row['id']
                                                    FileUtils::mkdir_p image_path
                                                    
                                                    src_image = end_point + '/media/images/'+site_id+'/'+collection_type+'/'+row['id']+'/' + val
                                                    
                                                    collection_data['data'][cidx]['hasmany_data'][hasmany_type]['data'][hsidx][fld_key] = self.getAndSaveImages(src_image, image_path+'/' + val)
                                                when 'file'
                                                    # Directory Check
                                                    file_path = jekyll_path+'/assets/files/'+collection_type+'/'+hasmany_type+'/'+row['id']
                                                    FileUtils::mkdir_p file_path
                                                    
                                                    src_file = end_point + '/media/files/'+site_id+'/'+collection_type+'/'+row['id']+'/' + val
                                                    
                                                    self.getAndSaveFile(src_file, file_path+'/' + val)
                                            end
                                        end
                                    end
                                end
                            end
                        end # has many data each
                    end
                end
                
                # Loop through the collection data
                case collection_data['settings']['type']
                    when 'collection'
                        # Add to collection hash
                        collection_config[ collection_type ] = {'output' => true}
                        
                        # Directory Check
                        collection_path = jekyll_path+'/_' + collection_type
                        FileUtils::mkdir_p collection_path
        
                        # Create files saved array
                        files_saved = Array.new
                        
                        # Save Individual Collection Files
                        collection_data['data'].each do |row|
                            col_data = row.clone;
                            col_data.delete('id')
                            id_key = collection_type + '_id'
                            col_data[ id_key ] = row['id']
                            jfile = JekyllFile.new(collection_path, col_data, 'collection')
                            jfile.savePageFile
        
                            files_saved.push( Pathname.new( jfile.getFileName ).basename.to_s )
        
                            self.log('Saving Collection File ' + jfile.getFileName)
                        end
        
                        # Clean up unused collection files
                        self.cleanUpFolder(collection_path, files_saved)
                end
                
                # Save Json Data
                self.writeFile( jekyll_path+'/_data/'+collection_type+'.json', JSON.pretty_generate(collection_data['data']) )
                self.log('Writing File /_data/'+collection_type+'.json')
                
            end
        end

        # Add Collections to _config.tml
        config['collections'] = collection_config
        self.writeFile( jekyll_path+"/_config.yml", config.to_yaml )
        self.log('Writing File /_config.yml')
        
        @@logger.close
    end
taxonomyImages(row) click to toggle source
# File lib/zerofetcher.rb, line 683
def self.taxonomyImages(row)
    if row.key?("taxonomy")
        ##puts ' - Found taxonomy key ['+row['id']+']'
        row['taxonomy'].each_with_index do |tax_row,idx|
            if tax_row.key?("image")
                if tax_row["image"]
                    ##puts ' - ' + idx.to_s + ' saving tax image'
                    ##puts ' - - ['+tax_row["image"]+']'
                    image_path = @@jekyll_path+'/assets/images/tax-images/' + tax_row['taxonomy_id'] 
                    src_image = @@end_point + '/media/images/'+@@site_id+'/taxonomies/' + tax_row["image"]
                    #puts 'F: ' + src_image + ' -> ' + image_path + '/' + tax_row["image"]
                    
                    row['taxonomy'][idx]['image'] = self.getAndSaveImages(src_image, image_path + '/' + tax_row["image"])
                end
            end
        end
    end
    
    #return row
end
writeFile(path, contents) click to toggle source
# File lib/zerofetcher.rb, line 715
def self.writeFile(path, contents)
    File.open(path, 'wb') do |fo|
        fo.write(contents)
    end
end