symphonia 2.1.7

data/app/assets/stylesheets/symphonia/symphonia_bootstrap.scss

@@ -0,0 +1,56 @@
+//  require _bootstrap
+// *= require rails_bootstrap_forms
+// *= require bootstrap-datepicker3
+//@import "bootstrap-sprockets";
+@import "bootstrap";
+@import "bootstrap-datepicker3";
+
+//@media (min-width: $screen-sm) {
+//  #internal_static_page_sign {
+//    font-size: 20em;
+//  }
+//}
+//
+//@media (min-width: $screen-md) {
+//  #internal_static_page_sign {
+//    font-size: 25em;
+//  }
+//}
+//
+//@media (min-width: $screen-lg) {
+//  #internal_static_page_sign {
+//    font-size: 30em;
+//  }
+//}
+
+body > .container {
+  padding-top: 80px; // fixed navbar
+}
+footer.footer {
+  //position: absolute;
+  height: 40px;
+  line-height: 40px;
+  bottom: 0;
+  width: 100%;
+}
+
+@keyframes highlight {
+  from {
+    background-color: map-get($theme-colors, warning);
+  }
+  to {
+    background-color: inherit;
+  }
+}
+
+@media print {
+  .contextual {
+    @extend .d-print-none;
+  }
+  a[href]:after {
+    content: none
+  }
+  .btn {
+    @extend .d-print-none;
+  }
+}

data/app/channels/application_cable/channel.rb

@@ -0,0 +1,5 @@
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base
+
+  end
+end

data/app/controllers/symphonia/accounts_controller.rb

@@ -0,0 +1,169 @@
+module Symphonia
+  class AccountsController < ApplicationController
+
+    before_action :login_require, only: [:show, :edit, :update]
+    before_action -> { menu_item(:my_account) }, only: [:show, :edit, :update]
+    before_action :prepare_user, only: [:register, :create]
+
+    helper Recaptcha::ClientHelper if defined? Recaptcha
+
+    def show
+      @user = current_account
+
+      respond_to do |format|
+        format.html { render(template: "#{@user.class.name.underscore.pluralize}/show") }
+        format.json { render json: @user }
+      end
+    end
+
+    def register
+      menu_item(:register)
+    end
+
+    def create
+      menu_item(:register)
+      @user.attributes = user_params
+      if Symphonia.config[:self_activation_enabled]
+        @user.status = @user.class.statuses[:active]
+      else
+        @user.status = @user.class.statuses[:pending]
+      end
+      respond_to do |format|
+        verified = if defined?(Recaptcha)
+          @user.valid? && verify_recaptcha(model: @user)
+        else
+          true
+        end
+        if verified && @user.save
+          Notifier.activation_user(@user).deliver_now
+          Notifier.user_registered(@user).deliver_now
+          format.html { redirect_to '/', notice: t(:text_user_registered) }
+          format.json { render status: :created }
+        else
+          format.html {
+            render action: 'register'
+          }
+          format.json { render json: @user.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    def edit
+      @user = current_account
+    end
+
+    def update
+      @user = current_account
+      @user.attributes = user_params
+      respond_to do |format|
+        @user.edited_by = User.current.logged_in? && User.current
+        @user.edited_at = Time.now
+        if @user.save
+          format.html { redirect_to({ action: 'show' }, notice: t(:text_updated)) }
+          format.json { head :no_content }
+          format.js
+        else
+          format.html {
+            render action: 'edit'
+          }
+          format.json { render json: @user.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    #----
+
+    def new_activation
+    end
+
+    def resend_activation
+      @user = find_account_by_mail(params.require(:mail))
+      if @user
+        if @user.active?
+          redirect_to root_path, flash: { error: t(:text_user_alerady_active) }
+        else
+          @user.reset_perishable_token!
+          Notifier.activation_user(@user).deliver_later
+          redirect_to root_path, notice: t(:text_activation_resend)
+        end
+      else
+        redirect_to root_path, flash: { error: t(:text_user_not_found) }
+      end
+    end
+
+    def activation
+      @user = find_account_by_token(params[:activation_code])
+      if @user
+        @user.activate!
+        redirect_to(login_path, notice: t(:text_activation_success))
+      else
+        redirect_to root_path, flash: { error: t(:text_user_not_found_or_token_invalid) }
+      end
+    end
+
+    def current
+
+    end
+
+    def admin
+
+    end
+
+    def reset_password
+      @user = find_account_by_token(params.require(:id))
+      return render_404 if @user.nil?
+
+      if params[:password] && params[:password_confirmation]
+        @user.password = params[:password]
+        @user.password_confirmation = params[:password_confirmation]
+      end
+
+      if @user.changed? && @user.save
+        return redirect_to(user_current_path, notice: t(:text_updated))
+      end
+    end
+
+    def lost_password
+      @user = find_account_by_mail(params[:mail]) if params[:mail]
+      if @user
+        if @user.active?
+          @user.reset_perishable_token!
+          Notifier.reset_password_user(@user).deliver_later
+          redirect_to login_path, notice: t(:text_reset_password_resend)
+        else
+          redirect_to login_path, flash: { error: t("authlogic.error_messages.not_active") }
+        end
+      else
+        respond_to do |format|
+          format.html
+          format.js
+        end
+      end
+    end
+
+    private
+
+    def prepare_user
+      return render_403 unless Symphonia.config[:allow_registrations]
+      @user = User.new
+    end
+
+    def user_params
+      params.require(:user).permit(:login, :first_name, :last_name, :password, :password_confirmation, :email, :mail, preference_ids: [])
+    end
+
+    def current_account
+      User.current
+    end
+
+    def find_account_by_mail(mail)
+      User.where(email: mail).first
+    end
+
+    def find_account_by_token(id)
+      User.find_using_perishable_token(id, 1.week)
+    end
+
+  end
+
+end

data/app/controllers/symphonia/admin_controller.rb

@@ -0,0 +1,22 @@
+module Symphonia
+  class AdminController < ApplicationController
+    before_action :login_require
+
+    def index
+      @admin_modules = AdminModule.where(user_id: [nil, current_user.id]).order(:position).all
+      @modules_count = @admin_modules.count
+
+      respond_to do |format|
+        format.html
+      end
+    end
+
+    def test_mail
+      Notifier.test_mail(current_user.id).deliver_later
+
+      redirect_to symphonia.root_path, notice: 'Test mail'
+    end
+
+  end
+
+end

data/app/controllers/symphonia/api_controller.rb

@@ -0,0 +1,64 @@
+module Symphonia
+  class ApiController < ApplicationController
+    include ::Swagger::Blocks
+    # https://github.com/fotinakis/swagger-blocks
+    swagger_root do
+      key :swagger, '2.0'
+      info do
+        key :version, '1.0.0'
+        key :title, 'Symphonia API'
+        key :description, ''
+        # key :termsOfService, 'http://helloreverb.com/terms/'
+        contact do
+          key :name, 'Lukas Pokorny'
+          key :email, 'pokorny@luk4s.cz'
+        end
+        license do
+          key :name, 'GPLv3'
+        end
+      end
+      # tag do
+      #   key :name, 'pet'
+      #   key :description, 'Pets operations'
+      #   externalDocs do
+      #     key :description, 'Find more info here'
+      #     key :url, 'https://swagger.io'
+      #   end
+      # end
+      # key :host, 'petstore.swagger.wordnik.com'
+      key :basePath, '/'
+      key :consumes, ['application/json']
+      key :produces, ['application/json']
+
+      security_definition :token do
+        key :type, :apiKey
+        key :name, :Authorization
+        key :in, :header
+      end
+      security do
+        key :token, []
+      end
+      # security_definition :petstore_auth do
+      #   key :type, :oauth2
+      #   key :authorizationUrl, 'http://swagger.io/api/oauth/dialog'
+      #   key :flow, :implicit
+      #   scopes do
+      #     key 'write:pets', 'modify pets in your account'
+      #     key 'read:pets', 'read your pets'
+      #   end
+      # end
+    end
+
+    # A list of all classes that have swagger_* declarations.
+    SWAGGERED_CLASSES = [
+      UsersController,
+      User,
+      Swagger::ErrorModel,
+      self
+    ]
+
+    def index
+      render json: ::Swagger::Blocks.build_root_json(SWAGGERED_CLASSES)
+    end
+  end
+end

data/app/controllers/symphonia/application_controller.rb

@@ -0,0 +1,8 @@
+module Symphonia
+  class ApplicationController < ::ActionController::Base
+
+    include ControllerExtensions
+
+    helper Symphonia::BootstrapModalHelper
+  end
+end

data/app/controllers/symphonia/attachments_controller.rb

@@ -0,0 +1,37 @@
+module Symphonia
+  class AttachmentsController < ApplicationController
+
+    before_action :require_login, :find_attachment
+
+    def show
+      # find_attachment
+      render(plain: @attachment.attachment.url(:original), layout: false)
+    end
+
+    def destroy
+      # find_attachment
+      @attachment.destroy
+      respond_to do |format|
+        format.html do
+          flash[:notice] = t(:"text_#{@attachment.type.underscore}_successfully_destroy")
+          redirect_back_or_default(polymorphic_path(@attachment.attachable))
+        end
+        format.js
+      end
+    end
+
+    def reorder
+      # find_attachment
+      new_position = params.require(:position).to_i
+      @attachment.insert_at(new_position)
+      head :ok
+    end
+
+    private
+
+    def find_attachment
+      @attachment = Attachment.find(params.require(:id))
+    end
+  end
+
+end

data/app/controllers/symphonia/filters_controller.rb

@@ -0,0 +1,23 @@
+module Symphonia
+  class FiltersController < ApplicationController
+    before_action :require_login
+    before_action :find_filters
+
+    def options
+      respond_to do |format |
+        format.html
+        format.js
+      end
+    end
+
+    private
+
+    def find_filters
+      _type = params.delete(:type)
+      @query = _type.constantize.query.new
+    rescue StandardError => e
+      Rails.logger.debug e.message
+      render_404
+    end
+  end
+end

data/app/controllers/symphonia/images_controller.rb

@@ -0,0 +1,16 @@
+module Symphonia
+  class ImagesController < ApplicationController
+    # before_action :require_login
+
+    # raise '??? images ??'
+    # def index
+    #   @images = Image.order(created_at: :asc)
+    #   @images = @images.like(params[:q]) if params[:q].present?
+    #   @images = @images.page(params[:page])
+    #   respond_to do |format|
+    #     format.html
+    #     format.js
+    #   end
+    # end
+  end
+end

data/app/controllers/symphonia/login_controller.rb

@@ -0,0 +1,80 @@
+module Symphonia
+  class LoginController < ApplicationController
+
+    before_action { menu_item(:login) }
+
+    def index
+      if current_model.constantize.current.logged_in?
+        return destroy
+      else
+        return new
+      end
+    end
+
+    def new
+      if current_model.constantize.current.logged_in?
+        return redirect_to(after_login_path)
+      end
+      @model_session = "#{current_model}Session".constantize.new
+      render :new
+    end
+
+    def create
+      @model_session = "#{current_model}Session".constantize.new(login_session_params)
+      if @model_session.save
+        current_model.constantize.current = @model_session.user
+        redirect_to after_login_path
+      else
+        render :new
+      end
+    end
+
+    def login_session_params
+      params.require(:login_session).permit(:login, :password, :remember_me).to_h
+    end
+
+    def destroy
+      current_session && current_session.destroy
+      redirect_to '/', notice: t(:text_successfully_logout)
+    end
+
+    private
+
+    def current_model
+      raise NotImplementedError
+    end
+
+    def current_session
+      raise NotImplementedError
+    end
+
+    def after_login_path
+      path = session[:return_to].presence
+      path ||= Symphonia.config.after_login_path.presence
+      path ||= get_first_menu_item_path(Symphonia::MenuManager.menu(:top_menu).values) || :admin_path
+      case path
+        when Symbol
+          main_app.send(path)
+        when Proc
+          path.call(self)
+        else
+          path
+      end
+    end
+
+    def get_first_menu_item_path(menu_items)
+      menu_items.detect do |item|
+        if (submenu = item[:children]).present?
+          if (subitem = get_first_menu_item_path(submenu.values))
+            return subitem
+            break
+          end
+        else
+          item[:if].nil? || item[:if].call
+        end
+      end.try(:[], :url)
+    end
+
+  end
+
+end

data/app/controllers/symphonia/roles_controller.rb

@@ -0,0 +1,100 @@
+module Symphonia
+  class RolesController < ApplicationController
+
+    include BaseController
+
+    def model
+      Role
+    end
+
+    def safe_attributes
+      [:name, :description, permissions: []]
+    end
+    # helper Symphonia::RendererHelper
+    #
+    # before_action :authorize
+    before_action :load_permissions, only: [:new, :edit, :update, :create]
+    #
+    # #layout 'admin'
+    #
+    # def index
+    #   @query = Symphonia::Role.query.new(self)
+    #   @entities = @query.entities
+    #   respond_to do |format|
+    #     format.html do
+    #       @entities = @entities.page(params[:page])
+    #       render layout: !request.xhr?
+    #     end
+    #     format.xml { render xml: @entities.all }
+    #     format.json { render json: @entities.all }
+    #   end
+    # end
+    #
+    # def show
+    #   @role = Role.find(params[:id])
+    #   respond_to do |format|
+    #     format.html
+    #     format.json { render json: @role }
+    #   end
+    # end
+    #
+    # def new
+    #   @role = Role.new
+    # end
+    #
+    # def edit
+    #   @role = Role.find(params[:id])
+    # end
+
+    def create
+      @entity = @role = Role.new(entity_params)
+      @role.permissions = Symphonia::Permissions.find_all(params[:permissions]).map(&:name)
+      super
+      # respond_to do |format|
+      #   if @role.save
+      #     format.html { redirect_to((params[:continue] ? new_role_path : roles_path), notice: t(:text_created)) }
+      #     format.json { render(json: @role, status: :created, location: @role) }
+      #   else
+      #     format.html { render(action: 'new') }
+      #     format.json { render(json: @role.errors, status: :unprocessable_entity) }
+      #   end
+      # end
+    end
+
+    def update
+      @entity = @role = Role.find(params[:id])
+      @role.permissions = Symphonia::Permissions.find_all(params[:permissions]).map(&:name)
+      super
+      # respond_to do |format|
+      #   if @role.update_attributes(role_params)
+      #     format.html { redirect_to(edit_role_path(@role), notice: t(:text_updated)) }
+      #     format.json { head(:no_content) }
+      #   else
+      #     format.html { render(action: 'edit') }
+      #     format.json { render(json: @role.errors, status: :unprocessable_entity) }
+      #   end
+      # end
+    end
+
+    # def destroy
+    #   @role = Role.find(params[:id])
+    #   @role.destroy
+    #   respond_to do |format|
+    #     format.html { redirect_to(roles_url, notice: t(:text_destroyed)) }
+    #     format.json { head :no_content }
+    #     format.js { render js: "Symphonia.filters.removeRow('#{view_context.dom_id(@role)}')"}
+    #   end
+    # end
+    #
+    private
+    #
+    def load_permissions
+      @permissions = Symphonia::Permissions.all
+    end
+    #
+    # def role_params
+    #   params.require(:role).permit(:name, :description, permissions: [])
+    # end
+  end
+
+end

data/app/controllers/symphonia/user_sessions_controller.rb

@@ -0,0 +1,16 @@
+module Symphonia
+  class UserSessionsController < LoginController
+    private
+
+    def current_model
+      @model = User
+      @model.name
+    end
+
+    def current_session
+      current_user_session
+    end
+
+  end
+
+end