CyberPanel/postfixSenderPolicy/cacheManager.py

#!/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))