locomotivecms_mounter 1.0.0.alpha1

data/lib/locomotive/mounter/writer/api/content_types_writer.rb

@@ -0,0 +1,151 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module Api
+
+        # Push content types to a remote LocomotiveCMS engine.
+        #
+        # In a first time, create the content types without any relationships fields.
+        # Then, add the relationships one by one.
+        #
+        # If the :force option is passed, the remote fields not defined in the mounter version
+        # of the content type will be destroyed when pushed. The options of
+        # a select field will be pushed as well, otherwise they won't unless if
+        # it is a brand new content type.
+        #
+        class ContentTypesWriter < Base
+
+          def prepare
+            super
+
+            # assign an _id to a local content type if possible
+            self.get(:content_types, nil, true).each do |attributes|
+              content_type = self.content_types[attributes['slug']]
+
+              self.apply_response(content_type, attributes)
+            end
+          end
+
+          def write
+            done = {}
+
+            # first new content types
+            self.not_persisted.each do |content_type|
+              self.create_content_type(content_type)
+
+              done[content_type.slug] = content_type.with_relationships? ? :todo : :done
+            end
+
+            # then update the others
+            self.content_types.values.each do |content_type|
+              next unless done[content_type.slug].nil?
+
+              self.update_content_type(content_type)
+            end
+
+            # finally, update the newly created embedding a relationship field
+            done.each do |slug, status|
+              next if status == :done
+
+              content_type = self.content_types[slug]
+
+              self.update_content_type(content_type)
+            end
+          end
+
+          protected
+
+          # Persist a content type by calling the API. It is enhanced then
+          # by the response if no errors occured.
+          #
+          # @param [ Object ] content_type The content type to create
+          #
+          def create_content_type(content_type)
+            self.output_resource_op content_type
+
+            response = self.post :content_types, content_type.to_params, nil, true
+
+            self.apply_response(content_type, response)
+
+            # status = self.response_to_status(response)
+
+            self.output_resource_op_status content_type, :success
+          rescue Exception => e
+            self.output_resource_op_status content_type, :error, e.message
+          end
+
+          # Update a content type by calling the API.
+          #
+          # @param [ Object ] content_type The content type to update
+          #
+          def update_content_type(content_type)
+            self.output_resource_op content_type
+
+            params = self.content_type_to_params(content_type)
+
+            # make a call to the API for the update
+            self.put :content_types, content_type._id, params
+
+            self.output_resource_op_status content_type, :success
+          rescue Exception => e
+            self.output_resource_op_status content_type, :error, e.message
+          end
+
+          def content_types
+            self.mounting_point.content_types
+          end
+
+          # Return the content types not persisted yet.
+          #
+          # @return [ Array ] The list of non persisted content types.
+          #
+          def not_persisted
+            self.content_types.values.find_all { |content_type| !content_type.persisted? }
+          end
+
+          # Enhance the content type with the information returned by an API call.
+          #
+          # @param [ Object ] content_type The content type instance
+          # @param [ Hash ] response The API response
+          #
+          def apply_response(content_type, response)
+            return if content_type.nil? || response.nil?
+
+            content_type._id = response['id']
+            content_type.klass_name = response['klass_name']
+
+            response['entries_custom_fields'].each do |remote_field|
+              field = content_type.find_field(remote_field['name'])
+              _id   = remote_field['id']
+
+              if field.nil?
+                if self.force?
+                  content_type.fields << Locomotive::Mounter::Models::ContentField.new(_id: _id, _destroy: true)
+                end
+              else
+                field._id = _id
+              end
+            end
+          end
+
+          # Get the params of a content type for an update.
+          # Delete the select_options unless the force flag is true.
+          #
+          # @param [ Object ] content_type The ContentType
+          #
+          # @return [ Hash ] The params of the ContentType ready to be used in the API
+          #
+          def content_type_to_params(content_type)
+            content_type.to_params(all_fields: true).tap do |params|
+              params[:entries_custom_fields].each do |attributes|
+                attributes.delete(:select_options) unless self.force?
+              end
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/mounter/writer/api/pages_writer.rb

@@ -0,0 +1,225 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module Api
+
+        # Push pages to a remote LocomotiveCMS engine.
+        #
+        # New pages are created and existing ones are partially updated.
+        #
+        # If the :force option is passed, the existing pages are fully updated (title, ...etc).
+        # But in any cases, the content of the page will be destroyed, unless the layout of the page
+        # changes.
+        #
+        class PagesWriter < Base
+
+          attr_accessor :new_pages
+          attr_accessor :remote_translations
+
+          def prepare
+            super
+
+            self.new_pages, self.remote_translations = [], {}
+
+            # set the unique identifier to each local page
+            self.get(:pages, nil, true).each do |attributes|
+              page = self.pages[attributes['fullpath'].dasherize]
+
+              self.remote_translations[attributes['fullpath']] = attributes['translated_in']
+
+              page._id = attributes['id'] if page
+            end
+
+            # assign the parent_id and the content_type_id to all the pages
+            self.pages.values.each do |page|
+              next if page.index_or_404?
+
+              page.parent_id = page.parent._id
+            end
+          end
+
+          # Write all the pages to the remote destination
+          def write
+            self.each_locale do |locale|
+              self.output_locale
+
+              # first write the pages which are layouts for others
+              self.layouts.each { |page| self.write_page(page) }
+
+              # and proceed the others
+              self.other_than_layouts.each { |page| self.write_page(page) }
+            end
+          end
+
+          protected
+
+          def write_page(page)
+            locale = Locomotive::Mounter.locale
+
+            return unless page.translated_in?(locale)
+
+            self.output_resource_op page
+
+            success = page.persisted? ? self.update_page(page) : self.create_page(page)
+
+            self.output_resource_op_status page, success ? :success : :error
+            self.flush_log_buffer
+          end
+
+          # Persist a page by calling the API. The returned _id
+          # is then set to the page itself.
+          #
+          # @param [ Object ] page The page to create
+          #
+          # @return [ Boolean ] True if the call to the API succeeded
+          #
+          def create_page(page)
+            if !page.index_or_404? && page.parent_id.nil?
+              raise Mounter::WriterException.new("We are unable to find the parent page for #{page.fullpath}")
+            end
+
+            params = self.buffer_log { page_to_params(page) }
+
+            # make a call to the API to create the page, no need to set
+            # the locale since it first happens for the default locale.
+            response = self.post :pages, params, nil, true
+
+            if response
+              page._id = response['id']
+              self.new_pages << page._id
+            end
+
+            !response.nil?
+          end
+
+          # Update a page by calling the API.
+          #
+          # @param [ Object ] page The page to persist
+          #
+          # @return [ Boolean ] True if the call to the API succeeded
+          #
+          def update_page(page)
+            locale  = Locomotive::Mounter.locale
+
+            # All the attributes of the page or just some of them
+            params = self.buffer_log do
+              self.page_to_params(page, self.data? || !self.already_translated?(page))
+            end
+
+            # make a call to the API for the update
+            response = self.put :pages, page._id, params, locale
+
+            !response.nil?
+          end
+
+          # Shortcut to get pages.
+          #
+          # @return [ Hash ] The hash whose key is the fullpath and the value is the page itself
+          #
+          def pages
+            self.mounting_point.pages
+          end
+
+          # Return the pages which are layouts for others.
+          # They are sorted by the depth.
+          #
+          # @return [ Array ] The list of layouts
+          #
+          def layouts
+            self.pages.values.find_all do |page|
+              self.safely_translated?(page) && page.is_layout?
+            end.sort { |a, b| a.depth <=> b.depth }
+          end
+
+          # Return the pages wich are not layouts for others.
+          # They are sorted by both the depth and the position.
+          #
+          # @return [ Array ] The list of non-layout pages
+          #
+          def other_than_layouts
+            list = (self.pages.values - self.layouts)
+
+            # get only the translated ones in the current locale
+            list.delete_if do |page|
+              # if (!page.parent.nil? && !page.translated_in?(self.mounting_point.default_locale)) ||
+              #   !page.translated_in?(Locomotive::Mounter.locale)
+              if !self.safely_translated?(page)
+                self.output_resource_op page
+                self.output_resource_op_status page, :not_translated
+                true
+              end
+            end
+
+            # sort them
+            list.sort { |a, b| a.depth_and_position <=> b.depth_and_position }
+          end
+
+          # Tell if the page passed in parameter has already been
+          # translated on the remote engine for the locale passed
+          # as the second parameter.
+          #
+          # @param [ Object ] page The page
+          # @param [ String / Symbol ] locale The locale. Use the current locale by default
+          #
+          # @return [ Boolean] True if already translated.
+          #
+          def already_translated?(page, locale = nil)
+            locale ||= Locomotive::Mounter.locale
+
+            (@remote_translations[page.fullpath] || []).include?(locale.to_s)
+          end
+
+          # Tell if the page is correctly localized, meaning it is localized itself
+          # as well as its parent.
+          #
+          # @param [ Object ] page The page
+          #
+          # @return [ Boolean] True if safely translated.
+          #
+          def safely_translated?(page)
+            if page.parent.nil?
+              page.translated_in?(Locomotive::Mounter.locale)
+            else
+              page.parent.translated_in?(Locomotive::Mounter.locale) &&
+              page.translated_in?(Locomotive::Mounter.locale)
+            end
+          end
+
+          # Return the parameters of a page sent by the API.
+          # It includes the editable_elements if the data option is enabled or
+          # if the page is a new one.
+          #
+          # @param [ Object ] page The page
+          # @param [ Boolean ] safe If true the to_safe_params is called, otherwise to_params is applied.
+          #
+          # @return [ Hash ] The parameters of the page
+          #
+          def page_to_params(page, safe = false)
+            (safe ? page.to_safe_params : page.to_params).tap do |params|
+              # raw template
+              params[:raw_template] = self.replace_content_assets!(params[:raw_template])
+
+              if self.data? || self.new_pages.include?(page._id)
+                params[:editable_elements] = (page.editable_elements || []).map(&:to_params)
+              end
+
+              # editable elements
+              (params[:editable_elements] || []).each do |element|
+                if element[:content] =~ /$\/samples\//
+                  element[:source] = self.path_to_file(element.delete(:content))
+                elsif element[:content] =~ %r($http://)
+                  element[:source_url] = element.delete(:content)
+                else
+                  # string / text elements
+                  element[:content] = self.replace_content_assets!(element[:content])
+                end
+              end
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/mounter/writer/api/site_writer.rb

@@ -0,0 +1,164 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module Api
+
+        class SiteWriter < Base
+
+          attr_accessor :remote_site
+
+          # Check if the site has to be created before.
+          def prepare
+            super
+
+            self.fetch_site
+
+            # if self.fetch_site.nil?
+            #   Mounter.logger.warn 'The site does not exist. Trying to create it.'
+
+            #   unless self.has_admin_rights?
+            #     raise Mounter::WriterException.new('Your account does not own admin rights.')
+            #   end
+            # else
+            #   self.check_locales
+            # end
+          end
+
+          # Create the site if it does not exist
+          def write
+            if self.site.persisted?
+              self.check_locales! unless self.force? # requirements
+
+              self.update_site
+            else
+              self.create_site
+            end
+
+
+            # unless self.site.persisted?
+            #   # create it in the default locale
+            #   Mounter.with_locale(self.default_locale) do
+            #     self.output_locale
+
+            #     self.output_resource_op self.site
+
+            #     if (site = self.post(:sites, self.site.to_hash(false), Mounter.locale)).nil?
+            #       raise Mounter::WriterException.new('Sorry, we are unable to create the site.')
+            #     else
+            #       self.site._id = site['id']
+
+            #       self.output_resource_op_status self.site
+            #     end
+            #   end
+
+            #   # update it in other locales
+            #   self.site.translated_in.each do |locale|
+            #     next if locale.to_s == self.default_locale.to_s
+            #     Mounter.with_locale(locale) do
+            #       self.output_locale
+
+            #       self.output_resource_op self.site
+
+            #       self.put(:sites, self.site._id, self.site.to_hash(false), Mounter.locale)
+
+            #       self.output_resource_op_status self.site
+            #     end
+            #   end
+            # else
+            #   self.output_resource_op self.site
+            #   self.output_resource_op_status self.site, :skipped
+            # end
+          end
+
+          protected
+
+          # Create the current site in all the locales
+          #
+          def create_site
+            # create it in the default locale
+            Mounter.with_locale(self.default_locale) do
+              self.output_locale
+
+              self.output_resource_op self.site
+
+              if (site = self.post(:sites, self.site.to_hash(false), Mounter.locale)).nil?
+                raise Mounter::WriterException.new('Sorry, we are unable to create the site.')
+              else
+                self.site._id = site['id']
+                self.output_resource_op_status self.site
+              end
+            end
+
+            # update it in other locales
+            self.update_site(true)
+          end
+
+          # Update the current site in all the locales
+          #
+          # @param [ Boolean ] exclude_current_locale Update the site for all the locales other than the default one.
+          #
+          def update_site(exclude_current_locale = false)
+            self.each_locale do |locale|
+              next if exclude_current_locale && locale.to_s == self.default_locale.to_s
+
+              self.output_locale
+
+              begin
+                self.output_resource_op self.site
+
+                self.put(:sites, self.site._id, self.site.to_hash(false), locale)
+
+                self.output_resource_op_status self.site
+              rescue Exception => e
+                self.output_resource_op_status self.site, :error, e.message
+              end
+            end
+          end
+
+          def safe_attributes
+            %w(id locales)
+          end
+
+          def fetch_site
+            self.get(:current_site).tap do |_site|
+              if _site
+                self.remote_site  = _site
+                self.site._id     = _site['id']
+              end
+            end
+          end
+
+          # To push all the other resources, the big requirement is to
+          # have the same locales between the local site and the remote one.
+          #
+          def check_locales!
+            default_locale  = self.mounting_point.default_locale.to_s
+            locales         = self.site.locales.map(&:to_s)
+            remote_locales  = self.remote_site['locales']
+            message         = nil
+
+            unless locales.all? { |l| remote_locales.include?(l) }
+              message = "Your site locales (#{locales.join(', ')}) do not match exactly the ones of your target (#{remote_locales.join(', ')})"
+            end
+
+            if default_locale != remote_locales.first
+              message = "Your default site locale (#{default_locale.inspect}) is not the same as the one of your target (#{remote_locales.first.inspect})"
+            end
+
+            if message
+              self.output_resource_op self.site
+              self.output_resource_op_status self.site, :error, message
+              raise Mounter::WriterException.new('Use the force option in order to force your locale settings.')
+            end
+          end
+
+          def has_admin_rights?
+            self.get(:my_account, nil, true)['admin']
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/mounter/writer/api/snippets_writer.rb

@@ -0,0 +1,111 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module Api
+
+        # Push snippets to a remote LocomotiveCMS engine.
+        #
+        # The force option is not used.
+        #
+        class SnippetsWriter < Base
+
+          def prepare
+            super
+
+            # set the unique identifier to each local snippet
+            self.get(:snippets, nil, true).each do |attributes|
+              snippet = self.snippets[attributes['slug']]
+
+              snippet._id = attributes['id'] if snippet
+            end
+          end
+
+          # Write all the snippets to the remote destination
+          def write
+            self.each_locale do |locale|
+              self.output_locale
+
+              self.snippets.values.each { |snippet| self.write_snippet(snippet) }
+            end
+          end
+
+          protected
+
+          # Write a snippet by calling the API.
+          #
+          # @param [ Object ] snippet The snippet
+          #
+          def write_snippet(snippet)
+            locale = Locomotive::Mounter.locale
+
+            return unless snippet.translated_in?(locale)
+
+            self.output_resource_op snippet
+
+            success = snippet.persisted? ? self.update_snippet(snippet) : self.create_snippet(snippet)
+
+            self.output_resource_op_status snippet, success ? :success : :error
+            self.flush_log_buffer
+          end
+
+          # Persist a snippet by calling the API. The returned id
+          # is then set to the snippet itself.
+          #
+          # @param [ Object ] snippet The snippet to create
+          #
+          # @return [ Boolean ] True if the call to the API succeeded
+          #
+          def create_snippet(snippet)
+            params = self.buffer_log { snippet_to_params(snippet) }
+
+            # make a call to the API to create the snippet, no need to set
+            # the locale since it first happens for the default locale.
+            response = self.post :snippets, params, nil, true
+
+            snippet._id = response['id'] if response
+
+            !response.nil?
+          end
+
+          # Update a snippet by calling the API.
+          #
+          # @param [ Object ] snippet The snippet to persist
+          #
+          # @return [ Boolean ] True if the call to the API succeeded
+          #
+          def update_snippet(snippet)
+            params = self.buffer_log { snippet_to_params(snippet) }
+
+            locale = Locomotive::Mounter.locale
+
+            # make a call to the API for the update
+            response = self.put :snippets, snippet._id, params, locale
+
+            !response.nil?
+          end
+
+          # Shortcut to get all the local snippets.
+          #
+          # @return [ Hash ] The hash whose key is the slug and the value is the snippet itself
+          #
+          def snippets
+            self.mounting_point.snippets
+          end
+
+          # Return the parameters of a snippet sent by the API.
+          #
+          # @param [ Object ] snippet The snippet
+          #
+          # @return [ Hash ] The parameters of the page
+          #
+          def snippet_to_params(snippet)
+            snippet.to_params.tap do |params|
+              params[:template] = self.replace_content_assets!(params[:template])
+            end
+          end
+
+        end
+      end
+    end
+  end
+end