public GetRemindersCommand(DiscordClient client, IDatabase db, ReminderService reminderSvc, IEventLogger logger)
{
_client = client;
_db = db;
ReminderSvc = reminderSvc;
_logger = logger;
}
static void Main(string[] args)
{
Console.WriteLine("[Reminder Notifier] starting...");
var storage = new ReminderStorage();
var service = new ReminderService(storage);
service.ItemNotified += OnReminderItemFired;
service.Create(
new CreateReminderModel(
"ContactId",
"First",
DateTimeOffset.UtcNow.AddSeconds(3)
)
);
service.Create(
new CreateReminderModel(
"ContactId",
"Second",
DateTimeOffset.UtcNow.AddMinutes(1)
)
);
Console.ReadKey();
}
public ActionResult NewEmployeeReminder(EmployeeRemindersViewModel reminder)
{
List <string> Errors = new List <string>();
bool isvalid = false;
if (ModelState.IsValid)
{
reminder.CreatedOn = DateTime.Now;
reminder.CreatedBy = 1;
ReminderService.Create(reminder);
//GridRouteValues() is an extension method which returns the
//route values defining the grid state - current page, sort expression, filter etc.
RouteValueDictionary routeValues = this.GridRouteValues();
return(RedirectToAction("Index", routeValues));
}
else
{
foreach (ModelState modelState in ViewData.ModelState.Values)
{
foreach (ModelError error in modelState.Errors)
{
Errors.Add(error.ErrorMessage);
}
}
}
//TempData["isvalid"] = isvalid;
return(View());
}
public async Task Remind(int seconds, [Remainder] string remindMsg)
{
await Context.Channel.SendMessageAsync(
$"Ok, I will send you the message '{remindMsg}' in {seconds} seconds.");
await ReminderService.RemindAsyncSeconds(Context.User, seconds, remindMsg);
}
public PagedResult <ReminderItemDTO> GetReminders(Token token, GetRemindersParam remindersParam, PartialRetrievingInfo pageInfo)
{
var securityInfo = SecurityManager.EnsureAuthentication(token);
var service = new ReminderService(Session, securityInfo, Configuration);
return(service.GetReminders(remindersParam, pageInfo));
}
public ZmanimJobScheduler(string name, DateTime dateToStart, ReminderService reminderService, Account account)
{
Name = name;
DateToStart = dateToStart;
ReminderService = reminderService;
Account = account;
}
static void Main(string[] args)
{
WriteLine("Reminder", "enter the Telegram API key");
var key = Console.ReadLine();
var client = new HttpClient
{
BaseAddress = new Uri("https://localhost:5001")
};
using var service = new ReminderService(
storage: new ReminderStorage(client),
sender: new ReminderSender(key),
receiver: new ReminderReceiver(key),
parameters: ReminderServiceParameters.Default
);
service.ReminderSent += OnReminderSent;
service.ReminderFailed += OnReminderFailed;
WriteLine("Reminder", "starting");
service.Start();
WriteLine("Reminder", "started. Press any key to stop application");
Console.ReadKey();
WriteLine("Reminder", "stopped");
}
internal ActorRuntime(IActorSystem system, ActorEndpoint endpoint)
{
System = system;
Timers = new TimerService(endpoint);
Reminders = new ReminderService(endpoint);
Activation = new ActivationService(endpoint);
}
public async Task Start()
{
DS = new DataService();
LS = new LogService();
_ = LS.WriteAsync("Starting StatusBot...", ConsoleColor.DarkGreen);
client = new DiscordSocketClient(new DiscordSocketConfig
{
LogLevel = LogSeverity.Verbose,
AlwaysDownloadUsers = true,
DefaultRetryMode = RetryMode.AlwaysRetry
});
TS = new TimerService(client);
RS = new ReminderService(client, TS, DS, LS);
ES = new EventService(client, LS, DS, RS);
client.Log += ES.Log;
var serviceprovider = ConfigureServices();
string token = File.ReadAllText("token.txt");
var time = Stopwatch.StartNew();
await client.LoginAsync(TokenType.Bot, token);
await client.StartAsync();
time.Stop();
_ = LS.WriteAsync($"Connected in {time.Elapsed.TotalSeconds.ToString("F3")} seconds", ConsoleColor.DarkGreen);
handler = new CommandHandler(serviceprovider);
await handler.ConfigureAsync();
client.MessageReceived += ES.MessageReceived;
client.Connected += ES.AutoSetGame;
client.GuildMemberUpdated += ES.UserStatusHandler;
// Block this program until it is closed.
await Task.Delay(-1);
}
public ActionResult NewGeneralReminder(GeneralRemindersViewModel reminder)
{
try
{
if (ModelState.IsValid)
{
//The model is valid - insert the reminder and redisplay the grid.
reminder.CreatedOn = DateTime.Now;
reminder.CreatedBy = 1;
ReminderService.Create(reminder);
//GridRouteValues() is an extension method which returns the
//route values defining the grid state - current page, sort expression, filter etc.
RouteValueDictionary routeValues = this.GridRouteValues();
return(RedirectToAction("Index", routeValues));
}
//The model is invalid - render the current view to show any validation errors
return(View());
}
catch (Exception ex)
{
throw ex;
}
}
public async Task ExecuteLoadWorkshoCommandAsync()
{
if (IsBusy)
{
return;
}
try
{
IsBusy = true;
IsReminderSet = await ReminderService.HasReminderAsync(SelectedWorkshop.Id);
SelectedWorkshop.FeedbackLeft = await StoreManager.FeedbackStore.LeftFeedback(SelectedWorkshop);
}
catch (Exception ex)
{
Logger.Log($"{ex.Message}, Method, ExecuteLoadWorkshopCommandAsync", Prism.Logging.Category.Info, Priority.None);
EventAggregator.GetEvent <ErrorEvent>().Publish(ex);
}
finally
{
IsBusy = false;
}
}
public ReminderItemDTO ReminderOperation(Token token, ReminderOperationParam remindersParam)
{
var securityInfo = SecurityManager.EnsureAuthentication(token);
var service = new ReminderService(Session, securityInfo, Configuration);
return(service.ReminderOperation(remindersParam));
}
public async Task <RuntimeResult> ListRemindersAsync()
{
var entries = UserRepository.GetReminders(Context.User)
.OrderBy(x => x.Time);
if (!entries.Any())
{
return(CommandRuntimeResult.FromError("You do not have a reminder set yet!"));
}
var sb = new StringBuilder();
var embed = ReminderService.GetReminderEmbed("");
var userTimeOffset = GetUserTimeOffset(Context.User);
if (userTimeOffset > TimeSpan.Zero)
{
embed.WithFooter(x => x.Text = $"Converted to {Context.User.GetFullnameOrDefault()}'s timezone.");
}
foreach (var entry in entries)
{
var time = entry.Time.ToOffset(userTimeOffset);
sb.AppendLine($"**{time} ({entry.Time.Humanize()})**");
string channelname = Context.Guild.GetChannel(entry.ChannelId)?.Name ?? "Unknown Channel";
sb.AppendLine($@" '{entry.Content}' at #{channelname}");
sb.AppendLine();
}
await ReplyAsync("", embed : embed.WithDescription(sb.ToString()).Build()).ConfigureAwait(false);
return(CommandRuntimeResult.FromSuccess());
}
public ZmanimJobScheduler(string name, DateTime dateToStart, ReminderService reminderService, Account account)
{
Name = name;
DateToStart = dateToStart;
ReminderService = reminderService;
Account = account;
}
public ReminderItemDTO SaveReminder(Token token, ReminderItemDTO reminder)
{
var securityInfo = SecurityManager.EnsureAuthentication(token);
var service = new ReminderService(Session, securityInfo, Configuration);
return(service.SaveReminder(reminder));
}
public PlanEvent
(
IDataAccess dataAccess,
IDiscordBotService discordBot,
IGitHubFileReader fileReader,
IPlanZoomMeeting planZoomMeeting,
EmailContentBuilder emailBuilder,
NewsletterHtmlBuilder htmlBuilder,
ReminderService reminderService,
LinkShortenerService linkShortenerService,
LinkShortenerSettings linkShortenerSettings,
ILogger <PlanEvent> logger
)
{
this.fileReader = fileReader;
this.dataAccess = dataAccess;
this.planZoomMeeting = planZoomMeeting;
this.htmlBuilder = htmlBuilder;
_reminderService = reminderService;
_linkShortenerService = linkShortenerService;
_linkShortenerSettings = linkShortenerSettings;
_logger = logger;
this.emailBuilder = emailBuilder;
this.discordBot = discordBot;
}
async Task ExecuteReminderCommandAsync()
{
if (!IsReminderSet)
{
var result = await ReminderService.AddReminderAsync(SelectedWorkshop.Id,
new Plugin.Calendars.Abstractions.CalendarEvent
{
AllDay = false,
Description = SelectedWorkshop.Abstract,
Location = SelectedWorkshop.Room?.Name ?? string.Empty,
Name = SelectedWorkshop.Title,
Start = SelectedWorkshop.StartTime.Value,
End = SelectedWorkshop.EndTime.Value
});
if (!result)
{
return;
}
Logger.Log($"{DevopenspaceLoggerKeys.ReminderAdded}, Title, {SelectedWorkshop.Title}", Prism.Logging.Category.Info, Priority.None);
IsReminderSet = true;
}
else
{
var result = await ReminderService.RemoveReminderAsync(SelectedWorkshop.Id);
if (!result)
{
return;
}
Logger.Log($"{DevopenspaceLoggerKeys.ReminderRemoved}, Title, {SelectedWorkshop.Title}", Prism.Logging.Category.Info, Priority.None);
IsReminderSet = false;
}
}
public ReminderServiceTests()
{
_messagingService = Substitute.For <IMessagingService>();
_reminderRepository = Substitute.For <IRepository <Reminder> >();
_contactRepository = Substitute.For <IContactRepository>();
_sut = new ReminderService(_messagingService, _reminderRepository, _contactRepository);
}
public void WhenItemSent_IfTimeDifferent_ShouldRaiseEvent()
{
// Arrange
var time = new DateTimeOffset(2021, 01, 18, 03, 40, 00, new TimeSpan(+3, 0, 0));
var timeNow = DateTimeOffset.Now;
var item = new ReminderItem(Guid.NewGuid(), "ContactId", "Mesage", DateTimeOffset.Now, ReminderItemStatus.Created);
var item2 = new ReminderItem(Guid.NewGuid(), "ContactId", "Mesage", time, ReminderItemStatus.Created);
var eventRaised = false;
var eventRaised2 = false;
var receiver = new ReminderReceiverFake();
var service = new ReminderService(new ReminderStorage(item), SuccessSender, receiver, Parameters);
var service2 = new ReminderService(new ReminderStorage(item2), SuccessSender, receiver, Parameters);
// Act
service.ItemSent += (sender, args) => eventRaised = true;
if (timeNow > time)
{
service2.ItemSent += (sender, args) => eventRaised2 = true;
}
else
{
service2.ItemSent += (sender, args) => eventRaised2 = false;
}
service.Start();
service2.Start();
receiver.Emit();
WaitTimers();
// Assert
Assert.AreNotEqual(eventRaised, eventRaised2);
}
public void WhenItemsSent_IfAddTwoItemsWithDifferentStatus_ShouldRaiseEvent()
{
// Arrange
var item = new ReminderItem(Guid.NewGuid(), "ContactId", "Mesage", DateTimeOffset.Now, ReminderItemStatus.Ready);
var item2 = new ReminderItem(Guid.NewGuid(), "ContactId", "Mesage", DateTimeOffset.Now, ReminderItemStatus.Created);
var eventRaised = false;
var receiver = new ReminderReceiverFake();
var service = new ReminderService(new ReminderStorage(item), SuccessSender, receiver, Parameters);
var service2 = new ReminderService(new ReminderStorage(item2), SuccessSender, receiver, Parameters);
// Act
service.ItemSent += (sender, args) => eventRaised = true;
service2.ItemSent += (sender, args) => eventRaised = true;
service.Start();
service2.Start();
receiver.Emit();
WaitTimers();
// Assert
for (int i = 0; i < 2; i++)
{
Assert.IsTrue(eventRaised);
}
}
public JsonResult FetchEmail(int ID, int?ReminderID)
{
var Email = ReminderService.GetEmail(ID);
var used = ReminderService.CheckUsedEmployee(ID, ReminderID);
//return an object
return(Json(new { Email = Email, CanBeUsed = !used }, JsonRequestBehavior.AllowGet));
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
var services = app.ApplicationServices;
ReminderService reminder = services.GetService(typeof(IReminderRequest)) as ReminderService;
IReminderResponseService responseReminder = services.GetService(typeof(IReminderResponseService)) as IReminderResponseService;
reminder.AddResponses(responseReminder);
}
public ActionResult NewGeneralReminder()
{
GeneralRemindersViewModel obj = new GeneralRemindersViewModel();
obj.Groups = ReminderService.GetGroups();
return(View(obj));
}
public void Configuration(IAppBuilder app)
{
GlobalConfiguration.Configuration.UseSqlServerStorage(@"Server=FRKDRGT;Database=TodoApp;Integrated Security=true");
app.UseHangfireDashboard();
app.UseHangfireServer();
ReminderService service = new ReminderService();
RecurringJob.AddOrUpdate(() => service.NotifySend(), Cron.Minutely());
}
private void DoAdd()
{
if (SelectedSearch != null &&
StartDate.HasValue)
{
DateTime reminderTime = StartDate.Value.AddMinutes(-1 * Minutes);
ReminderService.CreateReminder(SelectedSearch, Index, StartDate.Value, Spoor, reminderTime);
}
}
public void Run(int userId, int taskId, int interval = 60)
{
ValidateForFeature();
var reminderService = new ReminderService(interval);
Task.Run(() =>
reminderService.SubsribeAndRun(() => Notify(userId, taskId)),
reminderService.Reminder.CancellationTokenSource.Token);
_services.AddOrUpdate(taskId, (c) => reminderService, (c, d) => reminderService);
}
public async Task RemindMe(
[Summary("The time until I should remind you, format: 0d:0h:0m:0s")]
Timediff time,
[Summary("The text you want to get reminded of")][Remainder]
string text)
{
try
{
var user = Context.User as IGuildUser;
if (user == null)
{
await ReplyAsync("You can't set reminders in DM!");
return;
}
int maxDays = Information.MaximumRemindDays;
if (time.Days > maxDays)
{
await ReplyAsync(
$"Sorry I'm not allowing you to set a reminder for anything longer than {maxDays} days..");
return;
}
await ReminderService.AddReminder(Context.User, text, DateTime.Now + time.Span, Context.Guild);
ConsoleHelper.Log(
$"{Helper.GetName(Context.User)} set a reminder for {DateTime.Now + time.Span:dd.MM.yyyy HH:mm}!",
LogSeverity.Info);
//Don't say Day when it's the same day
string when;
if ((DateTime.Now + time.Span).DayOfYear == DateTime.Now.DayOfYear)
{
when = (DateTime.Now + time.Span).ToString("HH:mm");
}
else
{
when = (DateTime.Now + time.Span).ToString("dd.MM.yyyy HH:mm");
}
await ReplyAsync(
$"All set {Helper.GetName(Context.User)}, I'll remind you at **{when}**!");
} catch (MaximumRemindersException)
{
await ReplyAsync($"You can't have more than {Information.MaximumReminders} reminders simultaneously!");
} catch (Exception ex)
{
await ReplyAsync("Whoops, unfortunately I couldn't set that reminder.. :confused:");
ConsoleHelper.Log($"Error setting reminder for {Helper.GetName(Context.User)} at " +
$"{DateTime.Now + time.Span:yyyyMMddHHmm}! ({ex.Message})", LogSeverity.Error);
}
}
public ActionResult NewEmployeeReminder()
{
//TempData["isvalid"] = true;
EmployeeRemindersViewModel obj = new EmployeeRemindersViewModel();
obj.Positions = ReminderService.GetPositions();
obj.Employees = ReminderService.GetEmployees();
obj.Groups = ReminderService.GetGroups();
return(View(obj));
}
public AppointmentListForm(IFormManager formManager, AppointmentService appointmentService, ReminderService reminderService)
{
_formManager = formManager;
this.appointmentService = appointmentService;
this.reminderService = reminderService;
appointments = appointmentService.FindAllAggregates();
InitializeComponent();
appointmentBindingSource = new BindingSource();
initBindingSource(appointments);
appointmentGridView.DataSource = appointmentBindingSource;
}
public static Task GuildAvailable(SocketGuild guild)
{
try
{
ReminderService.Init(guild);
} catch (Exception ex)
{
ConsoleHelper.Log($"Could not init Guild's reminders! ({ex.Message})", LogSeverity.Error);
}
return(Task.CompletedTask);
}
public static IServiceProvider RegisterResponsesReminder(this IServiceProvider services)
{
ReminderService reminder = services.GetService(typeof(IReminderRequest)) as ReminderService;
//ReminderConfiguration configuration = services.GetService(typeof(ReminderConfiguration)) as ReminderConfiguration;
IFactoryBroker factory = services.GetService(typeof(IFactoryBroker)) as IFactoryBroker;
reminder.AddResponses(
new ReminderResponseBroker(factory)
);
return(services);
}
public void DeleteReminderShouldThrowException()
{
var mockRepo = new Mock <IReminderRepository>();
int Id = 2;
mockRepo.Setup(repo => repo.DeletReminder(Id)).Returns(false);
var service = new ReminderService(mockRepo.Object);
var actual = Assert.Throws <ReminderNotFoundException>(() => service.DeletReminder(Id));
Assert.Equal($"Reminder with id: {Id} does not exist", actual.Message);
}
