def submitFTPDelete(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'deleteFTPAccount') == 0:
return ACLManager.loadErrorJson('deleteStatus', 0)
data = json.loads(self.request.body)
ftpUserName = data['ftpUsername']
admin = Administrator.objects.get(pk=userID)
ftp = Users.objects.get(user=ftpUserName)
if ftp.domain.admin != admin:
return ACLManager.loadErrorJson()
FTPUtilities.submitFTPDeletion(ftpUserName)
final_json = json.dumps({'status': 1, 'deleteStatus': 1, 'error_message': "None"})
return HttpResponse(final_json)
except BaseException, msg:
data_ret = {'status': 0, 'deleteStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def submitEmailDeletion(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'deleteEmail') == 0:
return ACLManager.loadErrorJson('deleteEmailStatus', 0)
data = json.loads(self.request.body)
email = data['email']
eUser = EUsers.objects.get(email=email)
admin = Administrator.objects.get(pk=userID)
if ACLManager.checkOwnership(eUser.emailOwner.domainOwner.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson()
mailUtilities.deleteEmailAccount(email)
data_ret = {'status': 1, 'deleteEmailStatus': 1, 'error_message': "None"}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'status': 0, 'deleteEmailStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def submitZoneDeletion(self, userID=None, data=None):
try:
zoneDomain = data['zoneDomain']
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
if ACLManager.currentContextPermission(currentACL,
'deleteZone') == 0:
return ACLManager.loadErrorJson('delete_status', 0)
if ACLManager.checkOwnershipZone(zoneDomain, admin,
currentACL) == 1:
pass
else:
return ACLManager.loadError()
delZone = Domains.objects.get(name=zoneDomain)
admin = Administrator.objects.get(pk=userID)
if currentACL['admin'] == 1:
if delZone.admin != admin:
return ACLManager.loadErrorJson()
delZone.delete()
final_dic = {'delete_status': 1, 'error_message': "None"}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
except BaseException, msg:
final_dic = {'delete_status': 0, 'error_message': str(msg)}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
def changePassword(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'listFTPAccounts') == 0:
return ACLManager.loadErrorJson('changePasswordStatus', 0)
data = json.loads(self.request.body)
userName = data['ftpUserName']
password = data['passwordByPass']
admin = Administrator.objects.get(pk=userID)
ftp = Users.objects.get(user=userName)
if currentACL['admin'] == 1:
pass
elif ftp.domain.admin != admin:
return ACLManager.loadErrorJson()
FTPUtilities.changeFTPPassword(userName, password)
data_ret = {'status': 1, 'changePasswordStatus': 1, 'error_message': "None"}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'status': 0, 'changePasswordStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def deleteEmail(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']
delEmail = EmailsInList.objects.get(id=id)
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
elif delEmail.owner.owner.id != userID:
ACLManager.loadErrorJson()
delEmail.delete()
data_ret = {"status": 1}
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 emailVerificationJob(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)
extraArgs = {}
extraArgs['listName'] = data['listName']
delList = EmailLists.objects.get(listName=extraArgs['listName'])
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
elif delList.owner.id != userID:
ACLManager.loadErrorJson()
em = EM('verificationJob', extraArgs)
em.start()
time.sleep(2)
data_ret = {"status": 1}
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 submitEmailList(self):
try:
data = json.loads(self.request.body)
extraArgs = {}
extraArgs['domain'] = data['domain']
extraArgs['path'] = data['path']
extraArgs['listName'] = data['listName'].replace(' ', '')
extraArgs['tempStatusPath'] = "/home/cyberpanel/" + str(randint(1000, 9999))
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
if ACLManager.checkOwnership(data['domain'], admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson()
if emACL.checkIfEMEnabled(admin.userName) == 0:
return ACLManager.loadErrorJson()
em = EM('createEmailList', extraArgs)
em.start()
time.sleep(2)
data_ret = {"status": 1, 'tempStatusPath': extraArgs['tempStatusPath']}
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 fetchDatabases(self, userID=None, data=None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL,
'deleteDatabase') == 0:
return ACLManager.loadErrorJson('fetchStatus', 0)
databaseWebsite = data['databaseWebsite']
admin = Administrator.objects.get(pk=userID)
if ACLManager.checkOwnership(databaseWebsite, admin,
currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson()
website = Websites.objects.get(domain=databaseWebsite)
databases = Databases.objects.filter(website=website)
json_data = "["
checker = 0
for items in databases:
dic = {
'id': items.pk,
'dbName': items.dbName,
'dbUser': items.dbUser,
}
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_json = json.dumps({
'status': 1,
'fetchStatus': 1,
'error_message': "None",
"data": json_data
})
return HttpResponse(final_json)
except BaseException, msg:
logging.CyberCPLogFileWriter.writeToFile(str(msg))
final_json = json.dumps({
'status': 0,
'fetchStatus': 0,
'error_message': str(msg)
})
return HttpResponse(final_json)
def getEmailsForDomain(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'deleteEmail') == 0:
return ACLManager.loadErrorJson('fetchStatus', 0)
data = json.loads(self.request.body)
domain = data['domain']
admin = Administrator.objects.get(pk=userID)
if ACLManager.checkOwnership(domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson()
try:
domain = Domains.objects.get(domain=domain)
except:
final_dic = {'status': 0, 'fetchStatus': 0, 'error_message': "No email accounts exists!"}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
emails = domain.eusers_set.all()
if emails.count() == 0:
final_dic = {'status': 0, 'fetchStatus': 0, 'error_message': "No email accounts exists!"}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
json_data = "["
checker = 0
count = 1
for items in emails:
dic = {'id': count, 'email': items.email}
count = count + 1
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, 'fetchStatus': 1, 'error_message': "None", "data": json_data}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
except BaseException, msg:
data_ret = {'status': 0, 'fetchStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def obtainHostNameSSL(request):
try:
userID = request.session['userID']
try:
if request.method == 'POST':
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
elif currentACL['hostnameSSL'] == 1:
pass
else:
return ACLManager.loadErrorJson('SSL', 0)
data = json.loads(request.body)
virtualHost = data['virtualHost']
path = "/home/" + virtualHost + "/public_html"
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()
## ssl issue
execPath = "/usr/local/CyberCP/bin/python2 " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " issueSSLForHostName --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:
data_ret = {"status": 0, "SSL": 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
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 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 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 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 getCurrentBackups(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
backupDomain = data['websiteToBeBacked']
if ACLManager.checkOwnership(backupDomain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('fetchStatus', 0)
if ACLManager.checkOwnership(backupDomain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson()
website = Websites.objects.get(domain=backupDomain)
backups = website.backups_set.all()
json_data = "["
checker = 0
for items in backups:
if items.status == 0:
status = "Pending"
else:
status = "Completed"
dic = {'id': items.id,
'file': items.fileName,
'date': items.date,
'size': items.size,
'status': status
}
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_json = json.dumps({'status': 1, 'fetchStatus': 1, 'error_message': "None", "data": json_data})
return HttpResponse(final_json)
except BaseException, msg:
final_dic = {'status': 0, 'fetchStatus': 0, 'error_message': str(msg)}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
def submitModify(self):
try:
userID = self.request.session['userID']
data = json.loads(self.request.body)
packageName = data['packageName']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'modifyPackage') == 0:
return ACLManager.loadErrorJson('modifyStatus', 0)
modifyPack = Package.objects.get(packageName=packageName)
diskSpace = modifyPack.diskSpace
bandwidth = modifyPack.bandwidth
ftpAccounts = modifyPack.ftpAccounts
dataBases = modifyPack.dataBases
emails = modifyPack.emailAccounts
data_ret = {'emails': emails, 'modifyStatus': 1, 'error_message': "None",
"diskSpace": diskSpace, "bandwidth": bandwidth, "ftpAccounts": ftpAccounts,
"dataBases": dataBases, "allowedDomains": modifyPack.allowedDomains, 'allowFullDomain': modifyPack.allowFullDomain}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'modifyStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def zoneCreation(self, userID=None, data=None):
try:
admin = Administrator.objects.get(pk=userID)
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL,
'createDNSZone') == 0:
return ACLManager.loadErrorJson('zoneCreation', 0)
zoneDomain = data['zoneDomain']
newZone = Domains(admin=admin, name=zoneDomain, type="NATIVE")
newZone.save()
content = "ns1." + zoneDomain + " hostmaster." + zoneDomain + " 1 10800 3600 604800 3600"
soaRecord = Records(domainOwner=newZone,
domain_id=newZone.id,
name=zoneDomain,
type="SOA",
content=content,
ttl=3600,
prio=0,
disabled=0,
auth=1)
soaRecord.save()
final_dic = {'zoneCreation': 1}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
except BaseException, msg:
final_dic = {'zoneCreation': 0, 'error_message': str(msg)}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
def deleteACLFunc(request):
try:
val = request.session['userID']
currentACL = ACLManager.loadedACL(val)
if currentACL['admin'] == 1:
data = json.loads(request.body)
acl = ACL.objects.get(name=data['aclToBeDeleted'])
if acl.administrator_set.all().count() == 0:
acl.delete()
finalResponse = {'status': 1}
else:
finalResponse = {
'status':
0,
'errorMesssage':
'This ACL is currently in used by existing users.',
'error_message':
'This ACL is currently in used by existing users.'
}
else:
return ACLManager.loadErrorJson()
json_data = json.dumps(finalResponse)
return HttpResponse(json_data)
except BaseException, msg:
finalResponse = {
'status': 0,
'errorMessage': str(msg),
'error_message': str(msg)
}
json_data = json.dumps(finalResponse)
return HttpResponse(json_data)
def deleteDNSRecord(self, userID=None, data=None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL,
'addDeleteRecords') == 0:
return ACLManager.loadErrorJson('delete_status', 0)
id = data['id']
delRecord = Records.objects.get(id=id)
delRecord.delete()
final_dic = {
'status': 1,
'delete_status': 1,
'error_message': "None"
}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
except BaseException, msg:
final_dic = {
'status': 0,
'delete_status': 0,
'error_message': str(msg)
}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
def getContainerTop(self, userID=None, data=None):
try:
name = data['name']
if ACLManager.checkContainerOwnership(name, userID) != 1:
return ACLManager.loadErrorJson('containerTopStatus', 0)
client = docker.from_env()
dockerAPI = docker.APIClient()
try:
container = client.containers.get(name)
except docker.errors.NotFound as err:
data_ret = {'containerTopStatus': 0, 'error_message': 'Container does not exist'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except:
data_ret = {'containerTopStatus': 0, 'error_message': 'Unknown'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
try:
top = container.top()
except docker.errors.APIError as err:
data_ret = {'containerTopStatus': 0, 'error_message': str(err)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
data_ret = {'containerTopStatus': 1, 'error_message': 'None', 'processes': top}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'containerTopStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def findAllACLs(self, request):
try:
userID = self.admin.pk
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
aclNames = ACLManager.findAllACLs()
else:
return ACLManager.loadErrorJson()
json_data = "["
checker = 0
for items in aclNames:
dic = {'acl': items}
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_json = json.dumps({
'status': 1,
'error_message': "None",
"data": json_data
})
return HttpResponse(final_json)
except BaseException, msg:
return self.ajaxPre(0, str(msg))
def getFurtherDataFromLogFile(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadErrorJson('logstatus', 0)
fewLinesOfLogFile = logging.CyberCPLogFileWriter.readLastNFiles(
50, logging.CyberCPLogFileWriter.fileName)
fewLinesOfLogFile = str(fewLinesOfLogFile)
status = {"logstatus": 1, "logsdata": fewLinesOfLogFile}
final_json = json.dumps(status)
return HttpResponse(final_json)
except KeyError, msg:
status = {
"logstatus":
0,
"error":
"Could not fetch data from log file, please see CyberCP main log file through command line."
}
logging.CyberCPLogFileWriter.writeToFile(
str(msg) + "[getFurtherDataFromLogFile]")
return HttpResponse("Not Logged in as admin")
def switchTOLSWS(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadErrorJson('status', 0)
data = json.loads(request.body)
try:
licenseKey = data['licenseKey']
except:
licenseKey = 'trial'
execPath = "sudo /usr/local/CyberCP/bin/python " + virtualHostUtilities.cyberPanel + "/serverStatus/serverStatusUtil.py"
execPath = execPath + " switchTOLSWS --licenseKey " + licenseKey
ProcessUtilities.popenExecutioner(execPath)
time.sleep(2)
data_ret = {
'status': 1,
'error_message': "None",
}
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 licenseStatus(request):
try:
userID = request.session['userID']
try:
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadErrorJson('status', 0)
command = 'sudo cat /usr/local/lsws/conf/serial.no'
serial = ProcessUtilities.outputExecutioner(command)
command = 'sudo /usr/local/lsws/bin/lshttpd -V'
expiration = ProcessUtilities.outputExecutioner(command)
final_dic = {
'status': 1,
"erroMessage": 0,
'lsSerial': serial,
'lsexpiration': expiration
}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
except BaseException, msg:
final_dic = {'status': 0, 'erroMessage': str(msg)}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
except KeyError, msg:
final_dic = {'status': 0, 'erroMessage': str(msg)}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
def killProcess(request):
try:
userID = request.session['userID']
try:
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadErrorJson('status', 0)
data = json.loads(request.body)
pid = data['pid']
ProcessUtilities.executioner('sudo kill ' + pid)
proc = httpProc(request, None)
return proc.ajax(1, None)
except BaseException, msg:
final_dic = {'status': 0, 'erroMessage': str(msg)}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
except KeyError, msg:
final_dic = {'status': 0, 'erroMessage': str(msg)}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
def fetchWebsiteData(self):
try:
currentACL = ACLManager.loadedACL(self.admin.pk)
website = Websites.objects.get(domain=self.data['domainName'])
admin = Administrator.objects.get(pk=self.admin.pk)
if ACLManager.checkOwnership(self.data['domainName'], admin,
currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson()
Data = {}
Data['ftpAllowed'] = website.package.ftpAccounts
Data['ftpUsed'] = website.users_set.all().count()
Data['dbUsed'] = website.databases_set.all().count()
Data['dbAllowed'] = website.package.dataBases
diskUsageDetails = virtualHostUtilities.getDiskUsage(
"/home/" + self.data['domainName'], website.package.diskSpace)
## bw usage calculation
try:
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " findDomainBW --virtualHostName " + self.data[
'domainName'] + " --bandwidth " + str(
website.package.bandwidth)
output = subprocess.check_output(shlex.split(execPath))
bwData = output.split(",")
except BaseException:
bwData = [0, 0]
## bw usage calculations
Data['bwAllowed'] = website.package.bandwidth
Data['bwUsed'] = bwData[0]
Data['bwUsage'] = bwData[1]
if diskUsageDetails != None:
if diskUsageDetails[1] > 100:
diskUsageDetails[1] = 100
Data['diskUsage'] = diskUsageDetails[1]
Data['diskUsed'] = diskUsageDetails[0]
Data['diskAllowed'] = website.package.diskSpace
else:
Data['diskUsed'] = 0
Data['diskUsage'] = 0
Data['diskInMBTotal'] = website.package.diskSpace
Data['status'] = 1
final_json = json.dumps(Data)
return HttpResponse(final_json)
except BaseException, msg:
return self.ajaxPre(0, str(msg))
def removeDestination(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL,
'addDeleteDestinations') == 0:
return ACLManager.loadErrorJson('destStatus', 0)
data = json.loads(request.body)
ipAddress = data['IPAddress']
if data['type'] == 'SFTP':
ipFile = '/home/cyberpanel/sftp/%s' % (ipAddress)
else:
ipFile = '/home/cyberpanel/aws/%s' % (ipAddress)
os.remove(ipFile)
final_dic = {'status': 1, 'error_message': 'None'}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
except BaseException, msg:
final_dic = {'destStatus': 0, 'error_message': str(msg)}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
def exportContainer(self, request=None, userID=None, data=None):
try:
name = request.GET.get('name')
if ACLManager.checkContainerOwnership(name, userID) != 1:
return ACLManager.loadErrorJson('containerStatus', 0)
client = docker.from_env()
dockerAPI = docker.APIClient()
try:
container = client.containers.get(name)
except docker.errors.NotFound as err:
data_ret = {'containerStatus': 0, 'error_message': 'Container does not exist'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except:
data_ret = {'containerStatus': 0, 'error_message': 'Unknown'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
eFile = container.export() # Export with default chunk size
response = HttpResponse(eFile, content_type='application/force-download')
response['Content-Disposition'] = 'attachment; filename="' + name + '.tar"'
return response
except BaseException, msg:
data_ret = {'containerStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def deleteBackup(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
data = json.loads(request.body)
backupDomain = data['websiteToBeBacked']
if ACLManager.checkOwnership(backupDomain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('fetchStatus', 0)
id = data['backupID']
IncJob.objects.get(id=id).delete()
final_dic = {'status': 1, 'error_message': 'None'}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
except BaseException, msg:
final_dic = {'destStatus': 0, 'error_message': str(msg)}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
def fetchFTPAccounts(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'deleteFTPAccount') == 0:
return ACLManager.loadErrorJson('fetchStatus', 0)
data = json.loads(self.request.body)
domain = data['ftpDomain']
website = Websites.objects.get(domain=domain)
ftpAccounts = website.users_set.all()
json_data = "["
checker = 0
for items in ftpAccounts:
dic = {"userName": items.user}
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_json = json.dumps({'fetchStatus': 1, 'error_message': "None", "data": json_data})
return HttpResponse(final_json)
except BaseException, msg:
data_ret = {'fetchStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
