Class: ZeroFetcher

Inherits:

Object

• Object
• ZeroFetcher

Defined in:

lib/zerofetcher.rb

Class Method Summary

• .cleanUpFolder(path, files) ⇒ Object
• .cleanUpPages(path, pages) ⇒ Object
• .cleanUpPagesFolder(path, pages) ⇒ Object
• .getAndSaveFile(source, dest) ⇒ Object
• .getAndSaveImages(source, dest) ⇒ Object
• .getImageVariantDestination(source, variant) ⇒ Object
• .getImageVariantSource(source, variant) ⇒ Object
• .loadDataFromApi(end_point, api_key, site_id) ⇒ Object
• .log(data) ⇒ Object
• .optimizeImage(dest) ⇒ Object
• .readFile(file) ⇒ Object
• .run ⇒ Object
• .taxonomyImages(row) ⇒ Object
• .writeFile(path, contents) ⇒ Object

Class Method Details

.cleanUpFolder(path, files) ⇒ Object

# File 'lib/zerofetcher.rb', line 844

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) ⇒ Object

# File 'lib/zerofetcher.rb', line 858

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) ⇒ Object

# File 'lib/zerofetcher.rb', line 875

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) ⇒ Object

# File 'lib/zerofetcher.rb', line 756

def self.getAndSaveFile(source, dest)
    if !Pathname.new(dest).file?
        self.log('Get/Save ' + dest)
        #uri = URI.encode(source)

        p = URI::Parser.new
        uri = p.escape(source)
        begin
            open(dest, 'wb') do |file|
                begin
                    #file << open(uri).read
                    file = URI.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) ⇒ Object

# File 'lib/zerofetcher.rb', line 787

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) ⇒ Object

# File 'lib/zerofetcher.rb', line 836

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) ⇒ Object

# File 'lib/zerofetcher.rb', line 818

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) ⇒ Object

# File 'lib/zerofetcher.rb', line 739

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) ⇒ Object

# File 'lib/zerofetcher.rb', line 722

def self.log(data)
    @@logger.debug { data }
end

.optimizeImage(dest) ⇒ Object

# File 'lib/zerofetcher.rb', line 781

def self.optimizeImage(dest)
    # disabled optimize here only
    return true
    #ImageOptimizer.new(dest, quality: 90, quiet: true).optimize
end

.readFile(file) ⇒ Object

# File 'lib/zerofetcher.rb', line 726

def self.readFile(file)
    file = File.open(file, "r")
    data = file.read
    file.close
    return data
end

.run ⇒ Object

# 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+'/_passwords'
    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']

    paths_with_passwords = Array.new

    # 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)

            if page['password_id']
                paths_with_passwords.push({'url' => page['url'], 'password_id' => page['password_id']})
            end

            # 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

    if data.key?("passwords")
        # Save individual password files
        data['passwords'].each do |password|
            self.log('writing File /_passwords/.htpasswd_'+password['id'])
            self.writeFile( jekyll_path+'/_passwords/.htpasswd_'+password['id'] , password['username']+':'+password['password'] );
        end

        # write _data/passwords.json
        self.writeFile( jekyll_path+'/_data/passwords.json', JSON.pretty_generate(paths_with_passwords) )
    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) ⇒ Object

# File 'lib/zerofetcher.rb', line 701

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) ⇒ Object

# File 'lib/zerofetcher.rb', line 733

def self.writeFile(path, contents)
    File.open(path, 'wb') do |fo|
        fo.write(contents)
    end
end