mirror of
https://github.com/opf/openproject.git
synced 2026-06-14 03:30:14 +00:00
as-op
836 lines
24 KiB
Ruby
836 lines
24 KiB
Ruby
# frozen_string_literal: true
|
||
|
||
#-- copyright
|
||
# OpenProject is an open source project management software.
|
||
# Copyright (C) the OpenProject GmbH
|
||
#
|
||
# This program is free software; you can redistribute it and/or
|
||
# modify it under the terms of the GNU General Public License version 3.
|
||
#
|
||
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
|
||
# Copyright (C) 2006-2013 Jean-Philippe Lang
|
||
# Copyright (C) 2010-2013 the ChiliProject Team
|
||
#
|
||
# 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 2
|
||
# 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, write to the Free Software
|
||
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||
#
|
||
# See COPYRIGHT and LICENSE files for more details.
|
||
#++
|
||
|
||
require "digest/sha1"
|
||
|
||
class User < Principal
|
||
ScimEmail = Struct.new("ScimEmail", :value, :primary, :type)
|
||
|
||
VALID_NAME_CHARS = "\\d\\p{Alpha}\\p{Mark}\\p{Space}\\p{Emoji}'\\u{2019}´\\-_.,@()+&*–"
|
||
INVALID_NAME_REGEX = /[^#{VALID_NAME_CHARS}]/
|
||
VALID_NAME_REGEX = /\A[#{VALID_NAME_CHARS}]+\z/
|
||
CURRENT_USER_LOGIN_ALIAS = "me"
|
||
USER_FORMATS_STRUCTURE = {
|
||
firstname_lastname: %i[firstname lastname],
|
||
firstname: [:firstname],
|
||
lastname_firstname: %i[lastname firstname],
|
||
lastname_n_firstname: %i[lastname firstname],
|
||
lastname_comma_firstname: %i[lastname firstname],
|
||
username: [:login]
|
||
}.freeze
|
||
|
||
include ::Associations::Groupable
|
||
include ::Users::Avatars
|
||
include ::Users::PermissionChecks
|
||
extend DeprecatedAlias
|
||
|
||
has_many :watches, class_name: "Watcher",
|
||
dependent: :delete_all
|
||
has_many :changesets, dependent: :nullify
|
||
has_many :passwords, -> {
|
||
order("id DESC")
|
||
}, class_name: "UserPassword",
|
||
dependent: :destroy,
|
||
inverse_of: :user
|
||
has_one :rss_token, class_name: "::Token::RSS", dependent: :destroy
|
||
has_many :api_tokens, class_name: "::Token::API", dependent: :destroy
|
||
has_many :oauth_client_tokens, dependent: :destroy
|
||
has_many :working_hours, class_name: "UserWorkingHours",
|
||
dependent: :destroy,
|
||
inverse_of: :user
|
||
has_many :non_working_times, class_name: "UserNonWorkingTime",
|
||
dependent: :destroy,
|
||
inverse_of: :user
|
||
|
||
# The user might have one invitation token
|
||
has_one :invitation_token, class_name: "::Token::Invitation", dependent: :destroy
|
||
|
||
# everytime a user subscribes to a calendar, a new ical_token is generated
|
||
# unlike on other token types, all previously generated ical_tokens are kept
|
||
# in order to keep all previously generated ical urls valid and usable
|
||
has_many :ical_tokens, class_name: "::Token::ICal", dependent: :destroy
|
||
has_many :ical_meeting_tokens, class_name: "::Token::ICalMeeting", dependent: :destroy
|
||
|
||
belongs_to :ldap_auth_source, optional: true
|
||
|
||
# Authorized OAuth grants
|
||
has_many :oauth_grants, # rubocop:disable Rails/InverseOf
|
||
class_name: "Doorkeeper::AccessGrant",
|
||
foreign_key: "resource_owner_id",
|
||
dependent: :delete_all
|
||
|
||
# User-defined oauth applications
|
||
has_many :oauth_applications,
|
||
class_name: "Doorkeeper::Application",
|
||
as: :owner,
|
||
dependent: :destroy
|
||
|
||
# Meeting memberships
|
||
has_many :meeting_participants,
|
||
class_name: "MeetingParticipant",
|
||
inverse_of: :user,
|
||
dependent: :destroy
|
||
|
||
has_many :recurring_meeting_interim_responses,
|
||
inverse_of: :user,
|
||
dependent: :destroy
|
||
|
||
has_many :notification_settings,
|
||
dependent: :destroy
|
||
|
||
has_many :project_queries,
|
||
class_name: "ProjectQuery",
|
||
inverse_of: :user,
|
||
dependent: :destroy
|
||
|
||
has_many :emoji_reactions, dependent: :destroy
|
||
has_many :reminders, foreign_key: "creator_id", dependent: :destroy, inverse_of: :creator
|
||
has_many :remote_identities, dependent: :destroy
|
||
|
||
# Resource allocations assigned to this user. Normal user-deletion goes
|
||
# through Principals::DeleteJob, which rewrites principal_id to a
|
||
# DeletedUser placeholder before destroy fires (registered in the
|
||
# resource_management engine). The `dependent: :nullify` here is a
|
||
# defensive fallback if a user is destroyed outside that flow — the column
|
||
# is already nullable for the unassigned/filter-only state.
|
||
has_many :resource_allocations,
|
||
class_name: "ResourceAllocation",
|
||
foreign_key: :principal_id,
|
||
dependent: :nullify,
|
||
inverse_of: :principal
|
||
|
||
# Users blocked via brute force prevention
|
||
# use lambda here, so time is evaluated on each query
|
||
scope :blocked, -> { create_blocked_scope(self, true) }
|
||
scope :not_blocked, -> { create_blocked_scope(self, false) }
|
||
|
||
scopes :find_by_login,
|
||
:newest,
|
||
:notified_globally,
|
||
:watcher_recipients,
|
||
:with_time_zone,
|
||
:having_reminder_mail_to_send
|
||
|
||
def self.create_blocked_scope(scope, blocked)
|
||
scope.where(blocked_condition(blocked))
|
||
end
|
||
|
||
def self.blocked_condition(blocked)
|
||
block_duration = Setting.brute_force_block_minutes.to_i.minutes
|
||
blocked_if_login_since = Time.zone.now - block_duration
|
||
negation = blocked ? "" : "NOT"
|
||
|
||
["#{negation} (users.failed_login_count >= ? AND users.last_failed_login_on > ?)",
|
||
Setting.brute_force_block_after_failed_logins.to_i,
|
||
blocked_if_login_since]
|
||
end
|
||
|
||
acts_as_customizable admin_only_allowed: true
|
||
|
||
attr_accessor :password, :password_confirmation, :last_before_login_on, :current_password_input
|
||
|
||
validates :login,
|
||
:firstname,
|
||
:lastname,
|
||
:mail,
|
||
presence: { unless: Proc.new { |user| user.builtin? } }
|
||
|
||
validates :login, uniqueness: { if: Proc.new { |user| user.login.present? }, case_sensitive: false }
|
||
validates :mail, uniqueness: { allow_blank: true, case_sensitive: false }
|
||
# Login must contain letters, numbers, underscores only
|
||
validates :login, format: { with: /\A[\p{L}0-9_\-@.+ ]*\z/i }
|
||
validates :login, length: { maximum: 256 }
|
||
|
||
validates :firstname, :lastname, length: { maximum: 256 }
|
||
validates :firstname, :lastname, format: { with: VALID_NAME_REGEX, allow_blank: true }
|
||
|
||
validates :mail, email: true, unless: Proc.new { |user| user.mail.blank? }
|
||
validates :mail, length: { maximum: 256, allow_nil: true }
|
||
|
||
validates :password,
|
||
confirmation: {
|
||
allow_nil: true,
|
||
message: ->(*) { I18n.t("activerecord.errors.models.user.attributes.password_confirmation.confirmation") }
|
||
}
|
||
|
||
auto_strip_attributes :login, nullify: false
|
||
auto_strip_attributes :mail, nullify: false
|
||
|
||
validate :login_is_not_aliased_value
|
||
validate :password_meets_requirements
|
||
|
||
after_save :update_password
|
||
|
||
scope :admin, -> { where(admin: true) }
|
||
|
||
def self.unique_attribute
|
||
:login
|
||
end
|
||
|
||
prepend ::Mixins::UniqueFinder
|
||
|
||
def current_password
|
||
passwords.first
|
||
end
|
||
|
||
def password_expired?
|
||
current_password.expired?
|
||
end
|
||
|
||
# create new password if password was set
|
||
def update_password
|
||
if password && ldap_auth_source_id.blank?
|
||
new_password = passwords.build(type: UserPassword.active_type.to_s)
|
||
new_password.plain_password = password
|
||
new_password.save
|
||
|
||
# force reload of passwords, so the new password is sorted to the top
|
||
passwords.reload
|
||
|
||
clean_up_former_passwords
|
||
clean_up_password_attribute
|
||
end
|
||
end
|
||
|
||
def mail=(arg)
|
||
write_attribute(:mail, arg.to_s.strip)
|
||
end
|
||
|
||
def self.available_custom_fields(_user)
|
||
user = User.current
|
||
RequestStore.fetch(:"#{name.underscore}_custom_fields_#{user.id}_#{user.admin?}") do
|
||
scope = CustomField.where(type: "#{name}CustomField").order(:position)
|
||
scope = scope.where(admin_only: false) if !user.admin?
|
||
scope
|
||
end
|
||
end
|
||
|
||
# Override acts_as_customizable to skip custom field validation for invited users
|
||
# since custom field values cannot be provided during the invitation process.
|
||
# We only skip the validation if no custom field changes are present.
|
||
def custom_values_to_validate
|
||
if invited? && custom_field_changes.empty?
|
||
[]
|
||
else
|
||
super
|
||
end
|
||
end
|
||
|
||
def self.search_in_project(query, options)
|
||
options.fetch(:project).users.like(query)
|
||
end
|
||
|
||
# Returns the user that matches provided login and password, or nil
|
||
def self.try_to_login(login, password, session = nil)
|
||
# Make sure no one can sign in with an empty password
|
||
return nil if password.to_s.empty?
|
||
|
||
user = find_by_login(login)
|
||
user = if user
|
||
try_authentication_for_existing_user(user, password, session)
|
||
else
|
||
try_authentication_and_create_user(login, password)
|
||
end
|
||
unless prevent_brute_force_attack(user, login).nil?
|
||
user.log_successful_login if user && !user.new_record?
|
||
return user
|
||
end
|
||
nil
|
||
end
|
||
|
||
# Tries to authenticate a user in the database via external auth source
|
||
# or password stored in the database
|
||
def self.try_authentication_for_existing_user(user, password, session = nil) # rubocop:disable Metrics/PerceivedComplexity
|
||
activate_user! user, session if session
|
||
|
||
return nil if !user.active? || OpenProject::Configuration.disable_password_login?
|
||
|
||
if user.ldap_auth_source
|
||
# user has an external authentication method
|
||
return nil unless user.ldap_auth_source.authenticate(user.login, password)
|
||
else
|
||
# authentication with local password
|
||
return nil unless user.check_password?(password)
|
||
return nil if user.force_password_change
|
||
return nil if user.password_expired?
|
||
end
|
||
user
|
||
end
|
||
|
||
def self.activate_user!(user, session)
|
||
if session[:invitation_token]
|
||
token = Token::Invitation.find_by_plaintext_value session[:invitation_token]
|
||
invited_id = token&.user&.id
|
||
|
||
if user.id == invited_id
|
||
user.activate!
|
||
token.destroy
|
||
session.delete :invitation_token
|
||
end
|
||
end
|
||
end
|
||
|
||
# Tries to authenticate with available sources and creates user on success
|
||
def self.try_authentication_and_create_user(login, password)
|
||
return nil if OpenProject::Configuration.disable_password_login?
|
||
|
||
user = LdapAuthSource.authenticate(login, password)
|
||
|
||
if user&.new_record?
|
||
Rails.logger.error "Failed to auto-create user from auth-source, as data is missing."
|
||
end
|
||
|
||
user
|
||
end
|
||
|
||
# Columns required for formatting the user's name.
|
||
def self.columns_for_name(formatter = nil)
|
||
case formatter || Setting.user_format
|
||
when :firstname
|
||
[:firstname]
|
||
when :username
|
||
[:login]
|
||
else
|
||
%i[firstname lastname]
|
||
end
|
||
end
|
||
|
||
# Formats the user's name.
|
||
def name(formatter = nil)
|
||
# Don't forget to check columns_for_name
|
||
case formatter || Setting.user_format
|
||
|
||
when :firstname_lastname then "#{firstname} #{lastname}"
|
||
when :lastname_firstname then "#{lastname} #{firstname}"
|
||
when :lastname_n_firstname then "#{lastname}#{firstname}"
|
||
when :lastname_comma_firstname then "#{lastname}, #{firstname}"
|
||
when :firstname then firstname
|
||
when :username then login
|
||
|
||
else
|
||
"#{firstname} #{lastname}"
|
||
end
|
||
end
|
||
|
||
# Return user's authentication provider for display
|
||
def human_authentication_provider
|
||
authentication_provider&.display_name
|
||
end
|
||
|
||
def provided_by_oidc?
|
||
authentication_provider.is_a?(OpenIDConnect::Provider)
|
||
end
|
||
|
||
##
|
||
# Allows the API and other sources to determine locking actions
|
||
# on represented collections of children of Principals.
|
||
# This only covers the transition from:
|
||
# lockable?: active -> locked.
|
||
# activatable?: locked -> active.
|
||
alias_method :lockable?, :active?
|
||
alias_method :activatable?, :locked?
|
||
|
||
def activate
|
||
self.status = self.class.statuses[:active]
|
||
end
|
||
|
||
def register
|
||
self.status = self.class.statuses[:registered]
|
||
end
|
||
|
||
def invite
|
||
self.status = self.class.statuses[:invited]
|
||
end
|
||
|
||
def lock
|
||
self.status = self.class.statuses[:locked]
|
||
end
|
||
|
||
deprecated_alias :activate!, :active!
|
||
deprecated_alias :register!, :registered!
|
||
deprecated_alias :invite!, :invited!
|
||
deprecated_alias :lock!, :locked!
|
||
|
||
# Returns true if +clear_password+ is the correct user's password, otherwise false
|
||
# If +update_legacy+ is set, will automatically save legacy passwords using the current
|
||
# format.
|
||
def check_password?(clear_password, update_legacy: true)
|
||
if ldap_auth_source.present?
|
||
ldap_auth_source.authenticate(login, clear_password)
|
||
else
|
||
return false if current_password.nil?
|
||
|
||
current_password.matches_plaintext?(clear_password, update_legacy:)
|
||
end
|
||
end
|
||
|
||
# Does the backend storage allow this user to change their password?
|
||
def change_password_allowed?
|
||
return false if OpenProject::Configuration.disable_password_login?
|
||
return false if uses_external_authentication? && current_password.nil?
|
||
|
||
ldap_auth_source_id.blank?
|
||
end
|
||
|
||
# Is the user authenticated via an external authentication source via OmniAuth?
|
||
def uses_external_authentication?
|
||
user_auth_provider_links.exists?
|
||
end
|
||
|
||
#
|
||
# Generate and set a random password.
|
||
#
|
||
# Also force a password change on the next login, since random passwords
|
||
# are at some point given to the user, we do this via email. These passwords
|
||
# are stored unencrypted in mail accounts, so they must only be valid for
|
||
# a short time.
|
||
def random_password!
|
||
self.password = OpenProject::Passwords::Generator.random_password
|
||
self.password_confirmation = password
|
||
self.force_password_change = true
|
||
self
|
||
end
|
||
|
||
##
|
||
# Brute force prevention - public instance methods
|
||
#
|
||
def failed_too_many_recent_login_attempts?
|
||
block_threshold = Setting.brute_force_block_after_failed_logins.to_i
|
||
return false if block_threshold == 0 # disabled
|
||
|
||
last_failed_login_within_block_time? and
|
||
failed_login_count >= block_threshold
|
||
end
|
||
|
||
def log_failed_login
|
||
log_failed_login_count
|
||
log_failed_login_timestamp
|
||
save
|
||
end
|
||
|
||
def log_successful_login
|
||
update_attribute(:last_login_on, Time.current)
|
||
end
|
||
|
||
def pref
|
||
preference || build_preference
|
||
end
|
||
|
||
def time_zone
|
||
@time_zone ||= ActiveSupport::TimeZone[pref.time_zone] || ActiveSupport::TimeZone["Etc/UTC"]
|
||
end
|
||
|
||
def reload(*)
|
||
@time_zone = nil
|
||
|
||
super
|
||
end
|
||
|
||
def wants_comments_in_reverse_order?
|
||
pref.comments_in_reverse_order?
|
||
end
|
||
|
||
def self.find_by_rss_key(key)
|
||
return nil unless Setting.feeds_enabled?
|
||
|
||
token = Token::RSS.find_by(value: key)
|
||
|
||
if token&.user&.active?
|
||
token.user
|
||
end
|
||
end
|
||
|
||
def self.find_by_api_key(key)
|
||
return nil unless Setting.api_tokens_enabled?
|
||
|
||
token = Token::API.find_by_plaintext_value(key)
|
||
|
||
if token&.user&.active?
|
||
token.user
|
||
end
|
||
end
|
||
|
||
##
|
||
# Finds all users with the mail address matching the given mail
|
||
# Includes searching for suffixes from +Setting.mail_suffix_separtors+.
|
||
#
|
||
# For example:
|
||
# - With Setting.mail_suffix_separators = '+'
|
||
# - Will find 'foo+bar@example.org' with input of 'foo@example.org'
|
||
def self.where_mail_with_suffix(mail)
|
||
skip_suffix_check, regexp = mail_regexp(mail)
|
||
|
||
# If the recipient part already contains a suffix, don't expand
|
||
if skip_suffix_check
|
||
where("LOWER(mail) = ?", mail)
|
||
else
|
||
where("LOWER(mail) ~* ?", regexp)
|
||
end
|
||
end
|
||
|
||
##
|
||
# Finds a user by mail where it checks whether the mail exists
|
||
# NOTE: This will return the FIRST matching user.
|
||
def self.find_by_mail(mail)
|
||
where_mail_with_suffix(mail).first
|
||
end
|
||
|
||
def rss_key
|
||
token = rss_token || ::Token::RSS.create(user: self)
|
||
token.value
|
||
end
|
||
|
||
def to_s
|
||
name
|
||
end
|
||
|
||
# Returns the current day according to user's time zone
|
||
def today
|
||
if time_zone.nil?
|
||
Time.zone.today
|
||
else
|
||
Time.now.in_time_zone(time_zone).to_date
|
||
end
|
||
end
|
||
|
||
def logged?
|
||
true
|
||
end
|
||
|
||
def anonymous?
|
||
!logged?
|
||
end
|
||
|
||
def active_admin?
|
||
admin? && active?
|
||
end
|
||
|
||
def consent_expired?
|
||
# Always if the user has not consented
|
||
return true if consented_at.blank?
|
||
|
||
# Did not expire if no consent_time set, but user has consented at some point
|
||
return false if Setting.consent_time.blank?
|
||
|
||
# Otherwise, expires when consent_time is newer than last consented_at
|
||
consented_at < Setting.consent_time
|
||
end
|
||
|
||
# Cheap version of Project.visible.count
|
||
def number_of_known_projects
|
||
if admin?
|
||
Project.count
|
||
else
|
||
Project.public_projects.count + memberships.size
|
||
end
|
||
end
|
||
|
||
def reported_work_package_count
|
||
WorkPackage.on_active_project.with_author(self).visible.count
|
||
end
|
||
|
||
def self.current=(user)
|
||
RequestStore[:current_user] = user
|
||
end
|
||
|
||
def self.current
|
||
RequestStore[:current_user] || User.anonymous
|
||
end
|
||
|
||
def self.execute_as(user, &)
|
||
previous_user = User.current
|
||
User.current = user
|
||
OpenProject::LocaleHelper.with_locale_for(user, &)
|
||
ensure
|
||
User.current = previous_user
|
||
end
|
||
|
||
# Temporarily elevates a user's permissions to admin for the duration
|
||
# of the given block.
|
||
#
|
||
# This method ensures that any changes to the user's admin status are
|
||
# safely reverted after the block is executed, regardless of whether
|
||
# an exception is raised within the block.
|
||
#
|
||
# Saving of the user is attempted to be prevented but this might not be foolproof.
|
||
# Saving the user within the block should be avoided to prevent undesired side effects.
|
||
#
|
||
# @param user [User] The user that requires temporary admin elevation.
|
||
def self.execute_as_admin(user)
|
||
previous_user_admin_state = user.admin
|
||
previous_user_readonly_state = user.readonly?
|
||
user.admin = true
|
||
user.reset_permission_caches
|
||
user.readonly!
|
||
yield
|
||
ensure
|
||
user.admin = previous_user_admin_state
|
||
user.reset_permission_caches
|
||
user.instance_variable_set(:@readonly, previous_user_readonly_state)
|
||
end
|
||
|
||
##
|
||
# Returns true if no authentication method has been chosen for this user yet.
|
||
# There are three possible methods currently:
|
||
#
|
||
# - username & password
|
||
# - OmniAuth
|
||
# - LDAP
|
||
def missing_authentication_method?
|
||
!uses_external_authentication? && passwords.empty? && ldap_auth_source_id.nil?
|
||
end
|
||
|
||
# Returns the anonymous user. If the anonymous user does not exist, it is created. There can be only
|
||
# one anonymous user per database.
|
||
def self.anonymous
|
||
RequestStore[:anonymous_user] ||= AnonymousUser.first
|
||
end
|
||
|
||
def self.system
|
||
SystemUser.first
|
||
end
|
||
|
||
def scim_emails
|
||
[ScimEmail.new(mail, true, "work")]
|
||
end
|
||
|
||
def scim_emails=(emails)
|
||
email = emails.find { |email| email.primary == true } ||
|
||
emails.find { |email| email.type == "work" } ||
|
||
emails.min
|
||
|
||
self.mail = email&.value
|
||
end
|
||
|
||
# rubocop:disable Naming/PredicateMethod
|
||
def scim_active=(is_active)
|
||
if is_active
|
||
activate
|
||
true
|
||
else
|
||
lock if active?
|
||
false
|
||
end
|
||
end
|
||
|
||
def scim_active
|
||
active?
|
||
end
|
||
# rubocop:enable Naming/PredicateMethod
|
||
|
||
def self.scim_resource_type
|
||
Scimitar::Resources::User
|
||
end
|
||
|
||
def self.scim_attributes_map
|
||
{
|
||
id: :id,
|
||
externalId: :scim_external_id,
|
||
userName: :login,
|
||
name: {
|
||
givenName: :firstname,
|
||
familyName: :lastname
|
||
},
|
||
emails: [
|
||
{
|
||
list: :scim_emails,
|
||
class: User,
|
||
using: {
|
||
value: :value,
|
||
primary: :primary,
|
||
type: :type
|
||
},
|
||
find_with: Proc.new do |qwe|
|
||
ScimEmail.new(qwe["value"], qwe["primary"] == true, qwe["type"])
|
||
end
|
||
}
|
||
],
|
||
groups: [
|
||
{
|
||
list: :groups,
|
||
using: {
|
||
value: :id
|
||
}
|
||
}
|
||
],
|
||
active: :scim_active
|
||
}
|
||
end
|
||
|
||
def self.scim_queryable_attributes
|
||
{
|
||
externalId: { column: UserAuthProviderLink.arel_table[:external_id] },
|
||
username: { column: :login },
|
||
givenName: { column: :firstname },
|
||
familyName: { column: :lastname },
|
||
emails: { column: :mail },
|
||
groups: { column: Group.arel_table[:id] },
|
||
"groups.value" => { column: Group.arel_table[:id] }
|
||
}
|
||
end
|
||
|
||
include Scimitar::Resources::Mixin
|
||
|
||
def non_working_time_entities_for_year(year)
|
||
NonWorkingDay.for_year(year).to_a + non_working_times.for_year(year).to_a
|
||
end
|
||
|
||
def non_working_days_for_year(year)
|
||
working_wdays = Setting.working_days.map { |d| d % 7 }
|
||
all_dates = system_non_working_dates_for_year(year) | user_non_working_dates_for_year(year)
|
||
all_dates.select { |d| working_wdays.include?(d.wday) }
|
||
end
|
||
|
||
private
|
||
|
||
def system_non_working_dates_for_year(year)
|
||
NonWorkingDay.for_year(year).pluck(:date).to_set
|
||
end
|
||
|
||
def user_non_working_dates_for_year(year)
|
||
year_range = Date.new(year, 1, 1)..Date.new(year, 12, 31)
|
||
non_working_times.for_year(year).flat_map do |t|
|
||
([t.start_date, year_range.begin].max..[t.end_date, year_range.end].min).to_a
|
||
end.to_set
|
||
end
|
||
|
||
protected
|
||
|
||
# Login must not be aliased value 'me'
|
||
def login_is_not_aliased_value
|
||
if login.present? && login.to_s == CURRENT_USER_LOGIN_ALIAS
|
||
errors.add(:login, :invalid)
|
||
end
|
||
end
|
||
|
||
# Password requirement validation based on settings
|
||
def password_meets_requirements
|
||
# Passwords are stored hashed as UserPasswords,
|
||
# self.password is only set when it was changed after the last
|
||
# save. Otherwise, password is nil.
|
||
unless password.nil? or anonymous?
|
||
password_errors = OpenProject::Passwords::Evaluator.errors_for_password(password)
|
||
password_errors.each { |error| errors.add(:password, error) }
|
||
|
||
if former_passwords_include?(password)
|
||
errors.add(:password,
|
||
I18n.t("activerecord.errors.models.user.attributes.password.reused",
|
||
count: Setting[:password_count_former_banned].to_i))
|
||
end
|
||
end
|
||
end
|
||
|
||
private
|
||
|
||
def self.mail_regexp(mail)
|
||
separators = Regexp.escape(Setting.mail_suffix_separators)
|
||
recipient, domain = mail.split("@").map { |part| Regexp.escape(part) }
|
||
skip_suffix_check = recipient.nil? || Setting.mail_suffix_separators.empty? || recipient.match?(/.+[#{separators}].+/)
|
||
regexp = "^#{recipient}([#{separators}][^@]+)*@#{domain}$"
|
||
|
||
[skip_suffix_check, regexp]
|
||
end
|
||
|
||
def former_passwords_include?(password)
|
||
return false if Setting[:password_count_former_banned].to_i == 0
|
||
|
||
ban_count = Setting[:password_count_former_banned].to_i
|
||
# make reducing the number of banned former passwords immediately effective
|
||
# by only checking this number of former passwords
|
||
passwords[0, ban_count].any? { |f| f.matches_plaintext?(password) }
|
||
end
|
||
|
||
def clean_up_former_passwords
|
||
# minimum 1 to keep the actual user password
|
||
keep_count = [1, Setting[:password_count_former_banned].to_i].max
|
||
(passwords[keep_count..] || []).each(&:destroy)
|
||
end
|
||
|
||
def clean_up_password_attribute
|
||
self.password = self.password_confirmation = nil
|
||
end
|
||
|
||
##
|
||
# Brute force prevention - class methods
|
||
#
|
||
def self.prevent_brute_force_attack(user, login)
|
||
if user.nil?
|
||
register_failed_login_attempt_if_user_exists_for(login)
|
||
else
|
||
block_user_if_too_many_recent_attempts_failed(user)
|
||
end
|
||
end
|
||
|
||
def self.register_failed_login_attempt_if_user_exists_for(login)
|
||
user = User.find_by_login(login)
|
||
user.presence&.log_failed_login
|
||
nil
|
||
end
|
||
|
||
def self.reset_failed_login_count_for(user)
|
||
user.update_attribute(:failed_login_count, 0) unless user.new_record?
|
||
end
|
||
|
||
def self.block_user_if_too_many_recent_attempts_failed(user)
|
||
if user.failed_too_many_recent_login_attempts?
|
||
user = nil
|
||
else
|
||
reset_failed_login_count_for user
|
||
end
|
||
|
||
user
|
||
end
|
||
|
||
##
|
||
# Brute force prevention - instance methods
|
||
#
|
||
def last_failed_login_within_block_time?
|
||
block_duration = Setting.brute_force_block_minutes.to_i.minutes
|
||
last_failed_login_on and
|
||
Time.zone.now - last_failed_login_on < block_duration
|
||
end
|
||
|
||
def log_failed_login_count
|
||
if last_failed_login_within_block_time?
|
||
self.failed_login_count += 1
|
||
else
|
||
self.failed_login_count = 1
|
||
end
|
||
end
|
||
|
||
def log_failed_login_timestamp
|
||
self.last_failed_login_on = Time.zone.now
|
||
end
|
||
|
||
def self.default_admin_account_changed?
|
||
!User.active.find_by_login("admin").try(:current_password).try(:matches_plaintext?, "admin")
|
||
end
|
||
end
|