File: //usr/local/CyberCP/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)