lesli 5.0.11 → 5.0.13

data/app/models/lesli/cloud_object/custom_field.rb

@@ -0,0 +1,158 @@
+=begin
+
+Lesli
+
+Copyright (c) 2023, Lesli Technologies, S. A.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see http://www.gnu.org/licenses/.
+
+Lesli · Your Smart Business Assistant. 
+
+Made with ♥ by https://www.lesli.tech
+Building a better future, one line of code at a time.
+
+@contact  hello@lesli.tech
+@website  https://lesli.tech
+@license  GPLv3 http://www.gnu.org/licenses/gpl-3.0.en.html
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// ·
+
+=end
+module Lesli
+class CloudObject::CustomField < ApplicationLesliRecord
+    self.abstract_class = true
+    belongs_to :user_creator, class_name: "::User", foreign_key: "users_id"
+
+    # @return [User] This method will always return nil
+    # @description At the current time, this is a dummy method that returns nil, so the function is_editable_by? in
+    #   ApplicationLesliRecord will work without issues
+    def user_main
+        return nil
+    end
+
+=begin
+    # @param cloud_object [ApplicationRecord] Cloud object to which an user can subscribe to
+    # @param user [User] The user that is subscribing to the *cloud_ubject*
+    # @param event [Symbol] A valid event from this class's *event* enum to wich the *user* will be subscribed
+    # @param notification_type [Symbol] A valid notification_type from this class's *notification_type* enum
+    # @return [void]
+    # @description Subscribes a *user* to one or all *events* of the *cloud_object*. If no *event* is provided, the *user*
+    #     is subscribed to all the *events*
+    # @example
+    #     first_ticket = CloudHelp::Ticket.find( 1 )
+    #     second_ticket = CloudHelp::Ticket.find( 2 )
+    #     user = current_user
+    #     CloudHelp::Ticket::Subscriber.add_subscriber( first_ticket, current_user )
+    #     CloudHelp::Ticket::Subscriber.add_subscriber( second_ticket, current_user, :http_post, :email )
+    def self.add_subscriber(cloud_object, user, event=nil, notification_type= :web)
+        model = dynamic_info[:model]
+
+        if event
+            return cloud_object.subscribers.create(
+                user: user,
+                event: event,
+                notification_type: model.notification_types[notification_type]
+            )
+        end
+        
+        model.events.values.each do |event|
+            cloud_object.subscribers.create(
+                user: user,
+                event: event,
+                notification_type: model.notification_types[notification_type]
+            )
+        end
+    end
+
+    # @param cloud_object [ApplicationRecord] Cloud object to which an user can subscribe to
+    # @param subject [String] The subject that will be shown in the notification
+    # @param event [Symbol] A valid event from this class's *event* enum
+    # @return [void]
+    # @description Notifies all the users subscribed to the *cloud_object*'s *event* using the *Courier* engine
+    # @example
+    #     ticket = CloudHelp::Ticket.find( 1 )
+    #     ClodHelp::Ticket::Subscriber.notify_subscribers(
+    #         ticket,
+    #         "A new comment has been added to ticket #{ticket.id}",
+    #         :comment_created
+    #     )
+    def self.notify_subscribers(cloud_object, subject, event)
+        module_name = dynamic_info[:module_name]
+        object_name = dynamic_info[:object_name]
+
+        cloud_object.subscribers.where(event: event).each do |subscriber|
+            Courier::Bell::Notifications.send(
+                user: subscriber.user,
+                subject: subject,
+                href: "#{module_name}/#{object_name}/#{cloud_object.id}",
+                type: subscriber.notification_type,
+                cloud_object_type: "#{module_name}/#{object_name}"
+            )
+        end
+    end
+
+    # @param cloud_object [ApplicationRecord] Cloud object to which an user can subscribe to
+    # @param user [User] The user that is subscribing to the *cloud_object*
+    # @return [Array] Array of subscriptions. There is one subscription per *event*.
+    # @description Generates an array of subscription, Each element contains a subscription *event*, 
+    #     information about wheter the *user* is subscribed or not and, if the user is subscribed, 
+    #     the notification type of the subscription
+    # @example
+    #     ticket = CloudHelp::Ticket.find( 1 )
+    #     subscription_events = CloudHelp::Ticket::Subscriber.subscription_events(
+    #         ticket,
+    #         current_user
+    #     )
+    def self.subscription_events(cloud_object, user)
+        model = dynamic_info[:model]
+
+        data = { }
+        events = model.events.keys
+        events.each do |event|
+            data[event] = {
+                event: event,
+                subscribed: false,
+                notification_type: :web
+            }
+        end
+        cloud_object.subscribers.where(users_id: user.id).each do |subscriber|
+            data[subscriber.event][:id] = subscriber.id
+            data[subscriber.event][:subscribed] = true
+            data[subscriber.event][:notification_type] = subscriber.notification_type
+        end
+        data.values
+    end
+
+    private
+
+    # @return [Hash] Hash that contains information about the class
+    # @description Returns dynamic information based on the current implementation of this abstract class
+    # @example
+    #     dynamic_info = CloudHelp::Ticket::Subscriber.dynamic_info
+    #     puts dynamic_info[:module_name] # will print 'help'
+    #     puts dynamic_info[:object_name] # will print 'ticket'
+    #     dynamic_info.model.new # will return an instance of CloudHelp::Ticket::Subscriber
+    def self.dynamic_info
+        module_info = self.name.split("::")
+        {
+            module_name: module_info[0].sub("Cloud", "").downcase,
+            object_name: module_info[1].downcase,
+            model: "#{module_info[0]}::#{module_info[1]}::Subscriber".constantize
+        }
+    end
+=end
+
+end
+end

data/app/models/lesli/cloud_object/discussion.rb

@@ -0,0 +1,219 @@
+=begin
+
+Lesli
+
+Copyright (c) 2023, Lesli Technologies, S. A.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see http://www.gnu.org/licenses/.
+
+Lesli · Ruby on Rails SaaS Development Framework.
+
+Made with ♥ by LesliTech
+Building a better future, one line of code at a time.
+
+@contact  hello@lesli.tech
+@website  https://www.lesli.tech
+@license  GPLv3 http://www.gnu.org/licenses/gpl-3.0.en.html
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// · 
+=end
+module Lesli
+    class CloudObject::Discussion < ApplicationLesliRecord
+        self.abstract_class = true
+        belongs_to :user_creator, class_name: "::User", foreign_key: "users_id"
+
+        # @return [User] This method will always return nil
+        # @description At the current time, this is a dummy method that returns nil, so the function is_editable_by? in
+        #   ApplicationLesliRecord will work without issues
+        def user_main
+            return nil
+        end
+
+        # @param account [Account] Account from current user
+        # @param cloud_id [Integer] Id of the *cloud_object* to which this discussion belongs to
+        # @param query [Query] that contains the search and pagination information
+        # @return [Array] Array of discussions. Each discussion contains a *responses* element,
+        #     which is an array that has all its responses ordered by date
+        # @description Retrieves and returns all discussions from a *cloud_object*,
+        #     including information of the user that published the comment
+        # @example
+        #     current_user = the user making this request
+        #     employee_id = params[:employee_id]
+        #     discussions = CloudTeam::Employee::Discussion.index( account, employee_id, @query )
+        def self.index(current_user, cloud_id, query)
+            cloud_object_model = self.cloud_object_model
+            account_model = cloud_object_model.reflect_on_association(:account).klass
+            
+            # get search string from query params
+            #search_string = query[:search].downcase.gsub(" ","%") unless query[:search].blank?
+            
+            discussions = self.joins(:cloud_object)
+            .joins("inner join lesli_users u on #{self.table_name}.user_id = u.id")
+            .where("#{cloud_object_model.table_name}.id = #{cloud_id}")
+            .where("#{cloud_object_model.table_name}.account_id = #{current_user.account.id}")
+            .select(
+                "#{self.table_name}.id",
+                "#{self.table_name}.user_id",
+                "#{self.table_name}.content",
+                Date2.new.date_time.db_timestamps("#{self.table_name}"),
+                "u.email",
+                "CONCAT_WS(' ', u.first_name, u.last_name) as user_name"
+            )
+
+            # Filter results by search string
+            # unless search_string.blank?
+            #     discussions = discussions.where("
+            #     (LOWER(ud.first_name) SIMILAR TO '%#{search_string}%') OR 
+            #     (LOWER(ud.last_name) SIMILAR TO '%#{search_string}%') OR 
+            #     (LOWER(#{self.table_name}.content) SIMILAR TO '%#{search_string}%')
+            #     ")
+            # end
+
+            discussions = self.format_discussions(discussions)
+
+            Kaminari.paginate_array(discussions).page(query[:pagination][:page]).per(query[:pagination][:perPage])
+        end
+
+        # @return [Hash] Information about the discussion
+        # @description Retrieves and returns a specific discussion, along with information about the user
+        #     that created it
+        # @example
+        #     discussion = CloudHelp::Ticket::Discussion.first
+        #     puts discussion.show #This will display extra information about the discussion, like the user's name
+        def show(current_user = nil)
+            discussion_attributes = attributes.merge({
+                editable: is_editable_by?(current_user),
+                email: user_creator.email,
+                user_name: user_creator.full_name
+            })
+            discussion_attributes["created_at"] = LC::Date.to_string_datetime(discussion_attributes["created_at"])
+
+            discussion_attributes
+        end
+
+        # @return [Class] The class of the association 'belongs_to'
+        # @description All discussions belong to a *cloud_object*. This method returns the specific class of
+        #     that cloud_object.
+        # @example
+        #     puts DeutscheLeibrenten::Project::Discussion.cloud_object_model.new # This will display an instance of DeutscheLeibrenten::Project
+        def self.cloud_object_model
+            self.reflect_on_association(:cloud_object).klass
+        end
+
+        private
+
+        # @param discussions [Arrray] An array of discussions that were previously filtered
+        # @return [Array] A new array of discussions, nesting the responses within the parent discussions
+        # @description Geretes a new array of discussions, nesting the responses inside the parent discussions and order them by date
+        #     This method uses the *nest_responses* method to support the nesting action recursively
+        # @example
+        #     # Imagine that discussions has 2 discussions, the first one is a normal discussion, and the second one is a response to the first one
+        #     puts discussions # will display something like
+        #     # [
+        #     #     {
+        #     #         id: 1,
+        #     #         users_id: 2,
+        #     #         created_at: Date(),
+        #     #         content: 'This is a root discussion',
+        #     #         user_name: 'System',
+        #     #         discussions_id: null
+        #     #     }, {
+        #     #         id: 2,
+        #     #         users_id: 2,
+        #     #         created_at: Date(),
+        #     #         content: 'This is a response',
+        #     #         user_name: 'Test',
+        #     #         discussions_id: 1
+        #     #     }
+        #     # ]
+        #     puts Discussion.format_discussions(discussions) # Will display something like 
+        #     # [
+        #     #     {
+        #     #         id: 1,
+        #     #         users_id: 2,
+        #     #         created_at: Date(),
+        #     #         content: 'This is a root discussion',
+        #     #         user_name: 'System',
+        #     #         discussions_id: null,
+        #     #         responses: [{
+        #     #             id: 2,
+        #     #             users_id: 2,
+        #     #             created_at: Date(),
+        #     #             content: 'This is a response',
+        #     #             response_to: 'System'
+        #     #             user_name: 'Test',
+        #     #             discussions_id: 1
+        #     #         }]
+        #     #     }
+        #     # ]
+        def self.format_discussions(discussions)
+            data = {}
+            root_discussions = []
+
+            # Add all responses to that discussion
+            discussions.each do |discussion|
+                discussion_data = {
+                    data: discussion,
+                    responses: []
+                }
+                data[discussion["id"]] = discussion_data
+
+                if discussion["#{self.table_name}_id"].present?
+                    parent_discussion = data[discussion["#{self.table_name}_id"]]
+                    next unless parent_discussion
+
+                    if parent_discussion[:data]["#{self.table_name}_id"].present?
+                        discussion["response_to"] = parent_discussion[:data]["user_name"]
+                    end
+                    parent_discussion[:responses].push(discussion["id"])
+                else
+                    root_discussions.push(discussion_data)
+                end
+            end
+
+            # Nest the responses to root discussions. A root discussion is any comment that is not a response to another comment
+            root_discussions.each do |discussion|
+                responses = []
+                self.nest_responses(data, discussion, responses)
+                discussion[:responses] = responses
+            end
+
+            # revert the root discussions so the most recent comments appear in the top
+            root_discussions.reverse
+        end
+
+        # @param data [Hash] Hash that contains all the discussions, the key is the id of the discussion
+        # @param discussion [Hash] Hash that contains the information
+        # @param responses [Array] Array of discussions, that are the responses to the *discussion* param.
+        #     It should start as an empty array
+        # @return [void]
+        # @description Recursive function that checks all discussions that are actually responses of other 
+        #     discussions and adds them to their *responses* param. It adds direct responses, responses of responses, etc.
+        #     This is a void function that modifies the *discussion* param directly
+        # @example
+        #     data = {}
+        #     CloudHelp::Ticket::Discussion.all.each do |discussion|
+        #         data[discussion.id] = discussion
+        #     end
+        #     CloudHelp::Ticket::Discussion.nest_responses(data, CloudHelp::Ticket::Discussion.first, [])
+        def self.nest_responses(data, discussion,  responses)
+            discussion[:responses].each do |response_id|
+                response = data[response_id]
+                responses.push(response[:data])
+                self.nest_responses(data, response, responses)
+            end
+        end
+    end
+end

data/app/models/lesli/cloud_object/subscriber.rb

@@ -0,0 +1,186 @@
+=begin
+
+Lesli
+
+Copyright (c) 2023, Lesli Technologies, S. A.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see http://www.gnu.org/licenses/.
+
+Lesli · Your Smart Business Assistant. 
+
+Made with ♥ by https://www.lesli.tech
+Building a better future, one line of code at a time.
+
+@contact  hello@lesli.tech
+@website  https://lesli.tech
+@license  GPLv3 http://www.gnu.org/licenses/gpl-3.0.en.html
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// ·
+
+=end
+
+module Lesli
+class CloudObject::Subscriber < ApplicationLesliRecord
+    self.abstract_class = true
+    belongs_to :user_creator, class_name: "::User", foreign_key: "users_id"
+
+    # @return [User] This method will always return nil
+    # @description At the current time, this is a dummy method that returns nil, so the function is_editable_by? in
+    #   ApplicationLesliRecord will work without issues
+    def user_main
+        return nil
+    end
+
+
+    # @attribute [Enumerable<Symbol>] action
+    #     @return [:discussion_created, :action_created, :file_created, :activity_created, :workflow_updated, :priority_updated, :http_get, :http_post, :http_put, :http_patch, :http_update]
+    enum action: {
+        object_created: "object_created",
+        object_updated: "object_updated",
+        object_destroyed: "object_destroyed",
+        object_status_updated: "object_status_updated",
+
+        action_created: "action_created",
+        action_updated: "action_updated",
+        action_destroyed: "action_destroyed",
+
+        discussion_created: "discussion_created",
+        discussion_updated: "discussion_updated",
+        discussion_destroyed: "discussion_destroyed",
+
+        file_created: "file_created",
+        file_updated: "file_updated",
+        file_destroyed: "file_destroyed"
+    }
+    validates :action, presence: true, inclusion: { in: :action }
+
+
+    # @attribute [Enumerable<Symbol>] notification_type
+    #     @return [:web, :email]
+    enum notification_type: {
+        email: "email",                 # notification sent by email only
+        webpush: "webpush",             # notification for web interface only
+        mobilepush: "mobilepush",       # notification for mobile only
+        mobiledialog: "mobiledialog",   # open a dialog in the main app screen
+        push: "push",                   # webpush & mobilepush
+    }
+    validates :notification_type, presence: true, inclusion: { in: :notification_type }
+
+    # @param cloud_object [ApplicationRecord] Cloud object to which an user can subscribe to
+    # @param user [User] The user that is subscribing to the *cloud_ubject*
+    # @param action [Symbol] A valid action from this class's *action* enum to wich the *user* will be subscribed
+    # @param notification_type [Symbol] A valid notification_type from this class's *notification_type* enum
+    # @return [void]
+    # @description Subscribes a *user* to one or all *actions* of the *cloud_object*. If no *action* is provided, the *user*
+    #     is subscribed to all the *actions*
+    # @example
+    #     first_ticket = CloudHelp::Ticket.find( 1 )
+    #     second_ticket = CloudHelp::Ticket.find( 2 )
+    #     user = current_user
+    #     CloudHelp::Ticket::Subscriber.add_subscriber( first_ticket, current_user )
+    #     CloudHelp::Ticket::Subscriber.add_subscriber( second_ticket, current_user, :http_post, :email )
+    def self.add_subscriber(cloud_object, user, action=nil, notification_type= :web)
+
+        if action
+            return cloud_object.subscribers.create(
+                user_creator: user,
+                action: action,
+                notification_type: self.notification_types[notification_type]
+            )
+        end
+
+        self.actions.values.each do |action|
+            cloud_object.subscribers.create(
+                user_creator: user,
+                action: action,
+                notification_type: self.notification_types[notification_type]
+            )
+        end
+    end
+
+
+
+    # @param cloud_object [ApplicationRecord] Cloud object to which an user can subscribe to
+    # @param subject [String] The subject that will be shown in the notification
+    # @param action [Symbol] A valid action from this class's *action* enum
+    # @return [void]
+    # @description Notifies all the users subscribed to the *cloud_object*'s *action* using the *Courier* engine except the
+    #     user that triggered the notification
+    # @example
+    #     ticket = CloudHelp::Ticket.find( 1 )
+    #     ClodHelp::Ticket::Subscriber.notify_subscribers(
+    #         ticket,
+    #         "A new comment has been added to ticket #{ticket.id}",
+    #         :discussion_created
+    #     )
+    def self.notify_subscribers(current_user, cloud_object, action, subject: nil, body: nil, url: nil)
+
+        unless cloud_object.subscribers.blank?
+            subscribers = cloud_object.subscribers.where(action: action)
+            subscribers = subscribers.where("users_id != ?", current_user.id) if current_user
+            
+            subscribers.each do |subscriber|
+                Courier::Bell::Notification.new(
+                    subscriber.user_main || subscriber.user_creator,
+                    subject || action,
+                    body: body,
+                    url: url,
+                    category: "info",
+                    channel: subscriber.notification_type
+                )
+            end
+        end
+    end
+
+    # @param cloud_object [ApplicationRecord] Cloud object to which an user can subscribe to
+    # @param user [User] The user that is subscribing to the *cloud_object*
+    # @return [Array] Array of subscriptions. There is one subscription per *action*.
+    # @description Generates an array of subscription, Each element contains a subscription *action*,
+    #     information about wheter the *user* is subscribed or not and, if the user is subscribed,
+    #     the notification type of the subscription
+    # @example
+    #     ticket = CloudHelp::Ticket.find( 1 )
+    #     subscription_actions = CloudHelp::Ticket::Subscriber.subscription_actions(
+    #         ticket,
+    #         current_user
+    #     )
+    def self.subscription_actions(cloud_object, user)
+        data = { }
+        actions = self.actions.keys
+        actions.each do |action|
+            data[action] = {
+                action: action,
+                subscribed: false,
+                notification_type: :email
+            }
+        end
+        cloud_object.subscribers.where(users_id: user.id).each do |subscriber|
+            data[subscriber.action][:id] = subscriber.id
+            data[subscriber.action][:subscribed] = true
+            data[subscriber.action][:notification_type] = subscriber.notification_type
+        end
+        data.values
+    end
+
+    # @return [Class] The class of the association 'belongs_to'
+    # @description All subscribers belong to a *cloud_object*. This method returns the specific class of
+    #     that cloud_object.
+    # @example
+    #     puts DeutscheLeibrenten::Project::Discussion.cloud_object_model.new # This will display an instance of DeutscheLeibrenten::Project
+    def self.cloud_object_model
+        self.reflect_on_association(:cloud_object).klass
+    end
+end
+end

data/app/models/lesli/shared/dashboard.rb

@@ -52,12 +52,23 @@ module Lesli
             #     # To execute this function, you must only do
             #     my_account = Account.first
             #     my_account.proposal = CloudProposal::Account.new
-            def self.initialize_data(account)
-                self.create!(
-                    account: account,
-                    name: "Default Dashboard",
+            def self.initialize_dashboard(modelo, account, components)
+
+                components.unshift({
+                    name: "Engine version",
+                    component_id: "engine-version",
+                    layout: 2,
+                    query_configuration: {},
+                    custom_configuration: {}
+                })
+
+                modelo.create_with(
                     default: true,
-                    main: false
+                    main: false,
+                    components_attributes: components
+                ).find_or_create_by!(
+                    account: account,
+                    name: "Default Dashboard"
                 )
             end
 

data/app/models/lesli/user/session.rb

@@ -30,8 +30,6 @@ Building a better future, one line of code at a time.
 // · 
 =end
 
-require "bcrypt"
-
 module Lesli
     class User::Session < ApplicationLesliRecord
         belongs_to :user

data/app/models/lesli/user.rb

@@ -52,6 +52,7 @@ module Lesli
         has_many :sessions
         has_many :requests
         has_many :shortcuts
+        has_many :notifications, class_name: "LesliBell::Notification"
         has_many :activities,   class_name: "User::Activity"
 
         # users can have many roles and too many privileges through the roles
@@ -62,23 +63,22 @@ module Lesli
 
 
         # devise implementation
-        devise :database_authenticatable,
-            :registerable,
-            :rememberable,
-            :recoverable,
-            :validatable,
-            :confirmable,
-            :trackable
-            #:omniauthable, omniauth_providers: [:google_oauth2, :facebook]
+        #if !defined?(LesliSecurity)
+            devise( 
+                :database_authenticatable,
+                :registerable,
+                :rememberable,
+                :recoverable,
+                :validatable,
+                :confirmable,
+                :trackable);
+                #:omniauthable, omniauth_providers: [:google_oauth2, :facebook]
+        #end
+
 
         # users belongs to an account only... and must have a role
         belongs_to :account, optional: true
 
-        # user details are saved on separate table
-        has_one :detail, inverse_of: :user, autosave: true, dependent: :destroy
-        accepts_nested_attributes_for :detail, update_only: true
-
-
         # users belongs to an account only... and must have a role
         belongs_to :account, optional: true
 

data/app/operators/lesli/controller_operator.rb

@@ -19,7 +19,7 @@ along with this program. If not, see http://www.gnu.org/licenses/.
 
 Lesli · Ruby on Rails SaaS Development Framework.
 
-Made with ♥ by https://www.lesli.tech
+Made with ♥ by LesliTech
 Building a better future, one line of code at a time.
 
 @contact  hello@lesli.tech
@@ -120,6 +120,9 @@ module Lesli
             # Get the list of controllers and actions from engines
             Lesli::System.engines.each do |engine, engine_info|
 
+                # Do not process main Rails app
+                next if engine == "Root"
+
                 # load and retrieve the list of controllers and actions from an engine
                 routes = "#{engine}::Engine".constantize.routes.routes.each do |route| 
                     route = route.defaults 

data/app/operators/lesli/user_registration_operator.rb

@@ -78,9 +78,9 @@ module Lesli
             # create new account for the new user only if multi-account is allowed
             if allow_multiaccount === true
                 account = Account.create!({
-                    user: resource,            # set user as owner of his just created account
-                    company_name: "Lesli",     # temporary company name
-                    status: :active            # account is active due user already confirmed his email
+                    user: resource,     # set user as owner of his just created account
+                    name: "Lesli",      # temporary company name
+                    status: :active     # account is active due user already confirmed his email
                 })
             end