django-outlook-sync 1.0.0__tar.gz

django_outlook_sync-1.0.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: django-outlook-sync
+Version: 1.0.0
+Summary: A standalone reusable Django package to automate background syncing of local desktop Outlook emails.
+Author-email: Yonas <yonas2754@gmail.com>
+Classifier: Framework :: Django
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pywin32; sys_platform == "win32"
+Requires-Dist: schedule>=1.2.0
+Requires-Dist: djangorestframework>=3.14.0
+
+# Django Outlook Sync Engine
+
+A reusable Django module to sync structural message items seamlessly from localized Outlook desktop software installations into individual app environments.
+
+## Setup Instructions
+1. Install your local package.
+2. Register `'django_outlook_sync'` in your `INSTALLED_APPS`.
+3. Run `python manage.py migrate`.

django_outlook_sync-1.0.0/README.md

@@ -0,0 +1,8 @@
+# Django Outlook Sync Engine
+
+A reusable Django module to sync structural message items seamlessly from localized Outlook desktop software installations into individual app environments.
+
+## Setup Instructions
+1. Install your local package.
+2. Register `'django_outlook_sync'` in your `INSTALLED_APPS`.
+3. Run `python manage.py migrate`.

django_outlook_sync-1.0.0/django_outlook_sync/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+class DjangoOutlookSyncConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'django_outlook_sync'
+    verbose_name = "Django Outlook Sync Engine"

django_outlook_sync-1.0.0/django_outlook_sync/bin/auto_sync.py

@@ -0,0 +1,52 @@
+import os
+import sys
+import time
+import subprocess
+import schedule
+from datetime import datetime
+
+def run_django_sync():
+    current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    print(f"[{current_time}] Triggering automated Outlook database sync...")
+    
+    try:
+        # Executes within context of target project using active runtime interpreter variables
+        result = subprocess.run(
+            [sys.executable, "manage.py", "sync_outlook"],
+            capture_output=True,
+            text=True
+        )
+        
+        log_file_path = "sync_log.txt"
+        with open(log_file_path, "a") as log:
+            log.write(f"--- Sync executed at {current_time} ---\n")
+            log.write(result.stdout)
+            if result.stderr:
+                log.write(f"Errors:\n{result.stderr}")
+            log.write("\n")
+            
+        print(f"[{current_time}] Sync pipeline finished successfully.")
+        
+    except Exception as e:
+        print(f"[{current_time}] Critical automation failure: {str(e)}")
+
+def main():
+    if not os.path.exists("manage.py"):
+        print("❌ Error: 'manage.py' not found! Open your terminal in a valid Django project root folder to run this engine daemon.")
+        sys.exit(1)
+
+    schedule.every(5).minutes.do(run_django_sync)
+    run_django_sync()
+
+    print("⏰ Outlook background daemon initialized. Keeping alive... (Press Ctrl+C to exit)")
+
+    while True:
+        try:
+            schedule.run_pending()
+            time.sleep(1)
+        except KeyboardInterrupt:
+            print("\nStopping Outlook background daemon. Goodbye!")
+            sys.exit(0)
+
+if __name__ == "__main__":
+    main()

django_outlook_sync-1.0.0/django_outlook_sync/management/commands/sync_outlook.py

@@ -0,0 +1,19 @@
+from django.core.management.base import BaseCommand
+from django_outlook_sync.outlook import OutlookService
+from django_outlook_sync.sync import SyncService
+
+class Command(BaseCommand):
+    help = "Sync outlook emails from running desktop application client environment"
+
+    def handle(self, *args, **options):
+        self.stdout.write("Initializing local COM Connection parameters...")
+        try:
+            outlook = OutlookService()
+            messages = outlook.get_messages()
+            
+            self.stdout.write("Running processing pipelines...")
+            SyncService().run(messages)
+            
+            self.stdout.write(self.style.SUCCESS("Outlook database sync completed successfully."))
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"Sync operation encountered failures: {str(e)}"))

django_outlook_sync-1.0.0/django_outlook_sync/models.py

@@ -0,0 +1,18 @@
+from django.db import models
+
+class EmailMessage(models.Model):
+    message_id = models.CharField(max_length=255, unique=True)
+    subject = models.CharField(max_length=500, blank=True, null=True)
+    sender = models.CharField(max_length=255, blank=True, null=True)
+    recipients = models.TextField(blank=True, null=True)
+    cc_recipients = models.TextField(blank=True, null=True)
+    html_body = models.TextField(blank=True, null=True)
+    received_at = models.DateTimeField()
+    is_thread_reply = models.BooleanField(default=False)
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        db_table = 'outlook_email_messages'
+
+    def __str__(self):
+        return f"{self.subject or 'No Subject'} - {self.sender or 'Unknown'}"

django_outlook_sync-1.0.0/django_outlook_sync/outlook.py

@@ -0,0 +1,18 @@
+import sys
+
+class OutlookService:
+    def __init__(self):
+        if sys.platform != "win32":
+            raise OSError("OutlookService requires a Windows Environment running Microsoft Outlook.")
+        
+        import win32com.client
+        import pythoncom
+        
+        pythoncom.CoInitialize()
+        self.outlook = win32com.client.Dispatch("Outlook.Application").GetNamespace("MAPI")
+
+    def get_messages(self):
+        inbox = self.outlook.GetDefaultFolder(6)
+        messages = inbox.Items
+        messages.Sort("[ReceivedTime]", True)
+        return messages

django_outlook_sync-1.0.0/django_outlook_sync/serializers.py

@@ -0,0 +1,18 @@
+from rest_framework import serializers
+from .models import EmailMessage
+
+class EmailMessageSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = EmailMessage
+        fields = [
+            'id',
+            'message_id',
+            'subject',
+            'sender',
+            'recipients',
+            'cc_recipients',
+            'received_at',
+            'is_thread_reply',
+            'created_at',
+            'html_body',
+        ]

django_outlook_sync-1.0.0/django_outlook_sync/sync.py

@@ -0,0 +1,153 @@
+import os
+import re
+from datetime import datetime, timedelta
+
+from django.conf import settings
+from django.utils.timezone import make_aware
+from django.db import transaction, IntegrityError
+
+from .models import EmailMessage
+
+
+class SyncService:
+
+    def __init__(self):
+        # Fetch configurations from parent project settings with safe default fallbacks
+        self.allowed_recipients = getattr(settings, "OUTLOOK_ALLOWED_RECIPIENTS", [])
+        self.auto_reply_template = getattr(
+            settings, 
+            "OUTLOOK_REPLY_TEMPLATE", 
+            "<p>Hello,</p><p>Your email has been received and processed.</p><p>Thank you.</p>"
+        )
+
+    def is_valid_recipient(self, to_field, cc_field):
+        if not self.allowed_recipients:
+            return True
+            
+        all_recipients = f"{to_field} {cc_field}".lower()
+        return all(name.lower() in all_recipients for name in self.allowed_recipients)
+
+    def run(self, messages):
+        now = datetime.now()
+        five_minutes_ago = now - timedelta(minutes=5)
+        saved_count = 0
+
+        output_dir = os.path.join(settings.BASE_DIR, "static", "email_images")
+        os.makedirs(output_dir, exist_ok=True)
+
+        try:
+            messages.Sort("[ReceivedTime]", True)
+            messages_list = list(messages)
+        except Exception as e:
+            print(f"Unable to natively sort messages: {e}")
+            messages_list = list(messages)
+
+        print(f"Processing {len(messages_list)} messages")
+
+        for msg in messages_list:
+            try:
+                if getattr(msg, "Class", 0) != 43:
+                    continue
+
+                message_id = getattr(msg, "EntryID", None)
+                if not message_id:
+                    continue
+
+                raw_time = getattr(msg, "ReceivedTime", None)
+                if not raw_time:
+                    continue
+
+                naive_dt = datetime(
+                    raw_time.year, raw_time.month, raw_time.day,
+                    raw_time.hour, raw_time.minute, raw_time.second,
+                )
+
+                if naive_dt < five_minutes_ago:
+                    continue
+
+                subject = getattr(msg, "Subject", "No Subject")
+                sender = getattr(msg, "SenderName", "Unknown Sender")
+                received_at = make_aware(naive_dt)
+
+                to_recipients = getattr(msg, "To", "")
+                cc_recipients = getattr(msg, "CC", "")
+
+                if not self.is_valid_recipient(to_recipients, cc_recipients):
+                    continue
+
+                id_exists = EmailMessage.objects.filter(message_id=message_id).exists()
+                footprint_exists = EmailMessage.objects.filter(
+                    sender=sender, subject=subject, received_at=received_at
+                ).exists()
+
+                if id_exists or footprint_exists:
+                    continue
+
+                html_body = getattr(msg, "HTMLBody", "")
+
+                if html_body and "Your email has been received and processed." in html_body:
+                    print(f"Skipping email '{subject}'—loop protection.")
+                    continue
+
+                print(f"Processing New Email: {subject} from {sender}")
+
+                if html_body:
+                    html_body = re.sub(
+                        r"IMPORTANT\..*?actually\s+virus\s+free\s*\.?",
+                        "", html_body, flags=re.DOTALL | re.IGNORECASE,
+                    )
+                    html_body = re.sub(r"<p[^>]*>\s*</p>", "", html_body)
+                    html_body = re.sub(r"<div[^>]*>\s*</div>", "", html_body)
+
+                safe_msg_id = re.sub(r"[^a-zA-Z0-9]", "", str(message_id))[-20:]
+                attachments = getattr(msg, "Attachments", None)
+
+                if attachments and attachments.Count > 0:
+                    for i in range(1, attachments.Count + 1):
+                        attachment = attachments.Item(i)
+                        try:
+                            cid = attachment.PropertyAccessor.GetProperty(
+                                "http://schemas.microsoft.com/mapi/proptag/0x3712001E"
+                            )
+                        except Exception:
+                            cid = None
+
+                        if cid:
+                            file_ext = os.path.splitext(attachment.FileName)[1] or ".png"
+                            filename = f"{safe_msg_id}_{cid}{file_ext}"
+                            file_path = os.path.join(output_dir, filename)
+                            attachment.SaveAsFile(file_path)
+
+                            html_body = html_body.replace(
+                                f"cid:{cid}", f"/static/email_images/{filename}"
+                            )
+
+                is_reply = subject and subject.lower().strip().startswith(("re:", "fw:"))
+
+                try:
+                    with transaction.atomic():
+                        EmailMessage.objects.create(
+                            message_id=message_id,
+                            subject=subject,
+                            sender=sender,
+                            recipients=to_recipients,
+                            cc_recipients=cc_recipients,
+                            html_body=html_body,
+                            received_at=received_at,
+                            is_thread_reply=is_reply,
+                        )
+
+                        reply = msg.Reply()
+                        reply.HTMLBody = self.auto_reply_template + reply.HTMLBody
+                        reply.Send()
+                        saved_count += 1
+
+                except IntegrityError:
+                    print(f"Duplicate blocked: {subject}")
+                    continue
+
+            except Exception as e:
+                print(f"Skipping unreadable email: {e}")
+                continue
+
+        print(f"Sync completed: {saved_count} emails processed since {five_minutes_ago}")

django_outlook_sync-1.0.0/django_outlook_sync.egg-info/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: django-outlook-sync
+Version: 1.0.0
+Summary: A standalone reusable Django package to automate background syncing of local desktop Outlook emails.
+Author-email: Yonas <yonas2754@gmail.com>
+Classifier: Framework :: Django
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pywin32; sys_platform == "win32"
+Requires-Dist: schedule>=1.2.0
+Requires-Dist: djangorestframework>=3.14.0
+
+# Django Outlook Sync Engine
+
+A reusable Django module to sync structural message items seamlessly from localized Outlook desktop software installations into individual app environments.
+
+## Setup Instructions
+1. Install your local package.
+2. Register `'django_outlook_sync'` in your `INSTALLED_APPS`.
+3. Run `python manage.py migrate`.

django_outlook_sync-1.0.0/django_outlook_sync.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+django_outlook_sync/__init__.py
+django_outlook_sync/apps.py
+django_outlook_sync/models.py
+django_outlook_sync/outlook.py
+django_outlook_sync/serializers.py
+django_outlook_sync/sync.py
+django_outlook_sync.egg-info/PKG-INFO
+django_outlook_sync.egg-info/SOURCES.txt
+django_outlook_sync.egg-info/dependency_links.txt
+django_outlook_sync.egg-info/entry_points.txt
+django_outlook_sync.egg-info/requires.txt
+django_outlook_sync.egg-info/top_level.txt
+django_outlook_sync/bin/__init__.py
+django_outlook_sync/bin/auto_sync.py
+django_outlook_sync/management/__init__.py
+django_outlook_sync/management/commands/__init__.py
+django_outlook_sync/management/commands/sync_outlook.py

django_outlook_sync-1.0.0/django_outlook_sync.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

django_outlook_sync-1.0.0/django_outlook_sync.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+django-outlook-daemon = django_outlook_sync.bin.auto_sync:main

django_outlook_sync-1.0.0/django_outlook_sync.egg-info/requires.txt

@@ -0,0 +1,5 @@
+schedule>=1.2.0
+djangorestframework>=3.14.0
+
+[:sys_platform == "win32"]
+pywin32

django_outlook_sync-1.0.0/django_outlook_sync.egg-info/top_level.txt

@@ -0,0 +1 @@
+django_outlook_sync

django_outlook_sync-1.0.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "django-outlook-sync"
+version = "1.0.0"
+authors = [
+    { name="Yonas", email="yonas2754@gmail.com" }
+]
+description = "A standalone reusable Django package to automate background syncing of local desktop Outlook emails."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Framework :: Django",
+    "Programming Language :: Python :: 3",
+    "Operating System :: Microsoft :: Windows",
+]
+dependencies = [
+    "pywin32; sys_platform == 'win32'",
+    "schedule>=1.2.0",
+    "djangorestframework>=3.14.0",
+]
+
+[project.scripts]
+django-outlook-daemon = "django_outlook_sync.bin.auto_sync:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["django_outlook_sync*"]

django_outlook_sync-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+