/* 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);
}
private string generateIcal(List <AppointmentInfo> appointments)
{
var calendar = new Ical.Net.Calendar();
calendar.AddTimeZone(new Ical.Net.CalendarComponents.VTimeZone("Europe/Berlin")); //bringt das was? Muss fast das ical checken...
foreach (var appointment in appointments)
{
var newEvent = new Ical.Net.CalendarComponents.CalendarEvent();
newEvent.Summary = appointment.Name;
newEvent.Location = appointment.Location;
newEvent.Start = new Ical.Net.DataTypes.CalDateTime(appointment.DatStart);
newEvent.End = new Ical.Net.DataTypes.CalDateTime(appointment.DatEnd);
newEvent.Description = appointment.Description;
calendar.Events.Add(newEvent);
}
var calendarSerializer = new Ical.Net.Serialization.CalendarSerializer();
var icalString = calendarSerializer.SerializeToString(calendar);
return(icalString);
}
public async Task <IActionResult> Get(CancellationToken cancellationToken, string tenant, DateTimeOffset?start, DateTimeOffset?end)
{
var query = new TenantSlugQuery(User, tenant);
var tenantModel = await Mediator.Send(query);
var tenantId = tenantModel.Id;
if (start == null)
{
start = DateTimeOffset.UtcNow.Subtract(TimeSpan.FromDays(60));
}
if (end == null)
{
end = start.Value.AddMonths(6);
}
var command = new EventRangeQuery(User, tenantId, start.Value, end.Value);
var events = await Mediator.Send(command, cancellationToken);
var calendar = new Ical.Net.Calendar();
calendar.Method = "PUBLISH";
calendar.AddTimeZone(tenantModel.TimeZone);
foreach (var e in events)
{
var calendarEvent = new CalendarEvent();
calendarEvent.Class = "PUBLIC";
calendarEvent.Uid = e.Id;
calendarEvent.Summary = e.Title;
calendarEvent.Description = e.Description;
calendarEvent.Location = e.Location;
calendarEvent.Categories.Add("Training");
if (e.Start.HasValue)
{
calendarEvent.Start = new CalDateTime(e.Start.Value.UtcDateTime)
{
HasTime = true
}
}
;
if (e.End.HasValue)
{
calendarEvent.End = new CalDateTime(e.End.Value.UtcDateTime)
{
HasTime = true
}
}
;
calendarEvent.LastModified = new CalDateTime(e.Modified.UtcDateTime);
calendar.Events.Add(calendarEvent);
}
var serializationContext = new SerializationContext();
var calendarSerializer = new CalendarSerializer(serializationContext);
var calendarText = calendarSerializer.SerializeToString(calendar);
var contentType = "text/calendar; charset=utf-8";
var contentDisposition = new System.Net.Mime.ContentDisposition();
contentDisposition.FileName = "training.ics";
contentDisposition.Inline = true;
Response.Headers.Add("Content-Disposition", contentDisposition.ToString());
Response.Headers.Add("X-Content-Type-Options", "nosniff");
return(Content(calendarText, contentType, Encoding.UTF8));
}
}
}
/*
* public async Task<IActionResult> GetSchedule([FromQuery] string group, [FromQuery] int weekNr)
* {
* if (!string.IsNullOrWhiteSpace(group))
* {
* try
* {
* using (HttpClient client = new HttpClient())
* {
* client.DefaultRequestHeaders.Add("Cookie",
* $"User={SessionReviver.UserCookie}; ASP.NET_SessionId={SessionReviver.SessionCookie}");
*
* string response = await client.GetStringAsync($"{BaseUrl}/api/group");
* List<GroupEntry> groups = JsonConvert.DeserializeObject<List<GroupEntry>>(response);
*
* GroupEntry groupEntry = groups.FirstOrDefault(g => g.Code.ToLowerInvariant() == group.ToLowerInvariant());
* if (groupEntry == null)
* {
* return BadRequest();
* }
*
* response = await client.GetStringAsync($"{BaseUrl}/api/year");
* List<YearEntry> years = JsonConvert.DeserializeObject<List<YearEntry>>(response);
*
* response = await client.GetStringAsync($"{BaseUrl}/api/docent");
* List<DocentEntry> docents = JsonConvert.DeserializeObject<List<DocentEntry>>(response);
*
* response = await client.GetStringAsync($"{BaseUrl}/api/facility");
* List<FacilityEntry> facilities = JsonConvert.DeserializeObject<List<FacilityEntry>>(response);
*
* YearEntry yearEntry =
* years.FirstOrDefault(y => y.Oru == groupEntry.Orus.First());
*
* string[] scheduleIds = null;
* if (weekNr <= 0 || weekNr > 52)
* {
* scheduleIds = GenerateScheduleFormats(yearEntry, groupEntry.Id);
* }
* else
* {
* scheduleIds = GenerateScheduleFormats(yearEntry, groupEntry.Id, new[] {weekNr});
* }
*
* response = await client.GetStringAsync(
* $"{BaseUrl}/api/schedule/?{GenerateScheduleQuerry(scheduleIds)}");
* List<ScheduleEntry> schedules = JsonConvert.DeserializeObject<List<ScheduleEntry>>(response);
*
* return Ok(GenerateScheduleItems(schedules, docents, facilities));
* }
* }
* catch (Exception e)
* {
*
* }
* }
*
* return NotFound();
* }
*/
public async Task <IActionResult> GetIcalSchedule([FromQuery] string group, [FromQuery] string docent)
{
int weekNr = 200;
if (!string.IsNullOrWhiteSpace(group) || !string.IsNullOrWhiteSpace(docent))
{
try
{
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Cookie",
$"User={SessionReviver.UserCookie}; ASP.NET_SessionId={SessionReviver.SessionCookie}");
List <GroupEntry> groups = new List <GroupEntry>();
List <DocentEntry> docents = new List <DocentEntry>();
string response;
ISubjectEntry subject = null;
if (!string.IsNullOrWhiteSpace(group))
{
response = await client.GetStringAsync($"{BaseUrl}/api/group");
groups = JsonConvert.DeserializeObject <List <GroupEntry> >(response);
GroupEntry groupEntry = groups.FirstOrDefault(g => g.Code.ToLowerInvariant() == group.ToLowerInvariant());
if (groupEntry == null)
{
return(BadRequest());
}
if (cache.ContainsKey(groupEntry.Id))
{
if (DateTime.UtcNow < cache[groupEntry.Id].lastUpdated.AddHours(4))
{
var serializer = new CalendarSerializer();
string serializedString = serializer.SerializeToString(cache[groupEntry.Id].Calendar);
return(Ok(serializedString));
}
}
response = await client.GetStringAsync($"{BaseUrl}/api/docent");
docents = JsonConvert.DeserializeObject <List <DocentEntry> >(response);
subject = groupEntry;
}
else if (!string.IsNullOrWhiteSpace(docent))
{
response = await client.GetStringAsync($"{BaseUrl}/api/docent");
docents = JsonConvert.DeserializeObject <List <DocentEntry> >(response);
DocentEntry docentEntry = docents.FirstOrDefault(d => d.Code.ToLowerInvariant() == docent.ToLowerInvariant());
if (docentEntry == null)
{
return(BadRequest());
}
if (cache.ContainsKey(docentEntry.Id))
{
if (DateTime.UtcNow < cache[docentEntry.Id].lastUpdated.AddHours(4))
{
var serializer = new CalendarSerializer();
string serializedString = serializer.SerializeToString(cache[docentEntry.Id].Calendar);
return(Ok(serializedString));
}
}
response = await client.GetStringAsync($"{BaseUrl}/api/group");
groups = JsonConvert.DeserializeObject <List <GroupEntry> >(response);
subject = docentEntry;
}
response = await client.GetStringAsync($"{BaseUrl}/api/year");
List <YearEntry> years = JsonConvert.DeserializeObject <List <YearEntry> >(response);
response = await client.GetStringAsync($"{BaseUrl}/api/facility");
List <FacilityEntry> facilities = JsonConvert.DeserializeObject <List <FacilityEntry> >(response);
YearEntry yearEntry =
years.FirstOrDefault(y => y.Oru == subject.Orus.First());
string[] scheduleIds = null;
if (weekNr <= 0 || weekNr > 52)
{
scheduleIds = GenerateScheduleFormats(yearEntry, subject.Id);
}
else
{
scheduleIds = GenerateScheduleFormats(yearEntry, subject.Id, new[] { weekNr });
}
response = await client.GetStringAsync(
$"{BaseUrl}/api/schedule/?{GenerateScheduleQuerry(scheduleIds)}");
List <ScheduleEntry> schedules = JsonConvert.DeserializeObject <List <ScheduleEntry> >(response);
ScheduleResponse[] scheduleItems = GenerateScheduleItems(schedules, docents, facilities);
var icalCalendar = new Ical.Net.Calendar();
var calendarSerializer = new CalendarSerializer();
foreach (ScheduleResponse scheduleItem in scheduleItems)
{
StringBuilder descrBuilder = new StringBuilder();
if (scheduleItem.Teachers.Length > 0)
{
descrBuilder.AppendLine("Teachers:");
foreach (string teacher in scheduleItem.Teachers)
{
descrBuilder.AppendLine(teacher);
}
}
if (scheduleItem.ClassRooms.Length > 0)
{
descrBuilder.AppendLine("\nClassrooms:");
foreach (string classroom in scheduleItem.ClassRooms)
{
descrBuilder.AppendLine(classroom);
}
}
icalCalendar.Events.Add(new CalendarEvent()
{
Start = new CalDateTime(scheduleItem.StartTime),
End = new CalDateTime(scheduleItem.EndTime),
Summary = scheduleItem.Subject,
Description = descrBuilder.ToString()
});
}
icalCalendar.AddTimeZone("Europe/Amsterdam");
cache[subject.Id] = new CacheEntry()
{
GroupName = subject.Id,
Calendar = icalCalendar,
lastUpdated = DateTime.UtcNow
};
string icalString = calendarSerializer.SerializeToString(icalCalendar);
return(Ok(icalString));
}
}
catch (Exception e)
{
}
}
return(NotFound());
}
