468 lines
18 KiB
C#
468 lines
18 KiB
C#
// (c) Copyright Ascensio System SIA 2010-2022
|
|
//
|
|
// This program is a free software product.
|
|
// You can redistribute it and/or modify it under the terms
|
|
// of the GNU Affero General Public License (AGPL) version 3 as published by the Free Software
|
|
// Foundation. In accordance with Section 7(a) of the GNU AGPL its Section 15 shall be amended
|
|
// to the effect that Ascensio System SIA expressly excludes the warranty of non-infringement of
|
|
// any third-party rights.
|
|
//
|
|
// This program is distributed WITHOUT ANY WARRANTY, without even the implied warranty
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For details, see
|
|
// the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
//
|
|
// You can contact Ascensio System SIA at Lubanas st. 125a-25, Riga, Latvia, EU, LV-1021.
|
|
//
|
|
// The interactive user interfaces in modified source and object code versions of the Program must
|
|
// display Appropriate Legal Notices, as required under Section 5 of the GNU AGPL version 3.
|
|
//
|
|
// Pursuant to Section 7(b) of the License you must retain the original Product logo when
|
|
// distributing the program. Pursuant to Section 7(e) we decline to grant you any rights under
|
|
// trademark law for use of our trademarks.
|
|
//
|
|
// All the Product's GUI elements, including illustrations and icon sets, as well as technical writing
|
|
// content are licensed under the terms of the Creative Commons Attribution-ShareAlike 4.0
|
|
// International. See the License terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
|
|
/*
|
|
*
|
|
* (c) Copyright Ascensio System Limited 2010-2018
|
|
*
|
|
* This program is freeware. You can redistribute it and/or modify it under the terms of the GNU
|
|
* General Public License (GPL) version 3 as published by the Free Software Foundation (https://www.gnu.org/copyleft/gpl.html).
|
|
* In accordance with Section 7(a) of the GNU GPL its Section 15 shall be amended to the effect that
|
|
* Ascensio System SIA expressly excludes the warranty of non-infringement of any third-party rights.
|
|
*
|
|
* THIS PROGRAM IS DISTRIBUTED WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR
|
|
* FITNESS FOR A PARTICULAR PURPOSE. For more details, see GNU GPL at https://www.gnu.org/copyleft/gpl.html
|
|
*
|
|
* You can contact Ascensio System SIA by email at sales@onlyoffice.com
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions of ONLYOFFICE must display
|
|
* Appropriate Legal Notices, as required under Section 5 of the GNU GPL version 3.
|
|
*
|
|
* Pursuant to Section 7 § 3(b) of the GNU GPL you must retain the original ONLYOFFICE logo which contains
|
|
* relevant author attributions when distributing the software. If the display of the logo in its graphic
|
|
* form is not reasonably feasible for technical reasons, you must include the words "Powered by ONLYOFFICE"
|
|
* in every copy of the program you distribute.
|
|
* Pursuant to Section 7 § 3(e) we decline to grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
*/
|
|
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
|
|
using ASC.Common;
|
|
using ASC.Common.Utils;
|
|
using ASC.Core;
|
|
using ASC.Web.Core.Calendars;
|
|
|
|
using Microsoft.Extensions.Logging;
|
|
|
|
namespace ASC.Calendar.iCalParser
|
|
{
|
|
[Scope]
|
|
public class DDayICalParser
|
|
{
|
|
public IServiceProvider ServiceProvider { get; }
|
|
|
|
private readonly ILogger<DDayICalParser> Log;
|
|
public TenantManager TenantManager { get; }
|
|
public TimeZoneConverter TimeZoneConverter { get; }
|
|
public AuthContext AuthContext { get; }
|
|
public iCalendar ICalendar { get; }
|
|
|
|
public DDayICalParser(
|
|
IServiceProvider serviceProvider,
|
|
TenantManager tenantManager,
|
|
TimeZoneConverter timeZoneConverter,
|
|
AuthContext authContext,
|
|
ILogger<DDayICalParser> options)
|
|
{
|
|
ServiceProvider = serviceProvider;
|
|
TenantManager = tenantManager;
|
|
TimeZoneConverter = timeZoneConverter;
|
|
AuthContext = authContext;
|
|
Log = options;
|
|
}
|
|
public Ical.Net.CalendarCollection DeserializeCalendar(string iCalCalendarString)
|
|
{
|
|
if (string.IsNullOrEmpty(iCalCalendarString)) return null;
|
|
|
|
try
|
|
{
|
|
using (var stringReader = new StringReader(iCalCalendarString))
|
|
{
|
|
return Ical.Net.CalendarCollection.Load(stringReader);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.LogError(ex, "DeserializeCalendar");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public Ical.Net.CalendarCollection DeserializeCalendar(TextReader reader)
|
|
{
|
|
try
|
|
{
|
|
return Ical.Net.CalendarCollection.Load(reader);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.LogError(ex, "DeserializeCalendar");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public string SerializeCalendar(Ical.Net.Calendar calendar)
|
|
{
|
|
try
|
|
{
|
|
var serializer = new Ical.Net.Serialization.CalendarSerializer();
|
|
return serializer.SerializeToString(calendar);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.LogError(ex, "SerializeCalendar");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public Ical.Net.CalendarComponents.CalendarEvent DeserializeEvent(string iCalEventString)
|
|
{
|
|
if (string.IsNullOrEmpty(iCalEventString)) return null;
|
|
|
|
try
|
|
{
|
|
using (var stringReader = new StringReader(iCalEventString))
|
|
{
|
|
var serializer = new Ical.Net.Serialization.EventSerializer();
|
|
return (Ical.Net.CalendarComponents.CalendarEvent)serializer.Deserialize(stringReader);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.LogError(ex, "DeserializeEvent");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public Ical.Net.CalendarComponents.CalendarEvent DeserializeEvent(TextReader stringReader)
|
|
{
|
|
try
|
|
{
|
|
var serializer = new Ical.Net.Serialization.EventSerializer();
|
|
return (Ical.Net.CalendarComponents.CalendarEvent)serializer.Deserialize(stringReader);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.LogError(ex, "DeserializeEvent");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public string SerializeEvent(Ical.Net.CalendarComponents.CalendarEvent eventObj)
|
|
{
|
|
try
|
|
{
|
|
var serializer = new Ical.Net.Serialization.EventSerializer();
|
|
return serializer.SerializeToString(eventObj);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.LogError(ex, "SerializeEvent");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public Ical.Net.DataTypes.RecurrencePattern DeserializeRecurrencePattern(string iCalRecurrencePatternString)
|
|
{
|
|
if (string.IsNullOrEmpty(iCalRecurrencePatternString)) return null;
|
|
|
|
try
|
|
{
|
|
using (var stringReader = new StringReader(iCalRecurrencePatternString))
|
|
{
|
|
var serializer = new Ical.Net.Serialization.DataTypes.RecurrencePatternSerializer();
|
|
return (Ical.Net.DataTypes.RecurrencePattern)serializer.Deserialize(stringReader);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.LogError(ex, "DeserializeRecurrencePattern");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public Ical.Net.DataTypes.RecurrencePattern DeserializeRecurrencePattern(TextReader stringReader)
|
|
{
|
|
try
|
|
{
|
|
var serializer = new Ical.Net.Serialization.DataTypes.RecurrencePatternSerializer();
|
|
return (Ical.Net.DataTypes.RecurrencePattern)serializer.Deserialize(stringReader);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.LogError(ex, "DeserializeRecurrencePattern");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public string SerializeRecurrencePattern(Ical.Net.DataTypes.RecurrencePattern recurrencePattern)
|
|
{
|
|
try
|
|
{
|
|
var serializer = new Ical.Net.Serialization.DataTypes.RecurrencePatternSerializer();
|
|
return serializer.SerializeToString(recurrencePattern);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.LogError(ex, "SerializeRecurrencePattern");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
/* public BaseCalendar ConvertCalendar(Ical.Net.Calendar calandarObj)
|
|
{
|
|
if (calandarObj == null) return null;
|
|
|
|
var icalendar = new iCalendar(AuthContext, TimeZoneConverter, TenantManager);
|
|
var result = new BusinessObjects.Calendar(AuthContext, TimeZoneConverter, icalendar, DataProvider);
|
|
|
|
result.Name = string.IsNullOrEmpty(calandarObj.Name)
|
|
? calandarObj.Properties.ContainsKey("X-WR-CALNAME")
|
|
? calandarObj.Properties["X-WR-CALNAME"].Value.ToString()
|
|
: string.Empty
|
|
: calandarObj.Name;
|
|
|
|
result.Description = calandarObj.Properties.ContainsKey("X-WR-CALDESC")
|
|
? calandarObj.Properties["X-WR-CALDESC"].Value.ToString()
|
|
: string.Empty;
|
|
|
|
var tzids = calandarObj.TimeZones.Select(x => x.TzId).Where(x => !string.IsNullOrEmpty(x)).ToList();
|
|
|
|
result.TimeZone = tzids.Any()
|
|
? TimeZoneConverter.GetTimeZone(tzids.First())
|
|
: (calandarObj.Properties.ContainsKey("X-WR-TIMEZONE")
|
|
? TimeZoneConverter.GetTimeZone(
|
|
calandarObj.Properties["X-WR-TIMEZONE"].Value.ToString())
|
|
: TimeZoneConverter.GetTimeZone(TenantManager.GetCurrentTenant().TimeZone));
|
|
|
|
return result;
|
|
}*/
|
|
|
|
public Ical.Net.Calendar ConvertCalendar(BaseCalendar calandarObj)
|
|
{
|
|
if (calandarObj == null) return null;
|
|
|
|
var result = new Ical.Net.Calendar();
|
|
|
|
result.Method = Ical.Net.CalendarMethods.Publish;
|
|
result.Scale = Ical.Net.CalendarScales.Gregorian;
|
|
result.Version = Ical.Net.LibraryMetadata.Version;
|
|
result.ProductId = "-//Ascensio System//OnlyOffice Calendar//EN";
|
|
|
|
if (!string.IsNullOrEmpty(calandarObj.Name))
|
|
{
|
|
result.AddProperty("X-WR-CALNAME", calandarObj.Name);
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(calandarObj.Description))
|
|
{
|
|
result.AddProperty("X-WR-CALDESC", calandarObj.Description);
|
|
}
|
|
|
|
if (calandarObj.TimeZone == null)
|
|
calandarObj.TimeZone = TimeZoneConverter.GetTimeZone(TenantManager.GetCurrentTenant().TimeZone);
|
|
|
|
var olsonTzId = TimeZoneConverter.WindowsTzId2OlsonTzId(calandarObj.TimeZone.Id);
|
|
var olsonTz = olsonTzId == calandarObj.TimeZone.Id
|
|
? calandarObj.TimeZone
|
|
: TimeZoneInfo.CreateCustomTimeZone(olsonTzId,
|
|
calandarObj.TimeZone.GetOffset(true),
|
|
calandarObj.TimeZone.DisplayName,
|
|
calandarObj.TimeZone.StandardName);
|
|
|
|
result.AddTimeZone(Ical.Net.CalendarComponents.VTimeZone.FromSystemTimeZone(olsonTz));
|
|
result.AddProperty("X-WR-TIMEZONE", olsonTzId);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
/*public BaseEvent ConvertEvent(Ical.Net.CalendarComponents.CalendarEvent eventObj)
|
|
{
|
|
if (eventObj == null) return null;
|
|
|
|
var result = new BusinessObjects.Event(AuthContext, TimeZoneConverter, ICalendar, DataProvider);
|
|
|
|
result.Name = eventObj.Summary;
|
|
|
|
result.Description = eventObj.Description;
|
|
|
|
result.AllDayLong = eventObj.IsAllDay;
|
|
|
|
result.Uid = eventObj.Uid;
|
|
|
|
result.UtcStartDate = ToUtc(eventObj.Start);
|
|
|
|
result.UtcEndDate = ToUtc(eventObj.End);
|
|
|
|
result.UtcUpdateDate = ToUtc(eventObj.Created);
|
|
|
|
var recurrenceRuleStr = string.Empty;
|
|
|
|
if (eventObj.RecurrenceRules != null && eventObj.RecurrenceRules.Any())
|
|
{
|
|
var recurrenceRules = eventObj.RecurrenceRules.ToList();
|
|
|
|
recurrenceRuleStr = SerializeRecurrencePattern(recurrenceRules.First());
|
|
}
|
|
|
|
result.RecurrenceRule = RecurrenceRule.Parse(recurrenceRuleStr);
|
|
|
|
if (eventObj.ExceptionDates != null && eventObj.ExceptionDates.Any())
|
|
{
|
|
result.RecurrenceRule.ExDates = new List<RecurrenceRule.ExDate>();
|
|
|
|
var exceptionDates = eventObj.ExceptionDates.ToList();
|
|
|
|
foreach (var periodList in exceptionDates.First())
|
|
{
|
|
var start = ToUtc(periodList.StartTime);
|
|
|
|
result.RecurrenceRule.ExDates.Add(new RecurrenceRule.ExDate
|
|
{
|
|
Date = start,
|
|
isDateTime = start != start.Date
|
|
});
|
|
}
|
|
}
|
|
|
|
result.Status = ConvertEventStatus(eventObj.Status);
|
|
|
|
return result;
|
|
}*/
|
|
|
|
public Ical.Net.CalendarComponents.CalendarEvent ConvertEvent(BaseEvent eventObj)
|
|
{
|
|
if (eventObj == null) return null;
|
|
|
|
var result = new Ical.Net.CalendarComponents.CalendarEvent();
|
|
|
|
result.Summary = eventObj.Name;
|
|
|
|
result.Location = string.Empty;
|
|
|
|
result.Description = eventObj.Description;
|
|
|
|
result.IsAllDay = eventObj.AllDayLong;
|
|
|
|
result.Uid = eventObj.Uid;
|
|
|
|
result.Start = new Ical.Net.DataTypes.CalDateTime(DateTime.SpecifyKind(eventObj.UtcStartDate, DateTimeKind.Utc), TimeZoneInfo.Utc.Id);
|
|
|
|
result.End = new Ical.Net.DataTypes.CalDateTime(DateTime.SpecifyKind(eventObj.UtcEndDate, DateTimeKind.Utc), TimeZoneInfo.Utc.Id);
|
|
|
|
result.Created = new Ical.Net.DataTypes.CalDateTime(DateTime.SpecifyKind(eventObj.UtcUpdateDate, DateTimeKind.Utc), TimeZoneInfo.Utc.Id);
|
|
|
|
result.RecurrenceRules = new List<Ical.Net.DataTypes.RecurrencePattern>();
|
|
|
|
var rrule = eventObj.RecurrenceRule.ToString(true);
|
|
|
|
if (!string.IsNullOrEmpty(rrule))
|
|
{
|
|
result.RecurrenceRules.Add(new Ical.Net.DataTypes.RecurrencePattern(rrule));
|
|
}
|
|
|
|
result.Status = ConvertEventStatus(eventObj.Status);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
public EventStatus ConvertEventStatus(string status)
|
|
{
|
|
switch (status)
|
|
{
|
|
case Ical.Net.EventStatus.Tentative:
|
|
return EventStatus.Tentative;
|
|
case Ical.Net.EventStatus.Confirmed:
|
|
return EventStatus.Confirmed;
|
|
case Ical.Net.EventStatus.Cancelled:
|
|
return EventStatus.Cancelled;
|
|
}
|
|
|
|
return EventStatus.Tentative;
|
|
}
|
|
|
|
public string ConvertEventStatus(EventStatus status)
|
|
{
|
|
switch (status)
|
|
{
|
|
case EventStatus.Tentative:
|
|
return Ical.Net.EventStatus.Tentative;
|
|
case EventStatus.Confirmed:
|
|
return Ical.Net.EventStatus.Confirmed;
|
|
case EventStatus.Cancelled:
|
|
return Ical.Net.EventStatus.Cancelled;
|
|
}
|
|
|
|
return Ical.Net.EventStatus.Tentative;
|
|
}
|
|
|
|
|
|
|
|
public Ical.Net.CalendarComponents.CalendarEvent CreateEvent(string name, string description, DateTime startUtcDate, DateTime endUtcDate, string repeatType, bool isAllDayLong, EventStatus status)
|
|
{
|
|
var evt = new Ical.Net.CalendarComponents.CalendarEvent
|
|
{
|
|
Summary = name,
|
|
Location = string.Empty,
|
|
Description = description,
|
|
IsAllDay = isAllDayLong,
|
|
DtStamp = new Ical.Net.DataTypes.CalDateTime(DateTime.SpecifyKind(DateTime.UtcNow, DateTimeKind.Utc), TimeZoneInfo.Utc.Id),
|
|
Start = new Ical.Net.DataTypes.CalDateTime(DateTime.SpecifyKind(startUtcDate, DateTimeKind.Utc), TimeZoneInfo.Utc.Id),
|
|
End = new Ical.Net.DataTypes.CalDateTime(DateTime.SpecifyKind(endUtcDate, DateTimeKind.Utc), TimeZoneInfo.Utc.Id),
|
|
RecurrenceRules = new List<Ical.Net.DataTypes.RecurrencePattern>(),
|
|
Status = ConvertEventStatus(status)
|
|
};
|
|
|
|
var rrule = RecurrenceRule.Parse(repeatType).ToString(true);
|
|
|
|
if (!string.IsNullOrEmpty(rrule))
|
|
{
|
|
evt.RecurrenceRules.Add(new Ical.Net.DataTypes.RecurrencePattern(rrule));
|
|
}
|
|
|
|
return evt;
|
|
}
|
|
|
|
|
|
public DateTime ToUtc(Ical.Net.DataTypes.IDateTime dateTime)
|
|
{
|
|
if (dateTime.IsUtc || string.IsNullOrEmpty(dateTime.TzId) || dateTime.TzId.Equals("UTC", StringComparison.InvariantCultureIgnoreCase))
|
|
return dateTime.Value;
|
|
|
|
if (dateTime.AsUtc != dateTime.Value)
|
|
return dateTime.AsUtc;
|
|
|
|
var timeZone = TimeZoneConverter.GetTimeZone(dateTime.TzId);
|
|
var utcOffse = timeZone.GetOffset();
|
|
|
|
return dateTime.Value - utcOffse;
|
|
}
|
|
}
|
|
}
|