def submitFTPCreation(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'createFTPAccount') == 0:
return ACLManager.loadErrorJson('creatFTPStatus', 0)
data = json.loads(self.request.body)
userName = data['ftpUserName']
password = data['passwordByPass']
domainName = data['ftpDomain']
admin = Administrator.objects.get(pk=userID)
if ACLManager.checkOwnership(domainName, admin, currentACL) == 1:
pass
else:
return ACLManager.loadError()
try:
api = data['api']
except:
api = '0'
admin = Administrator.objects.get(id=userID)
try:
path = data['path']
if len(path) > 0:
pass
else:
path = 'None'
except:
path = 'None'
result = FTPUtilities.submitFTPCreation(domainName, userName, password, path, admin.userName, api)
if result[0] == 1:
data_ret = {'status': 1, 'creatFTPStatus': 1, 'error_message': 'None'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
else:
data_ret = {'status': 0, 'creatFTPStatus': 0, 'error_message': result[1]}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'status': 0, 'creatFTPStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def liteSpeedTuning(self, request, userID):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadError()
return render(request, 'tuning/liteSpeedTuning.html', {})
except KeyError:
return redirect(loadLoginPage)
def submitPackage(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'createPackage') == 0:
return ACLManager.loadErrorJson('saveStatus', 0)
data = json.loads(self.request.body)
packageName = data['packageName'].replace(' ', '')
packageSpace = int(data['diskSpace'])
packageBandwidth = int(data['bandwidth'])
packageDatabases = int(data['dataBases'])
ftpAccounts = int(data['ftpAccounts'])
emails = int(data['emails'])
allowedDomains = int(data['allowedDomains'])
try:
api = data['api']
except:
api = '0'
try:
allowFullDomain = int(data['allowFullDomain'])
except:
allowFullDomain = 1
if packageSpace < 0 or packageBandwidth < 0 or packageDatabases < 0 or ftpAccounts < 0 or emails < 0 or allowedDomains < 0:
data_ret = {'saveStatus': 0, 'error_message': "All values should be positive or 0."}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
admin = Administrator.objects.get(pk=userID)
if api == '0':
packageName = admin.userName + "_" + packageName
package = Package(admin=admin, packageName=packageName, diskSpace=packageSpace,
bandwidth=packageBandwidth, ftpAccounts=ftpAccounts, dataBases=packageDatabases,
emailAccounts=emails, allowedDomains=allowedDomains, allowFullDomain=allowFullDomain)
package.save()
data_ret = {'status': 1, 'saveStatus': 1, 'error_message': "None"}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'status': 0, 'saveStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def NSCreation(self, userID=None, data=None):
try:
admin = Administrator.objects.get(pk=userID)
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL,
'createNameServer') == 0:
return ACLManager.loadErrorJson('NSCreation', 0)
domainForNS = data['domainForNS']
ns1 = data['ns1']
ns2 = data['ns2']
firstNSIP = data['firstNSIP']
secondNSIP = data['secondNSIP']
DNS.dnsTemplate(domainForNS, admin)
newZone = Domains.objects.get(name=domainForNS)
## NS1
record = Records(domainOwner=newZone,
domain_id=newZone.id,
name=ns1,
type="A",
content=firstNSIP,
ttl=3600,
prio=0,
disabled=0,
auth=1)
record.save()
## NS2
record = Records(domainOwner=newZone,
domain_id=newZone.id,
name=ns2,
type="A",
content=secondNSIP,
ttl=3600,
prio=0,
disabled=0,
auth=1)
record.save()
final_dic = {'NSCreation': 1, 'error_message': "None"}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
except BaseException, msg:
final_dic = {'NSCreation': 0, 'error_message': str(msg)}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
def CreatePackage(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
templateName = 'CLManager/createPackage.html'
packageList = ACLManager.loadPackages(userID, currentACL)
data = {}
data['packList'] = packageList
c = CLManagerMain(request, templateName, None, data)
return c.renderC()
except KeyError:
return redirect(loadLoginPage)
def fetchJobs(self):
try:
userID = self.request.session['userID']
admin = Administrator.objects.get(pk=userID)
if emACL.checkIfEMEnabled(admin.userName) == 0:
return ACLManager.loadErrorJson()
data = json.loads(self.request.body)
selectedTemplate = data['selectedTemplate']
template = EmailTemplate.objects.get(name=selectedTemplate)
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
elif template.owner != admin:
return ACLManager.loadErrorJson()
allJobs = EmailJobs.objects.filter(owner=template)
json_data = "["
checker = 0
counter = 1
for items in allJobs:
dic = {
'id': items.id,
'date': items.date,
'host': items.host,
'totalEmails': items.totalEmails,
'sent': items.sent,
'failed': items.failed
}
if checker == 0:
json_data = json_data + json.dumps(dic)
checker = 1
else:
json_data = json_data + ',' + json.dumps(dic)
counter = counter + 1
json_data = json_data + ']'
data_ret = {"status": 1, 'data': json_data}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
final_dic = {'status': 0, 'error_message': str(msg)}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
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,msg:
dic = {'status': 0, 'error_message': str(msg)}
json_data = json.dumps(dic)
return HttpResponse(json_data)
except KeyError,msg:
dic = {'status': 0, 'error_message': str(msg)}
json_data = json.dumps(dic)
return HttpResponse(json_data)
def submitDBCreation(self, userID=None, data=None, rAPI=None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
if ACLManager.currentContextPermission(currentACL,
'createDatabase') == 0:
return ACLManager.loadErrorJson('createDBStatus', 0)
databaseWebsite = data['databaseWebsite']
dbName = data['dbName']
dbUsername = data['dbUsername']
dbPassword = data['dbPassword']
webUsername = data['webUserName']
if ACLManager.checkOwnership(databaseWebsite, admin,
currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson()
if rAPI == None:
dbName = webUsername + "_" + dbName
dbUsername = webUsername + "_" + dbUsername
result = mysqlUtilities.submitDBCreation(dbName, dbUsername,
dbPassword,
databaseWebsite)
if result[0] == 1:
data_ret = {
'status': 1,
'createDBStatus': 1,
'error_message': "None"
}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
else:
data_ret = {
'status': 0,
'createDBStatus': 0,
'error_message': result[1]
}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {
'status': 0,
'createDBStatus': 0,
'error_message': str(msg)
}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def deleteDestination(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'addDeleteDestinations') == 0:
return ACLManager.loadErrorJson('delStatus', 0)
ipAddress = data['IPAddress']
delDest = dest.objects.get(destLoc=ipAddress)
delDest.delete()
path = "/usr/local/CyberCP/backup/"
destinations = path + "destinations"
data = open(destinations, 'r').readlines()
writeToFile = open(destinations, 'r')
for items in data:
if items.find(ipAddress) > -1:
continue
else:
writeToFile.writelines(items)
writeToFile.close()
## Deleting Cron Tab Entries for this destination
path = "/etc/crontab"
data = open(path, 'r').readlines()
writeToFile = open(path, 'w')
for items in data:
if items.find("backupSchedule.py") > -1:
continue
else:
writeToFile.writelines(items)
writeToFile.close()
final_dic = {'delStatus': 1, 'error_message': "None"}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
except BaseException, msg:
final_dic = {'delStatus': 1, 'error_message': str(msg)}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
def enableOrDisable(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadErrorJson()
data = json.loads(request.body)
if data['toggle'] == 1:
cageFSPath = '/home/cyberpanel/cagefs'
if os.path.exists(cageFSPath):
os.remove(cageFSPath)
else:
writeToFile = open(cageFSPath, 'w')
writeToFile.writelines('enable')
writeToFile.close()
data_ret = {'status': 1, 'error_message': 'None', 'success': 'Default status successfully changed changed.'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
if data['all'] == 0:
if data['mode'] == 1:
website = Websites.objects.get(domain=data['domain'])
command = '/usr/sbin/cagefsctl --enable %s' % (website.externalApp)
else:
website = Websites.objects.get(domain=data['domain'])
command = '/usr/sbin/cagefsctl --disable %s' % (website.externalApp)
ProcessUtilities.executioner(command)
data_ret = {'status': 1, 'error_message': 'None', 'success': 'Changes successfully applied.'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
else:
c = CLManagerMain(request, None, 'enableOrDisable', data)
c.start()
data_ret = {'status': 1, 'error_message': 'None', 'success': 'Job started in background, refresh in few seconds to see the status.'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'status': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def saveSettings(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadErrorJson()
data = json.loads(request.body)
name = data['name']
SPEED = data['SPEED']
VMEM = data['VMEM']
PMEM = data['PMEM']
IO = data['IO']
IOPS = data['IOPS']
EP = data['EP']
NPROC = data['NPROC']
INODESsoft = data['INODESsoft']
INODEShard = data['INODEShard']
clPackage = CLPackages.objects.get(name=name)
clPackage.speed = SPEED
clPackage.vmem = VMEM
clPackage.pmem = PMEM
clPackage.io = IO
clPackage.iops = IOPS
clPackage.ep = EP
clPackage.nproc = NPROC
clPackage.inodessoft = INODESsoft
clPackage.inodeshard = INODEShard
clPackage.save()
command = 'sudo lvectl package-set %s --speed=%s --pmem=%s --io=%s --nproc=%s --iops=%s --vmem=%s --ep=%s' % (
name, SPEED, PMEM, IO, NPROC, IOPS, VMEM, EP)
ProcessUtilities.executioner(command)
command = 'sudo lvectl apply all'
ProcessUtilities.popenExecutioner(command)
data_ret = {'status': 1}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'status': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def obtainMailServerSSL(request):
try:
userID = request.session['userID']
try:
if request.method == 'POST':
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
elif currentACL['mailServerSSL'] == 1:
pass
else:
return ACLManager.loadErrorJson('SSL', 0)
data = json.loads(request.body)
virtualHost = data['virtualHost']
admin = Administrator.objects.get(pk=userID)
if ACLManager.checkOwnership(virtualHost, admin,
currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson()
path = "/home/" + virtualHost + "/public_html"
## ssl issue
execPath = "/usr/local/CyberCP/bin/python2 " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " issueSSLForMailServer --virtualHostName " + virtualHost + " --path " + path
output = ProcessUtilities.outputExecutioner(execPath)
if output.find("1,None") > -1:
data_ret = {"status": 1, "SSL": 1, 'error_message': "None"}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
else:
data_ret = {"status": 0, "SSL": 0, 'error_message': output}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
## ssl issue ends
except BaseException, msg:
data_ret = {"status": 0, "SSL": 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except KeyError, msg:
data_ret = {"status": 0, "SSL": 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def listDomains(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadError()
try:
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:
return render(request, 'emailPremium/listDomains.html', {"installCheck": installCheck})
###
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>')
return render(request,'emailPremium/listDomains.html',{"pagination":pagination, "installCheck": installCheck})
except BaseException, msg:
logging.CyberCPLogFileWriter.writeToFile(str(msg))
return HttpResponse("See CyberCP main log file.")
except KeyError:
return redirect(loadLoginPage)
def submitForwardDeletion(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'emailForwarding') == 0:
return ACLManager.loadErrorJson('deleteForwardingStatus', 0)
data = json.loads(self.request.body)
destination = data['destination']
source = data['source']
forwardingOption = data['forwardingOption']
eUser = EUsers.objects.get(email=source)
admin = Administrator.objects.get(pk=userID)
if ACLManager.checkOwnership(eUser.emailOwner.domainOwner.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson()
if forwardingOption == 'Forward to email':
for items in Forwardings.objects.filter(destination=destination, source=source):
items.delete()
else:
for items in Pipeprograms.objects.filter(destination=destination, source=source):
items.delete()
## Delete Email PIPE
sourceusername = source.split("@")[0]
virtualfilter = '%s FILTER %spipe:dummy' % (source, sourceusername)
command = "sed -i 's/^" + source + ".*//g' /etc/postfix/script_filter"
ProcessUtilities.executioner(command)
command = "sed -i 's/^" + sourceusername + "pipe.*//g' /etc/postfix/master.cf"
ProcessUtilities.executioner(command)
#### Hashing filter Reloading Postfix
command = "postmap /etc/postfix/script_filter"
ProcessUtilities.executioner(command)
command = "postfix reload"
ProcessUtilities.executioner(command)
##
data_ret = {'status': 1, 'deleteForwardingStatus': 1, 'error_message': "None",
'successMessage': 'Successfully deleted!'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'status': 0, 'deleteForwardingStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def emailLimits(request,domain):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadError()
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
return render(request, 'emailPremium/emailLimits.html', Data)
else:
return render(request, 'emailPremium/emailLimits.html', {"error":1,"domain": "This domain does not exists"})
except KeyError:
return redirect(loadLoginPage)
def installOpenDKIM(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'dkimManager') == 0:
return ACLManager.loadErrorJson('installOpenDKIM', 0)
thread.start_new_thread(mailUtilities.installOpenDKIM, ('Install', 'openDKIM'))
final_json = json.dumps({'installOpenDKIM': 1, 'error_message': "None"})
return HttpResponse(final_json)
except BaseException, msg:
final_dic = {'installOpenDKIM': 0, 'error_message': str(msg)}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
def emailMarketing(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadError()
return render(self.request, 'emailMarketing/emailMarketing.html')
except KeyError, msg:
return redirect(loadLoginPage)
def modifyACL(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
aclNames = ACLManager.findAllACLs()
return render(request, 'userManagment/modifyACL.html',
{'aclNames': aclNames})
else:
return ACLManager.loadError()
except KeyError:
return redirect(loadLoginPage)
def createDatabase(self, request=None, userID=None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL,
'createDatabase') == 0:
return ACLManager.loadError()
websitesName = ACLManager.findAllSites(currentACL, userID)
return render(request, 'databases/createDatabase.html',
{'websitesList': websitesName})
except BaseException, msg:
return HttpResponse(str(msg))
def deletePacakge(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'deletePackage') == 0:
return ACLManager.loadError()
packageList = ACLManager.loadPackages(userID, currentACL)
return render(self.request, 'packages/deletePackage.html', {"packageList": packageList})
except BaseException, msg:
return HttpResponse(str(msg))
def listPackages(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'listPackages') == 0:
return ACLManager.loadError()
packageList = ACLManager.loadPackages(userID, currentACL)
return render(self.request, 'packages/listPackages.html', {"packList": packageList})
except BaseException, msg:
return redirect(loadLoginPage)
def createPacakge(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'createPackage') == 0:
return ACLManager.loadError()
admin = Administrator.objects.get(pk=userID)
return render(self.request, 'packages/createPackage.html', {"admin": admin.userName})
except KeyError:
return redirect(loadLoginPage)
def createDNSZone(self, request=None, userID=None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL,
'createDNSZone') == 0:
return ACLManager.loadError()
if os.path.exists('/home/cyberpanel/powerdns'):
return render(request, 'dns/createDNSZone.html', {"status": 1})
else:
return render(request, 'dns/createDNSZone.html', {"status": 0})
except BaseException, msg:
return HttpResponse(str(msg))
def submitCreatePackage(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadErrorJson()
data = json.loads(request.body)
selectedPackage = data['selectedPackage']
package = Package.objects.get(packageName=selectedPackage)
if package.clpackages_set.all().count() == 1:
data_ret = {'status': 0, 'error_message': 'This package already have one associated CloudLinux Package.'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
name = data['name']
SPEED = data['SPEED']
VMEM = data['VMEM']
PMEM = data['PMEM']
IO = data['IO']
IOPS = data['IOPS']
EP = data['EP']
NPROC = data['NPROC']
INODESsoft = data['INODESsoft']
INODEShard = data['INODEShard']
clPackage = CLPackages(name=name, owner=package, speed=SPEED, vmem=VMEM, pmem=PMEM, io=IO, iops=IOPS, ep=EP, nproc=NPROC, inodessoft=INODESsoft, inodeshard=INODEShard)
clPackage.save()
command = 'sudo lvectl package-set %s --speed=%s --pmem=%s --io=%s --nproc=%s --iops=%s --vmem=%s --ep=%s' % (name, SPEED, PMEM, IO, NPROC, IOPS, VMEM, EP)
ProcessUtilities.executioner(command)
command = 'sudo lvectl apply all'
ProcessUtilities.popenExecutioner(command)
data_ret = {'status': 1}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'status': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def smtpHostOperations(self):
try:
userID = self.request.session['userID']
admin = Administrator.objects.get(pk=userID)
if emACL.checkIfEMEnabled(admin.userName) == 0:
return ACLManager.loadErrorJson()
data = json.loads(self.request.body)
id = data['id']
operation = data['operation']
if operation == 'delete':
delHost = SMTPHosts.objects.get(id=id)
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
elif delHost.owner.id != userID:
ACLManager.loadErrorJson()
delHost.delete()
data_ret = {"status": 1, 'message': 'Successfully deleted.'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
else:
try:
verifyHost = SMTPHosts.objects.get(id=id)
verifyLogin = smtplib.SMTP(verifyHost.host, int(verifyHost.port))
verifyLogin.login(verifyHost.userName, verifyHost.password)
data_ret = {"status": 1, 'message': 'Login successful.'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except smtplib.SMTPHeloError:
data_ret = {"status": 0, 'error_message': 'The server did not reply properly to the HELO greeting.'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except smtplib.SMTPAuthenticationError:
data_ret = {"status": 0, 'error_message': 'Username and password combination not accepted.'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except smtplib.SMTPException:
data_ret = {"status": 0, 'error_message': 'No suitable authentication method was found.'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
final_dic = {'status': 0, 'error_message': str(msg)}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
def submitPackage(sender, **kwargs):
from packages.models import Package
from loginSystem.models import Administrator
from plogical.acl import ACLManager
try:
request = kwargs['request']
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL,
'createPackage') == 0:
return ACLManager.loadErrorJson('saveStatus', 0)
data = json.loads(request.body)
packageName = data['packageName']
packageSpace = int(data['diskSpace'])
packageBandwidth = int(data['bandwidth'])
packageDatabases = int(data['dataBases'])
ftpAccounts = int(data['ftpAccounts'])
emails = int(data['emails'])
allowedDomains = int(data['allowedDomains'])
if packageSpace < 0 or packageBandwidth < 0 or packageDatabases < 0 or ftpAccounts < 0 or emails < 0 or allowedDomains < 0:
data_ret = {
'saveStatus': 0,
'error_message': "All values should be positive or 0."
}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
admin = Administrator.objects.get(pk=userID)
package = Package(admin=admin,
packageName=packageName,
diskSpace=packageSpace,
bandwidth=packageBandwidth,
ftpAccounts=ftpAccounts,
dataBases=packageDatabases,
emailAccounts=emails,
allowedDomains=allowedDomains)
package.save()
data_ret = {'saveStatus': 1, 'error_message': "None"}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'saveStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def submitFTPCreation(sender, **kwargs):
from loginSystem.models import Administrator
from plogical.acl import ACLManager
from plogical.virtualHostUtilities import virtualHostUtilities
from ftp.models import Users
try:
request = kwargs['request']
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL,
'createFTPAccount') == 0:
return ACLManager.loadErrorJson('creatFTPStatus', 0)
data = json.loads(request.body)
userName = data['ftpUserName']
password = data['ftpPassword']
path = data['path']
domainName = data['ftpDomain']
admin = Administrator.objects.get(id=userID)
if len(path) > 0:
pass
else:
path = 'None'
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/ftpUtilities.py"
execPath = execPath + " submitFTPCreation --domainName " + domainName + " --userName " + userName \
+ " --password " + password + " --path " + path + " --owner " + admin.userName
output = subprocess.check_output(shlex.split(execPath))
if output.find("1,None") > -1:
userTemp = admin.userName + "_" + userName
user = Users.objects.get(user=userTemp)
user.user = userName
user.save()
data_ret = {'creatFTPStatus': 1, 'error_message': 'None'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
else:
data_ret = {'creatFTPStatus': 0, 'error_message': output}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'creatFTPStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def backupDestinations(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL,
'addDeleteDestinations') == 0:
return ACLManager.loadError()
return defRenderer(request, 'IncBackups/incrementalDestinations.html',
{})
except BaseException, msg:
logging.writeToFile(str(msg))
return redirect(loadLoginPage)
def restorePoint(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
data = json.loads(request.body)
backupDomain = data['websiteToBeBacked']
jobid = data['jobid']
if ACLManager.checkOwnership(backupDomain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('metaStatus', 0)
tempPath = "/home/cyberpanel/" + str(randint(1000, 9999))
if data['reconstruct'] == 'remote':
extraArgs = {}
extraArgs['website'] = backupDomain
extraArgs['jobid'] = jobid
extraArgs['tempPath'] = tempPath
extraArgs['reconstruct'] = data['reconstruct']
extraArgs['backupDestinations'] = data['backupDestinations']
extraArgs['password'] = data['password']
extraArgs['path'] = data['path']
else:
extraArgs = {}
extraArgs['website'] = backupDomain
extraArgs['jobid'] = jobid
extraArgs['tempPath'] = tempPath
extraArgs['reconstruct'] = data['reconstruct']
startJob = IncJobs('restorePoint', extraArgs)
startJob.start()
time.sleep(2)
final_json = json.dumps({
'status': 1,
'error_message': "None",
'tempPath': tempPath
})
return HttpResponse(final_json)
except BaseException, msg:
logging.writeToFile(str(msg))
final_dic = {'status': 0, 'metaStatus': 0, 'error_message': str(msg)}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
def wrap(request, *args, **kwargs):
try:
userID = request.session['userID']
except KeyError:
return redirect(loadLoginPage)
currentACL = ACLManager.loadedACL(userID)
if request.method == "POST":
isPost = True
else:
isPost = False
# check if docker is installed
dockerInstallPath = '/usr/bin/docker'
if not os.path.exists(dockerInstallPath):
if isPost:
data_ret = {
'status': 0,
'error_message': 'Docker not installed'
}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
else:
return render(request, 'dockerManager/install.html', {
'status': currentACL['admin'],
'conErr': 0
})
# Check if docker is running and we are able to connect
try:
client = docker.from_env()
client.ping()
except BaseException, msg:
logging.writeToFile(str(msg))
if isPost:
data_ret = {
'status': 0,
'error_message':
'Docker daemon not running or not responsive'
}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
else:
return render(request, 'dockerManager/install.html', {
'status': currentACL['admin'],
'conErr': 1
})
