mirror of
https://gh.wpcy.net/https://github.com/discourse/discourse.git
synced 2026-05-04 09:16:52 +08:00
97f0ddf757
Invoking `post.reload` within the `post_created` or `post_edited` events may cause data within `revisor.post_changes` to reset.
775 lines
26 KiB
Ruby
775 lines
26 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
# name: discourse-calendar
|
|
# about: Adds the ability to create a dynamic calendar with events in a topic.
|
|
# meta_topic_id: 97376
|
|
# version: 0.5
|
|
# author: Daniel Waterworth, Joffrey Jaffeux
|
|
# url: https://github.com/discourse/discourse/tree/main/plugins/discourse-calendar
|
|
|
|
libdir = File.join(File.dirname(__FILE__), "vendor/holidays/lib")
|
|
$LOAD_PATH.unshift(libdir) if $LOAD_PATH.exclude?(libdir)
|
|
|
|
require_relative "lib/calendar_settings_validator"
|
|
require_relative "lib/calendar_first_day_of_week"
|
|
require_relative "lib/calendar_upcoming_events_default_view"
|
|
|
|
enabled_site_setting :calendar_enabled
|
|
|
|
register_svg_icon "calendar-days"
|
|
register_asset "stylesheets/common/full-calendar-ext.scss"
|
|
register_asset "stylesheets/common/discourse-calendar.scss"
|
|
register_asset "stylesheets/common/discourse-calendar-holidays.scss"
|
|
register_asset "stylesheets/common/discourse-post-event.scss"
|
|
register_asset "stylesheets/common/discourse-post-event-preview.scss"
|
|
register_asset "stylesheets/common/post-event-builder.scss"
|
|
register_asset "stylesheets/common/discourse-post-event-invitees.scss"
|
|
register_asset "stylesheets/common/composer-event-node-view.scss"
|
|
register_asset "stylesheets/common/discourse-post-event-core-ext.scss"
|
|
register_asset "stylesheets/mobile/discourse-post-event-core-ext.scss", :mobile
|
|
register_asset "stylesheets/common/discourse-post-event-bulk-invite-modal.scss"
|
|
register_asset "stylesheets/mobile/discourse-calendar.scss", :mobile
|
|
register_asset "stylesheets/mobile/discourse-post-event.scss", :mobile
|
|
register_asset "stylesheets/colors.scss", :color_definitions
|
|
register_asset "stylesheets/common/user-preferences.scss"
|
|
register_asset "stylesheets/common/upcoming-events-list.scss"
|
|
register_svg_icon "calendar-day"
|
|
register_svg_icon "clock"
|
|
register_svg_icon "file-csv"
|
|
register_svg_icon "star"
|
|
register_svg_icon "file-arrow-up"
|
|
register_svg_icon "location-pin"
|
|
|
|
module ::DiscourseCalendar
|
|
PLUGIN_NAME = "discourse-calendar"
|
|
|
|
# Type of calendar ('static' or 'dynamic')
|
|
CALENDAR_CUSTOM_FIELD = "calendar"
|
|
|
|
# User custom field set when user is on holiday
|
|
HOLIDAY_CUSTOM_FIELD = "on_holiday"
|
|
|
|
# List of all users on holiday
|
|
USERS_ON_HOLIDAY_KEY = "users_on_holiday"
|
|
|
|
# User region used in finding holidays
|
|
REGION_CUSTOM_FIELD = "holidays-region"
|
|
|
|
# List of groups
|
|
GROUP_TIMEZONES_CUSTOM_FIELD = "group-timezones"
|
|
|
|
def self.users_on_holiday
|
|
PluginStore.get(PLUGIN_NAME, USERS_ON_HOLIDAY_KEY) || []
|
|
end
|
|
|
|
def self.users_on_holiday=(usernames)
|
|
PluginStore.set(PLUGIN_NAME, USERS_ON_HOLIDAY_KEY, usernames)
|
|
end
|
|
end
|
|
|
|
module ::DiscoursePostEvent
|
|
PLUGIN_NAME = "discourse-post-event"
|
|
|
|
# Topic where op has a post event custom field
|
|
TOPIC_POST_EVENT_STARTS_AT = "TopicEventStartsAt"
|
|
TOPIC_POST_EVENT_ENDS_AT = "TopicEventEndsAt"
|
|
TOPIC_POST_EVENT_ALL_DAY = "TopicEventAllDay"
|
|
end
|
|
|
|
require_relative "lib/discourse_calendar/engine"
|
|
|
|
Dir
|
|
.glob(File.expand_path("../lib/discourse_calendar/site_settings/*.rb", __FILE__))
|
|
.each { |f| require(f) }
|
|
|
|
after_initialize do
|
|
reloadable_patch do
|
|
Category.register_custom_field_type("sort_topics_by_event_start_date", :boolean)
|
|
Category.register_custom_field_type("disable_topic_resorting", :boolean)
|
|
register_preloaded_category_custom_fields("sort_topics_by_event_start_date")
|
|
register_preloaded_category_custom_fields("disable_topic_resorting")
|
|
end
|
|
|
|
add_to_serializer :basic_category, :sort_topics_by_event_start_date do
|
|
object.custom_fields["sort_topics_by_event_start_date"]
|
|
end
|
|
|
|
add_to_serializer :basic_category, :disable_topic_resorting do
|
|
object.custom_fields["disable_topic_resorting"]
|
|
end
|
|
|
|
reloadable_patch do
|
|
TopicQuery.add_custom_filter(:order_by_event_date) do |results, topic_query|
|
|
if SiteSetting.sort_categories_by_event_start_date_enabled &&
|
|
topic_query.options[:category_id]
|
|
category = Category.find_by(id: topic_query.options[:category_id])
|
|
if category && category.custom_fields &&
|
|
category.custom_fields["sort_topics_by_event_start_date"]
|
|
reorder_sql = <<~SQL
|
|
CASE WHEN COALESCE(custom_fields.value::timestamptz, topics.bumped_at) > NOW() THEN 0 ELSE 1 END,
|
|
CASE WHEN COALESCE(custom_fields.value::timestamptz, topics.bumped_at) > NOW() THEN COALESCE(custom_fields.value::timestamptz, topics.bumped_at) ELSE NULL END,
|
|
CASE WHEN COALESCE(custom_fields.value::timestamptz, topics.bumped_at) < NOW() THEN COALESCE(custom_fields.value::timestamptz, topics.bumped_at) ELSE NULL END DESC
|
|
SQL
|
|
results =
|
|
results.joins(
|
|
"LEFT JOIN topic_custom_fields AS custom_fields on custom_fields.topic_id = topics.id
|
|
AND custom_fields.name = '#{DiscoursePostEvent::TOPIC_POST_EVENT_STARTS_AT}'
|
|
",
|
|
).reorder(reorder_sql)
|
|
end
|
|
end
|
|
results
|
|
end
|
|
end
|
|
|
|
# DISCOURSE CALENDAR HOLIDAYS
|
|
|
|
add_admin_route "admin.calendar", "discourse-calendar", use_new_show_route: true
|
|
|
|
# DISCOURSE POST EVENT
|
|
|
|
require_relative "jobs/regular/discourse_post_event/bulk_invite"
|
|
require_relative "jobs/regular/discourse_post_event/bump_topic"
|
|
require_relative "jobs/regular/discourse_post_event/send_reminder"
|
|
require_relative "lib/discourse_post_event/engine"
|
|
require_relative "lib/discourse_post_event/event_finder"
|
|
require_relative "lib/discourse_post_event/event_parser"
|
|
require_relative "lib/discourse_post_event/event_validator"
|
|
require_relative "lib/discourse_post_event/export_csv_controller_extension"
|
|
require_relative "lib/discourse_post_event/export_csv_file_extension"
|
|
require_relative "lib/discourse_post_event/post_extension"
|
|
require_relative "lib/discourse_post_event/rrule_generator"
|
|
require_relative "lib/discourse_post_event/rrule_configurator"
|
|
require_relative "lib/discourse_post_event/web_hook_extension"
|
|
|
|
::ActionController::Base.prepend_view_path File.expand_path("../app/views", __FILE__)
|
|
|
|
add_api_parameter_route(
|
|
methods: :get,
|
|
actions: "discourse_post_event/events#index",
|
|
formats: :ics,
|
|
)
|
|
|
|
add_user_api_key_scope :events_calendar,
|
|
methods: :get,
|
|
actions: "discourse_post_event/events#index",
|
|
formats: :ics
|
|
|
|
register_calendar_subscription_feed(
|
|
name: "all_events",
|
|
scope: "discourse-calendar:events_calendar",
|
|
description_key: "discourse_calendar.preferences.all_events_description",
|
|
url: ->(base_url, _user, key) do
|
|
"#{base_url}/discourse-post-event/events.ics?user_api_key=#{key}"
|
|
end,
|
|
)
|
|
|
|
register_calendar_subscription_feed(
|
|
name: "my_events",
|
|
scope: "discourse-calendar:events_calendar",
|
|
description_key: "discourse_calendar.preferences.my_events_description",
|
|
url: ->(base_url, user, key) do
|
|
"#{base_url}/discourse-post-event/events.ics?attending_user=#{user.username_lower}&include_interested=true&user_api_key=#{key}"
|
|
end,
|
|
)
|
|
|
|
reloadable_patch do
|
|
ExportCsvController.prepend(DiscoursePostEvent::ExportCsvControllerExtension)
|
|
Jobs::ExportCsvFile.prepend(DiscoursePostEvent::ExportPostEventCsvReportExtension)
|
|
Post.prepend(DiscoursePostEvent::PostExtension)
|
|
::WebHook.prepend(DiscoursePostEvent::WebHookExtension)
|
|
end
|
|
|
|
add_to_class(:user, :can_create_discourse_post_event?) do
|
|
return @can_create_discourse_post_event if defined?(@can_create_discourse_post_event)
|
|
@can_create_discourse_post_event =
|
|
begin
|
|
return true if staff?
|
|
allowed_groups = SiteSetting.discourse_post_event_allowed_on_groups.to_s.split("|").compact
|
|
allowed_groups.present? &&
|
|
(
|
|
allowed_groups.include?(Group::AUTO_GROUPS[:everyone].to_s) ||
|
|
groups.where(id: allowed_groups).exists?
|
|
)
|
|
rescue StandardError
|
|
false
|
|
end
|
|
end
|
|
|
|
add_to_class(:guardian, :can_act_on_invitee?) do |invitee|
|
|
user && (user.id == invitee.user_id || can_act_on_discourse_post_event?(invitee.event))
|
|
end
|
|
|
|
add_to_class(:guardian, :can_create_discourse_post_event?) do
|
|
user && user.can_create_discourse_post_event?
|
|
end
|
|
|
|
add_to_serializer(:current_user, :can_create_discourse_post_event) do
|
|
object.can_create_discourse_post_event?
|
|
end
|
|
|
|
add_to_class(:user, :can_act_on_discourse_post_event?) do |event|
|
|
return @can_act_on_discourse_post_event if defined?(@can_act_on_discourse_post_event)
|
|
@can_act_on_discourse_post_event =
|
|
begin
|
|
return true if staff?
|
|
can_create_discourse_post_event? && Guardian.new(self).can_edit_post?(event.post)
|
|
rescue StandardError
|
|
false
|
|
end
|
|
end
|
|
|
|
add_to_class(:guardian, :can_act_on_discourse_post_event?) do |event|
|
|
user && user.can_act_on_discourse_post_event?(event)
|
|
end
|
|
|
|
add_class_method(:group, :discourse_post_event_allowed_groups) do
|
|
where(id: SiteSetting.discourse_post_event_allowed_on_groups.split("|").compact)
|
|
end
|
|
|
|
TopicView.on_preload do |topic_view|
|
|
if SiteSetting.discourse_post_event_enabled
|
|
topic_view.instance_variable_set(:@posts, topic_view.posts.includes(event: :image_upload))
|
|
end
|
|
end
|
|
|
|
add_to_serializer(
|
|
:post,
|
|
:event,
|
|
include_condition: -> do
|
|
SiteSetting.discourse_post_event_enabled && !object.nil? && !object.deleted_at.present?
|
|
end,
|
|
) { DiscoursePostEvent::EventSerializer.new(object.event, scope: scope, root: false) }
|
|
|
|
on(:post_created) do |post|
|
|
DiscoursePostEvent::Event.update_from_raw(post)
|
|
post.association(:event).reload
|
|
if SiteSetting.discourse_post_event_enabled && post.event
|
|
WebHook.enqueue_calendar_event_hooks(:calendar_event_created, post.event)
|
|
end
|
|
end
|
|
|
|
on(:post_edited) do |post|
|
|
event_before = post.event
|
|
had_image_before = event_before&.image_upload_id.present?
|
|
DiscoursePostEvent::Event.update_from_raw(post)
|
|
post.association(:event).reload
|
|
|
|
if SiteSetting.discourse_post_event_enabled
|
|
if post.event&.image_upload_id
|
|
post.event.sync_image_to_post_and_topic
|
|
elsif had_image_before
|
|
post.trigger_post_process
|
|
end
|
|
DiscoursePostEvent::Event.handle_post_event_webhooks(post, event_before)
|
|
end
|
|
end
|
|
|
|
on(:post_destroyed) do |post|
|
|
if SiteSetting.discourse_post_event_enabled && post.event
|
|
payload = WebHook.build_calendar_event_payload(post.event)
|
|
post.event.update!(deleted_at: Time.now)
|
|
WebHook.enqueue_calendar_event_hooks(:calendar_event_destroyed, post.event, payload)
|
|
end
|
|
end
|
|
|
|
on(:post_recovered) do |post|
|
|
if SiteSetting.discourse_post_event_enabled && post.event
|
|
post.event.update!(deleted_at: nil)
|
|
WebHook.enqueue_calendar_event_hooks(:calendar_event_created, post.event)
|
|
end
|
|
end
|
|
|
|
add_preloaded_topic_list_custom_field DiscoursePostEvent::TOPIC_POST_EVENT_STARTS_AT
|
|
|
|
add_to_serializer(
|
|
:topic_view,
|
|
:event_starts_at,
|
|
include_condition: -> do
|
|
SiteSetting.discourse_post_event_enabled &&
|
|
SiteSetting.display_post_event_date_on_topic_title &&
|
|
object.topic.custom_fields.keys.include?(DiscoursePostEvent::TOPIC_POST_EVENT_STARTS_AT)
|
|
end,
|
|
) { object.topic.event_starts_at }
|
|
|
|
add_to_class(:topic, :event_starts_at) do
|
|
@event_starts_at ||=
|
|
begin
|
|
value = custom_fields[DiscoursePostEvent::TOPIC_POST_EVENT_STARTS_AT].to_s
|
|
Time.find_zone("UTC").parse(value) if value.present?
|
|
end
|
|
end
|
|
|
|
add_to_serializer(
|
|
:topic_list_item,
|
|
:event_starts_at,
|
|
include_condition: -> do
|
|
SiteSetting.discourse_post_event_enabled &&
|
|
SiteSetting.display_post_event_date_on_topic_title && object.event_starts_at
|
|
end,
|
|
) { object.event_starts_at }
|
|
|
|
add_preloaded_topic_list_custom_field DiscoursePostEvent::TOPIC_POST_EVENT_ENDS_AT
|
|
|
|
add_to_serializer(
|
|
:topic_view,
|
|
:event_ends_at,
|
|
include_condition: -> do
|
|
SiteSetting.discourse_post_event_enabled &&
|
|
SiteSetting.display_post_event_date_on_topic_title &&
|
|
object.topic.custom_fields.keys.include?(DiscoursePostEvent::TOPIC_POST_EVENT_ENDS_AT)
|
|
end,
|
|
) { object.topic.event_ends_at }
|
|
|
|
add_to_class(:topic, :event_ends_at) do
|
|
@event_ends_at ||=
|
|
begin
|
|
value = custom_fields[DiscoursePostEvent::TOPIC_POST_EVENT_ENDS_AT].to_s
|
|
Time.find_zone("UTC").parse(value) if value.present?
|
|
end
|
|
end
|
|
|
|
add_to_serializer(
|
|
:topic_list_item,
|
|
:event_ends_at,
|
|
include_condition: -> do
|
|
SiteSetting.discourse_post_event_enabled &&
|
|
SiteSetting.display_post_event_date_on_topic_title && object.event_ends_at
|
|
end,
|
|
) { object.event_ends_at }
|
|
|
|
add_preloaded_topic_list_custom_field DiscoursePostEvent::TOPIC_POST_EVENT_ALL_DAY
|
|
|
|
add_to_serializer(
|
|
:topic_view,
|
|
:event_all_day,
|
|
include_condition: -> do
|
|
SiteSetting.discourse_post_event_enabled &&
|
|
SiteSetting.display_post_event_date_on_topic_title && object.topic.event_all_day
|
|
end,
|
|
) { object.topic.event_all_day }
|
|
|
|
add_to_class(:topic, :event_all_day) do
|
|
return @event_all_day if defined?(@event_all_day)
|
|
@event_all_day =
|
|
begin
|
|
value = custom_fields[DiscoursePostEvent::TOPIC_POST_EVENT_ALL_DAY].to_s
|
|
ActiveModel::Type::Boolean.new.cast(value)
|
|
end
|
|
end
|
|
|
|
add_to_serializer(
|
|
:topic_list_item,
|
|
:event_all_day,
|
|
include_condition: -> do
|
|
SiteSetting.discourse_post_event_enabled &&
|
|
SiteSetting.display_post_event_date_on_topic_title && object.event_all_day
|
|
end,
|
|
) { object.event_all_day }
|
|
|
|
add_to_serializer(
|
|
:topic_view,
|
|
:event_timezone,
|
|
include_condition: -> do
|
|
SiteSetting.discourse_post_event_enabled &&
|
|
SiteSetting.display_post_event_date_on_topic_title &&
|
|
object.topic.first_post&.event&.timezone.present?
|
|
end,
|
|
) { object.topic.first_post.event.timezone }
|
|
|
|
add_to_serializer(
|
|
:topic_view,
|
|
:event_show_local_time,
|
|
include_condition: -> do
|
|
SiteSetting.discourse_post_event_enabled &&
|
|
SiteSetting.display_post_event_date_on_topic_title &&
|
|
object.topic.first_post&.event.present?
|
|
end,
|
|
) { object.topic.first_post.event.show_local_time }
|
|
|
|
# DISCOURSE CALENDAR
|
|
|
|
require_relative "jobs/scheduled/create_holiday_events"
|
|
require_relative "jobs/scheduled/delete_expired_event_posts"
|
|
require_relative "jobs/scheduled/monitor_event_dates"
|
|
require_relative "jobs/scheduled/update_holiday_usernames"
|
|
require_relative "lib/calendar_validator"
|
|
require_relative "lib/calendar"
|
|
require_relative "lib/event_validator"
|
|
require_relative "lib/group_timezones"
|
|
require_relative "lib/holiday_status"
|
|
require_relative "lib/time_sniffer"
|
|
require_relative "lib/users_on_holiday"
|
|
|
|
register_post_custom_field_type(DiscourseCalendar::CALENDAR_CUSTOM_FIELD, :string)
|
|
register_post_custom_field_type(DiscourseCalendar::GROUP_TIMEZONES_CUSTOM_FIELD, :json)
|
|
TopicView.default_post_custom_fields << DiscourseCalendar::GROUP_TIMEZONES_CUSTOM_FIELD
|
|
|
|
register_user_custom_field_type(DiscourseCalendar::HOLIDAY_CUSTOM_FIELD, :boolean)
|
|
|
|
allow_staff_user_custom_field(DiscourseCalendar::HOLIDAY_CUSTOM_FIELD)
|
|
DiscoursePluginRegistry.serialized_current_user_fields << DiscourseCalendar::REGION_CUSTOM_FIELD
|
|
register_editable_user_custom_field(DiscourseCalendar::REGION_CUSTOM_FIELD)
|
|
register_user_custom_field_type(DiscourseCalendar::REGION_CUSTOM_FIELD, :string, max_length: 40)
|
|
|
|
on(:site_setting_changed) do |name, old_value, new_value|
|
|
next if %i[all_day_event_start_time all_day_event_end_time].exclude? name
|
|
|
|
Post
|
|
.where(id: CalendarEvent.select(:post_id).distinct)
|
|
.each { |post| CalendarEvent.update(post) }
|
|
end
|
|
|
|
on(:post_process_cooked) do |doc, post|
|
|
DiscourseCalendar::Calendar.update(post)
|
|
DiscourseCalendar::GroupTimezones.update(post)
|
|
CalendarEvent.update(post)
|
|
|
|
if SiteSetting.discourse_post_event_enabled
|
|
event = DiscoursePostEvent::Event.find_by(id: post.id)
|
|
event&.sync_image_to_post_and_topic(generate_thumbnails: true) if event&.image_upload_id
|
|
end
|
|
end
|
|
|
|
on(:post_recovered) do |post, _, _|
|
|
DiscourseCalendar::Calendar.update(post)
|
|
DiscourseCalendar::GroupTimezones.update(post)
|
|
CalendarEvent.update(post)
|
|
end
|
|
|
|
on(:post_destroyed) do |post, _, _|
|
|
DiscourseCalendar::Calendar.destroy(post)
|
|
CalendarEvent.where(post_id: post.id).destroy_all
|
|
end
|
|
|
|
validate(:post, :validate_calendar) do |force = nil|
|
|
return unless self.raw_changed? || force
|
|
|
|
validator = DiscourseCalendar::CalendarValidator.new(self)
|
|
validator.validate_calendar
|
|
end
|
|
|
|
validate(:post, :validate_event) do |force = nil|
|
|
return unless self.raw_changed? || force
|
|
return if self.is_first_post?
|
|
|
|
# Skip if not a calendar topic
|
|
return if !self.topic&.first_post&.custom_fields&.[](DiscourseCalendar::CALENDAR_CUSTOM_FIELD)
|
|
|
|
validator = DiscourseCalendar::EventValidator.new(self)
|
|
validator.validate_event
|
|
end
|
|
|
|
add_to_class(:post, :has_group_timezones?) do
|
|
custom_fields[DiscourseCalendar::GROUP_TIMEZONES_CUSTOM_FIELD].present?
|
|
end
|
|
|
|
add_to_class(:post, :group_timezones) do
|
|
custom_fields[DiscourseCalendar::GROUP_TIMEZONES_CUSTOM_FIELD] || {}
|
|
end
|
|
|
|
add_to_class(:post, :group_timezones=) do |val|
|
|
if val.present?
|
|
custom_fields[DiscourseCalendar::GROUP_TIMEZONES_CUSTOM_FIELD] = val
|
|
else
|
|
custom_fields.delete(DiscourseCalendar::GROUP_TIMEZONES_CUSTOM_FIELD)
|
|
end
|
|
end
|
|
|
|
add_to_serializer(:post, :calendar_details, include_condition: -> { object.is_first_post? }) do
|
|
start_date = 6.months.ago
|
|
|
|
standalone_sql = <<~SQL
|
|
SELECT post_number, description, start_date, end_date, username, recurrence, timezone
|
|
FROM calendar_events
|
|
WHERE topic_id = :topic_id
|
|
AND post_id IS NOT NULL
|
|
ORDER BY start_date, end_date
|
|
SQL
|
|
|
|
standalones =
|
|
DB
|
|
.query(standalone_sql, topic_id: object.topic_id)
|
|
.map do |row|
|
|
{
|
|
type: :standalone,
|
|
post_number: row.post_number,
|
|
message: row.description,
|
|
from: row.start_date,
|
|
to: row.end_date,
|
|
username: row.username,
|
|
recurring: row.recurrence,
|
|
post_url: Post.url("-", object.topic_id, row.post_number),
|
|
timezone: row.timezone,
|
|
}
|
|
end
|
|
|
|
timezones =
|
|
UserOption
|
|
.where(
|
|
user_id:
|
|
CalendarEvent.where(
|
|
topic_id: object.topic_id,
|
|
post_id: nil,
|
|
start_date: start_date..,
|
|
).select(:user_id),
|
|
)
|
|
.where("LENGTH(COALESCE(timezone, '')) > 0")
|
|
.pluck(:user_id, :timezone)
|
|
.to_h
|
|
|
|
grouped = {}
|
|
|
|
grouped_sql = <<~SQL
|
|
SELECT region, start_date, timezone, user_id, username, description
|
|
FROM calendar_events
|
|
WHERE topic_id = :topic_id
|
|
AND post_id IS NULL
|
|
AND start_date >= :start_date
|
|
ORDER BY region, start_date
|
|
SQL
|
|
|
|
DB
|
|
.query(grouped_sql, topic_id: object.topic_id, start_date: start_date)
|
|
.each do |row|
|
|
identifier = "#{row.region.split("_").first}-#{row.start_date.strftime("%Y-%j")}"
|
|
|
|
grouped[identifier] ||= {
|
|
type: :grouped,
|
|
from: row.start_date,
|
|
timezone: row.timezone,
|
|
name: [],
|
|
users: [],
|
|
}
|
|
|
|
grouped[identifier][:name] << row.description
|
|
grouped[identifier][:users] << { username: row.username, timezone: timezones[row.user_id] }
|
|
end
|
|
|
|
grouped.each do |_, v|
|
|
v[:name].uniq!
|
|
v[:name].sort!
|
|
v[:name] = v[:name].join(", ")
|
|
v[:users].uniq! { |u| u[:username] }
|
|
v[:users].sort! { |a, b| a[:username] <=> b[:username] }
|
|
end
|
|
|
|
standalones + grouped.values
|
|
end
|
|
|
|
add_to_serializer(
|
|
:post,
|
|
:group_timezones,
|
|
include_condition: -> do
|
|
post_custom_fields[DiscourseCalendar::GROUP_TIMEZONES_CUSTOM_FIELD].present?
|
|
end,
|
|
) do
|
|
result = {}
|
|
group_timezones = post_custom_fields[DiscourseCalendar::GROUP_TIMEZONES_CUSTOM_FIELD] || {}
|
|
group_names = group_timezones["groups"] || []
|
|
|
|
if group_names.present?
|
|
users =
|
|
User
|
|
.human_users
|
|
.joins(:groups, :user_option)
|
|
.where("groups.name": group_names)
|
|
.select("users.*", "groups.name AS group_name", "user_options.timezone")
|
|
|
|
usernames_on_holiday = DiscourseCalendar.users_on_holiday
|
|
|
|
users.each do |u|
|
|
result[u.group_name] ||= []
|
|
result[u.group_name] << UserTimezoneSerializer.new(
|
|
u,
|
|
root: false,
|
|
on_holiday: usernames_on_holiday&.include?(u.username),
|
|
).as_json
|
|
end
|
|
end
|
|
|
|
result
|
|
end
|
|
|
|
add_to_serializer(:site, :users_on_holiday, include_condition: -> { scope.is_staff? }) do
|
|
DiscourseCalendar.users_on_holiday
|
|
end
|
|
|
|
on(:reduce_cooked) do |fragment, post|
|
|
if SiteSetting.discourse_post_event_enabled
|
|
fragment
|
|
.css(".discourse-post-event")
|
|
.each do |event_node|
|
|
tz = event_node["data-timezone"] || "UTC"
|
|
starts_at = event_node["data-start"]
|
|
ends_at = event_node["data-end"]
|
|
|
|
formatted_start =
|
|
begin
|
|
DateTime.parse(starts_at).strftime("%B %-d, %Y %-I:%M %p")
|
|
rescue StandardError
|
|
starts_at
|
|
end
|
|
dates = "#{formatted_start} (#{tz})"
|
|
|
|
if ends_at
|
|
formatted_end =
|
|
begin
|
|
DateTime.parse(ends_at).strftime("%B %-d, %Y %-I:%M %p")
|
|
rescue StandardError
|
|
ends_at
|
|
end
|
|
dates = "#{dates} → #{formatted_end} (#{tz})"
|
|
end
|
|
|
|
event_name = event_node["data-name"] || post.topic.title
|
|
location = event_node["data-location"]
|
|
url = event_node["data-url"]
|
|
|
|
event = DiscoursePostEvent::Event.includes(:image_upload).find_by(id: post.id)
|
|
image_url = UrlHelper.absolute(event.image_upload.url) if event&.image_upload_id
|
|
|
|
rows = +""
|
|
|
|
rows << <<~HTML if image_url.present?
|
|
<tr>
|
|
<td style="padding: 0;">
|
|
<img src="#{CGI.escape_html(image_url)}" style="width: 100%; max-height: 400px; object-fit: cover; display: block;" />
|
|
</td>
|
|
</tr>
|
|
HTML
|
|
|
|
rows << <<~HTML
|
|
<tr>
|
|
<td style="padding: 12px;">
|
|
<a href="#{Discourse.base_url}#{post.url}" style="font-weight: bold; font-size: 1.1em;">#{CGI.escape_html(event_name)}</a>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td style="padding: 0 12px 12px; color: #666;">#{CGI.escape_html(dates)}</td>
|
|
</tr>
|
|
HTML
|
|
|
|
rows << <<~HTML if location.present?
|
|
<tr>
|
|
<td style="padding: 0 12px 12px; color: #666;">#{CGI.escape_html(location)}</td>
|
|
</tr>
|
|
HTML
|
|
|
|
rows << <<~HTML if url.present?
|
|
<tr>
|
|
<td style="padding: 0 12px 12px;"><a href="#{CGI.escape_html(url)}">#{CGI.escape_html(url)}</a></td>
|
|
</tr>
|
|
HTML
|
|
|
|
event_node.replace <<~HTML
|
|
<table cellspacing="0" cellpadding="0" border="0" style="border: 1px solid #dedede; margin-bottom: 10px; width: 100%;">
|
|
#{rows}
|
|
</table>
|
|
HTML
|
|
end
|
|
end
|
|
end
|
|
|
|
on(:user_destroyed) { |user| DiscoursePostEvent::Invitee.where(user_id: user.id).destroy_all }
|
|
|
|
add_post_revision_notifier_recipients do |post_revision|
|
|
# next if no modifications
|
|
next if !post_revision.modifications.present?
|
|
|
|
# do no notify recipients when only updating tags
|
|
next if post_revision.modifications.keys == ["tags"]
|
|
|
|
ids = []
|
|
post = post_revision.post
|
|
|
|
if post && post.is_first_post? && post.event
|
|
ids.concat(post.event.on_going_event_invitees.pluck(:user_id))
|
|
end
|
|
|
|
ids
|
|
end
|
|
|
|
on(:site_setting_changed) do |name, old_val, new_val|
|
|
next if name != :discourse_post_event_allowed_custom_fields
|
|
|
|
previous_fields = old_val.split("|")
|
|
new_fields = new_val.split("|")
|
|
removed_fields = previous_fields - new_fields
|
|
|
|
next if removed_fields.empty?
|
|
|
|
DiscoursePostEvent::Event.all.find_each do |event|
|
|
removed_fields.each { |field| event.custom_fields.delete(field) }
|
|
event.save
|
|
end
|
|
end
|
|
|
|
if defined?(DiscourseAutomation)
|
|
on(:discourse_post_event_event_started) do |event|
|
|
DiscourseAutomation::Automation
|
|
.where(enabled: true, trigger: "event_started")
|
|
.each do |automation|
|
|
fields = automation.serialized_fields
|
|
topic_id = fields.dig("topic_id", "value")
|
|
|
|
next unless event.post.topic.id.to_s == topic_id
|
|
|
|
automation.trigger!(
|
|
"kind" => "event_started",
|
|
"event" => event,
|
|
"placeholders" => {
|
|
"event_url" => event.url,
|
|
},
|
|
)
|
|
end
|
|
end
|
|
|
|
add_triggerable_to_scriptable("event_started", "send_chat_message")
|
|
|
|
add_automation_triggerable("event_started") do
|
|
placeholder :event_url
|
|
|
|
field :topic_id, component: :text
|
|
end
|
|
end
|
|
|
|
query =
|
|
Proc.new do |notifications, data|
|
|
notifications.where("data::json ->> 'topic_title' = ?", data[:topic_title].to_s).where(
|
|
"data::json ->> 'message' = ?",
|
|
data[:message].to_s,
|
|
)
|
|
end
|
|
|
|
reminders_consolidation_plan =
|
|
Notifications::DeletePreviousNotifications.new(
|
|
type: Notification.types[:event_reminder],
|
|
previous_query_blk: query,
|
|
)
|
|
|
|
invitation_consolidation_plan =
|
|
Notifications::DeletePreviousNotifications.new(
|
|
type: Notification.types[:event_invitation],
|
|
previous_query_blk: query,
|
|
)
|
|
|
|
register_notification_consolidation_plan(reminders_consolidation_plan)
|
|
register_notification_consolidation_plan(invitation_consolidation_plan)
|
|
|
|
Report.add_report("currently_away") do |report|
|
|
group_filter = report.filters.dig(:group) || Group::AUTO_GROUPS[:staff]
|
|
report.add_filter("group", type: "group", default: group_filter)
|
|
|
|
break unless group = Group.find_by(id: group_filter)
|
|
|
|
report.labels = [
|
|
{ property: :username, title: I18n.t("reports.currently_away.labels.username") },
|
|
]
|
|
|
|
group_usernames = group.users.pluck(:username)
|
|
on_holiday_usernames = DiscourseCalendar.users_on_holiday
|
|
report.data = (group_usernames & on_holiday_usernames).map { |username| { username: username } }
|
|
report.total = report.data.count
|
|
end
|
|
end
|
