lato_blog 2.1

data/app/assets/stylesheets/lato_blog/pages/_pages.scss

@@ -0,0 +1,2 @@
+@import "posts";
+@import "categories";

data/app/assets/stylesheets/lato_blog/pages/_posts.scss

@@ -0,0 +1,25 @@
+.posts__edit-status-switch, .posts__edit-publication-datetime {
+
+  .elements-button {
+    margin-top: 0;
+  }
+}
+
+.posts__edit-categories {
+  .inputs-checkbox {
+    margin: 0;
+    margin-bottom: 2px;
+  }
+
+  .elements-table__row {
+    td:first-child {
+      width: 50px;
+    }
+  }
+}
+
+.posts__index {
+  .elements-table__row td:first-child {
+    width: 60%;
+  }
+}

data/app/assets/stylesheets/lato_blog/theme.scss.erb

@@ -0,0 +1,12 @@
+<%
+  colors = core__get_colors
+%>
+
+$color_white: <%= colors[:white] %>;
+$color_black: <%= colors[:black] %>;
+$color_grey: <%= colors[:grey] %>;
+$color_main: <%= colors[:main] %>;
+$color_active: <%= colors[:active] %>;
+$color_danger: <%= colors[:danger] %>;
+$color_warning: <%= colors[:warning] %>;
+$color_success: <%= colors[:success] %>;

data/app/assets/stylesheets/lato_blog/widgets/_switchlang.scss

@@ -0,0 +1,3 @@
+.widgets-systeminfo {
+  
+}

data/app/assets/stylesheets/lato_blog/widgets/_widgets.scss

@@ -0,0 +1 @@
+@import "switchlang";

data/app/controllers/lato_blog/api/api_controller.rb

@@ -0,0 +1,5 @@
+module LatoBlog
+  class Api::ApiController < ApplicationController
+
+  end
+end

data/app/controllers/lato_blog/api/categories_controller.rb

@@ -0,0 +1,51 @@
+module LatoBlog
+  class Api::CategoriesController < Api::ApiController
+
+    def index
+      categories = LatoBlog::Category.all
+
+      # order categories
+      order = (params[:order] && params[:order] == 'ASC') ? 'ASC' : 'DESC'
+      categories = categories.order("title #{order}")
+
+      # filter language
+      categories = categories.where(meta_language: params[:language]) if params[:language]
+      # filter search
+      categories = categories.where('title like ?', "%#{params[:search]}%") if params[:search]
+
+      # save total categories
+      total = categories.length
+
+      # manage pagination
+      page = params[:page] ? params[:page].to_i : 1
+      per_page = params[:per_page] ? params[:per_page].to_i : 20
+      categories = core__paginate_array(categories, per_page, page)
+
+      # render response
+      core__send_request_success(
+        categories: (categories && !categories.empty?) ? categories.map(&:serialize) : [],
+        page: page,
+        per_page: per_page,
+        order: order,
+        total: total
+      )
+    end
+
+    def show
+      # check parameters
+      core__send_request_fail('Uncorrect parameters') && return unless params[:id] || params[:permalink]
+
+      # find post
+      if params[:id]
+        category = LatoBlog::Category.find_by(id: params[:id].to_i)
+      else
+        category = LatoBlog::Category.find_by(meta_permalink: params[:permalink])
+      end
+
+      # render respnse
+      core__send_request_fail('Category not found') && return unless category
+      core__send_request_success(category: category.serialize)
+    end
+
+  end
+end

data/app/controllers/lato_blog/api/posts_controller.rb

@@ -0,0 +1,93 @@
+module LatoBlog
+  class Api::PostsController < Api::ApiController
+
+    def index
+      posts = LatoBlog::Post.published.joins(:categories).joins(:post_parent)
+      posts = posts.where('lato_blog_post_parents.publication_datetime <= ?', DateTime.now)
+
+      # order posts
+      order = (params[:order] && params[:order] == 'ASC') ? 'ASC' : 'DESC'
+      posts = posts.order("lato_blog_post_parents.publication_datetime #{order}")
+
+      # filter language
+      posts = posts.where(meta_language: params[:language]) if params[:language]
+      # filter category permalink
+      posts = filter_category_permalink(posts) if params[:category_permalink]
+      # filter category id
+      posts = filter_category_id(posts) if params[:category_id]
+      # filter search
+      posts = posts.where('lato_blog_posts.title like ?', "%#{params[:search]}%") if params[:search]
+
+      # take posts uniqueness
+      posts = posts.uniq(&:id)
+
+      # save total posts
+      total = posts.length
+
+      # manage pagination
+      page = params[:page] ? params[:page].to_i : 1
+      per_page = params[:per_page] ? params[:per_page].to_i : 20
+      posts = core__paginate_array(posts, per_page, page)
+
+      # render response
+      core__send_request_success(
+        posts: (posts && !posts.empty?) ? posts.map(&:serialize) : [],
+        page: page,
+        per_page: per_page,
+        order: order,
+        total: total
+      )
+    end
+
+    def show
+      # check parameters
+      core__send_request_fail('Uncorrect parameters') && return unless params[:id] || params[:permalink]
+
+      # find post
+      if params[:id]
+        post = LatoBlog::Post.find_by(id: params[:id].to_i, meta_status: 'published')
+      else
+        post = LatoBlog::Post.find_by(meta_permalink: params[:permalink], meta_status: 'published')
+      end
+
+      # render respnse
+      core__send_request_fail('Post not found') && return unless post
+      core__send_request_success(post: post.serialize)
+    end
+
+    private
+
+    def filter_category_permalink(posts)
+      return posts unless params[:category_permalink]
+      category_permalinks = params[:category_permalink].is_a?(Array) ? params[:category_permalink] : params[:category_permalink].split(',')
+      posts = posts.where(lato_blog_categories: { meta_permalink: category_permalinks })
+      # manage AND clause
+      if params[:category_permalink_AND] == 'true'
+        ids = []
+        posts.pluck(:id).each do |id|
+          ids.push(id) if posts.where(id: id).length >= category_permalinks.length
+        end
+        posts = posts.where(id: ids)
+      end
+      # return posts
+      posts
+    end
+
+    def filter_category_id(posts)
+      return posts unless params[:category_id]
+      category_ids = params[:category_id].is_a?(Array) ? params[:category_id] : params[:category_id].split(',')
+      posts = posts.where(lato_blog_categories: { id: category_ids })
+      # manage AND clause
+      if params[:category_id_AND] == 'true'
+        ids = []
+        posts.pluck(:id).each do |id|
+          ids.push(id) if posts.where(id: id).length >= category_ids.length
+        end
+        posts = posts.where(id: ids)
+      end
+      # return posts
+      posts
+    end
+
+  end
+end

data/app/controllers/lato_blog/application_controller.rb

@@ -0,0 +1,13 @@
+module LatoBlog
+
+  # ApplicationController
+  class ApplicationController < ActionController::Base
+
+    protect_from_forgery with: :exception
+
+    def index
+      redirect_to lato_blog.posts_path
+    end
+
+  end
+end

data/app/controllers/lato_blog/back/back_controller.rb

@@ -0,0 +1,45 @@
+module LatoBlog
+  class Back::BackController < ApplicationController
+
+    # Specific helpers import to fix not found functions bug
+    helper LatoBlog::ApplicationHelper
+    helper LatoBlog::FieldsHelper
+
+    layout 'lato_core/admin'
+
+    # check user is logged
+    before_action :core__manage_superuser_session
+    # set default language if not exist
+    before_action :set_default_current_language
+
+    # This function switch the default language used by the system and redirect to the same user page.
+    def switch_current_language
+      set_current_language params[:language]
+
+      respond_to do |format|
+        format.js
+      end
+    end
+
+    private
+
+    # Language helpers:
+
+    # This function set a default language on cookie if no languages are set.
+    def set_default_current_language
+      if !cookies[:lato_blog__current_language]
+        cookies[:lato_blog__current_language] = BLOG_LANGUAGES_IDENTIFIER.first
+      end
+    end
+
+    # This function set the language received as params as default language if it is possible.
+    def set_current_language language
+      if BLOG_LANGUAGES_IDENTIFIER.include? language
+        cookies[:lato_blog__current_language] = language
+      else
+        set_default_current_language
+      end
+    end
+
+  end
+end

data/app/controllers/lato_blog/back/categories_controller.rb

@@ -0,0 +1,141 @@
+module LatoBlog
+  class Back::CategoriesController < Back::BackController
+
+    before_action do
+      core__set_menu_active_item('blog_articles')
+    end
+
+    # This function shows the list of possible categories.
+    def index
+      core__set_header_active_page_title(LANGUAGES[:lato_blog][:pages][:categories])
+      # find categories to show
+      @categories = LatoBlog::Category.where(meta_language: cookies[:lato_blog__current_language]).order('title ASC')
+      @widget_index_categories = core__widgets_index(@categories, search: 'title', pagination: 10)
+    end
+
+    # This function shows a single category. It create a redirect to the edit path.
+    def show
+      # use edit as default post show page
+      redirect_to lato_blog.edit_category_path(params[:id])
+    end
+
+    # This function shows the view to create a new category.
+    def new
+      core__set_header_active_page_title(LANGUAGES[:lato_blog][:pages][:categories_new])
+      @category = LatoBlog::Category.new
+
+      if params[:language]
+        set_current_language params[:language]
+      end
+
+      if params[:parent]
+        @category_parent = LatoBlog::CategoryParent.find_by(id: params[:parent])
+      end
+
+      fetch_external_objects
+    end
+
+    # This function creates a new category.
+    def create
+      @category = LatoBlog::Category.new(new_category_params)
+
+      if !@category.save
+        flash[:danger] = @category.errors.full_messages.to_sentence
+        redirect_to lato_blog.new_category_path
+        return
+      end
+
+      flash[:success] = LANGUAGES[:lato_blog][:flashes][:category_create_success]
+      redirect_to lato_blog.category_path(@category.id)
+    end
+
+    # This function show the view to edit a category.
+    def edit
+      core__set_header_active_page_title(LANGUAGES[:lato_blog][:pages][:categories_edit])
+      @category = LatoBlog::Category.find_by(id: params[:id])
+      return unless check_category_presence
+
+      if @category.meta_language != cookies[:lato_blog__current_language]
+        set_current_language @category.meta_language
+      end
+
+      fetch_external_objects
+    end
+
+    # This function updates a category.
+    def update
+      @category = LatoBlog::Category.find_by(id: params[:id])
+      return unless check_category_presence
+
+      if !@category.update(edit_category_params)
+        flash[:danger] = @category.errors.full_messages.to_sentence
+        redirect_to lato_blog.edit_category_path(@category.id)
+        return
+      end
+      
+      flash[:success] = LANGUAGES[:lato_blog][:flashes][:category_update_success]
+      redirect_to lato_blog.category_path(@category.id)
+    end
+
+    # This function destroyes a category.
+    def destroy
+      @category = LatoBlog::Category.find_by(id: params[:id])
+      return unless check_category_presence
+
+      if !@category.destroy
+        flash[:danger] = @category.category_parent.errors.full_messages.to_sentence
+        redirect_to lato_blog.edit_category_path(@category.id)
+        return
+      end
+      
+      flash[:success] = LANGUAGES[:lato_blog][:flashes][:category_destroy_success]
+      redirect_to lato_blog.categories_path(status: 'deleted')
+    end
+
+    private
+
+      def fetch_external_objects
+        @categories_list = LatoBlog::Category.where(meta_language: cookies[:lato_blog__current_language]).where.not(
+        id: @category.id).map { |cat| { title: cat.title, value: cat.id } }
+      end
+
+      # This function checks the @post variable is present and redirect to index if it not exist.
+      def check_category_presence
+        if !@category
+          flash[:warning] = LANGUAGES[:lato_blog][:flashes][:category_not_found]
+          redirect_to lato_blog.categories_path
+          return false
+        end
+
+        return true
+      end
+
+      # Params helpers:
+
+      # This function generate params for a new category.
+      def new_category_params
+        # take params from front-end request
+        category_params = params.require(:category).permit(:title, :lato_blog_category_id).to_h
+        # add current superuser id
+        category_params[:lato_core_superuser_creator_id] = @core__current_superuser.id
+        # add post parent id
+        category_params[:lato_blog_category_parent_id] = (params[:parent] && !params[:parent].blank? ? params[:parent] : generate_category_parent)
+        # add metadata
+        category_params[:meta_language] = cookies[:lato_blog__current_language]
+        # return final post object
+        return category_params
+      end
+
+      # This function generate params for a edit category.
+      def edit_category_params
+        params.require(:category).permit(:title, :lato_blog_category_id, :meta_permalink)
+      end
+
+      # This function generate and save a new category parent and return the id.
+      def generate_category_parent
+        category_parent = LatoBlog::CategoryParent.create
+        return category_parent.id
+      end
+
+  end
+end

data/app/controllers/lato_blog/back/post_fields_controller.rb

@@ -0,0 +1,86 @@
+module LatoBlog
+  class Back::PostFieldsController < Back::BackController
+
+    before_action do
+      core__set_menu_active_item('blog_articles')
+    end
+
+    def index
+      core__set_header_active_page_title(LANGUAGES[:lato_blog][:pages][:post_fields])
+      @post_fields = LatoBlog::PostField.all.order('meta_visible')
+      @widget_index_post_fields = core__widgets_index(@post_fields, search: 'key', pagination: 10)
+    end
+
+    def destroy
+      @post_field = LatoBlog::PostField.find_by(id: params[:id])
+
+      unless @post_field
+        flash[:warning] = LANGUAGES[:lato_blog][:flashes][:post_field_not_found]
+        redirect_to lato_blog.root_path
+        return
+      end
+
+      unless @post_field.destroy
+        flash[:danger] = @post_field.category_parent.errors.full_messages.to_sentence
+        redirect_to lato_blog.post_fields_path
+        return
+      end
+
+      flash[:success] = LANGUAGES[:lato_blog][:flashes][:post_field_destroy_success]
+      redirect_to lato_blog.post_fields_path
+    end
+
+    # Single fields endpoints:
+    # **************************************************************************
+
+    # This function create a new field for the post.
+    def create_relay_field
+      # find post field
+      @post_field = LatoBlog::PostField.find_by(id: params[:post_field_id])
+      unless @post_field
+        @error = true
+        respond_to { |r| r.js }
+      end
+      # find subfield info
+      child_field_info = nil
+      @post_field.meta_datas[:fields].each do |key, content|
+        child_field_info = [key, content] if key == params[:key]
+      end
+      unless child_field_info
+        @error = true
+        respond_to { |r| r.js }
+      end
+      # prepare data to create field
+      child_field_key = child_field_info.first
+      child_field_content = child_field_info.last
+      # override class and position
+      child_field_content[:class] = nil
+      child_field_content[:position] = !@post_field.post_fields.empty? ? @post_field.post_fields.order('position ASC').last.position + 1 : 1
+      # create subfield for the post field
+      blog__create_db_post_field(@post_field.post, child_field_key, child_field_content, @post_field)
+      # send response to client
+      @error = false
+      respond_to { |r| r.js }
+    end
+
+    # This function destroy a post for the field.
+    def destroy_relay_field
+      # find post field
+      child_field = LatoBlog::PostField.find_by(id: params[:id])
+      @post_field = child_field.post_field
+      unless @post_field
+        @error = true
+        respond_to { |r| r.js }
+      end
+      # find post field child and destroy it
+      unless child_field.destroy
+        @error = true
+        respond_to { |r| r.js }
+      end
+      # send response to client
+      @error = false
+      respond_to { |r| r.js }
+    end
+
+  end
+end