locomotivecms_mounter_pull_19 1.5.4

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,250 @@
+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
+
+          MAX_ATTEMPTS = 5
+
+          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.values.find do |_page|
+                _page.safe_fullpath(false) == attributes['fullpath'].dasherize
+              end
+
+              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
+
+              done, attempts = {}, 0
+
+              # begin by the layouts (pages inside the layouts folder)
+              _write_layouts(pages, done)
+
+              while done.size < pages.length - 1 && attempts < MAX_ATTEMPTS
+                _write(pages['index'], done, attempts > 0)
+
+                # keep track of the attempts because we don't want to get an infinite loop.
+                attempts += 1
+              end
+
+              write_page(pages['404'])
+
+              if done.size < pages.length - 1
+                self.log %{Warning: NOT all the pages were pushed.\n\tCheck that the pages inheritance was done right OR that you translated all your pages.\n}.colorize(color: :red)
+              end
+            end
+          end
+
+          protected
+
+          def _write_layouts(pages, done)
+            if pages['layouts']
+              _write(pages['layouts'], done, false, false)
+
+              layouts = pages.values.find_all { |page| page.fullpath =~ /^layouts\// }
+
+              # make sure the templates without the extends tag are first in the list
+              layouts.sort! do |a, b|
+                (a.depth_and_position + (a.extends_template? ? 1000 : 0)) <=> (b.depth_and_position + (b.extends_template? ? 1000 : 0))
+              end
+              layouts.each do |page|
+                _write(page, done, false, false)
+              end
+            end
+          end
+
+          def _write(page, done, already_done = false, with_children = true)
+            if self.safely_translated?(page)
+              write_page(page) unless already_done
+            else
+              self.output_resource_op page
+              self.output_resource_op_status page, :not_translated
+            end
+
+            # mark it as done
+            done[page.fullpath] = true
+
+            # loop over its children
+            if with_children
+              (page.children || []).sort_by(&:depth_and_position).each do |child|
+                template_fullpath = child.template_fullpath
+                template_fullpath = page.fullpath if template_fullpath && template_fullpath == 'parent'
+
+                if done[child.fullpath].nil? && (!template_fullpath || done[template_fullpath])
+                  _write(child, done)
+                end
+              end
+            end
+          end
+
+          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
+
+          # 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)
+              else
+                params.delete(:editable_elements)
+              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,125 @@
+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
+          end
+
+          # Create the site if it does not exist
+          def write
+            if self.site.persisted?
+              self.check_locales! unless self.force? # requirements
+
+              if self.force?
+                self.update_site
+              end
+            else
+              self.create_site
+            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 name locales timezone)
+          end
+
+          def fetch_site
+            begin
+              self.get(:current_site).tap do |_site|
+                if _site
+                  self.remote_site  = _site
+                  self.site._id     = _site['id']
+                end
+              end
+            rescue WriterException, ApiReadException => e
+              nil
+            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