FULL COMMIT

app.py

@@ -0,0 +1,13 @@
+import os
+import gradio as gr
+
+def start_app(telegram_token: str, ngrok_token: str):
+    cmnd = f"bash run_with_ngrok.sh {telegram_token} {ngrok_token}"
+    os.system(cmnd)
+    return 'Application started'
+
+demo = gr.Interface(
+    start_app, 
+    [gr.Textbox(label="Telegram Token"),gr.Textbox(label="NGROK Token")],
+    [gr.Textbox(label="Result")]
+).launch()

requirements.txt

@@ -0,0 +1,13 @@
+black
+pytest
+asyncio
+sqlmodel
+sqlalchemy
+pyngrok
+fastapi
+uvicorn
+pydantic
+typing
+httpx
+datetime
+curl

run_with_ngrok.sh

@@ -0,0 +1,3 @@
+export TELEGRAM_TOKEN=$1
+export NGROK_TOKEN=$2
+python3 -m src.__init__ ngrok >> logs.txt

src/__init__.py

@@ -0,0 +1,62 @@
+import sys
+import os
+
+from pyngrok import ngrok
+import uvicorn
+import asyncio
+
+from .events import Events
+from .constants import Constants
+
+__all__ = []
+
+if __name__ == "__main__":
+    if Events.TOKEN is None:
+        sys.exit("No TELEGRAM_TOKEN found in the environment, exiting now.")
+
+    PORT = Events.PORT
+    loop = asyncio.get_event_loop()
+
+    # Run with ngrok if the parameter is given
+    running_option = None
+    if len(sys.argv) == 2:
+        running_option = sys.argv[1]
+
+    if running_option == "ngrok":
+        ngrok_token = str(os.environ.get("NGROK_TOKEN"))
+        if ngrok_token == "None":
+            print(
+                "NGROK auth token is not found in the environment. Ngrok will timeout after a few hours."
+            )
+        else:
+            print(f"NGROK TOKEN: {ngrok_token}")
+            ngrok.set_auth_token(ngrok_token)
+        http_tunnel = ngrok.connect(PORT, bind_tls=True)
+        ssh_tunnel = ngrok.connect(22, "tcp")
+        public_url = http_tunnel.public_url
+        ssh_url = ssh_tunnel.public_url
+        Events.HOST_URL = public_url
+        _ = loop.run_until_complete(
+            Events.send_a_message_to_user(
+                Constants.BROADCAST_CHAT_ID, f"ssh: {ssh_url}, http:{public_url}"
+            )
+        )
+    else:
+        public_url = loop.run_until_complete(Events.get_public_ip())
+        Events.HOST_URL = f"https://{public_url}"
+        if running_option == "self_signed":
+            Events.SELF_SIGNED = True
+
+    print(Events.HOST_URL)
+    success = loop.run_until_complete(Events.set_telegram_webhook_url())
+
+    if success:
+        uvicorn.run(
+            "src.listener:app",
+            host="0.0.0.0",
+            port=PORT,
+            reload=True,
+            log_level="info",
+        )
+    else:
+        print("Fail, closing the app.")

src/constants.py

@@ -0,0 +1,561 @@
+from .db import default_schedule, get_user_status
+
+
+class Constants:
+    smile = "😊"
+    hello = "👋🏻"
+    sad = "😔"
+    sun_glasses = "😎"
+
+    BROADCAST_CHAT_ID = -1001786782026
+    FEEDBACK_FORWARD_CHAT_ID = -683998033
+    BOT_ID = 5065052385
+
+    class Common:
+        @staticmethod
+        def inactive_user(name: str, language_code: str = "en") -> str:
+            if language_code == "tr":
+                return f"{name}, sistemime kayıtlı değilsin, you are not in the system, please join by typing; *join* or /join. {Constants.smile}"
+            else:
+                return f"{name}, you are not in the system, please join by typing; *join* or /join. {Constants.smile}"
+
+        @staticmethod
+        def no_memory_found(name: str, language_code: str = "en") -> str:
+            if language_code == "tr":
+                return f"{name}, ne yazık ki hatıra kasan boş. Lütfen bu komutla not ekle *add Cümle* {Constants.smile}"
+            else:
+                return f"{name}, I could not find any note in your Vault. Please add a note with, *add Sentence* {Constants.smile}"
+
+        @staticmethod
+        def unknown_command(name: str, language_code: str = "en") -> str:
+
+            if language_code == "tr":
+                return (
+                    f"Sevgili {name}, ne yazık ki bu komutu bilmiyorum {Constants.sad}"
+                    f"\n- /start veya *start* ile başlangıç mesajını görebilirsin"
+                    f"\n- /leave veya *leave* ile günlük hatırlatmaları durdurabilirsin"
+                    f"\n- /send veya *send* ile rastgele bir not yollarım"
+                    f"\n- *send number* ile çok sayıda not yollarım"
+                    f"\n- /status veya *status* ile status bilgini yollarım"
+                    f"\n- /list veya *list* ile tüm notlarını gönderirim"
+                    f"\nTemel komutlarım bunlardı, günlük takvimi ayarlama vb. diğer tüm detaylı komutları görmek için, *help veya /help"
+                )
+            else:
+                return (
+                    f"Dear {name}, unfortunately I do not know that command {Constants.sad}"
+                    f"\n- /start or *start* to see the start message"
+                    f"\n- /leave or *leave* to deactivate daily reminders"
+                    f"\n- /send or *send* to get a random note"
+                    f"\n- *send number* to get multiple random notes"
+                    f"\n- /status or *status* to get your status information"
+                    f"\n- /list or *list* to list notes"
+                    f"\nThese were my main commands, to see additional commands like editing daily schedule please use, *help* or /help"
+                )
+
+    class Start:
+        @staticmethod
+        def start_message(name: str, language_code: str = "eng") -> str:
+            if language_code == "tr":
+                return (
+                    f"Merhabalar {name} {Constants.hello}"
+                    f"\nHatıra Kasası notlarını kaydetmene imkan sağlar ve her gün sana rastgele notlar yollar."
+                    f"\n\nHayatımızda karşılaştığımız güzel ve önemli cümleleri bir yere not almak ve sonrasında onları hatırlamak oldukça zor değil mi {Constants.sad}?"
+                    f"\nİşte ben bu sorunu oldukça basit ve kullanması kolay bir yöntemle çözüyorum {Constants.sun_glasses}. Zira karışık çözümleri hayatımıza sokmak zor {Constants.sad}."
+                    f"\nBu yöntemdeki güzellik şurada, bana verdiğin her notu elbet bir gün sana yollayacağım. Ne zaman yollayacağımı da düşünmene gerek yok."
+                    f"\nBu güzel fikri verdiği için sevgili hanımım Seyyide'ye teşekkür ederim."
+                    f"\n- Botu anlatan kısa rehbere geçmek için buyur tıkla, /tutorial1"
+                )
+            else:
+                return (
+                    f"Hello {name} {Constants.hello}"
+                    f"\nKeeping note of beautiful & important stuff that we come across throughout the life, and later remembering them is quite difficult isn't it 😔? Here is the Memory Vault for the rescue! Just take your notes, and I will occasionally remind them to you 😎"
+                    f"\nUnfortunately in this era our days&agendas are very busy and it is very hard to follow something consistently. Memory Vault helps us on this front by continuously reminding our notes to us so that you won't ever forget them. You can use it for"
+                    f"\n1. Habit Building"
+                    f"\n2. Language Learning"
+                    f"\n3. Learning the way of Entrepreneurship"
+                    f"\n4. Remembering names"
+                    f"\n5. Notetaking"
+                    f"\n6. Or, Anything Custom, Memory Vault is very flexible and general solution! "
+                    f"\n"
+                    f"\n❤️ Sincerely thanks to my dear wife Seyyide for the beautiful idea."
+                    f"\n"
+                    f"\n- To start to a small tutorial please click, /tutorial1"
+                )
+
+        @staticmethod
+        def group_warning(name: str, language_code: str = "eng") -> str:
+            if language_code == "tr":
+                return (
+                    f"\nBu arada Hatıra Kasasını gruplarda kullanmak için onu ya"
+                    f"\n- Grup admini yapmalı -- Bu durumda Hatıra Kasası gruptaki tüm mesajları dinleyip cevap verecektir"
+                    f"\n- Ya da Hatıra Kasası'nın herhangi bir mesajını yanıtlamalısın."
+                )
+            else:
+                return (
+                    f"Btw, to use Memory Vault in a group you should either"
+                    f"\n- Make Memory-Vault group admin -- In this case Memory Vault will listen and reply to every message."
+                    f"\n- Or reply to any message from Memory Vault to interact."
+                )
+
+    class Help:
+        @staticmethod
+        def help_message(name: str, language_code: str = "eng") -> str:
+            if language_code == "tr":
+                return (
+                    f"\n\nHafıza Kasası sana her gün, takvimindeki saatlerde kasandan rastgele notlar gönderir."
+                    f"\n- /help veya *help* yardım mesajını alabilirsin"
+                    f"\n- /join veya *join* ile günlük gönderimi aktifleştirebilirsin"
+                    f"\n- /leave veya *leave* ile günlük hatırlatmayı durdurabilirsin"
+                    f"\n- /send veya *send* ile rastgele bir not yollarım"
+                    f"\n- *send number* ile çok sayıda not yollarım"
+                    f"\n- /status veya *status* ile status bilgini yollarım"
+                    f"\n- /list veya *list* ile tüm notlarını gönderirim"
+                    f"\n\n- *add Note* ile kasana bir not ekleyebilirsin"
+                    f"\nÖrnek:"
+                    f"\n*add Vakit hiç bir zaman geri gelmez*"
+                    f"\n\n- *delete id* ile bir notu silebilirsin. Not id'lerini bu komutlarla öğrenebilirsin, *list* veya /list"
+                    f"\nÖrnek:"
+                    f"\n*delete 2*"
+                    f"\n\n- *gmt zaman-dilimi* ile zaman dilimi belirleyebilirsin, varsayılan zaman dilimi *GMT0*'dır"
+                    f"\nÖrnek:"
+                    f"\nGMT+3: *gmt 3*"
+                    f"\nGMT0: *gmt 0*"
+                    f"\nGMT-5: *gmt -5*"
+                    f"\n\n- /support veya *support* ile beni nasıl destekleyebileceğini öğrenebilirsin"
+                    f"\n- *feedback Cümle* ile bot hakkındaki düşüncelerini veya ƒeedback'lerini yollayabilirsin"
+                    f"\n\n*Schedule(takvim) hakkındaki komutlar:*"
+                    f"\nHer gün takvimindeki saat başlarında sana notlar yollarım. Varsayılan takvim saatleri *{default_schedule}*'dır. Yani her gün 8:00 ve 20:00'de sana bir adet not yollayacağım."
+                    f"\nSchedule komutlarıyla kendi günlük takvimini oluşturabilirsin. Ayrıca bir saati birden fazla kez ekleyerek o saatte birden çok not alabilirsin."
+                    f"\n- /schedule veya *schedule* ile şuanki takvimini yollarım"
+                    f"\n- *schedule reset* ile takvimini varsayılan takvime({default_schedule}) çekerim"
+                    f"\n- *schedule add saat1 saat2 saat3* ile saatleri takvimine eklerim"
+                    f"\nÖrnek:"
+                    f"\n*schedule add 1 3 9 11*"
+                    f"\n- *schedule remove saat* ile bir saati takviminden tamamen kaldırabilirsin"
+                    f"\nÖrnek:"
+                    f"\n*schedule remove 8*"
+                    f"\n\n*Grup Kullanımı*"
+                    f"\n - Beni *gruplarda da kullanabilirsin*, gruba ekleyip yönetici yapman yeterli. Yönetici yapmak istemiyorsan da grupta benim mesajlarıma yanıtla yaparak da komutları kullanabilirsin."
+                    f"\n- *Birden fazla Hatıra Kasasına* sahip olmak için beni farklı gruplarda kullanabilirsin. Mesela bir kelime öğrenme grubu kurabilirsin."
+                    f"\n- Örnek grup: Kuran'ı Kerim'den Dualar(@PrayersFromQuran)"
+                )
+            else:
+                return (
+                    f"\n\nMemory Vault will send you random notes from your memory vault, at the hours in your schedule every day."
+                    f"\n- /help or *help* to get help message"
+                    f"\n- /join or *join* to activate daily note sending"
+                    f"\n- /leave or *leave* to deactivate daily reminders"
+                    f"\n- /send or *send* to get a random note"
+                    f"\n- *send number* to get multiple random notes"
+                    f"\n- /status or *status* to get your status information"
+                    f"\n- /list or *list* to list notes"
+                    f"\n\n- *add Note* to add a note to your memory vault"
+                    f"\nExample:"
+                    f"\n*add Time never does come back*"
+                    f"\n\n- *delete id* to delete a note. You can learn the note ids with the command, *list* or /list"
+                    f"\nExample:"
+                    f"\n*delete 2*"
+                    f"\n\n- *gmt timezone* to set your timezone,  the default timezone is *GMT0*"
+                    f"\nExamples:"
+                    f"\nGMT+3: *gmt 3*"
+                    f"\nGMT0: *gmt 0*"
+                    f"\nGMT-5: *gmt -5*"
+                    f"\n\n- /support or *support* to learn how to support me"
+                    f"\n- *feedback Sentence* to send your thoughts and feedbacks about the bot"
+                    f"\n\n*Schedule related commands:*"
+                    f"\nI send notes according to the hours in your schedule. Default schedule hours are *{default_schedule}*. I will send you a note at 8:00 and 20:00 everyday."
+                    f"\nYou can create your own daily schedule. Furthermore you can add an hour multiple times to receive multiple notes at that hour."
+                    f"\n- /schedule or *schedule* to display your current schedule"
+                    f"\n- *schedule reset* to reset your schedule to the default schedule"
+                    f"\n- *schedule add hour1 hour2 hour3* to add hours to your schedule"
+                    f"\nExample:"
+                    f"\n*schedule add 1 3 9 11*"
+                    f"\n- *schedule remove hour* to remove an hour from your schedule"
+                    f"\nExample:"
+                    f"\n*schedule remove 8*"
+                    f"\n\n*Group Usage*"
+                    f"\n - You can *use me in groups* as well, just add me to a group and promote me to admin there. If you don't want to make me an admin, you can reply to my messages in the group to use my commands."
+                    f"\n- Furthermore *you can have multiple memory vaults* by using different groups. For example I would serve you well in a *language learning group*, where you add words you want to remember to your memory vault."
+                    f"\n- Example group: @PrayersFromQuran"
+                )
+
+    class Join:
+        @staticmethod
+        def successful_join(name: str, language_code: str = "en") -> str:
+            if language_code == "tr":
+                return (
+                    f"Hoşgeldin, sefa geldin {name}! Günlük not yollamayı açtın. Takvimindeki saatlere göre sana hatıra kasandan her gün notlar yollayacağım."
+                    f"Varsayılan takvimindeki saatleri {default_schedule}'dır. (8 -> 8:00, 20 -> 20:00). Daha detaylı bilgi için, *help* veya /help."
+                    f"\nYeni bir kullanıcı isen lütfen bu komuta tıklayarak rehbere başla, /tutorial1 {Constants.smile}"
+                )
+            else:
+                return (
+                    f"Welcome onboard {name}! "
+                    f"\nYou activated daily note sending. I will send you random notes from your memory vault according to your schedule."
+                    f"The default hours in the schedule are {default_schedule}(8 -> 8:00, 20 -> 20:00). You can get more detailed information by writing, *help* or /help."
+                    f"\nIf you are a new user, please start the tutorial by clicking, /tutorial1 {Constants.smile}"
+                )
+
+        @staticmethod
+        def already_joined(name: str, language_code: str = "en") -> str:
+            if language_code == "tr":
+                return f"{name}, hesabın zaten aktif. Hesabının mevcut durumunu görmek için bu komutu kullanabilirsin, /status."
+            else:
+                return f"{name}, Your account is already active. You can see your status via, /status."
+
+    class Leave:
+        @staticmethod
+        def successful_leave(name: str, language_code: str = "en") -> str:
+            if language_code == "tr":
+                return (
+                    f"Allah'a emanet ol {name}. Günlük not yollamamı kapattın, ama merak etme hatıra kasan benimle."
+                    f"İstediğin zaman bu komutlarla geri gelebilirsin, *join veya /join."
+                )
+            else:
+                return (
+                    f"Good bye {name}, you deactivated daily note sending. It was nice to have you here. "
+                    f"Your memory vault remains with me, you can return whenever you wish with command, *join* or /join."
+                )
+
+        @staticmethod
+        def already_left(name: str, language_code: str = "en") -> str:
+            if language_code == "tr":
+                return f"{name}, hesabın zaten atıl durumda."
+            else:
+                return f"{name}, Your account is already inactive."
+
+    class Send:
+        @staticmethod
+        def send_count_out_of_bound(name: str, language_code: str = "en") -> str:
+            if language_code == "tr":
+                return f"{name}, lütfen 1<n<50 arasında bir sayı ver, örn: *send 3*."
+            else:
+                return f"{name}, please give a number which is 1<n<50, ie: *send 3*."
+
+    class List:
+        @staticmethod
+        def list_messages(name: str, note_count: int, language_code: str = "en") -> str:
+            if language_code == "tr":
+                return (
+                    f"{name} Destur! {note_count} notun birer birer akacak."
+                    f"\n\nHatıra kasasının kapılarını açın!"
+                    f"\n*id | not*"
+                )
+            else:
+                return (
+                    f"Brace yourself {name}, you will receive {note_count} notes one by one."
+                    f"\n\nOpen the gates of the memory vault!"
+                    f"\n*id | note*"
+                )
+
+    class Add:
+        @staticmethod
+        def no_sentence(name: str, language_code: str = "en") -> str:
+            if language_code == "tr":
+                return f"{name} add kelimesinden sonra bir cümle bulamadım. Lütfen bu komutu kullan: *add Cümle*."
+            else:
+                return f"There is no sentence found after the word *add*. Please use this command: *add Sentence*"
+
+        @staticmethod
+        def already_added(name: str, language_code: str = "en") -> str:
+            if language_code == "tr":
+                return f"{name} bu not zaten kasada {Constants.smile}"
+
+            else:
+                return (
+                    f"{name} the note is already in your memory vault {Constants.smile}"
+                )
+
+        @staticmethod
+        def success(name: str, language_code: str = "en", note: str = "") -> str:
+            if language_code == "tr":
+                return (
+                    f"{name}, not kasana eklendi. Merak etme, onu güvende tutacağım {Constants.smile}"
+                    f"\n*Not*: \n{note}"
+                    f""
+                    f"\n\n Eğer son eklediğin notu silmek istiyorsan, bu komutu kullan */deletelast*"
+                )
+
+            else:
+                return (
+                    f"{name}, note is added to your memory vault. No worries, I will keep it safe {Constants.smile}"
+                    f"\n*Note*: \n{note}"
+                    f""
+                    f"\n\nIf you want to delete the last added note, you can use */deletelast*"
+                )
+
+    class Delete:
+        @staticmethod
+        def no_id(name: str, language_code: str = "en") -> str:
+            if language_code == "tr":
+                return f"{name}, bana notun id'sini vermen gerekiyor, örn: *delete 2*, bu komut ile id'leri öğrenebilirsin *list* veya /list"
+
+            else:
+                return f"{name}, need to give me id of the note, ie: *delete 2*, you can get it by using command, *list* or /list"
+
+        @staticmethod
+        def success(name: str, language_code: str = "en", note: str = "") -> str:
+            if language_code == "tr":
+                return (
+                    f"{name}, not kasadan silindi. Unutulan hatıraya elveda {Constants.sad}"
+                    f"\n*Silinen Not*:"
+                    f"\n{note}"
+                )
+            else:
+                return (
+                    f"{name}, your note is deleted from your memory vault. Good bye to the forgotten memory {Constants.sad}"
+                    f"\n*Deleted Note*:"
+                    f"\n{note}"
+                )
+
+    class Schedule:
+        @staticmethod
+        def empty_schedule(name: str, language_code: str = "en") -> str:
+            if language_code == "tr":
+                return f"{name}, takvimin boş, takvimine saatleri eklemek için bu komutu kullanabilirsin: *schedule add hour1 hour2 hour3*, örn: *schedule add 8 12*"
+
+            else:
+                return f"{name}, your schedule is empty, you can add hours to your schedule via, *schedule add hour1 hour2 hour3*, ie: *schedule add 8 12*"
+
+        @staticmethod
+        def success(name: str, language_code: str = "en", schedule: str = "") -> str:
+            if language_code == "tr":
+                return (
+                    f"{name}, güncel takvimin aşağıda, takvimindeki saat başlarında rastgele bir not alacaksın. örn: 8 -> 8:00"
+                    f"\n*Takvim*: {schedule}"
+                    f""
+                    f"\n\nUyarı: Eğer bu bottan faydalanmak istiyorsan, takvimini dolup taşırmamaya dikkat et ve gelen mesajlara dikkatini ver, göz atıp geçme."
+                )
+            else:
+                return (
+                    f"{name}, your current schedule is below, You will get a random note at each of these hours everyday. ie: 8 -> 8:00"
+                    f"\n*Schedule*: {schedule}"
+                    f""
+                    f"\n\nWarning: If you want to make use of this bot, be careful to not overflow your schedule and give attention to the incoming messages, do not just look and pass."
+                )
+
+        @staticmethod
+        def no_number_found(name: str, language_code: str = "en") -> str:
+            if language_code == "tr":
+                return f"{name}, *schedule add* komutu sonrasında bir sayı bulamadım, doğru kullanım örneği: *schedule add 1 3 5 21*"
+
+            else:
+                return f"{name}, there is no numbers found after *schedule add*, correct usage example: *schedule add 1 3 5 21*"
+
+        @staticmethod
+        def add_incorrect_number_input(name: str, language_code: str = "en") -> str:
+            if language_code == "tr":
+                return f"{name}, lütfen girdi olarak sayılar kullan, 0<=sayı<=23, örn: *schedule add 1 3 5 21*"
+
+            else:
+                return f"{name}, please use numbers 0<=number<=23, ie: *schedule add 1 3 5 21*"
+
+        @staticmethod
+        def remove_incorrect_number_input(name: str, language_code: str = "en") -> str:
+            if language_code == "tr":
+                return f"{name}, lütfen girdi olarak sayı kullan, 0<=sayı<=23, örn: *schedule remove 8*"
+
+            else:
+                return (
+                    f"{name}, please use number 0<=number<=23, ie: *schedule remove 8*"
+                )
+
+        @staticmethod
+        def unknown_command(name: str, language_code: str = "en") -> str:
+            if language_code == "tr":
+                return (
+                    f"{name}, bu komutu bilmiyorum. Aşağıdaki komutları kullanabilirsin."
+                    f"\n*schedule*"
+                    f"\n*schedule add 8 12*"
+                    f"\n*schedule reset*"
+                    f"\n*schedule remove 8*"
+                )
+            else:
+                return (
+                    f"{name}, I do not know that command. You can support the commands below."
+                    f"\n*schedule*"
+                    f"\n*schedule add 8 12*"
+                    f"\n*schedule reset*"
+                    f"\n*schedule remove 8*"
+                )
+
+    class Gmt:
+        @staticmethod
+        def success(name: str, language_code: str = "en", gmt: int = 0) -> str:
+            if language_code == "tr":
+                return f"{name}, güncel saat dilimin: GMT{gmt}."
+            else:
+                return f"{name}, your current timezone is: GMT{gmt}."
+
+        @staticmethod
+        def incorrect_timezone(name: str, language_code: str = "en") -> str:
+            if language_code == "tr":
+                return f"{name}, lütfen saat dilimini doğru kullan, örn: *gmt 3* or *gmt -3*"
+            else:
+                return f"{name}, please give your timezone correctly, ie: *gmt 3* or *gmt -3*"
+
+    class Broadcast:
+        @staticmethod
+        def no_sentence_found(name: str, language_code: str = "en") -> str:
+            if language_code == "tr":
+                return f"{name}, *broadcast* kelimesi sonrasında herhangi bir cümle bulamadım {Constants.sad}, doğru örn: *broadcast Cümle*"
+            else:
+                return f"{name}, there is no sentence found after the word *broadcast* {Constants.sad}, correct usage: *broadcast Sentence*"
+
+        @staticmethod
+        def success(name: str, language_code: str = "en") -> str:
+            if language_code == "tr":
+                return f"{name}, broadcast yollandı {Constants.smile}"
+            else:
+                return f"{name}, broadcast is sent {Constants.smile}"
+
+        @staticmethod
+        def no_right(name: str, language_code: str = "en") -> str:
+            if language_code == "tr":
+                return f"{name}, broadcast hakkın yok {Constants.smile}"
+            else:
+                return f"{name}, you have no broadcast right {Constants.smile}"
+
+    class Status:
+        @staticmethod
+        def get_status(
+            name: str,
+            language_code: str = "en",
+            gmt: int = 0,
+            active: bool = True,
+            schedule: str = "",
+            note_count: int = 0,
+        ) -> str:
+            if language_code == "tr":
+                if active:
+                    is_active = "aktif"
+                else:
+                    is_active = "pasif"
+                return (
+                    f"Mevcut durumun:"
+                    f"\n- Gmt: *GMT{gmt}*"
+                    f"\n- Günlük gönderim aktif: *{is_active}*"
+                    f"\n- Hatıra Kasandaki not sayısı: {note_count}"
+                    f"\n- Takvim: {schedule}"
+                    f""
+                    f"\n\nUyarı: Eğer bu bottan faydalanmak istiyorsan, takvimini dolup taşırmamaya dikkat et ve gelen mesajlara dikkatini ver, göz atıp geçme."
+                )
+            else:
+                return (
+                    f"Your current status:"
+                    f"\n- Gmt: *GMT{gmt}*"
+                    f"\n- Daily sending is active: *{active}*"
+                    f"\n- Number of notes in your Memory Vault: {note_count}"
+                    f"\n- Schedule: {schedule}"
+                    f""
+                    f"\n\nWarning: If you want to make use of this bot, be careful to not overflow your schedule and give attention to the incoming messages, do not just look and pass."
+                )
+
+    class Feedback:
+        @staticmethod
+        def no_message(name: str, language_code: str = "en"):
+            if language_code == "tr":
+                return f"{name}, *feedback* sonrasında bir cümle bulamadım {Constants.sad}, doğru örnek: *feedback Cümle*"
+            else:
+                return f"{name}, there is no message found after the word *feedback* {Constants.sad}, correct example: *feedback Sentence*"
+
+        @staticmethod
+        def success(name: str, language_code: str = "en", feedback: str = ""):
+            if language_code == "tr":
+                return (
+                    f"{name}, feedback'ini yöneticiye ilettim, desteğin için çok teşekkür ederim {Constants.smile}"
+                    f"\nFeedback: *{feedback}*"
+                )
+            else:
+                return (
+                    f"{name}, I forwarded your feedback to the admin, thank you for your support {Constants.smile}"
+                    f"\nFeedback: *{feedback}*"
+                )
+
+        @staticmethod
+        def fail(name: str, language_code: str = "en"):
+            if language_code == "tr":
+                return f"{name}, feedback'i yöneticiye iletemedim, bir hata oluştu."
+            else:
+                return f"{name}, I could not forward your feedback to the admin, an error occurred."
+
+    class Support:
+        @staticmethod
+        def support(name: str, language_code: str = "en"):
+            if language_code == "tr":
+                return (
+                    f"Teşekkür ederim {name}, beni desteklemek için"
+                    f"\n- @memory_vault_bot'u arkadaşlarınla paylaşabilir"
+                    f"\n- Bu komutla bana feedback verebilirsin, *feedback cümle*"
+                    f"\n- Github repo'ma yıldız verebilirsin, https://github.com/FarukOzderim/Memory-Vault/"
+                )
+            else:
+                return (
+                    f"Thank you {name}, to support me you can"
+                    f"\n- Share me with your friends"
+                    f"\n- Give feedback using the command, *feedback sentence*"
+                    f"\n- Star the github repository at https://github.com/FarukOzderim/Memory-Vault/"
+                )
+
+    class Tutorial:
+        @staticmethod
+        def tutorial_1(name: str, language_code: str = "en"):
+            if language_code == "tr":
+                return (
+                    f"*gmt zaman-dilimi* ile zaman dilimi belirleyebilirsin, varsayılan zaman dilimi *GMT0*'dır. Bu arada Türkiye GMT+3 zaman diliminde."
+                    f"\nÖrnek:"
+                    f"\nGMT+3: *gmt 3*"
+                    f"\nGMT0: *gmt 0*"
+                    f"\nGMT-5: *gmt -5*"
+                    f"\n\nBir sonraki rehber adımına geçmek için, /tutorial2"
+                )
+            else:
+                return (
+                    f"Use *gmt timezone* to set your timezone, the default timezone is *GMT0*. Btw New York is GMT-5, London is GMT0, Malaysia is GMT+8."
+                    f"\nExamples:"
+                    f"\nGMT+3: *gmt 3*"
+                    f"\nGMT0: *gmt 0*"
+                    f"\nGMT-5: *gmt -5*"
+                    f"\n\nFor the next tutorial step please use, /tutorial2"
+                )
+
+        @staticmethod
+        def tutorial_2(name: str, language_code: str = "en"):
+            if language_code == "tr":
+                return (
+                    f"Hatıra Kasana bir not eklemek için *add Cümle* komutunu kullanabilirsin."
+                    f"\nÖrnek:"
+                    f"\n*add Zaman çok kıymetlidir, her daim eriyen bir dondurmaya benzer.*"
+                    f"\n\nBir sonraki rehber adımına geçmek için, /tutorial3"
+                )
+            else:
+                return (
+                    f"To add a note to your Memory Vault, please use the command, *add Sentence*."
+                    f"\nExample:"
+                    f"\n*add Time never does come back*"
+                    f"\n\nFor the next tutorial step please use, /tutorial3"
+                )
+
+        @staticmethod
+        def tutorial_3(name: str, language_code: str = "en"):
+            if language_code == "tr":
+                return (
+                    f"\n- /leave veya *leave* ile günlük hatırlatmayı durdurabilirsin"
+                    f"\n- /send veya *send* ile rastgele bir not yollarım"
+                    f"\n- *send number* ile çok sayıda not yollarım"
+                    f"\n- /status veya *status* ile status bilgini yollarım"
+                    f"\n- /list veya *list* ile tüm notlarını gönderirim"
+                    f"\n\n{name} tebrikler rehberi bitirdin {Constants.smile}. "
+                    f"\nTemel komutlarım bunlardı, günlük takvimi ayarlama vb. diğer komutları görmek için, /help."
+                )
+
+            else:
+                return (
+                    f"\n- /leave or *leave* to deactivate daily reminders"
+                    f"\n- /send or *send* to get a random note"
+                    f"\n- *send number* to get multiple random notes"
+                    f"\n- /status or *status* to get your status information"
+                    f"\n- /list or *list* to list notes"
+                    f"\n\n{name} congratulations, you finished the tutorial {Constants.smile}. "
+                    f"\nThese were my main commands, to see additional commands like editing daily schedule please use, /help."
+                )

src/db.py

@@ -0,0 +1,495 @@
+import random
+from typing import List, Optional, Union, Tuple
+from fastapi import Depends, Query
+from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select, and_
+from sqlalchemy import UniqueConstraint
+
+default_schedule = "8,20"
+
+
+class UserBase(SQLModel):
+    __table_args__ = (UniqueConstraint("telegram_chat_id"),)
+    name: str
+    telegram_chat_id: int
+    gmt: Optional[int] = 0
+    active: Optional[bool] = True
+    scheduled_hours: Optional[str] = default_schedule
+
+
+class User(UserBase, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    reminders: List["Reminder"] = Relationship(back_populates="user")
+
+
+class UserRead(UserBase):
+    id: int
+
+
+class UserCreate(UserBase):
+    pass
+
+
+class ReminderBase(SQLModel):
+    reminder: str
+    user_id: Optional[int] = Field(default=None, foreign_key="user.id")
+
+
+class Reminder(ReminderBase, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    user: User = Relationship(back_populates="reminders")
+
+
+class ReminderRead(ReminderBase):
+    id: int
+
+
+class ReminderCreate(ReminderBase):
+    pass
+
+
+sqlite_file_name = "database.db"
+sqlite_url = f"sqlite:///{sqlite_file_name}"
+
+connect_args = {"check_same_thread": False}
+engine = create_engine(sqlite_url, echo=False, connect_args=connect_args)
+
+
+def create_db_and_tables():
+    SQLModel.metadata.create_all(engine)
+
+
+def get_session():
+    with Session(engine) as session:
+        yield session
+
+
+def join_user(
+    user: UserCreate,
+    session: Session = next(get_session()),
+) -> Optional[User]:
+    """
+    Joins the user to the system.
+
+    Args:
+        user:
+        session:
+
+    Returns: User or None
+
+    """
+    found_user = session.exec(
+        select(User).where(User.telegram_chat_id == user.telegram_chat_id)
+    ).first()
+    if found_user is None:
+        user = db_create_user(user, session)
+        return user
+    else:
+        if found_user.active:
+            return None
+        else:
+            found_user.active = True
+            session.add(found_user)
+            session.commit()
+            session.refresh(found_user)
+            return found_user
+
+
+def leave_user(
+    user: UserCreate,
+    session: Session = next(get_session()),
+) -> Optional[User]:
+    """
+    Deactivates the user.
+
+    Args:
+        user:
+        session:
+
+    Returns: User or None
+
+    """
+    found_user = session.exec(
+        select(User).where(User.telegram_chat_id == user.telegram_chat_id)
+    ).first()
+    if found_user is None:
+        return None
+    else:
+        if not found_user.active:
+            return None
+        else:
+            found_user.active = False
+            session.add(found_user)
+            session.commit()
+            session.refresh(found_user)
+            return found_user
+
+
+def get_user_status(
+    telegram_chat_id: int,
+    session: Session = next(get_session()),
+) -> Optional[Tuple[int, bool]]:
+    """
+    Get status of the user.
+
+    Args:
+        telegram_chat_id:
+        session:
+
+    Returns: (gmt,active)
+
+    """
+    found_user = session.exec(
+        select(User).where(User.telegram_chat_id == telegram_chat_id)
+    ).first()
+    if found_user is None:
+        return None, None
+    else:
+        return found_user.gmt, found_user.active
+
+
+def select_random_memory(
+    user: UserCreate,
+    session: Session = next(get_session()),
+) -> Optional[Union[Reminder, bool]]:
+    """
+    Select random memory from user's memory-vault.
+
+    Args:
+        user:
+        session:
+
+    Returns:
+
+    """
+    found_user = session.exec(
+        select(User).where(User.telegram_chat_id == user.telegram_chat_id)
+    ).first()
+    if found_user is None:
+        return None
+    if len(found_user.reminders) > 0:
+        memory_list = found_user.reminders
+        random_memory = random.choice(memory_list)
+        return random_memory
+    else:
+        return False
+
+
+def list_memories(
+    user: UserCreate,
+    session: Session = next(get_session()),
+) -> Optional[List[Reminder]]:
+    """
+    Return all the memory-vault.
+
+    Args:
+        user:
+        session:
+
+    Returns:
+
+    """
+    found_user = session.exec(
+        select(User).where(User.telegram_chat_id == user.telegram_chat_id)
+    ).first()
+    if found_user is None:
+        return None
+
+    return found_user.reminders
+
+
+def add_memory(
+    user: UserCreate,
+    memory: str,
+    session: Session = next(get_session()),
+) -> Optional[Union[Reminder, bool]]:
+    """
+    Add a memory to user's memory-vault.
+
+    Args:
+        user:
+        memory:
+        session:
+
+    Returns: Reminder
+
+    """
+    found_user = session.exec(
+        select(User).where(User.telegram_chat_id == user.telegram_chat_id)
+    ).first()
+
+    if found_user is None:
+        return None
+
+    else:
+        found_memory = session.exec(
+            select(Reminder).where(
+                and_(Reminder.user == found_user, Reminder.reminder == memory)
+            )
+        ).first()
+        if found_memory is not None:
+            return False
+        else:
+            reminder = ReminderCreate(
+                reminder=memory,
+                user_id=found_user.id,
+            )
+
+            db_reminder = Reminder.from_orm(reminder)
+            session.add(db_reminder)
+            session.commit()
+            session.refresh(db_reminder)
+            return db_reminder
+
+
+def delete_memory(
+    user: UserCreate,
+    memory_id: int,
+    session: Session = next(get_session()),
+) -> Union[bool, str, None]:
+    """
+    Delete a memory from user's memory-vault.
+
+    Args:
+        user:
+        memory_id:
+        session:
+
+    Returns: bool
+
+    """
+
+    found_user = session.exec(
+        select(User).where(User.telegram_chat_id == user.telegram_chat_id)
+    ).first()
+    if found_user is None:
+        return None
+    if len(found_user.reminders) > memory_id:
+        reminder = found_user.reminders[memory_id]
+        memory = reminder.reminder
+        session.delete(reminder)
+        session.commit()
+        return memory
+    else:
+        return False
+
+
+def delete_last_memory(
+    user: UserCreate,
+    session: Session = next(get_session()),
+) -> Union[bool, str, None]:
+    """
+    Delete the last memory from user's memory-vault.
+
+    Args:
+        user:
+        session:
+
+    Returns: bool
+
+    """
+
+    found_user = session.exec(
+        select(User).where(User.telegram_chat_id == user.telegram_chat_id)
+    ).first()
+    if found_user is None:
+        return None
+    if found_user.reminders:
+        reminder = found_user.reminders.pop()
+        memory = reminder.reminder
+        session.delete(reminder)
+        session.commit()
+        return memory
+    else:
+        return False
+
+
+def update_gmt(
+    user: UserCreate,
+    gmt: int,
+    session: Session = next(get_session()),
+) -> Optional[User]:
+    """
+    Update GMT of the user.
+
+    Returns: User or None
+    """
+    found_user = session.exec(
+        select(User).where(User.telegram_chat_id == user.telegram_chat_id)
+    ).first()
+    if found_user is None:
+        return None
+    else:
+        found_user.gmt = gmt
+        session.add(found_user)
+        session.commit()
+        session.refresh(found_user)
+        return found_user
+
+
+def get_schedule(
+    user: UserCreate,
+    session: Session = next(get_session()),
+) -> Optional[str]:
+    """
+    Get schedule of the user.
+
+    Args:
+        user:
+        session:
+
+    Returns: str or None
+    """
+    found_user = session.exec(
+        select(User).where(User.telegram_chat_id == user.telegram_chat_id)
+    ).first()
+    if found_user is None:
+        return None
+    else:
+        return found_user.scheduled_hours
+
+
+def reset_schedule(
+    user: UserCreate,
+    session: Session = next(get_session()),
+) -> Optional[str]:
+    """
+    Reset schedule of the user.
+
+    Args:
+        user:
+        session:
+
+    Returns: str or None
+
+    """
+    found_user = session.exec(
+        select(User).where(User.telegram_chat_id == user.telegram_chat_id)
+    ).first()
+    if found_user is None:
+        return None
+    else:
+        found_user.scheduled_hours = default_schedule
+        session.add(found_user)
+        session.commit()
+        session.refresh(found_user)
+        return found_user.scheduled_hours
+
+
+def remove_hour_from_schedule(
+    user: UserCreate,
+    hour: int,
+    session: Session = next(get_session()),
+) -> Optional[str]:
+    """
+    Remove all appearances of hour from schedule of the user.
+
+    Args:
+        user:
+        hour:
+        session:
+
+    Returns: str or None
+
+    """
+    found_user = session.exec(
+        select(User).where(User.telegram_chat_id == user.telegram_chat_id)
+    ).first()
+    if found_user is None:
+        return None
+    else:
+        old_schedule = create_schedule_array(found_user.scheduled_hours)
+        new_schedule = []
+        for number in old_schedule:
+            if not hour == number:
+                new_schedule.append(number)
+        str_schedule_list = [str(number) for number in new_schedule]
+        str_schedule = ",".join(str_schedule_list)
+        found_user.scheduled_hours = str_schedule
+        session.add(found_user)
+        session.commit()
+        session.refresh(found_user)
+        return found_user.scheduled_hours
+
+
+def add_hours_to_the_schedule(
+    user: UserCreate,
+    schedule_list: List[int],
+    session: Session = next(get_session()),
+) -> Optional[str]:
+    """
+    Add hours to the schedule of the user.
+
+    Args:
+        user:
+        schedule_list:
+        session:
+
+    Returns: str or None
+
+    """
+    found_user = session.exec(
+        select(User).where(User.telegram_chat_id == user.telegram_chat_id)
+    ).first()
+    if found_user is None:
+        return None
+    else:
+        old_schedule = create_schedule_array(found_user.scheduled_hours)
+        new_schedule = []
+        for number in old_schedule:
+            new_schedule.append(number)
+        for number in schedule_list:
+            new_schedule.append(number)
+        sorted_schedule = sorted(new_schedule)
+        str_sorted_schedule = [str(number) for number in sorted_schedule]
+        str_schedule = ",".join(str_sorted_schedule)
+        found_user.scheduled_hours = str_schedule
+        session.add(found_user)
+        session.commit()
+        session.refresh(found_user)
+        return found_user.scheduled_hours
+
+
+def db_create_user(
+    user: UserCreate,
+    session: Session = next(get_session()),
+) -> Optional[User]:
+    try:
+        user = User.from_orm(user)
+        session.add(user)
+        session.commit()
+        session.refresh(user)
+        return user
+
+    except Exception as ex:
+        return None
+
+
+def db_read_users(
+    *,
+    only_active_users: bool = True,
+    session: Session = next(get_session()),
+    offset: int = 0,
+    limit: int = 100,
+) -> List[User]:
+    if only_active_users:
+        users = session.exec(
+            select(User).where(User.active).offset(offset).limit(limit)
+        ).all()
+    else:
+        users = session.exec(select(User).offset(offset).limit(limit)).all()
+    return users
+
+
+def create_schedule_array(schedule_str: str) -> List[int]:
+    """
+    Create schedule array from schedule string splitted by comas(,).
+    """
+    if schedule_str == "":
+        return []
+    else:
+        schedule_list = []
+        str_list = schedule_str.split(",")
+        for str_number in str_list:
+            schedule_list.append(int(str_number))
+
+        return schedule_list

src/events.py

@@ -0,0 +1,178 @@
+import random
+import os
+import sys
+
+from typing import List
+import datetime
+import asyncio
+from httpx import AsyncClient, Response
+
+from .message_validations import ResponseToMessage
+from .db import db_read_users, Reminder, User
+from .constants import Constants
+
+
+class Events:
+    TOKEN = os.environ.get("TELEGRAM_TOKEN")
+    TELEGRAM_SEND_MESSAGE_URL = f"https://api.telegram.org/bot{TOKEN}/sendMessage"
+    TELEGRAM_SET_WEBHOOK_URL = f"https://api.telegram.org/bot{TOKEN}/setWebhook"
+    TELEGRAM_SEND_DOCUMENT_URL = f"https://api.telegram.org/bot{TOKEN}/sendDocument"
+
+    PORT = 8000
+    HOST_URL = None
+    SELF_SIGNED = False
+
+    @classmethod
+    async def main_event(cls) -> None:
+        """
+        Main Event Loop
+
+        Runs in a while loop, Triggers Events.send_user_hourly_memories at every hour.
+        """
+        while True:
+            await asyncio.sleep(cls.get_time_until_next_hour())
+            async with AsyncClient() as client:
+                endpoint = f"http://0.0.0.0:{cls.PORT}/trigger_send_user_hourly_memories/{Events.TOKEN}"
+                response = await client.post(url=endpoint)
+                endpoint = f"http://0.0.0.0:{cls.PORT}/trigger_archive_db/{Events.TOKEN}"
+                response = await client.post(url=endpoint)
+
+    @classmethod
+    def get_time_until_next_hour(cls) -> float:
+        # Ref: https://stackoverflow.com/a/52808375/15282482
+        delta = datetime.timedelta(hours=1)
+        now = datetime.datetime.now()
+        next_hour = (now + delta).replace(microsecond=0, second=0, minute=0)
+        return (next_hour - now).total_seconds()
+
+    @classmethod
+    def send_user_hourly_memories(
+        cls,
+        user: User,
+        hour: int,
+    ) -> None:
+        """
+        Sends memories to user if the current_hour is in his schedule.
+        """
+        hour = (hour + user.gmt) % 24
+        if user.scheduled_hours == "":
+            return
+        scheduled_hours = user.scheduled_hours.split(",")
+        number_of_messages_at_this_hour = 0
+
+        for str_hour in scheduled_hours:
+            if (
+                int(str_hour) > hour
+            ):  # Scheduled_hours are sorted, next items will be > hour as well.
+                break
+            if int(str_hour) == hour:
+                number_of_messages_at_this_hour += 1
+        number_of_messages_at_this_hour = min(
+            len(user.reminders), number_of_messages_at_this_hour
+        )
+        selected_reminders = random.sample(
+            user.reminders, number_of_messages_at_this_hour
+        )
+        for reminder in selected_reminders:  # Send the memory in background
+            asyncio.create_task(
+                cls.send_a_message_to_user(user.telegram_chat_id, reminder.reminder)
+            )
+            now = datetime.datetime.now()
+            print(
+                f"Created task to, {user.name}, {reminder.reminder}, hour: {hour}, gmt: {user.gmt}, now: {now}"
+            )
+
+    @classmethod
+    async def send_message_list_at_background(
+        cls, telegram_chat_id: int, message_list: List[str]
+    ) -> bool:
+        for message in message_list:
+            print(f"sending the message: {message}, to chat: {telegram_chat_id} ")
+            await Events.send_a_message_to_user(
+                telegram_id=telegram_chat_id, message=message
+            )
+        return True
+
+    @classmethod
+    async def send_a_message_to_user(
+        cls,
+        telegram_id: int,
+        message: str,
+        retry_count: int = 3,
+        sleep_time: float = 0.1,
+    ) -> bool:
+        message = ResponseToMessage(
+            **{
+                "text": message,
+                "chat_id": telegram_id,
+            }
+        )
+        await asyncio.sleep(sleep_time)
+        for retry in range(retry_count):
+            print(f"Sending the message in send_a_message_to_user, count {retry}")
+            # Avoid too many requests error from Telegram
+            response = await cls.request(cls.TELEGRAM_SEND_MESSAGE_URL, message.dict())
+            if response.status_code == 200:
+                return True
+            elif response.status_code == 429:
+                retry_after = int(response.json()["parameters"]["retry_after"])
+                print(f"Retry After: {retry_after}, message: {message}")
+                await asyncio.sleep(retry_after)
+            else:
+                print(
+                    f"Unhandled response code: {response.status_code}, response: {response.json()}"
+                )
+        return False
+
+    @classmethod
+    async def broadcast_message(cls, message: str) -> None:
+        users = db_read_users(limit=100000, only_active_users=False)
+        await asyncio.gather(
+            *(
+                Events.send_a_message_to_user(
+                    user.telegram_chat_id,
+                    message,
+                )
+                for user in users
+            )
+        )
+
+    @classmethod
+    async def request(cls, url: str, payload: dict, debug: bool = True) -> Response:
+        async with AsyncClient(timeout=30 * 60) as client:
+            request = await client.post(url, json=payload)
+            if debug:
+                print(request.json())
+            return request
+
+    @classmethod
+    async def set_telegram_webhook_url(cls) -> bool:
+        print(f"webhook_url:{cls.HOST_URL}")
+        if cls.SELF_SIGNED:
+            payload = {
+                "url": f"{cls.HOST_URL}/webhook/{cls.TOKEN}",
+                "certificate": open(os.environ.get("PEM_FILE"), "rb"),
+            }
+        else:
+            payload = {"url": f"{cls.HOST_URL}/webhook/{cls.TOKEN}"}
+        req = await cls.request(cls.TELEGRAM_SET_WEBHOOK_URL, payload)
+        return req.status_code == 200
+
+    @classmethod
+    def archive_db(cls) -> bool:
+        command = f'curl -v -F "chat_id={Constants.BROADCAST_CHAT_ID}" -F document=@database.db {cls.TELEGRAM_SEND_DOCUMENT_URL}'
+        os.system(command)
+
+    @classmethod
+    async def get_public_ip(cls):
+        # Reference: https://pytutorial.com/python-get-public-ip
+
+        endpoint = "https://ipinfo.io/json"
+        async with AsyncClient() as client:
+            response = await client.get(endpoint)
+
+        if response.status_code != 200:
+            sys.exit("Could not get the public ip, exiting!")
+        data = response.json()
+
+        return data["ip"]

src/listener.py

@@ -0,0 +1,84 @@
+import asyncio
+import datetime
+
+from fastapi import FastAPI, Depends
+from fastapi.concurrency import run_in_threadpool
+from .db import *
+from .message_validations import MessageBodyModel, ResponseToMessage
+from .constants import Constants
+from .events import Events
+from .response_logic import ResponseLogic
+
+app = FastAPI(openapi_url=None)
+
+
+@app.on_event("startup")
+def on_startup():
+    create_db_and_tables()
+    asyncio.create_task(Events.main_event())
+
+
+@app.get("/health")
+async def health():
+    return {"healthy": True}
+
+
+@app.post(f"/webhook/{Events.TOKEN}")
+async def listen_telegram_messages(message: MessageBodyModel):
+    print(message.dict())
+
+    if message.message:
+        name = message.message.from_field.first_name
+        chat_id = message.message.chat.id
+        text = message.message.text
+        language_code = message.message.from_field.language_code
+        if not text:  # Edit of message  etc.
+            return
+        else:
+            response_message = await ResponseLogic.create_response(
+                text, name, chat_id, language_code
+            )
+            return ResponseToMessage(
+                **{
+                    "text": response_message,
+                    "chat_id": chat_id,
+                }
+            )
+
+    if not message.message:  # Bot is added to a group
+        if not message.my_chat_member:
+            return
+
+        chat_id = message.my_chat_member.chat.id
+        name = message.my_chat_member.from_field.first_name
+        language_code = message.my_chat_member.from_field.language_code
+
+        new_member = message.my_chat_member.new_chat_member
+        if (
+            new_member
+            and new_member.user.id == Constants.BOT_ID
+            and new_member.status == "member"
+        ):
+            await Events.send_a_message_to_user(chat_id, Constants.hello)
+            await Events.send_a_message_to_user(
+                chat_id, Constants.Start.start_message(name, language_code)
+            )
+            await Events.send_a_message_to_user(
+                chat_id, Constants.Start.group_warning(name, language_code)
+            )
+            return
+
+    return
+
+@app.post(f"/trigger_archive_db/{Events.TOKEN}")
+def trigger_archive_db():
+    Events.archive_db()
+
+
+@app.post(f"/trigger_send_user_hourly_memories/{Events.TOKEN}")
+async def trigger_send_user_hourly_memories(*, session: Session = Depends(get_session)):
+    users = db_read_users(limit=100000, session=session)
+    now = datetime.datetime.now(datetime.timezone.utc)
+    print(f"Sending is triggered at hour {now.hour}")
+    for user in users:
+        Events.send_user_hourly_memories(user, now.hour)

src/message_validations.py

@@ -0,0 +1,78 @@
+from typing import Optional, List
+
+from pydantic import BaseModel, Field
+
+
+class Chat(BaseModel):
+    last_name: Optional[str]
+    id: Optional[int]
+    type: Optional[str]
+    first_name: Optional[str]
+    username: Optional[str]
+
+
+class From(BaseModel):
+    last_name: Optional[str]
+    id: Optional[int]
+    first_name: Optional[str]
+    user_name: Optional[str]
+    language_code: Optional[str]
+    is_bot: Optional[str]
+
+
+class ReplyMessage(BaseModel):
+    date: Optional[int]
+    chat: Optional[Chat]
+    message_id: Optional[int]
+    text: Optional[str]
+
+
+class Photo(BaseModel):
+    file_id: Optional[str]
+
+
+class Message(BaseModel):
+    date: Optional[int]
+    chat: Optional[Chat]
+    message_id: Optional[str]
+    from_field: From = Field(alias="from")
+    text: Optional[str]
+    photo: Optional[List[Photo]]
+
+
+class ChatGroup(BaseModel):
+    id: Optional[int]
+    title: Optional[str]
+    type: Optional[str]
+
+
+class MockVal(BaseModel):
+    rand_int: Optional[int]
+
+
+class OtherChatMember(BaseModel):
+    user: Optional[From]
+    status: Optional[str]
+
+
+class MyChatMember(BaseModel):
+    rand_int: Optional[int]
+    chat: Optional[ChatGroup]
+    from_field: Optional[From] = Field(alias="from")
+    date: Optional[int]
+    old_chat_member: Optional[OtherChatMember]
+    new_chat_member: Optional[OtherChatMember]
+
+
+class MessageBodyModel(BaseModel):
+    update_id: Optional[int]
+    message: Optional[Message]
+    my_chat_member: Optional[MyChatMember]
+    reply_to_message: Optional[ReplyMessage]
+
+
+class ResponseToMessage(BaseModel):
+    method: Optional[str] = "sendMessage"
+    chat_id: Optional[int] = 861126057
+    text: Optional[str] = ""
+    parse_mode: Optional[str] = "Markdown"

src/response_logic.py

@@ -0,0 +1,334 @@
+import random
+import asyncio
+
+from .db import *
+from .events import Events
+from .constants import Constants
+
+
+class ResponseLogic:
+    @staticmethod
+    async def create_response(
+        text: str, name: str, chat_id: int, language_code: str
+    ) -> str:
+
+        # Edge case check for "add\nSentence"
+        line_split_text = text.split("\n")
+        line_split_first_word = line_split_text[0]
+        split_text = text.split(" ")
+        first_word = split_text[0]
+        user = UserCreate(
+            name=name,
+            telegram_chat_id=chat_id,
+        )
+        if ResponseLogic.check_command_type(
+            first_word, "add"
+        ) or ResponseLogic.check_command_type(line_split_first_word, "add"):
+            if ResponseLogic.check_command_type(line_split_first_word, "add"):
+                memory = "\n".join(split_text[1:])
+            else:
+                memory = " ".join(split_text[1:])
+            if str.isspace(memory) or memory == "":
+                return Constants.Add.no_sentence(name, language_code)
+            else:
+                reminder = add_memory(user, memory)
+                if reminder is None:
+                    return Constants.Common.inactive_user(name, language_code)
+                elif reminder is False:
+                    return Constants.Add.already_added(name, language_code)
+                else:
+                    memory = reminder.reminder
+                    return Constants.Add.success(name, language_code, memory)
+        elif ResponseLogic.check_command_type(first_word, "start"):
+            user = join_user(user)
+            await Events.send_a_message_to_user(chat_id, Constants.hello)
+            return Constants.Start.start_message(name, language_code)
+        elif ResponseLogic.check_command_type(first_word, "help"):
+            message = Constants.Help.help_message(name, language_code)
+            return message
+
+        elif ResponseLogic.check_command_type(first_word, "join"):
+            user = join_user(user)
+
+            if user is not None:
+                return Constants.Join.successful_join(name, language_code)
+            else:
+                return Constants.Join.already_joined(name, language_code)
+
+        elif ResponseLogic.check_command_type(first_word, "leave"):
+            user = leave_user(user)
+            if user is not None and user.telegram_chat_id == chat_id:
+                return Constants.Leave.successful_leave(name, language_code)
+            else:
+                return Constants.Leave.already_left(name, language_code)
+
+        elif ResponseLogic.check_command_type(first_word, "send"):
+            if len(split_text) == 1:  # send
+                memory = select_random_memory(user)
+                if memory is None:
+                    return Constants.Common.inactive_user(name, language_code)
+                elif memory is False:
+                    return Constants.Common.no_memory_found(name, language_code)
+                else:
+                    return memory.reminder
+            else:  # send number
+                try:
+                    number_of_sending = int(split_text[1])
+                    if not (1 <= number_of_sending < 50):
+                        return Constants.Send.send_count_out_of_bound(
+                            name, language_code
+                        )
+                except:
+                    return Constants.Send.send_count_out_of_bound(name, language_code)
+
+                all_memories = list_memories(user)
+                if len(all_memories) == 0:
+                    return Constants.Common.no_memory_found(name, language_code)
+
+                send_count = min(len(all_memories), number_of_sending)
+                selected_memories = random.sample(all_memories, send_count)
+                for memory in selected_memories:  # Send the memories in background
+                    asyncio.create_task(
+                        Events.send_a_message_to_user(
+                            user.telegram_chat_id, memory.reminder
+                        )
+                    )
+                return ""
+
+        elif ResponseLogic.check_command_type(first_word, "list"):
+            memories = list_memories(user)
+            memory_count = len(memories)
+            if memories is None:
+                return Constants.Common.inactive_user(name, language_code)
+            elif memory_count == 0:
+                return Constants.Common.no_memory_found(name, language_code)
+            else:
+                background_message_list = []
+                for message_id, reminder in enumerate(memories):
+                    background_message_list.append(
+                        f"\n{message_id}: {reminder.reminder}"
+                    )
+                asyncio.create_task(
+                    Events.send_message_list_at_background(
+                        telegram_chat_id=chat_id, message_list=background_message_list
+                    )
+                )
+
+                response_message = Constants.List.list_messages(
+                    name, memory_count, language_code
+                )
+                return response_message
+
+        elif ResponseLogic.check_command_type(first_word, "delete"):
+            if len(split_text) < 2:
+                return Constants.Delete.no_id(name, language_code)
+            else:
+                try:
+                    memory_id = int(split_text[1])
+                    if memory_id < 0:
+                        return Constants.Delete.no_id(name, language_code)
+                    else:
+                        response = delete_memory(user, memory_id)
+                        if response is None:
+                            return Constants.Common.inactive_user(name, language_code)
+                        elif response is False:
+                            return Constants.Delete.no_id(name, language_code)
+                        else:
+                            memory = response
+
+                            return Constants.Delete.success(name, language_code, memory)
+
+                except Exception as ex:
+                    return Constants.Delete.no_id(name, language_code)
+
+        elif ResponseLogic.check_command_type(first_word, "schedule"):
+            if len(split_text) == 1:
+                schedule = get_schedule(user)
+                if schedule is None:
+                    return Constants.Common.inactive_user(name, language_code)
+                elif schedule == "":
+                    return Constants.Schedule.empty_schedule(name, language_code)
+                else:
+                    return Constants.Schedule.success(name, language_code, schedule)
+
+            elif len(split_text) > 1:
+                if split_text[1] == "reset":
+                    new_schedule = reset_schedule(user)
+                    if new_schedule is None:
+                        return Constants.Common.inactive_user(name, language_code)
+                    else:
+                        return Constants.Schedule.success(
+                            name, language_code, new_schedule
+                        )
+
+                elif split_text[1] == "add":
+                    str_numbers = []
+                    preceding_text = " ".join(split_text[2:])
+                    if str.isspace(preceding_text) or preceding_text == "":
+                        return Constants.Schedule.no_number_found(name, language_code)
+
+                    number_check = True
+                    try:
+                        for str_number in split_text[2:]:
+                            number = int(str_number)
+                            str_numbers.append(number)
+                            if not (0 <= number <= 23):
+                                number_check = False
+                                break
+                    except:
+                        return Constants.Schedule.add_incorrect_number_input(
+                            name, language_code
+                        )
+
+                    if not number_check:
+                        return Constants.Schedule.add_incorrect_number_input(
+                            name, language_code
+                        )
+
+                    else:
+                        new_schedule = add_hours_to_the_schedule(user, str_numbers)
+                        if new_schedule is None:
+                            return Constants.Common.inactive_user(name, language_code)
+                        else:
+                            return Constants.Schedule.success(
+                                name, language_code, new_schedule
+                            )
+
+                elif split_text[1] == "remove":
+                    preceding_text = " ".join(split_text[2:])
+                    number_check = True
+                    if str.isspace(preceding_text) or preceding_text == "":
+                        return Constants.Schedule.remove_incorrect_number_input(
+                            name, language_code
+                        )
+                    else:
+                        try:
+                            str_number = split_text[2]
+                            number = int(str_number)
+                            if not (0 <= number <= 23):
+                                number_check = False
+                        except:
+                            return Constants.Schedule.remove_incorrect_number_input(
+                                name, language_code
+                            )
+
+                        if not number_check:
+                            return Constants.Schedule.remove_incorrect_number_input(
+                                name, language_code
+                            )
+
+                        else:
+                            new_schedule = remove_hour_from_schedule(
+                                user, int(str_number)
+                            )
+                            if new_schedule is None:
+                                return Constants.Common.inactive_user(
+                                    name, language_code
+                                )
+                            else:
+                                return Constants.Schedule.success(
+                                    name, language_code, new_schedule
+                                )
+
+                else:
+                    return Constants.Schedule.unknown_command(name, language_code)
+
+        elif ResponseLogic.check_command_type(first_word, "gmt"):
+            try:
+                gmt = int(split_text[1])
+            except Exception as ex:
+                return Constants.Gmt.incorrect_timezone(name, language_code)
+            if not (-12 <= gmt <= 12):
+                return Constants.Gmt.incorrect_timezone(name, language_code)
+            else:
+                user = update_gmt(user, gmt)
+                if user is None:
+                    return Constants.Common.inactive_user(name, language_code)
+                else:
+                    return Constants.Gmt.success(name, language_code, user.gmt)
+
+        elif ResponseLogic.check_command_type(first_word, "broadcast"):
+            if not chat_id == Constants.BROADCAST_CHAT_ID:
+                return Constants.Broadcast.no_right(name, language_code)
+            else:
+                normalized_text = " ".join(split_text[1:])
+                if str.isspace(normalized_text) or normalized_text == "":
+                    return Constants.Broadcast.no_sentence_found(name, language_code)
+                else:
+                    await Events.broadcast_message(normalized_text)
+                    return Constants.Broadcast.success(name, language_code)
+
+        elif ResponseLogic.check_command_type(first_word, "status"):
+            gmt, active = get_user_status(chat_id)
+            if gmt is None:
+                return Constants.Common.inactive_user(name, language_code)
+            else:
+                schedule = get_schedule(user)
+                memory_count = len(list_memories(user))
+                return Constants.Status.get_status(
+                    name, language_code, gmt, active, schedule, memory_count
+                )
+
+        elif ResponseLogic.check_command_type(first_word, "feedback"):
+
+            message = " ".join(split_text[1:])
+            message_with_user_information = (
+                message + f"\nFrom the user: *{name}* \nchat id: *{chat_id}*"
+            )
+
+            if str.isspace(message) or message == "":
+                return Constants.Feedback.no_message(name, language_code)
+            else:
+                success = await Events.send_a_message_to_user(
+                    Constants.FEEDBACK_FORWARD_CHAT_ID, message_with_user_information
+                )
+                if success:
+                    return Constants.Feedback.success(name, language_code, message)
+                else:
+                    return Constants.Feedback.fail(name, language_code)
+
+        elif ResponseLogic.check_command_type(first_word, "deletelast"):
+            response = delete_last_memory(user)
+            if response is None:
+                return Constants.Common.inactive_user(name, language_code)
+            elif response is False:
+                return Constants.Common.no_memory_found(name, language_code)
+            else:
+                return Constants.Delete.success(name, language_code, response)
+
+        elif ResponseLogic.check_command_type(first_word, "support"):
+            return Constants.Support.support(name, language_code)
+
+        elif ResponseLogic.check_command_type(first_word, "tutorial1"):
+            return Constants.Tutorial.tutorial_1(name, language_code)
+
+        elif ResponseLogic.check_command_type(first_word, "tutorial2"):
+            return Constants.Tutorial.tutorial_2(name, language_code)
+
+        elif ResponseLogic.check_command_type(first_word, "tutorial3"):
+            return Constants.Tutorial.tutorial_3(name, language_code)
+
+        else:
+            return Constants.Common.unknown_command(name, language_code)
+
+    @staticmethod
+    def check_command_type(input_command: str, correct_command: str) -> bool:
+        """
+        Checks the first word of the command, which starts the decision tree.
+
+        Args:
+            input_command:
+            correct_command:
+
+        Returns: bool
+
+        """
+        input_command = input_command.lower()
+        if (
+            input_command == correct_command
+            or input_command == f"/{correct_command}"
+            or input_command == f"/{correct_command}@memory_vault_bot"
+        ):
+            return True
+        else:
+            return False