def topProcesses(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadError()
templateName = "serverStatus/topProcesses.html"
proc = httpProc(request, templateName)
return proc.renderPre()
except KeyError, msg:
logging.CyberCPLogFileWriter.writeToFile(
str(msg) + "[litespeedStatus]")
return redirect(loadLoginPage)
def deleteFTPAccount(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'deleteFTPAccount') == 0:
return ACLManager.loadError()
if not os.path.exists('/home/cyberpanel/pureftpd'):
return render(self.request, "ftp/deleteFTPAccount.html", {"status": 0})
websitesName = ACLManager.findAllSites(currentACL, userID)
return render(self.request, 'ftp/deleteFTPAccount.html', {'websiteList': websitesName, "status": 1})
except BaseException, msg:
logging.CyberCPLogFileWriter.writeToFile(str(msg))
return HttpResponse(str(msg))
def dkimManager(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'dkimManager') == 0:
return ACLManager.loadError()
openDKIMInstalled = 1
websitesName = ACLManager.findAllSites(currentACL, userID)
websitesName = websitesName + ACLManager.findChildDomains(websitesName)
return render(self.request, 'mailServer/dkimManager.html',
{'websiteList': websitesName, 'openDKIMInstalled': openDKIMInstalled})
except BaseException, msg:
return redirect(loadLoginPage)
def managePureFtpd(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadError()
try:
return render(request, 'manageServices/managePureFtpd.html',
{"status": 1})
except BaseException, msg:
logging.CyberCPLogFileWriter.writeToFile(str(msg))
return HttpResponse("See CyberCP main log file.")
except KeyError:
return redirect(loadLoginPage)
def manageLists(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadError()
if emACL.checkIfEMEnabled(admin.userName) == 0:
return ACLManager.loadError()
listNames = emACL.getEmailsLists(self.domain)
return render(self.request, 'emailMarketing/manageLists.html', {'listNames': listNames, 'domain': self.domain})
except KeyError, msg:
return redirect(loadLoginPage)
def getAdminStatus(request):
try:
val = request.session['userID']
currentACL = ACLManager.loadedACL(val)
json_data = json.dumps(currentACL)
return HttpResponse(json_data)
except KeyError:
return HttpResponse("Can not get admin Status")
def createNameserver(self, request=None, userID=None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL,
'createNameServer') == 0:
return ACLManager.loadError()
mailUtilities.checkHome()
if os.path.exists('/home/cyberpanel/powerdns'):
return render(request, "dns/createNameServer.html",
{"status": 1})
else:
return render(request, "dns/createNameServer.html",
{"status": 0})
except BaseException, msg:
return HttpResponse(str(msg))
def manageSSL(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
elif currentACL['manageSSL'] == 1:
pass
else:
return ACLManager.loadError()
websitesName = ACLManager.findAllSites(currentACL, userID)
return render(request, 'manageSSL/manageSSL.html',
{'websiteList': websitesName})
except KeyError:
return redirect(loadLoginPage)
def listEmails(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'listEmails') == 0:
return ACLManager.loadError()
if not os.path.exists('/home/cyberpanel/postfix'):
return render(self.request, "mailServer/listEmails.html", {"status": 0})
websitesName = ACLManager.findAllSites(currentACL, userID)
websitesName = websitesName + ACLManager.findChildDomains(websitesName)
return render(self.request, 'mailServer/listEmails.html',
{'websiteList': websitesName, "status": 1})
except BaseException, msg:
return redirect(loadLoginPage)
def changeLicense(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)
newKey = data['newKey']
command = 'sudo chown -R cyberpanel:cyberpanel /usr/local/lsws/conf'
ProcessUtilities.executioner(command)
serialPath = '/usr/local/lsws/conf/serial.no'
serialFile = open(serialPath, 'w')
serialFile.write(newKey)
serialFile.close()
command = 'sudo chown -R lsadm:lsadm /usr/local/lsws/conf'
ProcessUtilities.executioner(command)
command = 'sudo /usr/local/lsws/bin/lshttpd -r'
ProcessUtilities.executioner(command)
command = 'sudo /usr/local/lsws/bin/lswsctrl restart'
ProcessUtilities.executioner(command)
final_dic = {'status': 1, "erroMessage": 'None'}
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 submitDatabaseDeletion(self, userID=None, data=None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
if ACLManager.currentContextPermission(currentACL,
'deleteDatabase') == 0:
return ACLManager.loadErrorJson('deleteStatus', 0)
dbName = data['dbName']
db = Databases.objects.get(dbName=dbName)
if ACLManager.checkOwnership(db.website.domain, admin,
currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson()
result = mysqlUtilities.submitDBDeletion(dbName)
if result[0] == 1:
data_ret = {
'status': 1,
'deleteStatus': 1,
'error_message': "None"
}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
else:
data_ret = {
'status': 0,
'deleteStatus': 0,
'error_message': result[1]
}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {
'status': 0,
'deleteStatus': 0,
'error_message': str(msg)
}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def getRemoteTransferStatus(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'remoteBackups') == 0:
return ACLManager.loadErrorJson('remoteTransferStatus', 0)
ipAddress = data['ipAddress']
password = data['password']
dir = data['dir']
username = "******"
finalData = json.dumps({'dir': dir, "username": username, "password": password})
r = requests.post("https://" + ipAddress + ":8090/api/FetchRemoteTransferStatus", data=finalData,
verify=False)
data = json.loads(r.text)
if data['fetchStatus'] == 1:
if data['status'].find("Backups are successfully generated and received on") > -1:
data = {'remoteTransferStatus': 1, 'error_message': "None", "status": data['status'],
'backupsSent': 1}
json_data = json.dumps(data)
return HttpResponse(json_data)
elif data['status'].find("[5010]") > -1:
data = {'remoteTransferStatus': 0, 'error_message': data['status'],
'backupsSent': 0}
json_data = json.dumps(data)
return HttpResponse(json_data)
else:
data = {'remoteTransferStatus': 1, 'error_message': "None", "status": data['status'],
'backupsSent': 0}
json_data = json.dumps(data)
return HttpResponse(json_data)
else:
data = {'remoteTransferStatus': 0, 'error_message': data['error_message'],
'backupsSent': 0}
json_data = json.dumps(data)
return HttpResponse(json_data)
except BaseException, msg:
data = {'remoteTransferStatus': 0, 'error_message': str(msg), 'backupsSent': 0}
json_data = json.dumps(data)
return HttpResponse(json_data)
def saveChanges(self):
try:
userID = self.request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'modifyPackage') == 0:
return ACLManager.loadErrorJson('saveStatus', 0)
data = json.loads(self.request.body)
packageName = data['packageName']
if data['diskSpace'] < 0 or data['bandwidth'] < 0 or data['ftpAccounts'] < 0 or data[
'dataBases'] < 0 or \
data['emails'] < 0 or data['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)
modifyPack = Package.objects.get(packageName=packageName)
modifyPack.diskSpace = data['diskSpace']
modifyPack.bandwidth = data['bandwidth']
modifyPack.ftpAccounts = data['ftpAccounts']
modifyPack.dataBases = data['dataBases']
modifyPack.emailAccounts = data['emails']
modifyPack.allowedDomains = data['allowedDomains']
try:
modifyPack.allowFullDomain = int(data['allowFullDomain'])
except:
modifyPack.allowFullDomain = 1
modifyPack.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 changePermissions(request):
try:
userID = request.session['userID']
admin = Administrator.objects.get(pk=userID)
try:
data = json.loads(request.body)
domainName = data['domainName']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.checkOwnership(domainName, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('permissionsChanged', 0)
website = Websites.objects.get(domain=domainName)
externalApp = website.externalApp
command = "sudo chown -R " + externalApp + ":" + externalApp + " /home/" + domainName
ProcessUtilities.popenExecutioner(command)
command = "sudo chown -R lscpd:lscpd /home/" + domainName + "/logs"
ProcessUtilities.popenExecutioner(command)
command = "sudo find %s -type d -exec chmod 0755 {} \;" % (
"/home/" + domainName + "/public_html")
ProcessUtilities.popenExecutioner(command)
command = "sudo find %s -type f -exec chmod 0644 {} \;" % (
"/home/" + domainName + "/public_html")
ProcessUtilities.popenExecutioner(command)
data_ret = {'permissionsChanged': 1, 'error_message': "None"}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
logging.CyberCPLogFileWriter.writeToFile(str(msg))
data_ret = {'permissionsChanged': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except KeyError:
return redirect(loadLoginPage)
def spamAssassinHome(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadError()
checkIfSpamAssassinInstalled = 0
if mailUtilities.checkIfSpamAssassinInstalled() == 1:
checkIfSpamAssassinInstalled = 1
return render(request, 'emailPremium/SpamAssassin.html',{'checkIfSpamAssassinInstalled': checkIfSpamAssassinInstalled})
except KeyError:
return redirect(loadLoginPage)
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 = subprocess.check_output(
shlex.split(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, msg:
data_ret = {'status': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except KeyError, 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 deleteUser(request):
try:
userID = request.session['userID']
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
adminNames = ACLManager.loadDeletionUsers(userID, currentACL)
return render(request, 'userManagment/deleteUser.html',
{"acctNames": adminNames})
elif currentACL['deleteUser'] == 1:
adminNames = ACLManager.loadDeletionUsers(userID, currentACL)
return render(request, 'userManagment/deleteUser.html',
{"acctNames": adminNames})
else:
return ACLManager.loadError()
except KeyError:
return redirect(loadLoginPage)
def configureDefaultNameServers(self, request=None, userID=None):
try:
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadError()
if not os.path.exists('/home/cyberpanel/powerdns'):
return render(request, 'dns/addDeleteDNSRecords.html',
{"status": 0})
data = {}
data['domainsList'] = ACLManager.findAllDomains(currentACL, userID)
data['status'] = 1
if os.path.exists(DNSManager.defaultNameServersPath):
nsData = open(DNSManager.defaultNameServersPath,
'r').readlines()
try:
data['firstNS'] = nsData[0]
except:
pass
try:
data['secondNS'] = nsData[1]
except:
pass
try:
data['thirdNS'] = nsData[2]
except:
pass
try:
data['forthNS'] = nsData[3]
except:
pass
return render(request, 'dns/configureDefaultNameServers.html',
data)
except BaseException, msg:
return HttpResponse(str(msg))
def listContainers(self, request=None, userID=None, data=None):
try:
client = docker.from_env()
dockerAPI = docker.APIClient()
currentACL = ACLManager.loadedACL(userID)
containers = ACLManager.findAllContainers(currentACL, userID)
allContainers = client.containers.list()
containersList = []
showUnlistedContainer = True
# TODO: Add condition to show unlisted Containers only if user has admin level access
unlistedContainers = []
for container in allContainers:
if container.name not in containers:
unlistedContainers.append(container)
if not unlistedContainers:
showUnlistedContainer = False
adminNames = ACLManager.loadAllUsers(userID)
pages = float(len(containers)) / 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, 'dockerManager/listContainers.html', {"pagination": pagination,
"unlistedContainers": unlistedContainers,
"adminNames": adminNames,
"showUnlistedContainer": showUnlistedContainer})
except BaseException, msg:
return HttpResponse(str(msg))
def createPackage(sender, **kwargs):
from loginSystem.models import Administrator
from loginSystem.views import loadLoginPage
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.loadError()
admin = Administrator.objects.get(pk=userID)
return render(request, 'beautifulNames/createPackage.html',
{"admin": admin.userName})
except KeyError:
return redirect(loadLoginPage)
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, 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 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,msg:
dic = {'status': 0, 'error_message': str(msg)}
json_data = json.dumps(dic)
return HttpResponse(json_data)
except KeyError,msg:
dic = {'statusa': 0, 'error_message': str(msg)}
json_data = json.dumps(dic)
return HttpResponse(json_data)
def fetchSMTPHosts(self):
try:
userID = self.request.session['userID']
admin = Administrator.objects.get(pk=userID)
if emACL.checkIfEMEnabled(admin.userName) == 0:
return ACLManager.loadErrorJson()
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
allHosts = SMTPHosts.objects.all()
else:
admin = Administrator.objects.get(pk=userID)
allHosts = admin.smtphosts_set.all()
json_data = "["
checker = 0
counter = 1
for items in allHosts:
dic = {'id': items.id, 'owner': items.owner.userName, 'host': items.host, 'port': items.port,
'userName': items.userName}
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 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']
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 upload(request):
try:
data = request.POST
userID = request.session['userID']
admin = Administrator.objects.get(pk=userID)
currentACL = ACLManager.loadedACL(userID)
if ACLManager.checkOwnership(data['domainName'], admin,
currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson()
fm = FM(request, data)
return fm.upload()
except KeyError:
return redirect(loadLoginPage)
def composeEmailMessage(self):
try:
userID = self.request.session['userID']
admin = Administrator.objects.get(pk=userID)
if emACL.checkIfEMEnabled(admin.userName) == 0:
return ACLManager.loadErrorJson()
return render(self.request, 'emailMarketing/composeMessages.html')
except KeyError, msg:
return redirect(loadLoginPage)
def sendEmails(self):
try:
userID = self.request.session['userID']
admin = Administrator.objects.get(pk=userID)
if emACL.checkIfEMEnabled(admin.userName) == 0:
return ACLManager.loadErrorJson()
currentACL = ACLManager.loadedACL(userID)
templateNames = emACL.allTemplates(currentACL, admin)
hostNames = emACL.allSMTPHosts(currentACL, admin)
listNames = emACL.allEmailsLists(currentACL, admin)
Data = {}
Data['templateNames'] = templateNames
Data['hostNames'] = hostNames
Data['listNames'] = listNames
return render(self.request, 'emailMarketing/sendEmails.html', Data)
except KeyError, msg:
return redirect(loadLoginPage)
def createTemporaryFile(request):
try:
userID = request.session['userID']
data = json.loads(request.body)
domainName = data['domainName']
admin = Administrator.objects.get(pk=userID)
currentACL = ACLManager.loadedACL(userID)
if ACLManager.checkOwnership(domainName, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('createTemporaryFile', 0)
## Create file manager entry
if Websites.objects.filter(domain=domainName).exists():
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/filemanager.py"
execPath = execPath + " createTemporaryFile --domainName " + domainName
output = subprocess.check_output(shlex.split(execPath))
if output.find("0,") > -1:
data_ret = {'createTemporaryFile': 0, 'error_message': "None"}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
else:
domainRandomSeed = output.rstrip('\n')
data_ret = {
'createTemporaryFile': 1,
'error_message': "None",
'domainRandomSeed': domainRandomSeed
}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except KeyError:
return redirect(loadLoginPage)
def saveNSConfigurations(self, userID=None, data=None):
try:
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadErrorJson()
nsContent = ''
try:
nsContent = '%s\n%s\n%s\n%s\n' % (
data['firstNS'], data['secondNS'], data['thirdNS'],
data['forthNS'])
except:
try:
nsContent = '%s\n%s\n%s\n' % (
data['firstNS'], data['secondNS'], data['thirdNS'])
except:
try:
nsContent = '%s\n%s\n' % (data['firstNS'],
data['secondNS'])
except:
try:
nsContent = '%s\n' % (data['firstNS'])
except:
pass
writeToFile = open(DNSManager.defaultNameServersPath, 'w')
writeToFile.write(nsContent.rstrip('\n'))
writeToFile.close()
final_dic = {'status': 1, 'error_message': "None"}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
except BaseException, msg:
final_dic = {'status': 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']
admin = Administrator.objects.get(pk=userID)
if ACLManager.checkOwnership(domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson()
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)
