CyberPanel/emailPremium/views.py

# -*- coding: utf-8 -*-
import os
import time

from django.shortcuts import redirect
from django.http import HttpResponse

from loginSystem.models import Administrator
from mailServer.models import Domains, EUsers
from plogical.applicationInstaller import ApplicationInstaller
from websiteFunctions.models import Websites
from loginSystem.views import loadLoginPage
import plogical.CyberCPLogFileWriter as logging
import json
from .models import DomainLimits, EmailLimits
from math import ceil
from postfixSenderPolicy.client import cacheClient
from plogical.mailUtilities import mailUtilities
from plogical.virtualHostUtilities import virtualHostUtilities
from random import randint
from plogical.acl import ACLManager
from plogical.processUtilities import ProcessUtilities
from plogical.httpProc import httpProc
from cloudAPI.cloudManager import CloudManager


## Email Policy Server

def emailPolicyServer(request):
    proc = httpProc(request, 'emailPremium/policyServer.html',
                    None, 'admin')
    return proc.render()


def fetchPolicyServerStatus(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        try:
            if request.method == 'POST':

                command = 'sudo cat /etc/postfix/main.cf'
                output = ProcessUtilities.outputExecutioner(command).split('\n')

                installCheck = 0

                for items in output:
                    if items.find('check_policy_service unix:/var/log/policyServerSocket') > -1:
                        installCheck = 1
                        break

                data_ret = {'status': 1, 'error_message': 'None', 'installCheck': installCheck}
                json_data = json.dumps(data_ret)
                return HttpResponse(json_data)


        except BaseException as msg:
            data_ret = {'status': 0, 'error_message': str(msg)}
            json_data = json.dumps(data_ret)
            return HttpResponse(json_data)

    except KeyError as msg:
        logging.CyberCPLogFileWriter.writeToFile(str(msg))
        data_ret = {'status': 0, 'error_message': str(msg)}
        json_data = json.dumps(data_ret)
        return HttpResponse(json_data)


def savePolicyServerStatus(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        try:
            if request.method == 'POST':

                data = json.loads(request.body)

                policServerStatus = data['policServerStatus']

                install = '0'

                if policServerStatus == True:
                    install = "1"

                ## save configuration data

                execPath = "/usr/local/CyberCP/bin/python " + virtualHostUtilities.cyberPanel + "/plogical/mailUtilities.py"
                execPath = execPath + " savePolicyServerStatus --install " + install
                output = ProcessUtilities.outputExecutioner(execPath)

                if output.find("1,None") > -1:
                    data_ret = {'status': 1, 'error_message': "None"}
                    json_data = json.dumps(data_ret)
                    return HttpResponse(json_data)
                else:
                    data_ret = {'status': 0, 'error_message': output}
                    json_data = json.dumps(data_ret)
                    return HttpResponse(json_data)


        except BaseException as msg:
            data_ret = {'status': 0, 'error_message': str(msg)}
            json_data = json.dumps(data_ret)
            return HttpResponse(json_data)

    except KeyError as msg:
        logging.CyberCPLogFileWriter.writeToFile(str(msg))
        data_ret = {'status': 0, 'error_message': str(msg)}
        json_data = json.dumps(data_ret)
        return HttpResponse(json_data)


## Email Policy Server configs

def listDomains(request):
    websites = DomainLimits.objects.all()

    ## Check if Policy Server is installed.

    command = 'sudo cat /etc/postfix/main.cf'
    output = ProcessUtilities.outputExecutioner(command).split('\n')

    installCheck = 0

    for items in output:
        if items.find('check_policy_service unix:/var/log/policyServerSocket') > -1:
            installCheck = 1
            break

    if installCheck == 0:
        proc = httpProc(request, 'emailPremium/listDomains.html', {"installCheck": installCheck}, 'admin')
        return proc.render()

    ###

    pages = float(len(websites)) / float(10)
    pagination = []

    if pages <= 1.0:
        pages = 1
        pagination.append('<li><a href="\#"></a></li>')
    else:
        pages = ceil(pages)
        finalPages = int(pages) + 1

        for i in range(1, finalPages):
            pagination.append('<li><a href="\#">' + str(i) + '</a></li>')

    proc = httpProc(request, 'emailPremium/listDomains.html',
                    {"pagination": pagination, "installCheck": installCheck}, 'admin')
    return proc.render()


def getFurtherDomains(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()

        try:

            if request.method == 'POST':
                try:
                    data = json.loads(request.body)
                    status = data['page']
                    pageNumber = int(status)

                except BaseException as msg:
                    status = str(msg)

            finalPageNumber = ((pageNumber * 10)) - 10
            endPageNumber = finalPageNumber + 10
            websites = Websites.objects.all()[finalPageNumber:endPageNumber]

            json_data = "["
            checker = 0

            for items in websites:
                try:
                    domain = Domains.objects.get(domainOwner=items)
                    domainLimits = DomainLimits.objects.get(domain=domain)

                    dic = {'domain': items.domain, 'emails': domain.eusers_set.all().count(),
                           'monthlyLimit': domainLimits.monthlyLimit, 'monthlyUsed': domainLimits.monthlyUsed,
                           'status': domainLimits.limitStatus}

                    if checker == 0:
                        json_data = json_data + json.dumps(dic)
                        checker = 1
                    else:
                        json_data = json_data + ',' + json.dumps(dic)
                except BaseException as msg:
                    try:
                        domain = Domains.objects.get(domainOwner=items)
                    except:
                        domain = Domains(domainOwner=items, domain=items.domain)
                        domain.save()

                    domainLimits = DomainLimits(domain=domain)
                    domainLimits.save()

                    dic = {'domain': items.domain, 'emails': domain.eusers_set.all().count(),
                           'monthlyLimit': domainLimits.monthlyLimit, 'monthlyUsed': domainLimits.monthlyUsed,
                           'status': domainLimits.limitStatus}

                    if checker == 0:
                        json_data = json_data + json.dumps(dic)
                        checker = 1
                    else:
                        json_data = json_data + ',' + json.dumps(dic)

            json_data = json_data + ']'
            final_dic = {'listWebSiteStatus': 1, 'error_message': "None", "data": json_data}
            final_json = json.dumps(final_dic)
            return HttpResponse(final_json)

        except BaseException as msg:
            dic = {'listWebSiteStatus': 0, 'error_message': str(msg)}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)


    except KeyError as msg:
        dic = {'listWebSiteStatus': 0, 'error_message': str(msg)}
        json_data = json.dumps(dic)
        return HttpResponse(json_data)


def enableDisableEmailLimits(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()

        try:
            if request.method == 'POST':
                data = json.loads(request.body)
                operationVal = data['operationVal']
                domainName = data['domainName']

                domain = Domains.objects.get(domain=domainName)

                domainLimits = DomainLimits.objects.get(domain=domain)
                domainLimits.limitStatus = operationVal
                domainLimits.save()

                command = 'cyberpanelCleaner purgeLimitDomain ' + domainName + ' ' + str(operationVal)
                cacheClient.handleCachePurgeRequest(command)

                dic = {'status': 1, 'error_message': 'None'}
                json_data = json.dumps(dic)
                return HttpResponse(json_data)

        except BaseException as msg:
            dic = {'status': 0, 'error_message': str(msg)}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)


    except KeyError as msg:
        dic = {'statusa': 0, 'error_message': str(msg)}
        json_data = json.dumps(dic)
        return HttpResponse(json_data)


def emailLimits(request, domain):
    if Websites.objects.filter(domain=domain).exists():
        website = Websites.objects.get(domain=domain)
        domainEmail = Domains.objects.get(domainOwner=website)
        domainLimits = DomainLimits.objects.get(domain=domainEmail)

        Data = {}
        Data['domain'] = domain
        Data['monthlyLimit'] = domainLimits.monthlyLimit
        Data['monthlyUsed'] = domainLimits.monthlyUsed
        Data['emailAccounts'] = domainEmail.eusers_set.count()

        if domainLimits.limitStatus == 1:
            Data['limitsOn'] = 1
            Data['limitsOff'] = 0
        else:
            Data['limitsOn'] = 0
            Data['limitsOff'] = 1

        ## Pagination for emails

        pages = float(Data['emailAccounts']) / float(10)
        pagination = []

        if pages <= 1.0:
            pages = 1
            pagination.append('<li><a href="\#"></a></li>')
        else:
            pages = ceil(pages)
            finalPages = int(pages) + 1

            for i in range(1, finalPages):
                pagination.append('<li><a href="\#">' + str(i) + '</a></li>')

        Data['pagination'] = pagination

        proc = httpProc(request, 'emailPremium/emailLimits.html', Data, 'admin')
        return proc.render()
    else:
        proc = httpProc(request, 'emailPremium/emailLimits.html', {"error": 1, "domain": "This domain does not exists"},
                        'admin')
        return proc.render()


def changeDomainLimit(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        try:
            if request.method == 'POST':
                data = json.loads(request.body)
                newLimit = data['newLimit']
                domainName = data['domainName']

                domain = Domains.objects.get(domain=domainName)

                domainLimits = DomainLimits.objects.get(domain=domain)
                domainLimits.monthlyLimit = newLimit
                domainLimits.save()

                command = 'cyberpanelCleaner updateDomainLimit ' + domainName + ' ' + str(newLimit)
                cacheClient.handleCachePurgeRequest(command)

                dic = {'status': 1, 'error_message': 'None'}
                json_data = json.dumps(dic)
                return HttpResponse(json_data)

        except BaseException as msg:
            dic = {'status': 0, 'error_message': str(msg)}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)


    except KeyError as msg:
        dic = {'statusa': 0, 'error_message': str(msg)}
        json_data = json.dumps(dic)
        return HttpResponse(json_data)


def getFurtherEmail(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        try:
            if request.method == 'POST':

                data = json.loads(request.body)
                status = data['page']
                domainName = data['domainName']
                pageNumber = int(status)

                finalPageNumber = ((pageNumber * 10)) - 10
                endPageNumber = finalPageNumber + 10
                domain = Domains.objects.get(domain=domainName)
                emails = domain.eusers_set.all()[finalPageNumber:endPageNumber]

                json_data = "["
                checker = 0

                for item in emails:

                    try:
                        emailLts = EmailLimits.objects.get(email=item)

                        dic = {'email': item.email, 'monthlyLimit': emailLts.monthlyLimits,
                               'monthlyUsed': emailLts.monthlyUsed, 'hourlyLimit': emailLts.hourlyLimit,
                               'hourlyUsed': emailLts.hourlyUsed, 'status': emailLts.limitStatus}

                        if checker == 0:
                            json_data = json_data + json.dumps(dic)
                            checker = 1
                        else:
                            json_data = json_data + ',' + json.dumps(dic)
                    except BaseException as msg:
                        logging.CyberCPLogFileWriter.writeToFile(str(msg))

                json_data = json_data + ']'
                final_dic = {'status': 1, 'error_message': "None", "data": json_data}
                final_json = json.dumps(final_dic)

                return HttpResponse(final_json)

        except BaseException as msg:
            dic = {'status': 0, 'error_message': str(msg)}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)


    except KeyError as msg:
        dic = {'status': 0, 'error_message': str(msg)}
        json_data = json.dumps(dic)
        return HttpResponse(json_data)


def enableDisableIndividualEmailLimits(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        try:
            if request.method == 'POST':
                data = json.loads(request.body)
                operationVal = data['operationVal']
                emailAddress = data['emailAddress']

                email = EUsers.objects.get(email=emailAddress)
                emailtLts = EmailLimits.objects.get(email=email)
                emailtLts.limitStatus = operationVal
                emailtLts.save()

                command = 'cyberpanelCleaner purgeLimit ' + emailAddress + ' ' + str(operationVal)
                cacheClient.handleCachePurgeRequest(command)

                dic = {'status': 1, 'error_message': 'None'}
                json_data = json.dumps(dic)
                return HttpResponse(json_data)

        except BaseException as msg:
            dic = {'status': 0, 'error_message': str(msg)}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)

    except KeyError as msg:
        dic = {'statusa': 0, 'error_message': str(msg)}
        json_data = json.dumps(dic)
        return HttpResponse(json_data)


def emailPage(request, emailAddress):
    Data = {}
    Data['emailAddress'] = emailAddress

    email = EUsers.objects.get(email=emailAddress)
    logEntries = email.emaillogs_set.all().count()

    pages = float(logEntries) / float(10)
    pagination = []

    if pages <= 1.0:
        pages = 1
        pagination.append('<li><a href="\#"></a></li>')
    else:
        pages = ceil(pages)
        finalPages = int(pages) + 1

        for i in range(1, finalPages):
            pagination.append('<li><a href="\#">' + str(i) + '</a></li>')

    Data['pagination'] = pagination

    proc = httpProc(request, 'emailPremium/emailPage.html', Data, 'admin')
    return proc.render()


def getEmailStats(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        try:
            if request.method == 'POST':
                data = json.loads(request.body)
                emailAddress = data['emailAddress']

                email = EUsers.objects.get(email=emailAddress)
                emailLTS = EmailLimits.objects.get(email=email)

                final_dic = {'status': 1, 'error_message': "None", "monthlyLimit": emailLTS.monthlyLimits,
                             'monthlyUsed': emailLTS.monthlyUsed, 'hourlyLimit': emailLTS.hourlyLimit,
                             'hourlyUsed': emailLTS.hourlyUsed,
                             'limitStatus': emailLTS.limitStatus, 'logsStatus': emailLTS.emailLogs}

                final_json = json.dumps(final_dic)

                return HttpResponse(final_json)

        except BaseException as msg:
            dic = {'status': 0, 'error_message': str(msg)}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)


    except KeyError as msg:
        dic = {'status': 0, 'error_message': str(msg)}
        json_data = json.dumps(dic)
        return HttpResponse(json_data)


def enableDisableIndividualEmailLogs(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        try:
            if request.method == 'POST':
                data = json.loads(request.body)
                operationVal = data['operationVal']
                emailAddress = data['emailAddress']

                email = EUsers.objects.get(email=emailAddress)
                emailtLts = EmailLimits.objects.get(email=email)
                emailtLts.emailLogs = operationVal
                emailtLts.save()

                command = 'cyberpanelCleaner purgeLog ' + emailAddress + ' ' + str(operationVal)
                cacheClient.handleCachePurgeRequest(command)

                dic = {'status': 1, 'error_message': 'None'}
                json_data = json.dumps(dic)
                return HttpResponse(json_data)

        except BaseException as msg:
            dic = {'status': 0, 'error_message': str(msg)}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)

    except KeyError as msg:
        dic = {'statusa': 0, 'error_message': str(msg)}
        json_data = json.dumps(dic)
        return HttpResponse(json_data)


def changeDomainEmailLimitsIndividual(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        try:
            if request.method == 'POST':

                data = json.loads(request.body)
                emailAddress = data['emailAddress']
                monthlyLimit = data['monthlyLimit']
                hourlyLimit = data['hourlyLimit']

                ## Limits Check

                if monthlyLimit < hourlyLimit:
                    dic = {'status': 0, 'error_message': 'Monthly limit should be greater then hourly limit.'}
                    json_data = json.dumps(dic)
                    return HttpResponse(json_data)

                domainName = emailAddress.split('@')[1]
                dbDomain = Domains.objects.get(domain=domainName)

                domainLimit = DomainLimits.objects.get(domain=dbDomain)

                allEmails = dbDomain.eusers_set.all()
                currentEmailConsumption = 0

                for email in allEmails:
                    emailLTS = EmailLimits.objects.get(email=email)
                    currentEmailConsumption = emailLTS.monthlyLimits + currentEmailConsumption

                allowedLimit = domainLimit.monthlyLimit - currentEmailConsumption

                if monthlyLimit > allowedLimit:
                    dic = {'status': 0,
                           'error_message': 'You can not set this monthly limit, first increase limits for this domain.'}
                    json_data = json.dumps(dic)
                    return HttpResponse(json_data)

                ## Limits Check End

                email = EUsers.objects.get(email=emailAddress)
                emailLTS = EmailLimits.objects.get(email=email)

                emailLTS.monthlyLimits = monthlyLimit
                emailLTS.hourlyLimit = hourlyLimit

                emailLTS.save()

                command = 'cyberpanelCleaner purgeLimitEmail ' + emailAddress + ' ' + str(monthlyLimit) + ' ' + str(
                    hourlyLimit)
                cacheClient.handleCachePurgeRequest(command)

                dic = {'status': 1, 'error_message': 'None'}
                json_data = json.dumps(dic)
                return HttpResponse(json_data)

        except BaseException as msg:
            dic = {'status': 0, 'error_message': str(msg)}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)


    except KeyError as msg:
        dic = {'statusa': 0, 'error_message': str(msg)}
        json_data = json.dumps(dic)
        return HttpResponse(json_data)


def getEmailLogs(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        try:
            if request.method == 'POST':

                data = json.loads(request.body)
                status = data['page']
                emailAddress = data['emailAddress']
                pageNumber = int(status)

                finalPageNumber = ((pageNumber * 10)) - 10
                endPageNumber = finalPageNumber + 10
                email = EUsers.objects.get(email=emailAddress)
                logEntries = email.emaillogs_set.all()[finalPageNumber:endPageNumber]

                json_data = "["
                checker = 0

                for item in logEntries:

                    dic = {'id': item.id, 'source': emailAddress, 'destination': item.destination,
                           'time': item.timeStamp}

                    if checker == 0:
                        json_data = json_data + json.dumps(dic)
                        checker = 1
                    else:
                        json_data = json_data + ',' + json.dumps(dic)

                json_data = json_data + ']'
                final_dic = {'status': 1, 'error_message': "None", "data": json_data}
                final_json = json.dumps(final_dic)

                return HttpResponse(final_json)

        except BaseException as msg:
            dic = {'status': 0, 'error_message': str(msg)}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)


    except KeyError as msg:
        dic = {'status': 0, 'error_message': str(msg)}
        json_data = json.dumps(dic)
        return HttpResponse(json_data)


def flushEmailLogs(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        try:
            if request.method == 'POST':

                data = json.loads(request.body)
                emailAddress = data['emailAddress']

                email = EUsers.objects.get(email=emailAddress)

                for logEntry in email.emaillogs_set.all():
                    logEntry.delete()

                dic = {'status': 1, 'error_message': 'None'}
                json_data = json.dumps(dic)
                return HttpResponse(json_data)

        except BaseException as msg:
            dic = {'status': 0, 'error_message': str(msg)}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)

    except KeyError as msg:
        dic = {'statusa': 0, 'error_message': str(msg)}
        json_data = json.dumps(dic)
        return HttpResponse(json_data)


### SpamAssassin

def spamAssassinHome(request):
    checkIfSpamAssassinInstalled = 0

    if mailUtilities.checkIfSpamAssassinInstalled() == 1:
        checkIfSpamAssassinInstalled = 1

    proc = httpProc(request, 'emailPremium/SpamAssassin.html',
                    {'checkIfSpamAssassinInstalled': checkIfSpamAssassinInstalled}, 'admin')
    return proc.render()


def installSpamAssassin(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        try:

            execPath = "/usr/local/CyberCP/bin/python " + virtualHostUtilities.cyberPanel + "/plogical/mailUtilities.py"
            execPath = execPath + " installSpamAssassin"
            ProcessUtilities.popenExecutioner(execPath)

            final_json = json.dumps({'status': 1, 'error_message': "None"})
            return HttpResponse(final_json)
        except BaseException as msg:
            final_dic = {'status': 0, 'error_message': str(msg)}
            final_json = json.dumps(final_dic)
            return HttpResponse(final_json)
    except KeyError:
        final_dic = {'status': 0, 'error_message': "Not Logged In, please refresh the page or login again."}
        final_json = json.dumps(final_dic)
        return HttpResponse(final_json)


def installStatusSpamAssassin(request):
    try:
        userID = request.session['userID']
        try:
            if request.method == 'POST':

                command = "sudo cat " + mailUtilities.spamassassinInstallLogPath
                installStatus = ProcessUtilities.outputExecutioner(command)

                if installStatus.find("[200]") > -1:

                    execPath = "export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin  && /usr/local/CyberCP/bin/python " + virtualHostUtilities.cyberPanel + "/plogical/mailUtilities.py"
                    execPath = execPath + " configureSpamAssassin"
                    output = ProcessUtilities.outputExecutioner(execPath, 'root')

                    if output.find("1,None") > -1:

                        import os
                        if os.path.exists(mailUtilities.mailScannerInstallLogPath):
                            os.remove(mailUtilities.mailScannerInstallLogPath)

                        final_json = json.dumps({
                            'error_message': "None",
                            'requestStatus': installStatus,
                            'abort': 1,
                            'installed': 1,
                        })
                        return HttpResponse(final_json)
                    else:
                        final_json = json.dumps({
                            'error_message': "Failed to install SpamAssassin configurations.",
                            'requestStatus': installStatus,
                            'abort': 1,
                            'installed': 0,
                        })
                        return HttpResponse(final_json)

                elif installStatus.find("[404]") > -1:

                    final_json = json.dumps({
                        'abort': 1,
                        'installed': 0,
                        'error_message': "None",
                        'requestStatus': installStatus,
                    })
                    return HttpResponse(final_json)

                else:
                    final_json = json.dumps({
                        'abort': 0,
                        'error_message': "None",
                        'requestStatus': installStatus,
                    })
                    return HttpResponse(final_json)
        except BaseException as msg:
            final_dic = {'abort': 1, 'installed': 0, 'error_message': str(msg)}
            final_json = json.dumps(final_dic)
            return HttpResponse(final_json)
    except KeyError:
        final_dic = {'abort': 1, 'installed': 0,
                     'error_message': "Not Logged In, please refresh the page or login again."}
        final_json = json.dumps(final_dic)
        return HttpResponse(final_json)


def fetchSpamAssassinSettings(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson('fetchStatus', 0)

        try:
            if request.method == 'POST':

                report_safe = 0
                required_hits = '5.0'
                rewrite_header = 'Subject [SPAM]'
                required_score = '5'

                confPath = "/etc/mail/spamassassin/local.cf"

                if mailUtilities.checkIfSpamAssassinInstalled() == 1:

                    command = "sudo cat " + confPath

                    data = ProcessUtilities.outputExecutioner(command).splitlines()

                    # logging.CyberCPLogFileWriter.writeToFile(str(data))

                    for items in data:
                        if items.find('report_safe ') > -1:
                            if items.find('0') > -1:
                                report_safe = 0
                                continue
                            else:
                                report_safe = 1
                        if items.find('rewrite_header ') > -1:
                            tempData = items.split(' ')
                            rewrite_header = ''
                            counter = 0
                            for headerData in tempData:
                                if counter == 0:
                                    counter = counter + 1
                                    continue
                                rewrite_header = rewrite_header + headerData.strip('\n') + ' '
                            continue
                        if items.find('required_score ') > -1:
                            required_score = items.split(' ')[1].strip('\n')
                            continue
                        if items.find('required_hits ') > -1:
                            required_hits = items.split(' ')[1].strip('\n')
                            continue

                    final_dic = {'fetchStatus': 1,
                                 'installed': 1,
                                 'report_safe': report_safe,
                                 'rewrite_header': rewrite_header,
                                 'required_score': required_score,
                                 'required_hits': required_hits,
                                 }

                else:
                    final_dic = {'fetchStatus': 1,
                                 'installed': 0}

                final_json = json.dumps(final_dic)
                return HttpResponse(final_json)


        except BaseException as msg:
            final_dic = {'fetchStatus': 0, 'error_message': str(msg)}
            final_json = json.dumps(final_dic)
            return HttpResponse(final_json)
    except KeyError:
        return redirect(loadLoginPage)


def saveSpamAssassinConfigurations(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson('saveStatus', 0)

        try:
            if request.method == 'POST':
                data = json.loads(request.body)

                report_safe = data['report_safe']
                required_hits = data['required_hits']
                rewrite_header = data['rewrite_header']
                required_score = data['required_score']

                if report_safe == True:
                    report_safe = "report_safe 1"
                else:
                    report_safe = "report_safe 0"

                required_hits = "required_hits " + required_hits
                rewrite_header = "rewrite_header " + rewrite_header
                required_score = "required_score " + required_score

                ## writing data temporary to file

                tempConfigPath = "/home/cyberpanel/" + str(randint(1000, 9999))

                confPath = open(tempConfigPath, "w")

                confPath.writelines(report_safe + "\n")
                confPath.writelines(required_hits + "\n")
                confPath.writelines(rewrite_header + "\n")
                confPath.writelines(required_score + "\n")

                confPath.close()

                ## save configuration data

                execPath = "/usr/local/CyberCP/bin/python " + virtualHostUtilities.cyberPanel + "/plogical/mailUtilities.py"
                execPath = execPath + " saveSpamAssassinConfigs --tempConfigPath " + tempConfigPath
                output = ProcessUtilities.outputExecutioner(execPath)

                if output.find("1,None") > -1:
                    data_ret = {'saveStatus': 1, 'error_message': "None"}
                    json_data = json.dumps(data_ret)
                    return HttpResponse(json_data)
                else:
                    data_ret = {'saveStatus': 0, 'error_message': output}
                    json_data = json.dumps(data_ret)
                    return HttpResponse(json_data)


        except BaseException as msg:
            data_ret = {'saveStatus': 0, 'error_message': str(msg)}
            json_data = json.dumps(data_ret)
            return HttpResponse(json_data)

    except KeyError as msg:
        logging.CyberCPLogFileWriter.writeToFile(str(msg))
        data_ret = {'saveStatus': 0, 'error_message': str(msg)}
        json_data = json.dumps(data_ret)
        return HttpResponse(json_data)


def mailQueue(request):
    proc = httpProc(request, 'emailPremium/mailQueue.html',
                    None, 'admin')
    return proc.render()


def fetchMailQueue(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()

        data = json.loads(request.body)

        json_data = "["
        checker = 0

        queues = ProcessUtilities.outputExecutioner('postqueue -j').split('\n')

        for queue in queues:
            if checker == 0:
                json_data = json_data + queue
                checker = 1
            else:
                json_data = json_data + ',' + queue

        json_data = json_data.rstrip(',') + ']'
        final_dic = {'status': 1, 'error_message': "None", "data": json_data}
        final_json = json.dumps(final_dic)

        return HttpResponse(final_json)


    except BaseException as msg:
        dic = {'status': 0, 'error_message': str(msg)}
        json_data = json.dumps(dic)
        return HttpResponse(json_data)


def fetchMessage(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        try:

            data = json.loads(request.body)
            id = data['id']

            command = 'postcat -vq %s' % (id)
            emailMessageContent = ProcessUtilities.outputExecutioner(command)

            dic = {'status': 1, 'error_message': 'None', 'emailMessageContent': emailMessageContent}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)

        except BaseException as msg:
            dic = {'status': 0, 'error_message': str(msg)}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)

    except KeyError as msg:
        dic = {'status': 0, 'error_message': str(msg)}
        json_data = json.dumps(dic)
        return HttpResponse(json_data)


def flushQueue(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        try:

            command = 'postqueue -f'
            ProcessUtilities.executioner(command)

            dic = {'status': 1, 'error_message': 'None'}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)

        except BaseException as msg:
            dic = {'status': 0, 'error_message': str(msg)}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)

    except KeyError as msg:
        dic = {'status': 0, 'error_message': str(msg)}
        json_data = json.dumps(dic)
        return HttpResponse(json_data)


def delete(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        try:

            data = json.loads(request.body)
            type = data['type']

            if type == 'all':
                command = 'postsuper -d ALL'
            else:
                command = 'postsuper -d ALL deferred'

            ProcessUtilities.executioner(command)

            dic = {'status': 1, 'error_message': 'None'}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)

        except BaseException as msg:
            dic = {'status': 0, 'error_message': str(msg)}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)

    except KeyError as msg:
        dic = {'status': 0, 'error_message': str(msg)}
        json_data = json.dumps(dic)
        return HttpResponse(json_data)


## MailScanner

def MailScanner(request):
    checkIfMailScannerInstalled = 0

    ipFile = "/etc/cyberpanel/machineIP"
    f = open(ipFile)
    ipData = f.read()
    ipAddress = ipData.split('\n', 1)[0]

    if mailUtilities.checkIfMailScannerInstalled() == 1:
        checkIfMailScannerInstalled = 1

    proc = httpProc(request, 'emailPremium/MailScanner.html',
                    {'checkIfMailScannerInstalled': checkIfMailScannerInstalled, 'ipAddress': ipAddress}, 'admin')
    return proc.render()


def installMailScanner(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        try:

            ### Check selinux

            if ProcessUtilities.decideDistro() == ProcessUtilities.centos or ProcessUtilities.decideDistro() == ProcessUtilities.cent8:
                command = 'sestatus'
                result = ProcessUtilities.outputExecutioner(command)

                if result.find('disabled') == -1:
                    final_json = json.dumps(
                        {'status': 0, 'error_message': "Disable selinux before installing MailScanner."})
                    return HttpResponse(final_json)

            execPath = "/usr/local/CyberCP/bin/python " + virtualHostUtilities.cyberPanel + "/plogical/mailUtilities.py"
            execPath = execPath + " installMailScanner"
            ProcessUtilities.popenExecutioner(execPath)

            final_json = json.dumps({'status': 1, 'error_message': "None"})
            return HttpResponse(final_json)
        except BaseException as msg:
            final_dic = {'status': 0, 'error_message': str(msg)}
            final_json = json.dumps(final_dic)
            return HttpResponse(final_json)
    except KeyError:
        final_dic = {'status': 0, 'error_message': "Not Logged In, please refresh the page or login again."}
        final_json = json.dumps(final_dic)
        return HttpResponse(final_json)


def installStatusMailScanner(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()

        try:
            if request.method == 'POST':

                command = "sudo cat " + mailUtilities.mailScannerInstallLogPath
                installStatus = ProcessUtilities.outputExecutioner(command)

                if installStatus.find("[200]") > -1:

                    final_json = json.dumps({
                        'error_message': "None",
                        'requestStatus': installStatus,
                        'abort': 1,
                        'installed': 1,
                    })
                    return HttpResponse(final_json)

                elif installStatus.find("[404]") > -1:

                    final_json = json.dumps({
                        'abort': 1,
                        'installed': 0,
                        'error_message': "None",
                        'requestStatus': installStatus,
                    })
                    return HttpResponse(final_json)

                else:
                    final_json = json.dumps({
                        'abort': 0,
                        'error_message': "None",
                        'requestStatus': installStatus,
                    })
                    return HttpResponse(final_json)


        except BaseException as msg:
            final_dic = {'abort': 1, 'installed': 0, 'error_message': str(msg)}
            final_json = json.dumps(final_dic)
            return HttpResponse(final_json)
    except KeyError:
        final_dic = {'abort': 1, 'installed': 0,
                     'error_message': "Not Logged In, please refresh the page or login again."}
        final_json = json.dumps(final_dic)
        return HttpResponse(final_json)


###Rspamd

def Rspamd(request):
    url = "https://platform.cyberpersons.com/CyberpanelAdOns/Adonpermission"
    data = {
        "name": "email-debugger",
        "IP": ACLManager.GetServerIP()
    }

    import requests
    response = requests.post(url, data=json.dumps(data))
    Status = response.json()['status']

    if (Status == 1) or ProcessUtilities.decideServer() == ProcessUtilities.ent:
        checkIfRspamdInstalled = 0

        ipFile = "/etc/cyberpanel/machineIP"
        f = open(ipFile)
        ipData = f.read()
        ipAddress = ipData.split('\n', 1)[0]

        if mailUtilities.checkIfRspamdInstalled() == 1:
            checkIfRspamdInstalled = 1

        proc = httpProc(request, 'emailPremium/Rspamd.html',
                        {'checkIfRspamdInstalled': checkIfRspamdInstalled, 'ipAddress': ipAddress}, 'admin')
        return proc.render()
    else:
        return redirect("https://cyberpanel.net/cyberpanel-addons")

def installRspamd(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()

        url = "https://platform.cyberpersons.com/CyberpanelAdOns/Adonpermission"
        data = {
            "name": "email-debugger",
            "IP": ACLManager.GetServerIP()
        }

        import requests
        response = requests.post(url, data=json.dumps(data))
        Status = response.json()['status']

        if (Status == 1) or ProcessUtilities.decideServer() == ProcessUtilities.ent:
            try:

                execPath = "/usr/local/CyberCP/bin/python " + virtualHostUtilities.cyberPanel + "/plogical/mailUtilities.py"
                execPath = execPath + " installRspamd"
                ProcessUtilities.popenExecutioner(execPath)

                final_json = json.dumps({'status': 1, 'error_message': "None"})
                return HttpResponse(final_json)
            except BaseException as msg:
                final_dic = {'status': 0, 'error_message': str(msg)}
                final_json = json.dumps(final_dic)
                return HttpResponse(final_json)
    except KeyError:
        final_dic = {'status': 0, 'error_message': "Not Logged In, please refresh the page or login again."}
        final_json = json.dumps(final_dic)
        return HttpResponse(final_json)

def installStatusRspamd(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        try:
            if request.method == 'POST':

                command = "sudo cat " + mailUtilities.RspamdInstallLogPath
                installStatus = ProcessUtilities.outputExecutioner(command)

                if installStatus.find("[200]") > -1:

                    final_json = json.dumps({
                        'error_message': "None",
                        'requestStatus': installStatus,
                        'abort': 1,
                        'installed': 1,
                    })
                    cmd = 'rm -f %s'%mailUtilities.RspamdInstallLogPath
                    ProcessUtilities.executioner(cmd)
                    return HttpResponse(final_json)


                elif installStatus.find("[404]") > -1:

                    final_json = json.dumps({
                        'abort': 1,
                        'installed': 0,
                        'error_message': "None",
                        'requestStatus': installStatus,
                    })
                    cmd = 'rm -f %s' % mailUtilities.RspamdInstallLogPath
                    ProcessUtilities.executioner(cmd)
                    return HttpResponse(final_json)

                else:
                    final_json = json.dumps({
                        'abort': 0,
                        'error_message': "None",
                        'requestStatus': installStatus,
                    })
                    return HttpResponse(final_json)
        except BaseException as msg:
            final_dic = {'abort': 1, 'installed': 0, 'error_message': str(msg)}
            final_json = json.dumps(final_dic)
            return HttpResponse(final_json)
    except KeyError:
        final_dic = {'abort': 1, 'installed': 0,
                     'error_message': "Not Logged In, please refresh the page or login again."}
        final_json = json.dumps(final_dic)
        return HttpResponse(final_json)

def fetchRspamdSettings(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson('fetchStatus', 0)

        url = "https://platform.cyberpersons.com/CyberpanelAdOns/Adonpermission"
        data = {
            "name": "email-debugger",
            "IP": ACLManager.GetServerIP()
        }

        import requests
        response = requests.post(url, data=json.dumps(data))
        Status = response.json()['status']

        if (Status == 1) or ProcessUtilities.decideServer() == ProcessUtilities.ent:
            try:
                if request.method == 'POST':

                    enabled = True
                    action = ''
                    max_Size = ''
                    scan_mime_parts = True
                    log_clean = True
                    Server = ''
                    CLAMAV_VIRUS = ''

                    confPath = "/etc/rspamd/local.d/antivirus.conf"
                    postfixpath = "/etc/postfix/main.cf"

                    if mailUtilities.checkIfRspamdInstalled() == 1:

                        command = "sudo cat " + confPath

                        data = ProcessUtilities.outputExecutioner(command).splitlines()

                        for items in data:
                            if items.find('enabled ') > -1:
                                if items.find('enabled = true') < 0:
                                    enabled = False
                                    continue
                                else:
                                    enabled = True
                            if items.find('action =') > -1:
                                tempData = items.split(' ')
                                # logging.CyberCPLogFileWriter.writeToFile(str(tempData) + "action")
                                try:
                                    if len(tempData) > 4:
                                        a = tempData[4]
                                    elif len(tempData) > 2:
                                        a = tempData[2]
                                    else:
                                        continue
                                    ac = a.split('"')
                                    if len(ac) > 1:
                                        action = ac[1]
                                except:
                                    pass
                            if items.find('max_size') > -1:
                                tempData = items.split(' ')
                                if len(tempData) > 4:
                                    max = tempData[4]
                                    max_Size = max.rstrip(";")

                            if items.find('scan_mime_parts ') > -1:
                                if items.find('scan_mime_parts = true') < 0:
                                    scan_mime_parts = False
                                    continue
                                else:
                                    scan_mime_parts = True
                            if items.find('log_clean  ') > -1:
                                if items.find('scan_mime_parts = true') < 0:
                                    log_clean = False
                                    continue
                                else:
                                    log_clean = True
                            if items.find('servers =') > -1:
                                tempData = items.split(' ')
                                if len(tempData) > 4:
                                    Ser = tempData[4]
                                    x = Ser.rstrip(";")
                                    y = x.split('"')
                                    if len(y) > 1:
                                        Server = y[1]
                            if items.find('CLAMAV_VIRUS =') > -1:
                                tempData = items.split(' ')
                                if len(tempData) > 6:
                                    CLAMAV = tempData[6]
                                    i = CLAMAV.rstrip(";")
                                    j = i.split('"')
                                    if len(j) > 1:
                                        CLAMAV_VIRUS = j[1]

                        ###postfix
                        smtpd_milters = ""
                        non_smtpd_milters = ""
                        command = "sudo cat " + postfixpath

                        postdata = ProcessUtilities.outputExecutioner(command).splitlines()
                        for i in postdata:
                            if (i.find('smtpd_milters=') > -1 or i.find('smtpd_milters =') > -1) and i.find('non_smtpd_milters') < 0:
                                ### non_smtpd_milters = inet:127.0.0.1:8891, inet:127.0.0.1:11332
                                split_data = i.split(',')
                                if len(split_data) > 1:
                                    tempData = split_data[1]
                                    if os.path.exists(ProcessUtilities.debugPath):
                                        logging.CyberCPLogFileWriter.writeToFile(f'smtpd_milters: {tempData}')
                                    smtpd_milters = tempData.lstrip(' ')
                                else:
                                    # If no comma, try to get the value after the equals sign
                                    eq_split = i.split('=')
                                    if len(eq_split) > 1:
                                        smtpd_milters = eq_split[1].strip()
                            if i.find('non_smtpd_milters=') > -1 or i.find('non_smtpd_milters =') > -1:
                                eq_split = i.split('=')
                                if len(eq_split) > 1:
                                    tempData = eq_split[1]

                                    if os.path.exists(ProcessUtilities.debugPath):
                                        logging.CyberCPLogFileWriter.writeToFile(f'non_smtpd_milters: {tempData}')

                                    non_smtpd_milters = tempData.lstrip(' ')


                        ###Redis
                        Redispath = "/etc/rspamd/local.d/redis.conf"
                        read_servers = ''
                        write_servers = ''
                        command = "sudo cat " + Redispath

                        postdata = ProcessUtilities.outputExecutioner(command).splitlines()

                        for i in postdata:
                            if i.find('write_servers =') > -1:
                                tempData = i.split(' ')
                                # logging.CyberCPLogFileWriter.writeToFile(str(tempData) + "redis")
                                if len(tempData) > 2:
                                    write = tempData[2]
                                    i = write.rstrip(";")
                                    j = i.split('"')
                                    if len(j) > 1:
                                        write_servers = j[1]
                                    # logging.CyberCPLogFileWriter.writeToFile(str(write_servers) + "write_servers")

                            if i.find('read_servers =') > -1:
                                tempData = i.split(' ')
                                # logging.CyberCPLogFileWriter.writeToFile(str(tempData) + "redis2")
                                if len(tempData) > 2:
                                    read = tempData[2]
                                    i = read.rstrip(";")
                                    j = i.split('"')
                                    if len(j) > 1:
                                        read_servers = j[1]
                                    # logging.CyberCPLogFileWriter.writeToFile(str(read_servers) + "read_servers")

                        #ClamAV configs

                        clamav_Debug = True
                        LogFile = ''
                        TCPAddr = ''
                        TCPSocket = ''

                        if  ProcessUtilities.decideDistro() == ProcessUtilities.centos or ProcessUtilities.decideDistro() == ProcessUtilities.cent8:
                            clamavconfpath = '/etc/clamd.d/scan.conf'
                        elif ProcessUtilities.decideDistro() == ProcessUtilities.ubuntu or ProcessUtilities.decideDistro() == ProcessUtilities.ubuntu20:
                            clamavconfpath = "/etc/clamav/clamd.conf"

                        command = "sudo cat " + clamavconfpath
                        data = ProcessUtilities.outputExecutioner(command).splitlines()
                        for items in data:
                            if items.find('TCPSocket') > -1:
                                tempData = items.split(' ')
                                if len(tempData) > 1:
                                    TCPSocket = tempData[1]
                            if items.find('TCPAddr') > -1:
                                tempData = items.split(' ')
                                if len(tempData) > 1:
                                    TCPAddr = tempData[1]
                            if items.find('LogFile') > -1:
                                tempData = items.split(' ')
                                if len(tempData) > 1:
                                    LogFile = tempData[1]
                            if items.find('Debug') > -1:
                                if items.find('Debug true') < 0:
                                    clamav_Debug = False
                                    continue
                                else:
                                    clamav_Debug = True


                        final_dic = {'fetchStatus': 1,
                                     'installed': 1,
                                     'enabled': enabled,
                                     'action': action,
                                     'max_Size': max_Size,
                                     'scan_mime_parts': scan_mime_parts,
                                     'log_clean ': log_clean,
                                     'Server': Server,
                                     'CLAMAV_VIRUS': CLAMAV_VIRUS,
                                     'smtpd_milters': smtpd_milters,
                                     'non_smtpd_milters': non_smtpd_milters,
                                     'read_servers': read_servers,
                                     'write_servers': write_servers,
                                     'clamav_Debug': clamav_Debug,
                                     'LogFile': LogFile,
                                     'TCPAddr': TCPAddr,
                                     'TCPSocket': TCPSocket,

                                     }


                    else:
                        final_dic = {'fetchStatus': 1,
                                     'installed': 0}

                    final_json = json.dumps(final_dic)
                    return HttpResponse(final_json)
            except BaseException as msg:
                final_dic = {'fetchStatus': 0, 'error_message': str(msg)}
                final_json = json.dumps(final_dic)
                return HttpResponse(final_json)
    except KeyError:
        return redirect(loadLoginPage)

def saveRspamdConfigurations(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson('saveStatus', 0)

        try:
            if request.method == 'POST':
                data = json.loads(request.body)
                tempfilepath = "/home/cyberpanel/tempfilerspamdconfigs"
                json_object = json.dumps(data, indent=4)
                writeDataToFile = open(tempfilepath, "w")
                writeDataToFile.write(json_object)
                writeDataToFile.close()

                execPath = "/usr/local/CyberCP/bin/python " + virtualHostUtilities.cyberPanel + "/plogical/mailUtilities.py"
                execPath = execPath + " changeRspamdConfig "
                output = ProcessUtilities.outputExecutioner(execPath)

                data_ret = {'saveStatus': 1, 'error_message': 'None'}
                json_data = json.dumps(data_ret)
                return HttpResponse(json_data)


        except BaseException as msg:
            data_ret = {'saveStatus': 0, 'error_message': str(msg)}
            json_data = json.dumps(data_ret)
            return HttpResponse(json_data)

    except KeyError:
        return redirect(loadLoginPage)

def savepostfixConfigurations(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson('saveStatus', 0)

        try:
            if request.method == 'POST':
                data = json.loads(request.body)
                tempfilepath = "/home/cyberpanel/tempfilepostfixconfigs"
                json_object = json.dumps(data, indent=4)
                writeDataToFile = open(tempfilepath, "w")
                writeDataToFile.write(json_object)
                writeDataToFile.close()

                # status, msg = mailUtilities.changeRspamdConfig(request.body)
                execPath = "/usr/local/CyberCP/bin/python " + virtualHostUtilities.cyberPanel + "/plogical/mailUtilities.py"
                execPath = execPath + " changePostfixConfig "
                output = ProcessUtilities.outputExecutioner(execPath)

                data_ret = {'saveStatus': 1, 'error_message': 'None'}
                json_data = json.dumps(data_ret)
                return HttpResponse(json_data)

        except BaseException as msg:
            data_ret = {'saveStatus': 0, 'error_message': str(msg)}
            json_data = json.dumps(data_ret)
            return HttpResponse(json_data)

    except KeyError:
        return redirect(loadLoginPage)

def saveRedisConfigurations(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson('saveStatus', 0)

        try:
            if request.method == 'POST':
                data = json.loads(request.body)
                tempfilepath = "/home/cyberpanel/saveRedisConfigurations"
                json_object = json.dumps(data, indent=4)
                writeDataToFile = open(tempfilepath, "w")
                writeDataToFile.write(json_object)
                writeDataToFile.close()

                # status, msg = mailUtilities.changeRspamdConfig(request.body)
                execPath = "/usr/local/CyberCP/bin/python " + virtualHostUtilities.cyberPanel + "/plogical/mailUtilities.py"
                execPath = execPath + " changeRedisxConfig "
                output = ProcessUtilities.outputExecutioner(execPath)

                data_ret = {'saveStatus': 1, 'error_message': 'None'}
                json_data = json.dumps(data_ret)
                return HttpResponse(json_data)

        except BaseException as msg:
            data_ret = {'saveStatus': 0, 'error_message': str(msg)}
            json_data = json.dumps(data_ret)
            return HttpResponse(json_data)

    except KeyError:
        return redirect(loadLoginPage)

def saveclamavConfigurations(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson('saveStatus', 0)

        try:
            if request.method == 'POST':
                data = json.loads(request.body)
                tempfilepath = "/home/cyberpanel/saveclamavConfigurations"
                json_object = json.dumps(data, indent=4)
                writeDataToFile = open(tempfilepath, "w")
                writeDataToFile.write(json_object)
                writeDataToFile.close()

                # status, msg = mailUtilities.changeRspamdConfig(request.body)
                execPath = "/usr/local/CyberCP/bin/python " + virtualHostUtilities.cyberPanel + "/plogical/mailUtilities.py"
                execPath = execPath + " changeclamavConfig"
                output = ProcessUtilities.outputExecutioner(execPath)

                data_ret = {'saveStatus': 1, 'error_message': 'None'}
                json_data = json.dumps(data_ret)
                return HttpResponse(json_data)

        except BaseException as msg:
            data_ret = {'saveStatus': 0, 'error_message': str(msg)}
            json_data = json.dumps(data_ret)
            return HttpResponse(json_data)

    except KeyError:
        return redirect(loadLoginPage)

def unistallRspamd(request):
    try:
        logging.CyberCPLogFileWriter.writeToFile("unistallRspamd...1")
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()


        try:

            execPath = "/usr/local/CyberCP/bin/python " + virtualHostUtilities.cyberPanel + "/plogical/mailUtilities.py"
            execPath = execPath + " uninstallRspamd"
            ProcessUtilities.popenExecutioner(execPath)


            final_json = json.dumps({'status': 1, 'error_message': "None"})
            return HttpResponse(final_json)
        except BaseException as msg:
            final_dic = {'status': 0, 'error_message': str(msg)}
            final_json = json.dumps(final_dic)
            return HttpResponse(final_json)


    except KeyError:

        final_dic = {'status': 0, 'error_message': "Not Logged In, please refresh the page or login again."}

        final_json = json.dumps(final_dic)

        return HttpResponse(final_json)

def uninstallStatusRspamd(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        try:
            if request.method == 'POST':

                command = "sudo cat " + mailUtilities.RspamdUnInstallLogPath
                installStatus = ProcessUtilities.outputExecutioner(command)

                if installStatus.find("[200]") > -1:

                    final_json = json.dumps({
                        'error_message': "None",
                        'requestStatus': installStatus,
                        'abort': 1,
                        'installed': 1,
                    })
                    cmd = 'rm -f %s' % mailUtilities.RspamdUnInstallLogPath
                    ProcessUtilities.executioner(cmd)
                    return HttpResponse(final_json)


                elif installStatus.find("[404]") > -1:

                    final_json = json.dumps({
                        'abort': 1,
                        'installed': 0,
                        'error_message': "None",
                        'requestStatus': installStatus,
                    })
                    cmd = 'rm -f %s' % mailUtilities.RspamdUnInstallLogPath
                    ProcessUtilities.executioner(cmd)
                    return HttpResponse(final_json)

                else:
                    final_json = json.dumps({
                        'abort': 0,
                        'error_message': "None",
                        'requestStatus': installStatus,
                    })
                    return HttpResponse(final_json)
        except BaseException as msg:
            final_dic = {'abort': 1, 'installed': 0, 'error_message': str(msg)}
            final_json = json.dumps(final_dic)
            return HttpResponse(final_json)
    except KeyError:
        final_dic = {'abort': 1, 'installed': 0,
                     'error_message': "Not Logged In, please refresh the page or login again."}
        final_json = json.dumps(final_dic)
        return HttpResponse(final_json)

def FetchRspamdLog(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()

        fileName = "/var/log/rspamd/rspamd.log"
        try:
            command = "sudo tail -100 " + fileName
            fewLinesOfLogFile = ProcessUtilities.outputExecutioner(command)
            status = {"status": 1, "logstatus": 1, "logsdata": fewLinesOfLogFile}
            final_json = json.dumps(status)
            return HttpResponse(final_json)
        except:
            status = {"status": 1, "logstatus": 1, "logsdata": 'Emtpy File.'}
            final_json = json.dumps(status)
            return HttpResponse(final_json)
    except KeyError:
        final_dic = {'abort': 1, 'installed': 0,
                     'error_message': "Not Logged In, please refresh the page or login again."}
        final_json = json.dumps(final_dic)
        return HttpResponse(final_json)


def RestartRspamd(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        try:
            command = "systemctl restart rspamd"
            ProcessUtilities.executioner(command)

            if ProcessUtilities.decideDistro() == ProcessUtilities.centos or ProcessUtilities.decideDistro() == ProcessUtilities.cent8:
                command = 'systemctl start clamd@scan'
            else:
                command = "systemctl restart clamav-daemon"

            ProcessUtilities.executioner(command)

            dic = {'status': 1, 'error_message': 'None',}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)
        except BaseException as msg:
            dic = {'status': 0, 'error_message': str(msg)}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)
    except KeyError:
        dic = {'status': 0, 'error_message': str("Not Logged In, please refresh the page or login again.")}
        json_data = json.dumps(dic)
        return HttpResponse(json_data)


##Email Debugger

def EmailDebugger(request):
    url = "https://platform.cyberpersons.com/CyberpanelAdOns/Adonpermission"
    data = {
        "name": "email-debugger",
        "IP": ACLManager.GetServerIP()
    }

    import requests
    response = requests.post(url, data=json.dumps(data))
    Status = response.json()['status']

    if (Status == 1) or ProcessUtilities.decideServer() == ProcessUtilities.ent:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        currentACL = ACLManager.loadedACL(userID)
        websitesName = ACLManager.findAllSites(currentACL, userID)

        proc = httpProc(request, 'emailPremium/EmailDebugger.html',
                        {'websiteList': websitesName}, 'admin')
        return proc.render()
    else:
        return redirect("https://cyberpanel.net/cyberpanel-addons")

def RunServerLevelEmailChecks(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()

        if ACLManager.CheckForPremFeature('email-debugger'):
            ob = CloudManager()
            res = ob.RunServerLevelEmailChecks()
            return res
        else:
            dic = {'status': 0, 'error_message': 'Kindly purchase email debugger Add-on'}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)
    except BaseException as msg:
        dic = {'status': 0, 'error_message': str(msg)}
        json_data = json.dumps(dic)
        return HttpResponse(json_data)


def ResetEmailConfigurations(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        if ACLManager.CheckForPremFeature('email-debugger'):
            ob = CloudManager()
            res = ob.ResetEmailConfigurations()
            return res
        else:
            dic = {'status': 0, 'error_message': 'Kindly purchase email debugger Add-on'}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)
    except BaseException as msg:
        dic = {'status': 0, 'error_message': str(msg)}
        json_data = json.dumps(dic)
        return HttpResponse(json_data)

def statusFunc(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()

        ob = CloudManager(json.loads(request.body))
        res = ob.statusFunc()
        return res
    except BaseException as msg:
        dic = {'status': 0, 'error_message': str(msg)}
        json_data = json.dumps(dic)
        return HttpResponse(json_data)

def ReadReport(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        if ACLManager.CheckForPremFeature('email-debugger'):
            try:
                ob = CloudManager(json.loads(request.body))
                res = ob.ReadReport()
                Result = json.loads(res.content)
                status = Result['status']
                #fetch Ip
                IP = ACLManager.GetServerIP()
                if status == 1:
                    def CheckPort(port):
                        import socket
                        # Create a TCP socket
                        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                        try:
                            s.settimeout(1)
                            s.connect((IP, port))
                            return 1
                        except socket.error as e:
                            return 0
                        finally:
                            s.close()

                    report = {}

                    if CheckPort(25):
                        report['Port25'] = 'Open'
                    else:
                        report['Port25'] = 'Closed, mail will not go through.'

                    if CheckPort(587):
                        report['Port587'] = 'Open'
                    else:
                        report['Port587'] = 'Closed, mail will not go through.'

                    if CheckPort(465):
                        report['Port465'] = 'Open'
                    else:
                        report['Port465'] = 'Closed, mail will not go through.'

                    if CheckPort(110):
                        report['Port110'] = 'Open'
                    else:
                        report['Port110'] = 'Closed, POP3 will not work.'

                    if CheckPort(143):
                        report['Port143'] = 'Open'
                    else:
                        report['Port143'] = 'Closed, IMAP will not work.'

                    if CheckPort(993):
                        report['Port993'] = 'Open'
                    else:
                        report['Port993'] = 'Closed, IMAP will not work.'

                    if CheckPort(995):
                        report['Port995'] = 'Open'
                    else:
                        report['Port995'] = 'Closed, POP3 will not work.'

                    report['serverHostName'] = IP
                    finalResult = Result
                    finalResult['report'] = report

                    final_json = json.dumps(finalResult)
                    return HttpResponse(final_json)
                else:
                    return 0 , Result
            except BaseException as msg:
                logging.CyberCPLogFileWriter.writeToFile("Result....3:" + str(msg))
        else:
            dic = {'status': 0, 'error_message': 'Kindly purchase email debugger Add-on'}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)
    except KeyError:
        return redirect(loadLoginPage)

def debugEmailForSite(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        if ACLManager.CheckForPremFeature('email-debugger'):
            ob = CloudManager(json.loads(request.body))
            res = ob.debugEmailForSite()
            return res
        else:
            dic = {'status': 0, 'error_message': 'Kindly purchase email debugger Add-on'}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)
    except KeyError:
        return redirect(loadLoginPage)

def fixMailSSL(request):
    try:
        userID = request.session['userID']
        currentACL = ACLManager.loadedACL(userID)

        if currentACL['admin'] == 1:
            pass
        else:
            return ACLManager.loadErrorJson()
        admin = Administrator.objects.get(pk=userID)
        if ACLManager.CheckForPremFeature('email-debugger'):
            cm = CloudManager(json.loads(request.body), admin)
            res = cm.fixMailSSL(request)
            if os.path.exists(ProcessUtilities.debugPath):
                logging.CyberCPLogFileWriter.writeToFile("Result....3:" + str(res.content))
            return res
        else:
            dic = {'status': 0, 'error_message': 'Kindly purchase email debugger Add-on'}
            json_data = json.dumps(dic)
            return HttpResponse(json_data)
    except KeyError:
        return redirect(loadLoginPage)