postfix_access_policy_delegation protocol

postfixSenderPolicy/cacheManager.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python2.7
+import os,sys
+sys.path.append('/usr/local/CyberCP')
+import django
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "CyberCP.settings")
+django.setup()
+sys.path.append('/usr/local/CyberCP')
+from plogical.CyberCPLogFileWriter import CyberCPLogFileWriter as logging
+from emailPremium.models import EmailLimits, DomainLimits, Domains, EUsers
+
+class cacheManager:
+    domains = {}
+
+    @staticmethod
+    def flushCache():
+        try:
+
+            for domain, domainOBJ in cacheManager.domains.iteritems():
+                domaindb = Domains.objects.get(domain=domain)
+                dbDomain = DomainLimits.objects.get(domain=domaindb)
+
+                totalDomainUsed = 0
+
+                for email, emailOBJ in domainOBJ.emails.iteritems():
+                    emailID = EUsers.objects.get(email=email)
+                    dbEmail = EmailLimits.objects.get(email=emailID)
+
+                    dbEmail.monthlyUsed = emailOBJ.monthlyUsed
+                    dbEmail.hourlyUsed = emailOBJ.hourlyUsed
+
+                    totalDomainUsed = totalDomainUsed + emailOBJ.monthlyUsed
+                    dbEmail.save()
+
+                dbDomain.monthlyUsed = totalDomainUsed
+                dbDomain.save()
+
+        except BaseException, msg:
+            logging.writeToFile(str(msg))
+
+    @staticmethod
+    def disableEnableLogs(self, emailAddress, operationValue):
+        try:
+            domainName = emailAddress.split('@')[1]
+
+            if domainName in cacheManager.domains:
+                domainOBJ = cacheManager.domains[domainName]
+                if emailAddress in domainOBJ.emails:
+                    emailOBJ = domainOBJ.emails[emailAddress]
+                    emailOBJ.logStatus = operationValue
+
+        except BaseException, msg:
+            logging.writeToFile(str(msg))
+
+    @staticmethod
+    def purgeLog(command):
+        try:
+            email = command[2]
+            operationVal = int(command[3])
+            domain = email.split('@')[1]
+
+            if domain in cacheManager.domains:
+                domainOBJ = cacheManager.domains[domain]
+                emailOBJ = domainOBJ.emails[email]
+                emailOBJ.logStatus = operationVal
+
+        except BaseException, msg:
+            logging.writeToFile(str(msg))
+
+    @staticmethod
+    def purgeLimit(command):
+        try:
+            email = command[2]
+            operationVal = int(command[3])
+            domain = email.split('@')[1]
+
+            if domain in cacheManager.domains:
+                domainOBJ = cacheManager.domains[domain]
+                emailOBJ = domainOBJ.emails[email]
+                emailOBJ.limitStatus = operationVal
+
+        except BaseException, msg:
+            logging.writeToFile(str(msg))
+
+    @staticmethod
+    def purgeLimitDomain(command):
+        try:
+            domain = command[2]
+            operationVal = int(command[3])
+
+            if domain in cacheManager.domains:
+                domainOBJ = cacheManager.domains[domain]
+                domainOBJ.limitStatus = operationVal
+
+        except BaseException, msg:
+            logging.writeToFile(str(msg))
+
+    @staticmethod
+    def updateDomainLimit(command):
+        try:
+            domain = command[2]
+            newLimit = int(command[3])
+
+            if domain in cacheManager.domains:
+                domainOBJ = cacheManager.domains[domain]
+                domainOBJ.monthlyLimits = newLimit
+
+        except BaseException, msg:
+            logging.writeToFile(str(msg))
+
+    @staticmethod
+    def purgeLimitEmail(command):
+        try:
+            email = command[2]
+            monthlyLimit = int(command[3])
+            hourlyLimit = int(command[4])
+            domain = email.split('@')[1]
+
+            if domain in cacheManager.domains:
+                domainOBJ = cacheManager.domains[domain]
+                emailOBJ = domainOBJ.emails[email]
+                emailOBJ.monthlyLimits = monthlyLimit
+                emailOBJ.hourlyLimits = hourlyLimit
+
+        except BaseException, msg:
+            logging.writeToFile(str(msg))
+
+    @staticmethod
+    def hourlyCleanUP():
+        try:
+
+            for domain, domainOBJ in cacheManager.domains.iteritems():
+                for email, emailOBJ in domainOBJ.emails.iteritems():
+                    emailID = EUsers.objects.get(email=email)
+                    dbEmail = EmailLimits.objects.get(email=emailID)
+
+                    dbEmail.hourlyUsed = 0
+                    emailOBJ.hourlyUsed = 0
+                    dbEmail.save()
+
+        except BaseException, msg:
+            logging.writeToFile(str(msg))
+
+    @staticmethod
+    def monthlyCleanUP():
+        try:
+
+            for domain, domainOBJ in cacheManager.domains.iteritems():
+                domaindb = Domains.objects.get(domain=domain)
+                dbDomain = DomainLimits.objects.get(domain=domaindb)
+
+
+                for email, emailOBJ in domainOBJ.emails.iteritems():
+                    emailID = EUsers.objects.get(email=email)
+                    dbEmail = EmailLimits.objects.get(email=emailID)
+
+                    dbEmail.monthlyUsed = 0
+                    emailOBJ.monthlyUsed = 0
+                    dbEmail.hourlyUsed = 0
+                    emailOBJ.hourlyUsed = 0
+                    dbEmail.save()
+
+                dbDomain.monthlyUsed = 0
+                dbDomain.save()
+
+        except BaseException, msg:
+            logging.writeToFile(str(msg))
+
+
+    @staticmethod
+    def cleanUP(*args):
+        cacheManager.flushCache()
+        logging.writeToFile('Email Cleanup Service')
+        os._exit(0)
+
+    @staticmethod
+    def handlePurgeRequest(command):
+        try:
+            finalCommand = command.split(' ')
+
+            if finalCommand[1] == 'purgeLog':
+                cacheManager.purgeLog(finalCommand)
+            elif finalCommand[1] == 'purgeLimit':
+                cacheManager.purgeLimit(finalCommand)
+            elif finalCommand[1] == 'purgeLimitDomain':
+                cacheManager.purgeLimitDomain(finalCommand)
+            elif finalCommand[1] == 'updateDomainLimit':
+                cacheManager.updateDomainLimit(finalCommand)
+            elif finalCommand[1] == 'purgeLimitEmail':
+                cacheManager.purgeLimitEmail(finalCommand)
+            elif finalCommand[1] == 'hourlyCleanup':
+                cacheManager.hourlyCleanUP()
+            elif finalCommand[1] == 'monthlyCleanup':
+                cacheManager.monthlyCleanUP()
+
+
+        except BaseException, msg:
+            logging.writeToFile(str(msg))
+