public void EventToActivityAsyncShouldThrowArgumentNullException()
{
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
Assert.Throws <ArgumentNullException>(() =>
{
SlackHelper.EventToActivity(null, slackApi.Object);
});
}
public async Task CommandToActivityAsyncShouldThrowArgumentNullException()
{
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await SlackHelper.CommandToActivityAsync(null, slackApi.Object, new CancellationToken()).ConfigureAwait(false);
});
}
public async Task WriteAsyncShouldFailWithNullEncoding()
{
var httpResponse = new Mock <HttpResponse>();
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await SlackHelper.WriteAsync(httpResponse.Object, HttpStatusCode.OK, "testText", null, new CancellationToken()).ConfigureAwait(false);
});
}
public async Task <ActionResult> Upload(
string title,
HttpPostedFileBase uploadImage,
string youTubeLink,
bool isNSFW)
{
if (string.IsNullOrEmpty(title))
{
throw new HttpException((int)HttpStatusCode.BadRequest, "Invalid input data!");
}
var post = DbContext.Posts.Create();
Image image = null;
if (uploadImage != null)
{
image = await ImagesHelper.SaveImageAsync(uploadImage, DbContext);
post.Image = image;
}
else
{
string html;
if (!YouTubeHelper.TryGetEmbedHtml(youTubeLink, out html))
{
throw new HttpException((int)HttpStatusCode.BadRequest, "Invalid input data!");
}
post.YouTubeLink = html;
}
var owner = DbContext.Users.First(u => u.UserName == User.Identity.Name);
if (string.IsNullOrEmpty(post.YouTubeLink) && image == null)
{
throw new HttpException((int)HttpStatusCode.InternalServerError, "Invalid input data!");
}
post.DateCreated = DateTime.Now;
post.Title = title;
post.Owner = owner;
post.IsNSFW = isNSFW;
post.Votes.Add(new Vote()
{
Type = VoteType.Up,
Voter = owner
});
var dbPost = DbContext.Posts.Add(post);
await DbContext.SaveChangesAsync();
// Don't await so we dont slow down the upload.
NotifySubscribedUsersForNewPost();
SlackHelper.SendNotification(dbPost, GetCurrentWebsiteRoot());
return(RedirectToAction("Index", "Home"));
}
public async Task EventToActivityAsyncShouldReturnActivity()
{
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
var payload = File.ReadAllText(Directory.GetCurrentDirectory() + @"/Files/MessageBody.json");
var slackBody = JsonConvert.DeserializeObject <SlackRequestBody>(payload);
var activity = await SlackHelper.EventToActivityAsync(slackBody.Event, slackApi.Object, new CancellationToken()).ConfigureAwait(false);
Assert.Equal(slackBody.Event.Text, activity.Text);
}
public void EventToActivityAsyncShouldReturnActivity()
{
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
var payload = File.ReadAllText(Directory.GetCurrentDirectory() + @"/Files/MessageBody.json");
var slackBody = JsonConvert.DeserializeObject <EventRequest>(payload);
var activity = SlackHelper.EventToActivity(slackBody, slackApi.Object);
Assert.Equal(slackBody.Event.AdditionalProperties["text"].ToString(), activity.Text);
}
public async Task CommandToActivityAsyncShouldReturnActivity()
{
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
var payload = File.ReadAllText(Directory.GetCurrentDirectory() + @"/Files/SlashCommandBody.txt");
var commandBody = SlackHelper.QueryStringToDictionary(payload);
var slackBody = JsonConvert.DeserializeObject <SlackRequestBody>(JsonConvert.SerializeObject(commandBody));
var activity = await SlackHelper.CommandToActivityAsync(slackBody, slackApi.Object, new CancellationToken()).ConfigureAwait(false);
Assert.Equal(slackBody.TriggerId, activity.Id);
}
public void CommandToActivityAsyncShouldReturnActivity()
{
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
var payload = File.ReadAllText(Directory.GetCurrentDirectory() + @"/Files/SlashCommandBody.txt");
var commandBody = SlackHelper.QueryStringToDictionary(payload);
var slackBody = JsonConvert.DeserializeObject <CommandPayload>(JsonConvert.SerializeObject(commandBody));
var activity = SlackHelper.CommandToActivity(slackBody, slackApi.Object);
Assert.Equal(slackBody.TriggerId, activity.Id);
}
public async Task EventToActivityAsyncShouldReturnActivityWithTeamId()
{
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
var payload = File.ReadAllText(Directory.GetCurrentDirectory() + @"/Files/MessageBody.json");
var slackBody = JsonConvert.DeserializeObject <EventRequest>(payload);
slackBody.Event.Channel = null;
var activity = await SlackHelper.EventToActivityAsync(slackBody, slackApi.Object, new CancellationToken()).ConfigureAwait(false);
Assert.Equal(slackBody.Event.AdditionalProperties["team"].ToString(), activity.Conversation.Id);
}
public static GymSearchListResponse searchByLocationImplementation(SearchGymRequest request)
{
var location = System.Data.Entity.Spatial.DbGeography.FromText(String.Format("POINT({0} {1})", request.longitude, request.latitude));
GymSearchListResponse rv;
using (var db = new UniversalGymEntities())
{
var searchRequest = new Data.SearchRequest
{
SearchDate = DateTime.Now,
Position = location,
UniqueDeviceIdentifier = request.uniqueDeviceId,
};
var user = db.Users.SingleOrDefault(a => a.CurrentToken == request.authToken && a.UserId == request.accountId);
if (user != null)
{
searchRequest.UserId = user.UserId;
}
db.SearchRequests.Add(searchRequest);
db.SaveChanges();
var searchText = "DeviceId: "
+ request.uniqueDeviceId
+ Environment.NewLine;
if (searchRequest.User != null)
{
searchText = searchText
+ "User: "
+ searchRequest.User.Email;
}
SlackHelper.sendSearchChannel(searchText, request.latitude.ToString(), request.longitude.ToString());
var gyms = db.Gyms.Where(w => w.Position != null).OrderBy(o => o.Position.Distance(location));
rv = GymSearchListHelper.createGymSearchListResponse(gyms, location.Latitude, location.Longitude);
if (user != null)
{
rv.credits = user.Credits;
}
else
{
rv.credits = 0;
}
}
return(rv);
}
private static async Task <IActionResult> DeleteProposal(IBinder binder, InteractiveMessagePayload payload, Proposal proposal)
{
var proposals = await binder.GetTable("proposals");
if (proposal != null)
{
// Bloquer la suppression d'une proposition plannifiée
if (!string.IsNullOrWhiteSpace(proposal.PlannedIn))
{
var plan = await binder.GetTableRow <Plan>("plans", payload.PartitionKey, proposal.PlannedIn);
if (plan != null)
{
return(Utils.Ok(new SlackMessage {
Text = $"Ce vidéo est déjà planifié pour le {plan.Date:dddd d MMMM}.",
Attachments = { MessageHelpers.GetRemoveMessageAttachment() }
}));
}
}
var result = await proposals.ExecuteAsync(TableOperation.Delete(proposal));
if (result.IsError())
{
await MessageHelpers.PostErrorMessage(binder, payload);
return(Utils.Ok());
}
// Notifier le owner si c'est pas lui qui supprime sa proposition
if (proposal.ProposedBy != payload.User.Id)
{
await SlackHelper.PostMessage(binder, payload.Team.Id, new PostMessageRequest {
Channel = proposal.ProposedBy,
Text = $"<@{payload.User.Id}> vient de supprimer votre proposition de vidéo dans <#{payload.Channel.Id}>:",
Attachments = { await MessageHelpers.GetProposalAttachment(binder, proposal, allowActions: false) }
});
}
}
// NOTE: Présentement la seule place qu'on peut supprimer une proposition c'est à partir de la liste de toutes les propositions.
// Si ça change, va falloir ajouter plus de logique ici pour recréer le bon type de message.
var allProposals = await ProposalHelpers.GetActiveProposals(proposals, payload.PartitionKey);
var message = await MessageHelpers.GetListMessage(binder, allProposals, payload.Channel.Id);
message.ReplaceOriginal = true;
return(Utils.Ok(message));
}
public void ActivityToSlackShouldConvertHeroCardsToBlocks()
{
var serializeConversation = File.ReadAllText(Directory.GetCurrentDirectory() + @"/Files/SlackActivity.json");
var card = new HeroCard
{
Title = "BotFramework Hero Card",
Subtitle = "Microsoft Bot Framework",
Text = "Build and connect intelligent bots to interact with your users naturally wherever they are," +
" from text/sms to Skype, Slack, Office 365 mail and other popular services.",
Images = new List <CardImage> {
new CardImage("https://sec.ch9.ms/ch9/7ff5/e07cfef0-aa3b-40bb-9baa-7c9ef8ff7ff5/buildreactionbotframework_960.jpg")
},
Buttons = new List <CardAction>
{
new CardAction(ActionTypes.OpenUrl, "OpenUrl", value: "https://docs.microsoft.com/bot-framework"),
new CardAction
{
Text = "Some Action Text",
DisplayText = "ImBack",
Title = "Some Action Title",
Value = "Some Action Value",
Type = ActionTypes.ImBack
}
},
};
var activity = new Activity
{
Timestamp = new DateTimeOffset(),
Text = "Hello!",
Conversation = JsonConvert.DeserializeObject <ConversationAccount>(serializeConversation),
Attachments = new List <Attachment>
{
card.ToAttachment()
}
};
var message = SlackHelper.ActivityToSlack(activity);
Assert.Equal(activity.Conversation.Id, message.Channel);
Assert.Equal(activity.Conversation.Properties["thread_ts"].ToString(), message.ThreadTs);
Assert.Equal(card.Title, (message.Blocks as JArray)[0]["text"]["text"]);
Assert.Equal(card.Subtitle, (message.Blocks as JArray)[1]["elements"][0]["text"]);
Assert.Equal(card.Images[0].Url, (message.Blocks as JArray)[2]["image_url"]);
Assert.Equal(card.Text, (message.Blocks as JArray)[3]["text"]["text"]);
Assert.Equal(card.Buttons[0].Value, (message.Blocks as JArray)[5]["elements"][0]["url"].ToString());
}
public static async Task PrepareVideoReminder(
[TimerTrigger("0 30 11 * * *")] TimerInfo timer, //11:30 daily
[Table("plans")] CloudTable plansTable,
IBinder binder)
{
Utils.SetCulture();
var plans = await GetTodayPlansWithVideoAndResponsible(plansTable);
foreach (var plan in plans)
{
var message = await MessageHelpers.GetPrepareVideoReminder(binder, plan);
await SlackHelper.PostMessage(binder, plan.Team, message);
}
}
public void EventToActivityAsyncShouldReturnActivityWithAttachmentsWhenFileSharing()
{
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
var payload = File.ReadAllText(Directory.GetCurrentDirectory() + @"/Files/MessageBodyWithFileShare.json");
var slackBody = JsonConvert.DeserializeObject <EventRequest>(payload);
var activity = SlackHelper.EventToActivity(slackBody, slackApi.Object);
Assert.Equal(ActivityTypes.Message, activity.Type);
Assert.Equal(slackBody.Event.Type, activity.Type);
Assert.Equal(slackBody.Event.AdditionalProperties["text"].ToString(), activity.Text);
Assert.Equal(slackBody.Event.AdditionalProperties["files"][0]["mimetype"].ToString(), activity.Attachments[0].ContentType);
Assert.Equal(slackBody.Event.AdditionalProperties["files"][0]["url_private_download"].ToString(), activity.Attachments[0].ContentUrl);
Assert.Equal(slackBody.Event.AdditionalProperties["files"][0]["name"].ToString(), activity.Attachments[0].Name);
}
public void ActivityToSlackShouldReturnMessageWithThreadTs()
{
var serializeConversation = File.ReadAllText(Directory.GetCurrentDirectory() + @"/Files/SlackActivity.json");
var activity = new Activity
{
Timestamp = new DateTimeOffset(),
Text = "Hello!",
Conversation = JsonConvert.DeserializeObject <ConversationAccount>(serializeConversation),
};
var message = SlackHelper.ActivityToSlack(activity);
Assert.Equal(activity.Conversation.Id, message.Channel);
Assert.Equal(activity.Conversation.Properties["thread_ts"].ToString(), message.ThreadTs);
}
public static async Task PlanResponsibleSecondReminder(
[TimerTrigger("0 15 11 * * *")] TimerInfo timer, // 11:15AM daily
[Table("plans")] CloudTable plansTable,
IBinder binder)
{
Utils.SetCulture();
var plans = await GetTodayPlansWithoutResponsible(plansTable);
foreach (var plan in plans)
{
await SlackHelper.PostMessage(binder, plan.Team, new PostMessageRequest {
Channel = plan.Channel,
Text = "<!channel> Rappel: Le Lunch & Watch de ce midi a besoin d'un responsable!",
Attachments = { await MessageHelpers.GetPlanAttachment(binder, plan) }
});
}
}
public void ActivityToSlackShouldReturnMessage()
{
var activity = new Activity
{
Timestamp = new DateTimeOffset(),
Text = "Hello!",
Attachments = new List <Attachment>
{
new Attachment(name: "image", thumbnailUrl: ImageUrl),
},
Conversation = new ConversationAccount(id: "testId"),
};
var message = SlackHelper.ActivityToSlack(activity);
Assert.Equal(activity.Conversation.Id, message.Channel);
Assert.Equal(activity.Attachments[0].Name, message.Attachments[0].AuthorName);
}
public static async Task PlanResponsibleFinalReminder(
[TimerTrigger("0 55 11 * * *")] TimerInfo timer, // 11:55AM daily
[Table("plans")] CloudTable plansTable,
IBinder binder)
{
Utils.SetCulture();
var plans = await GetTodayPlansWithoutResponsible(plansTable);
foreach (var plan in plans)
{
await SlackHelper.PostMessage(binder, plan.Team, new PostMessageRequest {
Channel = plan.Channel,
Text = "<!channel> *Dernier rappel*: Le Lunch & Watch de ce midi a besoin d'un responsable! Si personne ne se manifeste, l'événement sera annulé.",
Attachments = { await MessageHelpers.GetPlanAttachment(binder, plan) }
});
}
}
public static async Task <IActionResult> OnPropose(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "slack/commands/propose")] HttpRequest req,
IBinder binder, ExecutionContext context)
{
Utils.SetCulture();
var body = await SlackHelper.ReadSlackRequest(req, context);
var parameters = SlackHelper.ParseBody(body);
var dialogRequest = new OpenDialogRequest {
TriggerId = parameters["trigger_id"],
Dialog = DialogHelpers.GetProposeDialog(defaultName: parameters["text"])
};
await SlackHelper.OpenDialog(binder, parameters["team_id"], dialogRequest);
return(Utils.Ok());
}
private static async Task <IActionResult> ProcessDialogAction(IBinder binder, InteractiveMessagePayload payload)
{
var action = payload.Actions.First();
if (action.Name == "plan")
{
var dialogRequest = new OpenDialogRequest {
TriggerId = payload.TriggerId,
Dialog = await DialogHelpers.GetPlanDialog(binder, action.Value)
};
await SlackHelper.OpenDialog(binder, payload.Team.Id, dialogRequest);
}
// NOTE: Présentement toutes les dialog_actions suppriment le message original
return(Utils.Ok(new SlackMessage {
DeleteOriginal = true
}));
}
public int AddCredit(User toUser, User fromUser, int creditToAdd, int charged)
{
toUser.Credits += creditToAdd;
var item = new GiveCredit()
{
AmountToGiveNewUser = creditToAdd,
DateTime = DateTime.UtcNow,
UserIdToGiveCredits = toUser.UserId,
AmountCharged = charged,
};
if (fromUser != null)
{
item.UserIdWhoGiveCredits = fromUser.UserId;
// If we are giving a referal bonus eventually
//item.AmountToGiveReferer = 0;
}
Db.GiveCredits.Add(item);
Db.SaveChanges();
var giveCreditText = "Credit"
+ Environment.NewLine
+ "To: "
+ toUser.Email
+ Environment.NewLine;
if (fromUser != null)
{
giveCreditText = giveCreditText
+ "From: "
+ fromUser.Email
+ Environment.NewLine;
}
giveCreditText = giveCreditText
+ "$"
+ item.AmountToGiveNewUser;
SlackHelper.sendGiveCreditChannel(giveCreditText);
return(toUser.Credits);
}
public static async Task <IActionResult> OnList(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "slack/commands/list")] HttpRequest req,
[Table("proposals")] CloudTable proposalsTable,
IBinder binder, ExecutionContext context)
{
Utils.SetCulture();
var body = await SlackHelper.ReadSlackRequest(req, context);
var parameters = SlackHelper.ParseBody(body);
var team = parameters["team_id"];
var channel = parameters["channel_id"];
var allProposals = await ProposalHelpers.GetActiveProposals(proposalsTable, Utils.GetPartitionKey(team, channel));
var message = await MessageHelpers.GetListMessage(binder, allProposals, channel);
return(Utils.Ok(message));
}
static void Main(string[] args)
{
var arguments = LoadArguments(args);
switch (arguments.Option)
{
case ProgramOption.Help:
PrintHelp();
return;
case ProgramOption.Update:
case ProgramOption.Post:
var restaurantSettingses = JsonParser.ParseRestaurantSetting(arguments.JsonFilePath);
var slackSettings = JsonParser.ParseSlackSetting(arguments.SlackFilePath);
var menus = MenuParser.GetMenuFromMenicka(restaurantSettingses);
if (CheckMenu(menus) == false)
{
ScheduleUdate();
}
else
{
ScheduleEnd();
}
var slackHelper = new SlackHelper(slackSettings);
if (arguments.Option == ProgramOption.Post)
{
slackHelper.PostMenu(menus);
}
else
{
slackHelper.UpdateMenu(menus);
}
break;
}
}
public static async Task <IActionResult> OnPlan(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "slack/commands/plan")] HttpRequest req,
[Table("proposals")] CloudTable proposalsTable,
IBinder binder, ExecutionContext context)
{
Utils.SetCulture();
var body = await SlackHelper.ReadSlackRequest(req, context);
var parameters = SlackHelper.ParseBody(body);
var partitionKey = Utils.GetPartitionKey(parameters["team_id"], parameters["channel_id"]);
var dialogRequest = new OpenDialogRequest {
TriggerId = parameters["trigger_id"],
Dialog = await DialogHelpers.GetPlanDialog(binder, partitionKey, defaultDate : parameters["text"])
};
await SlackHelper.OpenDialog(binder, parameters["team_id"], dialogRequest);
return(Utils.Ok());
}
public void ActivityToSlackShouldReturnMessageFromChannelData()
{
const string messageText = "Hello from message";
var activity = new Activity
{
Timestamp = new DateTimeOffset(),
Text = "Hello!",
Recipient = new ChannelAccount("testRecipientId"),
ChannelData = new NewSlackMessage
{
Text = messageText,
Ephemeral = "testEphemeral"
},
Conversation = new ConversationAccount(id: "testId"),
};
var message = SlackHelper.ActivityToSlack(activity);
Assert.Equal(messageText, message.Text);
}
public static async Task <IActionResult> InstallCallback(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "install")] HttpRequest req,
[Table("teams")] CloudTable teamsTable,
ExecutionContext context)
{
if (!req.GetQueryParameterDictionary().TryGetValue("code", out var code))
{
return(new ContentResult {
Content = "Something went wrong: no code",
StatusCode = 400
});
}
var accessTokenResponse = await SlackHelper.RequestAccessToken(code, context);
var team = new Team(accessTokenResponse.TeamId, accessTokenResponse.AccessToken);
await teamsTable.ExecuteAsync(TableOperation.InsertOrReplace(team));
return(new ContentResult {
Content = "All set!"
});
}
public static async Task CompletePlans(
[TimerTrigger("0 0 13 * * *")] TimerInfo timer, // 1:00PM daily
[Table("plans")] CloudTable plansTable,
[Table("proposals")] CloudTable proposalsTable,
IBinder binder)
{
Utils.SetCulture();
var plans = await GetTodayPlansWithVideoAndResponsible(plansTable);
foreach (var plan in plans)
{
var proposal = await proposalsTable.Retrieve <Proposal>(plan.PartitionKey, plan.Video);
proposal.Complete = true;
await proposalsTable.ExecuteAsync(TableOperation.Replace(proposal));
await SlackHelper.PostMessage(binder, plan.Team, new PostMessageRequest {
Channel = plan.Owner,
Text = $"Avez-vous terminé l'écoute du vidéo _{proposal.Name}_?\nSi vous choisissez Non, alors le vidéo sera automatiquement re-proposé pour le continuer plus tard.",
Attachments =
{
new MessageAttachment {
CallbackId = "proposal_action",
Actions = new List <MessageAction> {
new MessageAction {
Type = "button", Text = "Oui, le vidéo est terminé", Name = "done", Value = $"{plan.PartitionKey}/{plan.Video}"
},
new MessageAction {
Type = "button", Text = "Non, pas encore", Name = "incomplete", Value = $"{plan.PartitionKey}/{plan.Video}"
}
}
}
}
});
await binder.RecordChannelActivity(proposal.Team, proposal.Channel);
}
}
public async Task Run(
[TimerTrigger(scheduleExpression)] TimerInfo myTimer,
[Table(Constants.Repositories.TableName)] CloudTable table,
ILogger log)
{
var version = Assembly.GetExecutingAssembly().GetCustomAttribute <AssemblyInformationalVersionAttribute>().InformationalVersion;
var github = new GitHubClient(new ProductHeaderValue($"{typeof(NewReleaseCheck).GetType().Namespace}", version));
TableContinuationToken token = null;
var repositoriesToCheck = new List <RepositoryEntity>();
do
{
var queryResult = await table.ExecuteQuerySegmentedAsync(new TableQuery <RepositoryEntity>(), token);
repositoriesToCheck.AddRange(queryResult.Results);
token = queryResult.ContinuationToken;
} while (token != null);
foreach (var repositoryToCheck in repositoriesToCheck)
{
var sourceRepository = $"{repositoryToCheck.Owner}/{repositoryToCheck.Name}";
log.LogInformation($"Checking for new release in {sourceRepository}...");
var latestSourceRelease = await github.Repository.Release.GetLatest(repositoryToCheck.Owner, repositoryToCheck.Name);
if (repositoryToCheck.LastUpdated == null || repositoryToCheck.LastUpdated < latestSourceRelease.PublishedAt)
{
await SlackHelper.SendReleaseNotification($"New release {latestSourceRelease.Name} in {sourceRepository} was found.", log);
repositoryToCheck.LastUpdated = DateTime.UtcNow;
await table.ExecuteAsync(TableOperation.Replace(repositoryToCheck));
continue;
}
log.LogInformation($"No new release in {sourceRepository} was found. Next check will be at {myTimer.Schedule.GetNextOccurrence(DateTime.Now)}", log);
}
}
public static BasicResponse contactFormImplementation(ContactFormRequest request)
{
if (String.IsNullOrWhiteSpace(request.email))
{
return(new BasicResponse {
message = "Please enter an email", status = 200, success = false
});
}
else if (String.IsNullOrWhiteSpace(request.name))
{
return(new BasicResponse {
message = "Please enter a name", status = 200, success = false
});
}
else if (String.IsNullOrWhiteSpace(request.message))
{
return(new BasicResponse {
message = "Please enter a message.", status = 200, success = false
});
}
var contactFormBody = "Name: "
+ request.name
+ Environment.NewLine
+ "Email: "
+ request.email
+ Environment.NewLine
+ "Message: "
+ request.message;
SlackHelper.sendSupportChannel(contactFormBody);
EmailNoTemplateHelper.SendEmail("Pedal Contact", "*****@*****.**", contactFormBody);
EmailTemplateHelper.SendEmail("Pedal Contact", request.email, Constants.PedalWebUrl, request.name, "contact_form.html", request.message);
return(new BasicResponse {
message = "Success", status = 200, success = true
});
}
public static async Task CancelOrphanPlans(
[TimerTrigger("0 05 12 * * *")] TimerInfo timer, // 12:05AM daily
[Table("plans")] CloudTable plansTable,
[Table("proposals")] CloudTable proposalsTable,
IBinder binder)
{
Utils.SetCulture();
var plans = await GetTodayPlansWithoutResponsible(plansTable);
foreach (var plan in plans)
{
if (!string.IsNullOrWhiteSpace(plan.Video))
{
var proposal = await proposalsTable.Retrieve <Proposal>(plan.PartitionKey, plan.Video);
if (proposal != null)
{
proposal.PlannedIn = "";
await proposalsTable.ExecuteAsync(TableOperation.Replace(proposal));
}
}
var result = await plansTable.ExecuteAsync(TableOperation.Delete(plan));
if (result.IsError())
{
continue;
}
await SlackHelper.PostMessage(binder, plan.Team, new PostMessageRequest {
Channel = plan.Channel,
Text = "Le Lunch & Watch de ce midi a été annulé car aucun responsable ne s'est manifesté."
});
}
}