def restoreRemoteBackups(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL,
'createBackup') == 0:
return ACLManager.loadError()
websitesName = ACLManager.findAllSites(currentACL, userID)
destinations = []
path = '/home/cyberpanel/sftp'
if os.path.exists(path):
for items in os.listdir(path):
destinations.append('sftp:%s' % (items))
path = '/home/cyberpanel/aws'
if os.path.exists(path):
for items in os.listdir(path):
destinations.append('s3:s3.amazonaws.com/%s' % (items))
return defRenderer(request, 'IncBackups/restoreRemoteBackups.html', {
'websiteList': websitesName,
'destinations': destinations
})
except BaseException, msg:
logging.writeToFile(str(msg))
return redirect(loadLoginPage)
def remoteBackupRestore(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'remoteBackups') == 0:
return ACLManager.loadErrorJson('remoteTransferStatus', 0)
backupDir = data['backupDir']
backupDirComplete = "/home/backup/transfer-" + str(backupDir)
# adminEmail = admin.email
##
execPath = "/usr/local/CyberCP/bin/python2 " + virtualHostUtilities.cyberPanel + "/plogical/remoteTransferUtilities.py"
execPath = execPath + " remoteBackupRestore --backupDirComplete " + backupDirComplete + " --backupDir " + str(
backupDir)
ProcessUtilities.popenExecutioner(execPath)
time.sleep(3)
data = {'remoteRestoreStatus': 1, 'error_message': 'None'}
json_data = json.dumps(data)
return HttpResponse(json_data)
except BaseException, msg:
data = {'remoteRestoreStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data)
return HttpResponse(json_data)
def getCurrentBackupSchedules(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'scheDuleBackups') == 0:
return ACLManager.loadErrorJson('fetchStatus', 0)
records = backupSchedules.objects.all()
json_data = "["
checker = 0
for items in records:
dic = {'id': items.id,
'destLoc': items.dest.destLoc,
'frequency': items.frequency,
}
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:
final_dic = {'fetchStatus': 0, 'error_message': str(msg)}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
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 restoreSite(self, request = None, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'restoreBackup') == 0:
return ACLManager.loadError()
path = os.path.join("/home", "backup")
if not os.path.exists(path):
return render(request, 'backup/restore.html')
else:
all_files = []
ext = ".tar.gz"
command = 'sudo chown -R cyberpanel:cyberpanel ' + path
ACLManager.executeCall(command)
files = os.listdir(path)
for filename in files:
if filename.endswith(ext):
all_files.append(filename)
return render(request, 'backup/restore.html', {'backups': all_files})
except BaseException, msg:
return HttpResponse(str(msg))
def getConnectionStatus(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'addDeleteDestinations') == 0:
return ACLManager.loadErrorJson('connStatus', 0)
ipAddress = data['IPAddress']
execPath = "/usr/local/CyberCP/bin/python2 " + virtualHostUtilities.cyberPanel + "/plogical/backupUtilities.py"
execPath = execPath + " getConnectionStatus --ipAddress " + ipAddress
output = ProcessUtilities.executioner(execPath)
if output.find('1,') > -1:
final_dic = {'connStatus': 1, 'error_message': "None"}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
else:
final_dic = {'connStatus': 0, 'error_message': output}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
except BaseException, msg:
final_dic = {'connStatus': 1, 'error_message': str(msg)}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
def scheduleDelete(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'scheDuleBackups') == 0:
return ACLManager.loadErrorJson('scheduleStatus', 0)
backupDest = data['destLoc']
backupFreq = data['frequency']
findTxt = ""
if backupDest == "Home" and backupFreq == "Daily":
findTxt = "0 3"
elif backupDest == "Home" and backupFreq == "Weekly":
findTxt = "0 0"
elif backupDest != "Home" and backupFreq == "Daily":
findTxt = "0 3"
elif backupDest != "Home" and backupFreq == "Weekly":
findTxt = "0 0"
###
logging.CyberCPLogFileWriter.writeToFile(findTxt)
logging.CyberCPLogFileWriter.writeToFile(backupFreq)
path = "/etc/crontab"
command = "cat " + path
output = ProcessUtilities.outputExecutioner(command).split('\n')
tempCronPath = "/home/cyberpanel/" + str(randint(1000, 9999))
writeToFile = open(tempCronPath, 'w')
for items in output:
if (items.find(findTxt) > -1 and items.find("backupScheduleLocal.py") > -1) or (items.find(findTxt) > -1 and items.find('backupSchedule.py')):
continue
else:
writeToFile.writelines(items + '\n')
writeToFile.close()
command = "sudo mv " + tempCronPath + " " + path
ProcessUtilities.executioner(command)
command = 'chown root:root %s' % (path)
ProcessUtilities.executioner(command)
command = "sudo systemctl restart crond"
ProcessUtilities.executioner(command)
destination = dest.objects.get(destLoc=backupDest)
newSchedule = backupSchedules.objects.get(dest=destination, frequency=backupFreq)
newSchedule.delete()
final_json = json.dumps({'delStatus': 1, 'error_message': "None"})
return HttpResponse(final_json)
except BaseException, msg:
final_json = json.dumps({'delStatus': 0, 'error_message': str(msg)})
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 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 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 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 createFTPAccount(sender, **kwargs):
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,
'createFTPAccount') == 0:
return ACLManager.loadError()
admin = Administrator.objects.get(pk=userID)
if not os.path.exists('/home/cyberpanel/pureftpd'):
return render(request, "ftp/createFTPAccount.html", {"status": 0})
websitesName = ACLManager.findAllSites(currentACL, userID)
return render(request, 'beautifulNames/createFTPAccount.html', {
'websiteList': websitesName,
'admin': admin.userName,
"status": 1
})
except BaseException, msg:
return HttpResponse(str(msg))
def getCurrentBackupDestinations(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'addDeleteDestinations') == 0:
return ACLManager.loadErrorJson('fetchStatus', 0)
records = dest.objects.all()
json_data = "["
checker = 0
for items in records:
if items.destLoc == "Home":
continue
dic = {'id': items.id,
'ip': items.destLoc,
}
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:
final_dic = {'fetchStatus': 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 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 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)
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 backupSite(self, request = None, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'createBackup') == 0:
return ACLManager.loadError()
websitesName = ACLManager.findAllSites(currentACL, userID)
return render(request, 'backup/backup.html', {'websiteList': websitesName})
except BaseException, msg:
return HttpResponse(str(msg))
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 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 remoteBackups(self, request, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'remoteBackups') == 0:
return ACLManager.loadError()
return render(request, 'backup/remoteBackups.html')
except BaseException, msg:
return HttpResponse(str(msg))
def backupDestinations(self, request = None, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'addDeleteDestinations') == 0:
return ACLManager.loadError()
return render(request, 'backup/backupDestinations.html', {})
except BaseException, msg:
return HttpResponse(str(msg))
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 submitBackupSchedule(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL,
'scheDuleBackups') == 0:
return ACLManager.loadErrorJson('scheduleStatus', 0)
data = json.loads(request.body)
backupDest = data['backupDestinations']
backupFreq = data['backupFreq']
websitesToBeBacked = data['websitesToBeBacked']
try:
websiteData = data['websiteData']
websiteData = 1
except:
websiteData = False
websiteData = 0
try:
websiteEmails = data['websiteEmails']
websiteEmails = 1
except:
websiteEmails = False
websiteEmails = 0
try:
websiteDatabases = data['websiteDatabases']
websiteDatabases = 1
except:
websiteDatabases = False
websiteDatabases = 0
newJob = BackupJob(websiteData=websiteData,
websiteDataEmails=websiteEmails,
websiteDatabases=websiteDatabases,
destination=backupDest,
frequency=backupFreq)
newJob.save()
for items in websitesToBeBacked:
jobsite = JobSites(job=newJob, website=items)
jobsite.save()
final_json = json.dumps({'status': 1, 'error_message': "None"})
return HttpResponse(final_json)
except BaseException, msg:
final_json = json.dumps({'status': 0, 'error_message': str(msg)})
return HttpResponse(final_json)
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 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 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 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 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 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))
