private async void insertevent()
{
UserData user = (UserData)Session["User"];
UserCredential credential;
using (var stream =
new FileStream(Server.MapPath("client_secret.json"), FileMode.Open, FileAccess.Read))
{
string credPath = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.Personal);;
credPath = Path.Combine(credPath, ".credentials/calendarinsert-dotnet-quickstart.json");
credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets, Scopes, "user", CancellationToken.None, new FileDataStore(credPath, true)).Result;
Console.WriteLine("Credential file saved to: " + credPath);
}
// Create Google Calendar API service.
var service = new CalendarService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
CalendarService cs = service;
Event newEvent = new Event()
{
Summary = "Project: " + txtprojname.Value.ToString(),
Location = "On Fincal",
Description = txtmeetd.Value.ToString(),
Start = new EventDateTime()
{
DateTime = DateTime.Parse(XmlConvert.ToString(DateTime.Parse(txtmeetdate.Value.ToString()), XmlDateTimeSerializationMode.Utc)), //DateTime.pr dt.ToUniversalTime().ToString("YYYY-MM-DD'T'HH:mm:ssZ"),
TimeZone = "Europe/Paris",
},
End = new EventDateTime()
{
DateTime = DateTime.Parse(XmlConvert.ToString(DateTime.Parse(txtmeetdate.Value.ToString()), XmlDateTimeSerializationMode.Utc)),
TimeZone = "Europe/Paris",
},
};
String calendarId = "primary";
EventsResource.InsertRequest request = service.Events.Insert(newEvent, calendarId);
Event newevent = await request.ExecuteAsync();
}
public async Task <string> AddEvent(Event e, string calendar = "primary")
{
if (calService == null)
{
await Auth(EditScopes);
}
EventsResource.InsertRequest req = calService.Events.Insert(e, calendar);
var ev = await req.ExecuteAsync();
return(ev.Id);
}
public async Task <ILoadedAppointment> CreateAppointmentAsync(string uniqueId, IAppointment appointmentData)
{
using (Logger.Scope($"GoogleCalendar.CreateAppointment(\"{appointmentData}\")"))
{
EventsResource.InsertRequest request = _service.Events.Insert(appointmentData.ToGoogleEvent(null, uniqueId), CalendarId);
Event createdEvent = await request.ExecuteAsync().ConfigureAwait(false);
Logger.Verbose($"Created new event \"{appointmentData}\" on {appointmentData.Schedule?.Start:d}");
if (appointmentData.Schedule?.Recurrence?.Exceptions != null)
{
await UpdateExceptionsAsync(createdEvent.Id, appointmentData.Schedule, true).ConfigureAwait(false);
}
return(new GoogleCalendarAppointment(createdEvent));
}
}
public async Task <string> SetUpEvent(DateTime eventDate, string title)
{
var service = new CalendarService(new BaseClientService.Initializer()
{
HttpClientInitializer = User,
ApplicationName = "BotApp"
});
EventsResource.InsertRequest request = service.Events.Insert(new Event {
Start = new EventDateTime {
DateTime = eventDate, TimeZone = TimeZone.CurrentTimeZone.ToString()
}, Summary = title
}, "primary");
Event createdEvent = await request.ExecuteAsync();
return(createdEvent != null ? "event created" : "something goes wrong");
}
public async Task <GoogleEventModel> InsertEvent(GoogleEventModel eventModel, string calendarID)
{
if (!eventModel.Start.HasValue)
{
return(null);
}
var start = eventModel.Start.Value;
var service = GetCalendarService();
var simpleStartDate = new DateTime(start.Year, start.Month, start.Day, start.Hour, start.Minute, start.Second);
var calendartimeZone = GetCurrentCalendar(service).TimeZone;
Event newEvent = new Event()
{
Id = eventModel.EventId,
Summary = eventModel.Summary,
Location = eventModel.Location,
Description = eventModel.Description,
Start = new EventDateTime()
{
DateTime = TimeZoneInfo.ConvertTimeBySystemTimeZoneId(simpleStartDate, TZConvert.IanaToWindows(calendartimeZone)),
TimeZone = calendartimeZone,
},
End = new EventDateTime()
{
DateTime = TimeZoneInfo.ConvertTimeBySystemTimeZoneId(simpleStartDate.AddMinutes(15), TZConvert.IanaToWindows(calendartimeZone)),
TimeZone = calendartimeZone,
},
Attendees = new EventAttendee[] { new EventAttendee()
{
Email = _user.Email
} },
};
//newEvent.Start.DateTimeRaw = newEvent.Start.DateTime.Value.ToLongDateString();
//newEvent.End.DateTimeRaw = newEvent.End.DateTime.Value.ToLongDateString();
EventsResource.InsertRequest request = service.Events.Insert(newEvent, calendarID);
Event createdEvent = await request.ExecuteAsync();
return(createdEvent.MapToGoogleEventModel());
}
public async Task AddEvent(UserVacationViewModel model, string userId)
{
var userToken = await _db.UserGoogleToken.FirstOrDefaultAsync(u => u.UserId == userId);
if (userToken != null)
{
UserCredential credential = await GetCredential(userToken.AccessToken, userToken.RefreshToken, userToken.IssuedAt, clientId, clientSecret);
var service = new CalendarService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "Futurify Vacation",
});
// Define parameters of request.
var newEvent = new Event
{
Summary = model.FirstName + " " + model.LastName,
Description = model.Title,
Start = new EventDateTime
{
DateTime = model.Start
},
End = new EventDateTime
{
DateTime = model.End
},
ColorId = "10",
};
EventsResource.InsertRequest requestInsertEvent = service.Events.Insert(newEvent, calendarId);
var insert = await requestInsertEvent.ExecuteAsync();
model.GoogleCalendarId = insert.Id;
}
}
public async Task addEvent(CommandContext ctx)
{
Console.WriteLine("AddEvent");
try
{
Event evt = new Event()
{
AnyoneCanAddSelf = true,
};
var x = DateTimeOffset.Now.Offset.Hours.ToString();
var sender = ctx.Message.Author;
var dmChannel = await Startup.discord.CreateDmAsync(sender);
await dmChannel.SendMessageAsync("What is the name of this event?");
var sum = await Startup.interactivity.WaitForMessageAsync(xm => xm.Author == ctx.Message.Author, TimeSpan.FromMinutes(5));
evt.Summary = sum.Message.Content;
await dmChannel.SendMessageAsync("What Date is the start of this event? yyyy-mm-dd");
var startDate = await Startup.interactivity.WaitForMessageAsync(xm => xm.Author == ctx.Message.Author, TimeSpan.FromMinutes(5));
await dmChannel.SendMessageAsync("What time does this event start at? 24h hh:mm");
var startTime = await Startup.interactivity.WaitForMessageAsync(xm => xm.Author == ctx.Message.Author, TimeSpan.FromMinutes(5));
evt.Start = new EventDateTime()
{
DateTime = DateTime.Parse($"{startDate.Message.Content}T{startTime.Message.Content}:00.0000000"),
TimeZone = "America/Los_Angeles"
};
await dmChannel.SendMessageAsync("What Date is the end of this event? yyyy-mm-dd");
var endDate = await Startup.interactivity.WaitForMessageAsync(xm => xm.Author == ctx.Message.Author, TimeSpan.FromMinutes(5));
await dmChannel.SendMessageAsync("What time does this event end at? 24h hh:mm");
var endTime = await Startup.interactivity.WaitForMessageAsync(xm => xm.Author == ctx.Message.Author, TimeSpan.FromMinutes(5));
evt.End = new EventDateTime()
{
DateTime = DateTime.Parse($"{endDate.Message.Content}T{endTime.Message.Content}:00.0000000"),
TimeZone = "America/Los_Angeles"
};
await dmChannel.SendMessageAsync("Does this event repeat? true/false");
var stor = await Startup.interactivity.WaitForMessageAsync(xm => xm.Author == ctx.Message.Author, TimeSpan.FromMinutes(5));
var repeat = Convert.ToBoolean(stor.Message.Content);
if (repeat)
{
await dmChannel.SendMessageAsync("How often does it repeat?", false, new DiscordEmbedBuilder()
{
Description = "(0) : Daily \n (1) : Weekly \n (2) : Monthly \n (3) Yearly",
}.Build());
var stor1 = await Startup.interactivity.WaitForMessageAsync(xm => xm.Author == ctx.Message.Author, TimeSpan.FromMinutes(5));
var repeatfreq = Convert.ToByte(stor1.Message.Content);
String freq;
switch (repeatfreq)
{
case 0:
freq = "DAILY";
break;
case 1:
freq = "WEEKLY";
break;
case 2:
freq = "MONTHLY";
break;
case 3:
freq = "YEARLY";
break;
default:
freq = "YEARLY";
break;
}
await dmChannel.SendMessageAsync("How many times does it repeat?");
var f = await Startup.interactivity.WaitForMessageAsync(xm => xm.Author == ctx.Message.Author, TimeSpan.FromMinutes(5));
int repeats = Convert.ToInt32(f.Message.Content);
evt.Recurrence = new String[] { $"RRULE:FREQ={freq};COUNT={repeats}" };
}
EventsResource.InsertRequest request = calendarLoad.s.Events.Insert(evt, "primary");
Event createdEvent = await request.ExecuteAsync();
await dmChannel.SendMessageAsync($"Event Created: {createdEvent.HtmlLink}");
}
catch (Exception e) { Console.WriteLine(e.Message); }
}
public async Task <string> UpdateEvent(GoogleEvent i, Guid OwnerGuid)
{
Event eventoEsistente = null;
//verifica se fare update o insert
var IsUpdate = (string.IsNullOrWhiteSpace(i.ID) == false);
if (i.ID == "null")
{
IsUpdate = false;
}
if (IsUpdate == false)
{
EventsResource.GetRequest request = Generic.Calendar.Events.Get(MainClass.StudentsCalendar, i.ID);
try { eventoEsistente = await request.ExecuteAsync(); } catch { }
IsUpdate = eventoEsistente != null;
}
GoogleEvent.UpdateResponse output = new GoogleEvent.UpdateResponse();
try
{
eventoEsistente = EventMixedFromGoogle(i, eventoEsistente);
if (IsUpdate)
{
EventsResource.UpdateRequest request = Generic.Calendar.Events.Update(
eventoEsistente, MainClass.StudentsCalendar, eventoEsistente.Id
);
eventoEsistente = await request.ExecuteAsync();
}
else
{
eventoEsistente.Id = null;
EventsResource.InsertRequest request = Generic.Calendar.Events.Insert(
eventoEsistente, MainClass.StudentsCalendar
);
eventoEsistente = await request.ExecuteAsync();
}
if (eventoEsistente != null)
{
output.item = eventoEsistente.ToGoogleEvent();
output.state = Visual1993.Data.WebServiceV2.WebRequestState.Ok;
}
}
catch (Exception ex) {
output.state = Visual1993.Data.WebServiceV2.WebRequestState.GenericError;
output.errorMessage = ex.Message;
}
//manda la mail al Loft team
//prendi le info dell'utente per la mail
//var internalEvent = (await InternalEvent.getAllFromGoogleID(i.ID)).items.FirstOrDefault();
//if (internalEvent == null) { output.errorMessage = "Impossibile trovare l'evento correlato"; return JsonConvert.SerializeObject(output);}
var utente = (await User.GetOne(OwnerGuid)).items.FirstOrDefault();
if (utente == null)
{
output.errorMessage = "Impossibile trovare l'utente che ha inserito l'evento"; return(JsonConvert.SerializeObject(output));
}
try {
var msgStr = "<html><body>" +
"<p>Nome: " + i.Name + "</p>" +
"<p>Inizio: " + i.StartDate.ToString() + "</p>" +
"<p>Fine: " + i.EndDate.ToString() + "</p>" +
"<p>Owner: " + i.OwnerName + "</p>" +
"<p>Luogo: " + i.Luogo + "</p>" +
"<p>Descrizione: " + i.Description + "</p>" +
"<p><a href=\"" + MainClass.ExternalAccessBaseUri + MainClass.LoftPrefix + "event/" + i.InternalEventGuid + "/accept\">Accetta</a></p>" +
"<p><a href=\"" + MainClass.ExternalAccessBaseUri + MainClass.LoftPrefix + "event/" + i.InternalEventGuid + "/deny\">Rifiuta</a></p>" +
"</body></html>"
;
var mail = new MailRESTRequest {
From = utente?.data?.Email ?? null,
To = MainClass.StaffMail,
Cc = MainClass.StaffCcMail,
IsBodyHtml = true,
SmtpProvider = MailRESTRequest.SmtpProviderEnum.Luiss,
Body = msgStr,
Subject = "Prenotazione evento Loft"
};
var web = new Visual1993.Data.WebServiceV2();
var config = new WebServiceV2.UrlToStringConfiguration
{
url = MainClass.Visual1993RestServer + "visual1993/mail/send",
Type = WebServiceV2.UrlToStringConfiguration.RequestType.JsonRaw,
Verb = WebServiceV2.UrlToStringConfiguration.RequestVerb.POST,
RawContent = JsonConvert.SerializeObject(mail)
};
var res = await web.UrlToString(config);
var resAsObj = JsonConvert.DeserializeObject <WebServiceV2.DefaultResponse>(res);
if (resAsObj.state != WebServiceV2.WebRequestState.Ok)
{
output.errorMessage = "mail not sent. Error: " + resAsObj.errorMessage;
}
//ma non impostare lo stato a !=Ok perchè la richiesta in se è andata a buon fine
}
catch (Exception ex)
{
output.errorMessage = ex.Message;
}
return(JsonConvert.SerializeObject(output));
}