def test_get_long_reminders(database, reddit):
utils.debug_time = utils.parse_datetime_string("2019-01-01 12:00:00")
user = database.get_or_add_user("Watchful1")
requested_date = utils.parse_datetime_string("2019-01-01 04:00:00")
target_date = utils.parse_datetime_string("2019-01-01 04:00:00")
for i in range(60):
database.add_reminder(
Reminder(source=f"https://www.reddit.com/message/messages/XXX{i}",
message=f"{i}" * 50,
user=user,
requested_date=requested_date,
target_date=target_date + timedelta(days=1)))
message = reddit_test.RedditObject(body="MyReminders!", author="Watchful1")
messages.process_message(message, reddit, database)
assert len(message.children) == 3
assert "Click here to delete all your reminders" in message.children[
0].body
assert "Click here to delete all your reminders" not in message.children[
1].body
assert "Click here to delete all your reminders" not in message.children[
2].body
assert "|Source|Message|Date|In|Remove|" in message.children[0].body
assert "|Source|Message|Date|In|Remove|" in message.children[1].body
assert "|Source|Message|Date|In|Remove|" in message.children[2].body
assert "[^(Info)]" not in message.children[0].body
assert "[^(Info)]" not in message.children[1].body
assert "[^(Info)]" in message.children[2].body
def get_reminder(self, reminder_id):
log.debug(f"Fetching reminder by id: {reminder_id}")
c = self.dbConn.cursor()
c.execute(
'''
SELECT rm.ID, rm.Source, rm.RequestedDate, rm.TargetDate, rm.Message, rm.User, rm.Defaulted, us.TimeZone
FROM reminders rm
LEFT JOIN user_settings us
ON us.User = rm.User
WHERE rm.ID = ?
''', (reminder_id, ))
result = c.fetchone()
if result is None or len(result) == 0:
log.debug("Reminder not found")
return None
reminder = Reminder(source=result[1],
target_date=utils.parse_datetime_string(result[3]),
message=result[4],
user=result[5],
db_id=result[0],
requested_date=utils.parse_datetime_string(
result[2]),
defaulted=result[6] == 1,
timezone=result[7])
return reminder
def test_send_recurring_reminder_limit(database, reddit):
old_limit = static.RECURRING_LIMIT
static.RECURRING_LIMIT = 3
reminder = Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message="KKKKK",
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-05 05:00:00"),
recurrence="one day")
database.add_reminder(reminder)
utils.debug_time = utils.parse_datetime_string("2019-01-04 12:00:00")
for i in range(static.RECURRING_LIMIT + 1):
utils.debug_time = utils.debug_time + timedelta(days=1)
notifications.send_reminders(reddit, database)
assert "I've sent you at least" not in reddit.sent_messages[-1].body
assert i + 1 == database.get_or_add_user("Watchful1").recurring_sent
utils.debug_time = utils.debug_time + timedelta(days=1)
notifications.send_reminders(reddit, database)
assert "I've sent you at least" in reddit.sent_messages[-1].body
reminders = database.get_all_user_reminders("Watchful1")
assert len(reminders) == 0
static.RECURRING_LIMIT = old_limit
def test_send_recurring_reminder(database, reddit):
reminder = Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message="KKKKK",
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-05 05:00:00"),
recurrence="one day")
database.add_reminder(reminder)
utils.debug_time = utils.parse_datetime_string("2019-01-05 12:00:00")
notifications.send_reminders(reddit, database)
assert len(reddit.sent_messages) == 1
message_body = reddit.sent_messages[0].body
assert "I'm here to remind you" in message_body
assert reminder.message in message_body
assert "The source comment or message" in message_body
assert reminder.source in message_body
assert "This is a repeating reminder. I'll message you again in " in message_body
assert reminder.recurrence in message_body
reminders = database.get_all_user_reminders("Watchful1")
assert len(reminders) == 1
assert reminders[0].target_date == utils.parse_datetime_string(
"2019-01-06 05:00:00")
def get_pending_reminders(self, count, timestamp):
log.debug("Fetching pending reminders")
c = self.dbConn.cursor()
results = []
for row in c.execute(
'''
SELECT rm.ID, rm.Source, rm.RequestedDate, rm.TargetDate, rm.Message, rm.User, rm.Defaulted, us.TimeZone
FROM reminders rm
LEFT JOIN user_settings us
ON us.User = rm.User
WHERE rm.TargetDate < ?
ORDER BY rm.TargetDate
LIMIT ?
''', (utils.get_datetime_string(timestamp), count)):
reminder = Reminder(
source=row[1],
target_date=utils.parse_datetime_string(row[3]),
message=row[4],
user=row[5],
db_id=row[0],
requested_date=utils.parse_datetime_string(row[2]),
defaulted=row[6] == 1,
timezone=row[7])
results.append(reminder)
log.debug(f"Found reminders: {len(results)}")
return results
def database_get_seen(database):
result = database.get_keystore("comment_timestamp")
if result is None:
log.warning("Comment time not in database, returning now")
now = utils.datetime_now()
database_set_seen(database, now)
return now
return utils.parse_datetime_string(result)
def test_remove_all_reminders(database, reddit):
utils.debug_time = utils.parse_datetime_string("2019-01-01 12:00:00")
message = reddit_test.RedditObject(body=f"RemoveAll!", author="Watchful1")
messages.process_message(message, reddit, database)
assert "Deleted" not in message.get_first_child().body
reminder1 = Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message="KKKKK",
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-04 05:00:00"))
reminder2 = Reminder(
source="https://www.reddit.com/message/messages/YYYYY",
message="FFFFF",
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-02-02 06:00:00"),
target_date=utils.parse_datetime_string("2019-02-05 07:00:00"))
reminder3 = Reminder(
source="https://www.reddit.com/message/messages/ZZZZZ",
message="JJJJJ",
user=database.get_or_add_user("Watchful2"),
requested_date=utils.parse_datetime_string("2019-03-02 06:00:00"),
target_date=utils.parse_datetime_string("2019-03-05 07:00:00"))
database.add_reminder(reminder1)
database.add_reminder(reminder2)
database.add_reminder(reminder3)
message = reddit_test.RedditObject(body=f"RemoveAll!", author="Watchful1")
messages.process_message(message, reddit, database)
body = message.get_first_child().body
assert "Deleted **2** reminders." in body
assert len(database.get_all_user_reminders("Watchful1")) == 0
assert len(database.get_all_user_reminders("Watchful2")) == 1
def test_add_cakeday(database, reddit):
username = "******"
created = utils.parse_datetime_string("2015-05-05 15:25:17")
user = reddit_test.User(username, created.timestamp())
message = reddit_test.RedditObject(body="Cakeday!", author=user)
utils.debug_time = utils.parse_datetime_string("2019-01-05 12:00:00")
messages.process_message(message, reddit, database)
result = message.get_first_child().body
assert "to remind you of your cakeday" in result
cakeday = database.get_cakeday(username)
assert cakeday is not None
assert cakeday.user == username
assert cakeday.date_time == utils.parse_datetime_string(
"2019-05-05 15:25:17")
assert cakeday.db_id is not None
def test_reset_recurring_reminder_limit(database, reddit):
reminder = Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message="KKKKK",
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-05 05:00:00"),
recurrence="one day")
database.add_reminder(reminder)
utils.debug_time = utils.parse_datetime_string("2019-01-05 12:00:00")
notifications.send_reminders(reddit, database)
assert database.get_or_add_user("Watchful1").recurring_sent == 1
message = reddit_test.RedditObject(body="MyReminders!", author="Watchful1")
messages.process_message(message, reddit, database)
assert database.get_or_add_user("Watchful1").recurring_sent == 0
def test_send_reminder(database, reddit):
reminder = Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message="KKKKK",
user="******",
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-05 05:00:00")
)
database.save_reminder(reminder)
utils.debug_time = utils.parse_datetime_string("2019-01-05 12:00:00")
notifications.send_reminders(reddit, database)
assert len(reddit.sent_messages) == 1
message_body = reddit.sent_messages[0].body
assert "I'm here to remind you" in message_body
assert reminder.message in message_body
assert "The source comment or message" in message_body
assert reminder.source in message_body
def test_add_cakeday(database, reddit):
username = "******"
created = utils.parse_datetime_string("2015-05-05 15:25:17")
user = reddit_test.User(username, created.timestamp())
message = reddit_test.RedditObject(body="Cakeday!", author=user)
utils.debug_time = utils.parse_datetime_string("2019-01-05 12:00:00")
messages.process_message(message, reddit, database)
result = message.get_first_child().body
assert "to remind you of your cakeday" in result
reminders = database.get_all_user_reminders(username)
assert len(reminders) == 1
assert reminders[0].user.name == username
assert reminders[0].target_date == utils.parse_datetime_string(
"2019-05-05 15:25:17")
assert reminders[0].id is not None
assert reminders[0].recurrence == "1 year"
assert reminders[0].message == "Happy Cakeday!"
def test_get_reminders(database, reddit):
utils.debug_time = utils.parse_datetime_string("2019-01-01 12:00:00")
message = reddit_test.RedditObject(body="MyReminders!", author="Watchful1")
messages.process_message(message, reddit, database)
result = message.get_first_child().body
assert "You don't have any reminders." in result
reminders = [
Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message="KKKKK",
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-04 05:00:00")),
Reminder(
source="https://www.reddit.com/message/messages/YYYYY",
message="FFFFF",
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-02-02 06:00:00"),
target_date=utils.parse_datetime_string("2019-02-05 07:00:00")),
Reminder(
source="https://www.reddit.com/message/messages/ZZZZZ",
message="GGGGG",
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-02-02 06:00:00"),
target_date=utils.parse_datetime_string("2019-02-05 07:00:00"),
recurrence="one day")
]
for reminder in reminders:
database.add_reminder(reminder)
message = reddit_test.RedditObject(body="MyReminders!", author="Watchful1")
messages.process_message(message, reddit, database)
result = message.get_first_child().body
assert "Click here to delete all your reminders" in result
assert "|Source|Message|Date|In|Repeat|Remove|" in result
assert "|Source|Message|Date|In|Remove|" in result
assert reminders[0].source in result
assert reminders[0].message in result
assert "01-04 05" in result
assert reminders[1].source in result
assert reminders[1].message in result
assert "02-05 07" in result
assert reminders[2].recurrence in result
user = database.get_or_add_user(user_name="Watchful1")
user.timezone = "America/Los_Angeles"
messages.process_message(message, reddit, database)
result = message.get_last_child().body
assert "Your timezone is currently set to: `America/Los_Angeles`" in result
assert "01-03 21" in result
assert "02-04 23" in result
def test_remove_cakeday(database, reddit):
cakeday1 = Cakeday(
user="******",
date_time=utils.parse_datetime_string("2015-05-05 15:25:17"))
cakeday2 = Cakeday(
user="******",
date_time=utils.parse_datetime_string("2015-05-05 15:25:17"))
database.add_cakeday(cakeday1)
database.add_cakeday(cakeday2)
message = reddit_test.RedditObject(body=f"Remove! cakeday",
author="Watchful3")
messages.process_message(message, reddit, database)
assert "You don't have a cakeday reminder set." in message.get_first_child(
).body
message = reddit_test.RedditObject(body=f"Remove! cakeday",
author="Watchful1")
messages.process_message(message, reddit, database)
assert "Cakeday reminder deleted." in message.get_first_child().body
assert database.get_cakeday("Watchful1") is None
assert database.get_cakeday("Watchful2") is not None
def test_add_cakeday_exists(database, reddit):
username = "******"
created = utils.parse_datetime_string("2015-05-05 15:25:17")
user = reddit_test.User(username, created.timestamp())
message = reddit_test.RedditObject(body="Cakeday!", author=user)
messages.process_message(message, reddit, database)
message2 = reddit_test.RedditObject(body="Cakeday!", author=user)
messages.process_message(message2, reddit, database)
result = message2.get_first_child().body
assert "It looks like you already have a cakeday reminder set." in result
def test_process_cakeday_comment(database, reddit):
username = "******"
user = reddit_test.User(
username,
utils.parse_datetime_string("2015-05-05 15:25:17").timestamp())
reddit.add_user(user)
created = utils.parse_datetime_string("2019-01-05 11:00:00")
comment_id = reddit_test.random_id()
thread_id = reddit_test.random_id()
comment = reddit_test.RedditObject(
body=f"{static.TRIGGER_CAKEDAY}!",
author=username,
created=created,
id=comment_id,
link_id="t3_" + thread_id,
permalink=f"/r/test/{thread_id}/_/{comment_id}/",
subreddit="test")
reddit.add_comment(comment)
utils.debug_time = utils.parse_datetime_string("2019-01-05 12:00:00")
comments.process_comment(comment.get_pushshift_dict(), reddit, database)
result = comment.get_first_child().body
assert "to remind you of your cakeday" in result
reminders = database.get_all_user_reminders(username)
assert len(reminders) == 1
assert reminders[0].user.name == username
assert reminders[0].source == utils.reddit_link(comment.permalink)
assert reminders[0].requested_date == created
assert reminders[0].target_date == utils.parse_datetime_string(
"2019-05-05 15:25:17")
assert reminders[0].id is not None
assert reminders[0].recurrence == "1 year"
assert reminders[0].message == "Happy Cakeday!"
def get_pending_cakedays(self, count, timestamp):
log.debug("Fetching pending cakedays")
c = self.dbConn.cursor()
results = []
for row in c.execute(
'''
SELECT ID, CakedayDate, User
FROM cakedays
WHERE CakedayDate < ?
ORDER BY CakedayDate ASC
LIMIT ?
''', (utils.get_datetime_string(timestamp), count)):
cakeday = Cakeday(user=row[2],
date_time=utils.parse_datetime_string(row[1]),
db_id=row[0])
results.append(cakeday)
log.debug(f"Found cakedays: {len(results)}")
return results
def test_get_reminders(database, reddit):
utils.debug_time = utils.parse_datetime_string("2019-01-01 12:00:00")
message = reddit_test.RedditObject(body="MyReminders!", author="Watchful1")
messages.process_message(message, reddit, database)
result = message.get_first_child().body
assert "You don't have any reminders." in result
reminder1 = Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message="KKKKK",
user="******",
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-04 05:00:00"))
reminder2 = Reminder(
source="https://www.reddit.com/message/messages/YYYYY",
message="FFFFF",
user="******",
requested_date=utils.parse_datetime_string("2019-02-02 06:00:00"),
target_date=utils.parse_datetime_string("2019-02-05 07:00:00"))
database.save_reminder(reminder1)
database.save_reminder(reminder2)
cakeday = Cakeday(
user="******",
date_time=utils.parse_datetime_string("2019-05-05 15:25:17"))
database.add_cakeday(cakeday)
message = reddit_test.RedditObject(body="MyReminders!", author="Watchful1")
messages.process_message(message, reddit, database)
result = message.get_first_child().body
assert "Click here to delete all your reminders" in result
assert "Happy cakeday!" in result
assert reminder1.source in result
assert reminder1.message in result
assert "01-04 05" in result
assert reminder2.source in result
assert reminder2.message in result
assert "02-05 07" in result
database.save_settings(
UserSettings(user="******", timezone="America/Los_Angeles"))
messages.process_message(message, reddit, database)
result = message.get_last_child().body
assert "Your timezone is currently set to: `America/Los_Angeles`" in result
assert "01-03 21" in result
assert "02-04 23" in result
def get_cakeday(self, user):
log.debug(f"Fetching cake by user: {user}")
c = self.dbConn.cursor()
c.execute(
'''
SELECT ID, CakedayDate, User
FROM cakedays
WHERE User = ?
''', (user, ))
result = c.fetchone()
if result is None or len(result) == 0:
log.debug("Cakeday not found")
return None
cakeday = Cakeday(user=result[2],
date_time=utils.parse_datetime_string(result[1]),
db_id=result[0])
return cakeday
def test_remove_reminder(database, reddit):
reminder1 = Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message="KKKKK",
user="******",
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-04 05:00:00"))
reminder2 = Reminder(
source="https://www.reddit.com/message/messages/YYYYY",
message="FFFFF",
user="******",
requested_date=utils.parse_datetime_string("2019-02-02 06:00:00"),
target_date=utils.parse_datetime_string("2019-02-05 07:00:00"))
reminder3 = Reminder(
source="https://www.reddit.com/message/messages/ZZZZZ",
message="JJJJJ",
user="******",
requested_date=utils.parse_datetime_string("2019-03-02 06:00:00"),
target_date=utils.parse_datetime_string("2019-03-05 07:00:00"))
database.save_reminder(reminder1)
database.save_reminder(reminder2)
database.save_reminder(reminder3)
message = reddit_test.RedditObject(body=f"Remove! test",
author="Watchful2")
messages.process_message(message, reddit, database)
assert "I couldn't find a reminder id to remove." in message.get_first_child(
).body
message = reddit_test.RedditObject(body=f"Remove! {reminder1.db_id}",
author="Watchful2")
messages.process_message(message, reddit, database)
assert "It looks like you don't own this reminder or it doesn't exist." in message.get_first_child(
).body
message = reddit_test.RedditObject(body=f"Remove! {reminder1.db_id}",
author="Watchful1")
messages.process_message(message, reddit, database)
assert "Reminder deleted." in message.get_first_child().body
assert len(database.get_user_reminders("Watchful1")) == 1
assert len(database.get_user_reminders("Watchful2")) == 1
cal = pdt.Calendar()
holdTime = cal.parse(time_string, current)
old_date = time.strftime('%Y-%m-%d %H:%M:%S', holdTime[0])
except Exception:
old_date = "None"
try:
new_date = utils.get_datetime_string(
utils.parse_time(time_string, current, None),
format_string='%Y-%m-%d %H:%M:%S')
except Exception:
new_date = "None"
if old_date != new_date and old_date != utils.get_datetime_string(
current, format_string='%Y-%m-%d %H:%M:%S'):
old_date_time = utils.parse_datetime_string(old_date)
new_date_time = utils.parse_datetime_string(new_date)
if old_date_time is None or new_date_time is None or \
not (old_date_time.replace(year=1, month=1, day=1) == current_hour and
new_date_time.replace(year=1, month=1, day=1) == zero_hour):
log.info(
f"{old_date.ljust(19)} | {new_date.ljust(19)} | {time_string}"
)
#{utils.reddit_link(comment['permalink']).ljust(120)} |
count += 1
# if count % 1000 == 0:
# log.info("comments: {}, {}".format(count, datetime.fromtimestamp(previousEpoch).strftime("%Y-%m-%d")))
if count > 2000:
breakOut = True
break
if breakOut:
import sys
from dateparser.search import search_dates
log = discord_logging.init_logging()
import utils
cal = parsedatetime.Calendar()
input_string = '''RemindMe May 7, 2021 16:00 PM "Reminder, an AMA with Shane Mauss, Dr. Peter McGraw - Comedian Shane Mauss Dr. Peter McGraw behavioral economist to start in /r/IAmA right now!"'''
base_time_string = None #"2020-07-25 20:00:00 -0800"
timezone_string = None #"America/Los_Angeles"
if base_time_string:
base_time = utils.datetime_as_timezone(
utils.parse_datetime_string(base_time_string, False,
'%Y-%m-%d %H:%M:%S %z'), "UTC")
else:
base_time = utils.datetime_now()
format_string = '%Y-%m-%d %H:%M:%S %Z'
log.info(f"Input string: {input_string}")
times = re.findall(r'(?:remindme.? +)(.*?)(?:\[|\n|\"|“|$)',
input_string.lower(),
flags=re.IGNORECASE)
if len(times) > 0 and times[0] != "":
log.info(f"Result: {times[0]}")
time_string = times[0][:50]
log.info(f"Result truncated: {time_string}")
else:
log.info(f"No string found")
def database_get_seen(database):
result = database.get_keystore("remindme_comment")
if result is None:
log.warning("Comment time not in database, returning now")
return utils.datetime_now()
return utils.parse_datetime_string(result)
def test_update_incorrect_comments(database, reddit):
comment_id1 = reddit_test.random_id()
thread_id1 = reddit_test.random_id()
comment1 = reddit_test.RedditObject(
body=f"{static.TRIGGER}! 1 day",
author="Watchful1",
created=utils.datetime_now(),
id=comment_id1,
link_id="t3_" + thread_id1,
permalink=f"/r/test/{thread_id1}/_/{comment_id1}/",
subreddit="test")
reddit.add_comment(comment1)
comments.process_comment(comment1.get_pushshift_dict(), reddit, database)
comment_id2 = reddit_test.random_id()
thread_id2 = reddit_test.random_id()
comment2 = reddit_test.RedditObject(
body=f"{static.TRIGGER}! 1 day",
author="Watchful1",
created=utils.datetime_now(),
id=comment_id2,
link_id="t3_" + thread_id2,
permalink=f"/r/test/{thread_id2}/_/{comment_id2}/",
subreddit="test")
reddit.add_comment(comment2)
comments.process_comment(comment2.get_pushshift_dict(), reddit, database)
comment_id3 = reddit_test.random_id()
thread_id3 = reddit_test.random_id()
comment3 = reddit_test.RedditObject(
body=f"{static.TRIGGER}! 1 day",
author="Watchful1",
created=utils.datetime_now(),
id=comment_id3,
link_id="t3_" + thread_id3,
permalink=f"/r/test/{thread_id3}/_/{comment_id3}/",
subreddit="test")
reddit.add_comment(comment3)
comments.process_comment(comment3.get_pushshift_dict(), reddit, database)
reminders = [
Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message=utils.reddit_link(comment1.permalink),
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-05 05:00:00")),
Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message=utils.reddit_link(comment1.permalink),
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-06 05:00:00")),
Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message=utils.reddit_link(comment1.permalink),
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-07 05:00:00")),
Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message=utils.reddit_link(comment2.permalink),
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-08 05:00:00")),
Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message=utils.reddit_link(comment2.permalink),
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-09 05:00:00"))
]
for reminder in reminders:
database.add_reminder(reminder)
comments.update_comments(reddit, database)
assert "3 OTHERS CLICKED THIS LINK" in reddit.get_comment(
comment_id1).get_first_child().body
assert "2 OTHERS CLICKED THIS LINK" in reddit.get_comment(
comment_id2).get_first_child().body
assert "CLICK THIS LINK" in reddit.get_comment(
comment_id3).get_first_child().body
if response.status_code != 200:
log.warning(
f"Bad response code, trying again: {response.status_code}")
time.sleep(5)
continue
comments = response.json()['data']
return comments
except Exception as err:
log.warning(f"Exception in request, trying again: {err}")
time.sleep(5)
continue
log.warning(f"Hit 10 exceptions, giving up")
return None
end_time = utils.parse_datetime_string("2021-01-01 00:00:00")
start_time = utils.parse_datetime_string("2021-04-01 00:00:00")
log.info(
f"Counting comments from {utils.get_datetime_string(start_time, False)} to {utils.get_datetime_string(end_time, False)}, {int((start_time - end_time).total_seconds())} seconds"
)
current_time = start_time
current_count = 0
while current_time > end_time:
current_comments = get_comments(current_time)
if current_comments is None:
break
ingest_delay_seconds = int(
(utils.datetime_from_timestamp(current_comments[0]['retrieved_on']) -
utils.datetime_from_timestamp(
current_comments[0]['created_utc'])).total_seconds())
new_c.execute(Database.tables['reminders'])
default_comment = "Hello, I'm here to remind you to see the parent comment!"
info_page = "http://np.reddit.com/r/RemindMeBot/comments/24duzp/remindmebot_info/"
startTime = time.perf_counter()
loop = 0
count_default_comment = 0
count_info_page = 0
for row in old_c.execute('''
SELECT permalink, message, new_date, origin_date, userID
FROM message_date
'''):
loop += 1
reminder = Reminder(source=row[0],
target_date=utils.parse_datetime_string(row[2]),
message=row[1],
user=row[4],
requested_date=utils.parse_datetime_string(row[3]))
try:
if isinstance(reminder.message, (bytes, bytearray)):
reminder.message = reminder.message.decode("utf-8")
reminder.message = reminder.message.strip(' "')
if reminder.message == default_comment:
count_default_comment += 1
reminder.message = None
if isinstance(reminder.source, (bytes, bytearray)):
reminder.source = reminder.source.decode("utf-8")
if reminder.source == info_page:
count_info_page += 1
def test_send_cakedays(database, reddit):
cakedays = [
Cakeday(
user="******",
date_time=utils.parse_datetime_string("2019-01-01 04:00:00")
),
Cakeday(
user="******",
date_time=utils.parse_datetime_string("2019-01-02 04:00:00")
),
Cakeday(
user="******",
date_time=utils.parse_datetime_string("2019-01-03 04:00:00")
),
Cakeday(
user="******",
date_time=utils.parse_datetime_string("2019-01-04 04:00:00")
)
]
for cakeday in cakedays:
database.add_cakeday(cakeday)
utils.debug_time = utils.parse_datetime_string("2019-01-01 02:00:00")
notifications.send_cakeday_notifications(reddit, database)
assert len(reddit.sent_messages) == 0
utils.debug_time = utils.parse_datetime_string("2019-01-01 06:00:00")
notifications.send_cakeday_notifications(reddit, database)
assert len(reddit.sent_messages) == 1
assert database.get_cakeday("Watchful1").date_time == utils.parse_datetime_string("2020-01-01 04:00:00")
utils.debug_time = utils.parse_datetime_string("2019-01-03 06:00:00")
notifications.send_cakeday_notifications(reddit, database)
assert len(reddit.sent_messages) == 3
assert database.get_cakeday("Watchful1").date_time == utils.parse_datetime_string("2020-01-01 04:00:00")
assert database.get_cakeday("Watchful2").date_time == utils.parse_datetime_string("2020-01-02 04:00:00")
assert database.get_cakeday("Watchful4").date_time == utils.parse_datetime_string("2019-01-04 04:00:00")
def get_incorrect_comments(self, count):
log.debug(f"Fetching incorrect comments")
c = self.dbConn.cursor()
results = []
for row in c.execute('''
SELECT cm.ID,
cm.ThreadID,
cm.CommentID,
cm.ReminderId,
cm.CurrentCount,
cm.User,
cm.Source,
rm.ID,
rm.Source,
rm.RequestedDate,
rm.TargetDate,
rm.Message,
rm.User,
rm.Defaulted,
rm.TimeZone,
rm.NewCount
FROM comments cm
LEFT JOIN
(
SELECT rm1.ID,
rm1.Source,
rm1.RequestedDate,
rm1.TargetDate,
rm1.Message,
rm1.User,
rm1.Defaulted,
us.TimeZone,
count(*) as NewCount
FROM reminders rm1
INNER JOIN reminders rm2
ON rm1.Source = rm2.Message
LEFT JOIN user_settings us
ON us.User = rm1.User
GROUP BY rm1.ID
) AS rm
ON cm.ReminderId = rm.ID
WHERE rm.NewCount != cm.CurrentCount
LIMIT ?
''', (count,)):
db_comment = DbComment(
thread_id=row[1],
comment_id=row[2],
reminder_id=row[3],
user=row[5],
source=row[6],
current_count=row[4],
db_id=row[0]
)
reminder = Reminder(
source=row[8],
target_date=utils.parse_datetime_string(row[10]),
message=row[11],
user=row[12],
db_id=row[7],
requested_date=utils.parse_datetime_string(row[9]),
count_duplicates=row[15],
thread_id=row[1],
timezone=row[14],
defaulted=row[13] == 1
)
results.append((db_comment, reminder))
log.debug(f"Found incorrect comments: {len(results)}")
return results
def test_send_reminders(database, reddit):
reminders = [
Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message="KKKKK",
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-05 05:00:00")),
Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message="KKKKK",
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-06 05:00:00")),
Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message="KKKKK",
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-07 05:00:00")),
Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message="KKKKK",
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-08 05:00:00")),
Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message="KKKKK",
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-09 05:00:00"))
]
for reminder in reminders:
database.add_reminder(reminder)
utils.debug_time = utils.parse_datetime_string("2019-01-05 12:00:00")
notifications.send_reminders(reddit, database)
assert len(database.get_all_user_reminders("Watchful1")) == 4
utils.debug_time = utils.parse_datetime_string("2019-01-08 12:00:00")
notifications.send_reminders(reddit, database)
assert len(database.get_all_user_reminders("Watchful1")) == 1
if response.status_code != 200:
log.warning(
f"Bad response code, trying again: {response.status_code}")
time.sleep(5)
continue
comments = response.json()['data']
return comments
except Exception as err:
log.warning(f"Exception in request, trying again: {err}")
time.sleep(5)
continue
log.warning(f"Hit 10 exceptions, giving up")
return None
end_time = utils.parse_datetime_string("2020-10-19 00:00:00")
start_time = utils.parse_datetime_string("2020-10-20 11:00:00")
log.info(
f"Counting comments from {utils.get_datetime_string(start_time, False)} to {utils.get_datetime_string(end_time, False)}, {int((start_time - end_time).total_seconds())} seconds"
)
current_time = start_time
current_count = 0
while current_time > end_time:
current_comments = get_comments(current_time)
if current_comments is None:
break
ingest_delay_seconds = int(
(utils.datetime_from_timestamp(current_comments[0]['retrieved_on']) -
utils.datetime_from_timestamp(
current_comments[0]['created_utc'])).total_seconds())
response = requests.get(url, headers={'User-Agent': USER_AGENT}, timeout=10)
if response.status_code != 200:
log.warning(f"Bad response code, trying again: {response.status_code} : {url}")
time.sleep(5)
continue
comments = response.json()['data']
return comments
except Exception as err:
log.warning(f"Exception in request, trying again: {err}")
time.sleep(5)
continue
log.warning(f"Hit 10 exceptions, giving up")
return None
end_time = utils.parse_datetime_string("2021-06-03 02:45:00")
start_time = utils.datetime_now() - timedelta(seconds=30)
log.info(f"Counting comments from {utils.get_datetime_string(start_time, False)} to {utils.get_datetime_string(end_time, False)}, {int((start_time - end_time).total_seconds())} seconds")
current_time = start_time
current_count = 0
while current_time > end_time:
current_comments = get_comments(current_time)
if current_comments is None:
break
ingest_delay_seconds = int((utils.datetime_from_timestamp(current_comments[0]['retrieved_utc']) - utils.datetime_from_timestamp(current_comments[0]['created_utc'])).total_seconds())
for comment in current_comments:
comment_time = utils.datetime_from_timestamp(comment['created_utc'])
if comment_time != current_time:
log.info(f"{utils.get_datetime_string(current_time)} {current_count} {ingest_delay_seconds if current_count > 0 else 0}")
current_count = 0
