#!/usr/local/CyberCP/bin/python2
import os
import os.path
import sys
import django
sys.path.append('/usr/local/CyberCP')
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "CyberCP.settings")
django.setup()
import json
from acl import ACLManager
import CyberCPLogFileWriter as logging
from websiteFunctions.models import Websites, ChildDomains
from virtualHostUtilities import virtualHostUtilities
import subprocess
import shlex
from installUtilities import installUtilities
from django.shortcuts import HttpResponse, render
from loginSystem.models import Administrator
from packages.models import Package
from mailUtilities import mailUtilities
from random import randint
import time
import re
from childDomain import ChildDomainManager
from math import ceil
from plogical.alias import AliasManager
from plogical.applicationInstaller import ApplicationInstaller
from databases.models import Databases
import randomPassword as randomPassword
import hashlib
from mysqlUtilities import mysqlUtilities
from plogical import hashPassword
class WebsiteManager:
def __init__(self, domain = None, childDomain = None):
self.domain = domain
self.childDomain = childDomain
def createWebsite(self, request = None, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'createWebsite') == 0:
return ACLManager.loadError()
adminNames = ACLManager.loadAllUsers(userID)
packagesName = ACLManager.loadPackages(userID, currentACL)
Data = {'packageList': packagesName, "owernList": adminNames}
return render(request, 'websiteFunctions/createWebsite.html', Data)
except BaseException, msg:
return HttpResponse(str(msg))
def modifyWebsite(self, request = None, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'modifyWebsite') == 0:
return ACLManager.loadError()
websitesName = ACLManager.findAllSites(currentACL, userID)
return render(request, 'websiteFunctions/modifyWebsite.html', {'websiteList': websitesName})
except BaseException, msg:
return HttpResponse(str(msg))
def deleteWebsite(self, request = None, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'deleteWebsite') == 0:
return ACLManager.loadError()
websitesName = ACLManager.findAllSites(currentACL, userID)
return render(request, 'websiteFunctions/deleteWebsite.html', {'websiteList': websitesName})
except BaseException, msg:
return HttpResponse(str(msg))
def siteState(self, request = None, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'suspendWebsite') == 0:
return ACLManager.loadError()
websitesName = ACLManager.findAllSites(currentACL, userID)
return render(request, 'websiteFunctions/suspendWebsite.html', {'websiteList': websitesName})
except BaseException, msg:
return HttpResponse(str(msg))
def listWebsites(self, request = None, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
websites = ACLManager.findAllSites(currentACL, userID)
pages = float(len(websites)) / float(10)
pagination = []
if pages <= 1.0:
pages = 1
pagination.append('')
else:
pages = ceil(pages)
finalPages = int(pages) + 1
for i in range(1, finalPages):
pagination.append('' + str(i) + '')
return render(request, 'websiteFunctions/listWebsites.html', {"pagination": pagination})
except BaseException, msg:
return HttpResponse(str(msg))
def listCron(self, request = None, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
websitesName = ACLManager.findAllSites(currentACL, userID)
return render(request, 'websiteFunctions/listCron.html', {'websiteList': websitesName})
except BaseException, msg:
return HttpResponse(str(msg))
def domainAlias(self, request = None, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadError()
aliasManager = AliasManager(self.domain)
noAlias, finalAlisList = aliasManager.fetchAlisForDomains()
path = "/home/" + self.domain + "/public_html"
return render(request, 'websiteFunctions/domainAlias.html', {
'masterDomain': self.domain,
'aliases': finalAlisList,
'path': path,
'noAlias': noAlias
})
except BaseException, msg:
return HttpResponse(str(msg))
def submitWebsiteCreation(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'createWebsite') == 0:
return ACLManager.loadErrorJson('createWebSiteStatus', 0)
domain = data['domainName']
adminEmail = data['adminEmail']
phpSelection = data['phpSelection']
packageName = data['package']
websiteOwner = data['websiteOwner']
externalApp = "".join(re.findall("[a-zA-Z]+", domain))[:7]
tempStatusPath = "/home/cyberpanel/" + str(randint(1000, 9999))
## Create Configurations
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " createVirtualHost --virtualHostName " + domain + \
" --administratorEmail " + adminEmail + " --phpVersion '" + phpSelection + \
"' --virtualHostUser " + externalApp + " --ssl " + str(data['ssl']) + " --dkimCheck " \
+ str(data['dkimCheck']) + " --openBasedir " + str(data['openBasedir']) + \
' --websiteOwner ' + websiteOwner + ' --package ' + packageName + ' --tempStatusPath ' + tempStatusPath
subprocess.Popen(shlex.split(execPath))
time.sleep(2)
data_ret = {'createWebSiteStatus': 1, 'error_message': "None", 'tempStatusPath': tempStatusPath}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'createWebSiteStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def submitDomainCreation(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
masterDomain = data['masterDomain']
domain = data['domainName']
phpSelection = data['phpSelection']
path = data['path']
tempStatusPath = "/home/cyberpanel/" + str(randint(1000, 9999))
if ACLManager.checkOwnership(masterDomain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('createWebSiteStatus', 0)
if currentACL['admin'] != 1:
data['openBasedir'] = 1
if len(path) > 0:
path = path.lstrip("/")
path = "/home/" + masterDomain + "/public_html/" + path
else:
path = "/home/" + masterDomain + "/public_html/" + domain
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " createDomain --masterDomain " + masterDomain + " --virtualHostName " + domain + \
" --phpVersion '" + phpSelection + "' --ssl " + str(data['ssl']) + " --dkimCheck " + str(
data['dkimCheck']) \
+ " --openBasedir " + str(data['openBasedir']) + ' --path ' + path + ' --websiteOwner ' \
+ admin.userName + ' --tempStatusPath ' + tempStatusPath
subprocess.Popen(shlex.split(execPath))
time.sleep(2)
data_ret = {'createWebSiteStatus': 1, 'error_message': "None", 'tempStatusPath': tempStatusPath}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'createWebSiteStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def fetchDomains(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
masterDomain = data['masterDomain']
if ACLManager.checkOwnership(masterDomain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('fetchStatus', 0)
cdManager = ChildDomainManager(masterDomain)
json_data = cdManager.findChildDomainsJson()
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 getFurtherAccounts(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
pageNumber = int(data['page'])
json_data = self.findWebsitesJson(currentACL, userID, pageNumber)
final_dic = {'listWebSiteStatus': 1, 'error_message': "None", "data": json_data}
final_json = json.dumps(final_dic)
return HttpResponse(final_json)
except BaseException, msg:
dic = {'listWebSiteStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(dic)
return HttpResponse(json_data)
def submitWebsiteDeletion(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'deleteWebsite') == 0:
return ACLManager.loadErrorJson('websiteDeleteStatus', 0)
websiteName = data['websiteName']
## Deleting master domain
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " deleteVirtualHostConfigurations --virtualHostName " + websiteName
subprocess.check_output(shlex.split(execPath))
data_ret = {'websiteDeleteStatus': 1, 'error_message': "None"}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'websiteDeleteStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def submitDomainDeletion(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
websiteName = data['websiteName']
if ACLManager.checkOwnership(websiteName, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('websiteDeleteStatus', 0)
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " deleteDomain --virtualHostName " + websiteName
subprocess.check_output(shlex.split(execPath))
data_ret = {'websiteDeleteStatus': 1, 'error_message': "None"}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'websiteDeleteStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def submitWebsiteStatus(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'suspendWebsite') == 0:
return ACLManager.loadErrorJson('websiteStatus', 0)
websiteName = data['websiteName']
state = data['state']
website = Websites.objects.get(domain=websiteName)
if state == "Suspend":
confPath = virtualHostUtilities.Server_root + "/conf/vhosts/" + websiteName
command = "sudo mv " + confPath + " " + confPath + "-suspended"
subprocess.call(shlex.split(command))
installUtilities.reStartLiteSpeed()
website.state = 0
else:
confPath = virtualHostUtilities.Server_root + "/conf/vhosts/" + websiteName
command = "sudo mv " + confPath + "-suspended" + " " + confPath
subprocess.call(shlex.split(command))
command = "chown -R " + "lsadm" + ":" + "lsadm" + " " + confPath
cmd = shlex.split(command)
subprocess.call(cmd)
installUtilities.reStartLiteSpeed()
website.state = 1
website.save()
data_ret = {'websiteStatus': 1, 'error_message': "None"}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'websiteStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def submitWebsiteModify(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'modifyWebsite') == 0:
return ACLManager.loadErrorJson('modifyStatus', 0)
packs = ACLManager.loadPackages(userID, currentACL)
admins = ACLManager.loadAllUsers(userID)
## Get packs name
json_data = "["
checker = 0
for items in packs:
dic = {"pack": 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 + ']'
### Get admin names
admin_data = "["
checker = 0
for items in admins:
dic = {"adminNames": items}
if checker == 0:
admin_data = admin_data + json.dumps(dic)
checker = 1
else:
admin_data = admin_data + ',' + json.dumps(dic)
admin_data = admin_data + ']'
websiteToBeModified = data['websiteToBeModified']
modifyWeb = Websites.objects.get(domain=websiteToBeModified)
email = modifyWeb.adminEmail
currentPack = modifyWeb.package.packageName
owner = modifyWeb.admin.userName
data_ret = {'modifyStatus': 1, 'error_message': "None", "adminEmail": email,
"packages": json_data, "current_pack": currentPack, "adminNames": admin_data,
'currentAdmin': owner}
final_json = json.dumps(data_ret)
return HttpResponse(final_json)
except BaseException, msg:
dic = {'modifyStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(dic)
return HttpResponse(json_data)
def saveWebsiteChanges(self, userID = None, data = None):
try:
domain = data['domain']
package = data['packForWeb']
email = data['email']
phpVersion = data['phpVersion']
newUser = data['admin']
currentACL = ACLManager.loadedACL(userID)
if ACLManager.currentContextPermission(currentACL, 'modifyWebsite') == 0:
return ACLManager.loadErrorJson('saveStatus', 0)
confPath = virtualHostUtilities.Server_root + "/conf/vhosts/" + domain
completePathToConfigFile = confPath + "/vhost.conf"
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " changePHP --phpVersion '" + phpVersion + "' --path " + completePathToConfigFile
output = subprocess.check_output(shlex.split(execPath))
if output.find("1,None") > -1:
pass
else:
data_ret = {'saveStatus': 0, 'error_message': output}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
## php changes ends
newOwner = Administrator.objects.get(userName=newUser)
modifyWeb = Websites.objects.get(domain=domain)
webpack = Package.objects.get(packageName=package)
modifyWeb.package = webpack
modifyWeb.adminEmail = email
modifyWeb.phpSelection = phpVersion
modifyWeb.admin = newOwner
modifyWeb.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 loadDomainHome(self, request = None, userID = None, data = None):
if Websites.objects.filter(domain=self.domain).exists():
currentACL = ACLManager.loadedACL(userID)
website = Websites.objects.get(domain=self.domain)
admin = Administrator.objects.get(pk=userID)
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadError()
Data = {}
Data['ftpTotal'] = website.package.ftpAccounts
Data['ftpUsed'] = website.users_set.all().count()
Data['databasesUsed'] = website.databases_set.all().count()
Data['databasesTotal'] = website.package.dataBases
Data['domain'] = self.domain
diskUsageDetails = virtualHostUtilities.getDiskUsage("/home/" + self.domain, website.package.diskSpace)
## bw usage calculation
try:
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " findDomainBW --virtualHostName " + self.domain + " --bandwidth " + str(
website.package.bandwidth)
output = subprocess.check_output(shlex.split(execPath))
bwData = output.split(",")
except BaseException, msg:
logging.CyberCPLogFileWriter.writeToFile(str(msg))
bwData = [0, 0]
## bw usage calculations
Data['bwInMBTotal'] = website.package.bandwidth
Data['bwInMB'] = bwData[0]
Data['bwUsage'] = bwData[1]
if diskUsageDetails != None:
if diskUsageDetails[1] > 100:
diskUsageDetails[1] = 100
Data['diskUsage'] = diskUsageDetails[1]
Data['diskInMB'] = diskUsageDetails[0]
Data['diskInMBTotal'] = website.package.diskSpace
else:
Data['diskUsage'] = 0
Data['diskInMB'] = 0
Data['diskInMBTotal'] = website.package.diskSpace
return render(request, 'websiteFunctions/website.html', Data)
else:
return render(request, 'websiteFunctions/website.html',
{"error": 1, "domain": "This domain does not exists."})
def launchChild(self, request = None, userID = None, data = None):
if ChildDomains.objects.filter(domain=self.childDomain).exists():
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadError()
website = Websites.objects.get(domain=self.domain)
Data = {}
Data['ftpTotal'] = website.package.ftpAccounts
Data['ftpUsed'] = website.users_set.all().count()
Data['databasesUsed'] = website.databases_set.all().count()
Data['databasesTotal'] = website.package.dataBases
Data['domain'] = self.domain
Data['childDomain'] = self.childDomain
diskUsageDetails = virtualHostUtilities.getDiskUsage("/home/" + self.domain, website.package.diskSpace)
## bw usage calculation
try:
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " findDomainBW --virtualHostName " + self.domain + " --bandwidth " + str(
website.package.bandwidth)
output = subprocess.check_output(shlex.split(execPath))
bwData = output.split(",")
except BaseException, msg:
logging.CyberCPLogFileWriter.writeToFile(str(msg))
bwData = [0, 0]
## bw usage calculations
Data['bwInMBTotal'] = website.package.bandwidth
Data['bwInMB'] = bwData[0]
Data['bwUsage'] = bwData[1]
if diskUsageDetails != None:
if diskUsageDetails[1] > 100:
diskUsageDetails[1] = 100
Data['diskUsage'] = diskUsageDetails[1]
Data['diskInMB'] = diskUsageDetails[0]
Data['diskInMBTotal'] = website.package.diskSpace
else:
Data['diskUsage'] = 0
Data['diskInMB'] = 0
Data['diskInMBTotal'] = website.package.diskSpace
return render(request, 'websiteFunctions/launchChild.html', Data)
else:
return render(request, 'websiteFunctions/launchChild.html', {"error":1,"domain": "This child domain does not exists"})
def getDataFromLogFile(self, userID = None, data = None):
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
logType = data['logType']
self.domain = data['virtualHost']
page = data['page']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('logstatus', 0)
if logType == 1:
fileName = "/home/" + self.domain + "/logs/" + self.domain + ".access_log"
else:
fileName = "/home/" + self.domain + "/logs/" + self.domain + ".error_log"
## get Logs
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " getAccessLogs --path " + fileName + " --page " + str(page)
output = subprocess.check_output(shlex.split(execPath))
if output.find("1,None") > -1:
final_json = json.dumps(
{'logstatus': 0, 'error_message': "Not able to fetch logs, see CyberPanel main log file!"})
return HttpResponse(final_json)
## get log ends here.
data = output.split("\n")
json_data = "["
checker = 0
for items in reversed(data):
if len(items) > 10:
logData = items.split(" ")
domain = logData[0].strip('"')
ipAddress = logData[1]
time = (logData[4]).strip("[").strip("]")
resource = logData[7].strip('"')
size = logData[10].replace('"', '')
dic = {'domain': domain,
'ipAddress': ipAddress,
'time': time,
'resource': resource,
'size': size,
}
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({'logstatus': 1, 'error_message': "None", "data": json_data})
return HttpResponse(final_json)
def fetchErrorLogs(self, userID = None, data = None):
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
self.domain = data['virtualHost']
page = data['page']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('logstatus', 0)
fileName = "/home/" + self.domain + "/logs/" + self.domain + ".error_log"
## get Logs
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " getErrorLogs --path " + fileName + " --page " + str(page)
output = subprocess.check_output(shlex.split(execPath))
if output.find("1,None") > -1:
final_json = json.dumps(
{'logstatus': 0, 'error_message': "Not able to fetch logs, see CyberPanel main log file!"})
return HttpResponse(final_json)
## get log ends here.
final_json = json.dumps({'logstatus': 1, 'error_message': "None", "data": output})
return HttpResponse(final_json)
def getDataFromConfigFile(self, userID = None, data = None):
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
self.domain = data['virtualHost']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('configstatus', 0)
filePath = installUtilities.Server_root_path + "/conf/vhosts/" + self.domain + "/vhost.conf"
command = 'sudo cat ' + filePath
configData = subprocess.check_output(shlex.split(command))
if len(configData) == 0:
status = {"configstatus": 0, "error_message": "Configuration file is currently empty!"}
final_json = json.dumps(status)
return HttpResponse(final_json)
status = {"configstatus": 1, "configData": configData}
final_json = json.dumps(status)
return HttpResponse(final_json)
def saveConfigsToFile(self, userID = None, data = None):
currentACL = ACLManager.loadedACL(userID)
if currentACL['admin'] != 1:
return ACLManager.loadErrorJson('configstatus', 0)
configData = data['configData']
self.domain = data['virtualHost']
mailUtilities.checkHome()
tempPath = "/home/cyberpanel/" + str(randint(1000, 9999))
vhost = open(tempPath, "w")
vhost.write(configData)
vhost.close()
## writing data temporary to file
filePath = installUtilities.Server_root_path + "/conf/vhosts/" + self.domain + "/vhost.conf"
## save configuration data
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " saveVHostConfigs --path " + filePath + " --tempPath " + tempPath
output = subprocess.check_output(shlex.split(execPath))
if output.find("1,None") > -1:
status = {"configstatus": 1}
final_json = json.dumps(status)
return HttpResponse(final_json)
else:
data_ret = {'configstatus': 0, 'error_message': output}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
## save configuration data ends
def getRewriteRules(self, userID = None, data = None):
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
self.domain = data['virtualHost']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('rewriteStatus', 0)
try:
childDom = ChildDomains.objects.get(domain=self.domain)
filePath = childDom.path + '/.htaccess'
except:
filePath = "/home/" + self.domain + "/public_html/.htaccess"
try:
rewriteRules = open(filePath, "r").read()
if len(rewriteRules) == 0:
status = {"rewriteStatus": 1, "error_message": "Rules file is currently empty"}
final_json = json.dumps(status)
return HttpResponse(final_json)
status = {"rewriteStatus": 1, "rewriteRules": rewriteRules}
final_json = json.dumps(status)
return HttpResponse(final_json)
except IOError:
status = {"rewriteStatus": 1, "error_message": "none", "rewriteRules": ""}
final_json = json.dumps(status)
return HttpResponse(final_json)
def saveRewriteRules(self, userID = None, data = None):
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
self.domain = data['virtualHost']
rewriteRules = data['rewriteRules']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('rewriteStatus', 0)
## writing data temporary to file
mailUtilities.checkHome()
tempPath = "/home/cyberpanel/" + str(randint(1000, 9999))
vhost = open(tempPath, "w")
vhost.write(rewriteRules)
vhost.close()
## writing data temporary to file
try:
childDomain = ChildDomains.objects.get(domain=self.domain)
filePath = childDomain.path + '/.htaccess'
except:
filePath = "/home/" + self.domain + "/public_html/.htaccess"
## save configuration data
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " saveRewriteRules --virtualHostName " + self.domain + " --path " + filePath + " --tempPath " + tempPath
output = subprocess.check_output(shlex.split(execPath))
if output.find("1,None") > -1:
status = {"rewriteStatus": 1, 'error_message': output}
final_json = json.dumps(status)
return HttpResponse(final_json)
else:
data_ret = {'rewriteStatus': 0, 'error_message': output}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def saveSSL(self, userID = None, data = None):
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
self.domain = data['virtualHost']
key = data['key']
cert = data['cert']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('sslStatus', 0)
mailUtilities.checkHome()
## writing data temporary to file
tempKeyPath = "/home/cyberpanel/" + str(randint(1000, 9999))
vhost = open(tempKeyPath, "w")
vhost.write(key)
vhost.close()
tempCertPath = "/home/cyberpanel/" + str(randint(1000, 9999))
vhost = open(tempCertPath, "w")
vhost.write(cert)
vhost.close()
## writing data temporary to file
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " saveSSL --virtualHostName " + self.domain + " --tempKeyPath " + tempKeyPath + " --tempCertPath " + tempCertPath
output = subprocess.check_output(shlex.split(execPath))
if output.find("1,None") > -1:
data_ret = {'sslStatus': 1, 'error_message': "None"}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
else:
logging.CyberCPLogFileWriter.writeToFile(
output)
data_ret = {'sslStatus': 0, 'error_message': output}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def changePHP(self, userID = None, data = None):
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
self.domain = data['childDomain']
phpVersion = data['phpSelection']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('changePHP', 0)
confPath = virtualHostUtilities.Server_root + "/conf/vhosts/" + self.domain
completePathToConfigFile = confPath + "/vhost.conf"
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " changePHP --phpVersion '" + phpVersion + "' --path " + completePathToConfigFile
output = subprocess.check_output(shlex.split(execPath))
if output.find("1,None") > -1:
pass
else:
data_ret = {'changePHP': 0, 'error_message': output}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
data_ret = {'changePHP': 1, 'error_message': "None"}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def getWebsiteCron(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
self.domain = data['domain']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('getWebsiteCron', 0)
website = Websites.objects.get(domain=self.domain)
if Websites.objects.filter(domain=self.domain).exists():
pass
else:
dic = {'getWebsiteCron': 0, 'error_message': 'You do not own this domain'}
json_data = json.dumps(dic)
return HttpResponse(json_data)
cronPath = "/var/spool/cron/" + website.externalApp
cmd = 'sudo test -e ' + cronPath + ' && echo Exists'
output = os.popen(cmd).read()
if "Exists" not in output:
data_ret = {'getWebsiteCron': 1, "user": website.externalApp, "crons": {}}
final_json = json.dumps(data_ret)
return HttpResponse(final_json)
cronPath = "/var/spool/cron/" + website.externalApp
crons = []
try:
f = subprocess.check_output(["sudo", "cat", cronPath])
print f
except subprocess.CalledProcessError as error:
dic = {'getWebsiteCron': 0, 'error_message': 'Unable to access Cron file'}
json_data = json.dumps(dic)
return HttpResponse(json_data)
counter = 0
for line in f.split("\n"):
if line:
split = line.split(" ", 5)
print line
print split
if len(split) == 6:
counter += 1
crons.append({"line": counter,
"minute": split[0],
"hour": split[1],
"monthday": split[2],
"month": split[3],
"weekday": split[4],
"command": split[5]})
print json.dumps(crons)
data_ret = {'getWebsiteCron': 1, "user": website.externalApp, "crons": crons}
final_json = json.dumps(data_ret)
return HttpResponse(final_json)
except BaseException, msg:
print msg
dic = {'getWebsiteCron': 0, 'error_message': str(msg)}
json_data = json.dumps(dic)
return HttpResponse(json_data)
def getCronbyLine(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
self.domain = data['domain']
line = data['line']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('getWebsiteCron', 0)
if Websites.objects.filter(domain=self.domain).exists():
pass
else:
dic = {'getWebsiteCron': 0, 'error_message': 'You do not own this domain'}
json_data = json.dumps(dic)
return HttpResponse(json_data)
line -= 1
website = Websites.objects.get(domain=self.domain)
cronPath = "/var/spool/cron/" + website.externalApp
crons = []
try:
f = subprocess.check_output(["sudo", "cat", cronPath])
print f
except subprocess.CalledProcessError as error:
dic = {'getWebsiteCron': 0, 'error_message': 'Unable to access Cron file'}
json_data = json.dumps(dic)
return HttpResponse(json_data)
f = f.split("\n")
cron = f[line]
if not cron:
dic = {'getWebsiteCron': 0, 'error_message': 'Cron line empty'}
json_data = json.dumps(dic)
return HttpResponse(json_data)
cron = cron.split(" ", 5)
if len(cron) != 6:
dic = {'getWebsiteCron': 0, 'error_message': 'Cron line incorrect'}
json_data = json.dumps(dic)
return HttpResponse(json_data)
data_ret = {"getWebsiteCron": 1,
"user": website.externalApp,
"cron": {
"minute": cron[0],
"hour": cron[1],
"monthday": cron[2],
"month": cron[3],
"weekday": cron[4],
"command": cron[5],
},
"line": line}
final_json = json.dumps(data_ret)
return HttpResponse(final_json)
except BaseException, msg:
print msg
dic = {'getWebsiteCron': 0, 'error_message': str(msg)}
json_data = json.dumps(dic)
return HttpResponse(json_data)
def saveCronChanges(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
self.domain = data['domain']
line = data['line']
minute = data['minute']
hour = data['hour']
monthday = data['monthday']
month = data['month']
weekday = data['weekday']
command = data['command']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('getWebsiteCron', 0)
website = Websites.objects.get(domain=self.domain)
cronPath = "/var/spool/cron/" + website.externalApp
tempPath = "/home/cyberpanel/" + website.externalApp + str(randint(10000, 99999)) + ".cron.tmp"
finalCron = "%s %s %s %s %s %s" % (minute, hour, monthday, month, weekday, command)
o = subprocess.call(['sudo', 'cp', cronPath, tempPath])
if o is not 0:
data_ret = {'addNewCron': 0, 'error_message': 'Unable to copy to temporary files'}
final_json = json.dumps(data_ret)
return HttpResponse(final_json)
# Confirming that directory is read/writable
o = subprocess.call(['sudo', 'chown', 'cyberpanel:cyberpanel', tempPath])
if o is not 0:
data_ret = {'addNewCron': 0, 'error_message': 'Error Changing Permissions'}
final_json = json.dumps(data_ret)
return HttpResponse(final_json)
with open(tempPath, 'r') as file:
data = file.readlines()
data[line] = finalCron + '\n'
with open(tempPath, 'w') as file:
file.writelines(data)
output = subprocess.call(["sudo", "/usr/bin/crontab", "-u", website.externalApp, tempPath])
os.remove(tempPath)
if output != 0:
data_ret = {'addNewCron': 0, 'error_message': 'Incorrect Syntax cannot be accepted.'}
final_json = json.dumps(data_ret)
return HttpResponse(final_json)
data_ret = {"getWebsiteCron": 1,
"user": website.externalApp,
"cron": finalCron,
"line": line}
final_json = json.dumps(data_ret)
return HttpResponse(final_json)
except BaseException, msg:
print msg
dic = {'getWebsiteCron': 0, 'error_message': str(msg)}
json_data = json.dumps(dic)
return HttpResponse(json_data)
def remCronbyLine(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
self.domain = data['domain']
line = data['line']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('addNewCron', 0)
line -= 1
website = Websites.objects.get(domain=self.domain)
cronPath = "/var/spool/cron/" + website.externalApp
cmd = 'sudo test -e ' + cronPath + ' && echo Exists'
output = os.popen(cmd).read()
if "Exists" not in output:
data_ret = {'remCronbyLine': 0, 'error_message': 'No Cron exists for this user'}
final_json = json.dumps(data_ret)
return HttpResponse(final_json)
cronPath = "/var/spool/cron/" + website.externalApp
tempPath = "/home/cyberpanel/" + website.externalApp + str(randint(10000, 99999)) + ".cron.tmp"
o = subprocess.call(['sudo', 'cp', cronPath, tempPath])
if o is not 0:
data_ret = {'addNewCron': 0, 'error_message': 'Unable to copy to temporary files'}
final_json = json.dumps(data_ret)
return HttpResponse(final_json)
# Confirming that directory is read/writable
o = subprocess.call(['sudo', 'chown', 'cyberpanel:cyberpanel', tempPath])
if o is not 0:
data_ret = {'addNewCron': 0, 'error_message': 'Error Changing Permissions'}
final_json = json.dumps(data_ret)
return HttpResponse(final_json)
with open(tempPath, 'r') as file:
data = file.readlines()
removedLine = data.pop(line)
with open(tempPath, 'w') as file:
file.writelines(data)
output = subprocess.call(["sudo", "/usr/bin/crontab", "-u", website.externalApp, tempPath])
os.remove(tempPath)
if output != 0:
data_ret = {'addNewCron': 0, 'error_message': 'Incorrect Syntax cannot be accepted'}
final_json = json.dumps(data_ret)
return HttpResponse(final_json)
data_ret = {"remCronbyLine": 1,
"user": website.externalApp,
"removeLine": removedLine,
"line": line}
final_json = json.dumps(data_ret)
return HttpResponse(final_json)
except BaseException, msg:
print msg
dic = {'remCronbyLine': 0, 'error_message': str(msg)}
json_data = json.dumps(dic)
return HttpResponse(json_data)
def addNewCron(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
self.domain = data['domain']
minute = data['minute']
hour = data['hour']
monthday = data['monthday']
month = data['month']
weekday = data['weekday']
command = data['command']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('addNewCron', 0)
website = Websites.objects.get(domain=self.domain)
cronPath = "/var/spool/cron/" + website.externalApp
cmd = 'sudo test -e ' + cronPath + ' && echo Exists'
output = os.popen(cmd).read()
if "Exists" not in output:
echo = subprocess.Popen(('echo'), stdout=subprocess.PIPE)
output = subprocess.call(('sudo', 'crontab', '-u', website.externalApp, '-'), stdin=echo.stdout)
echo.wait()
echo.stdout.close()
# Confirmation
o = subprocess.call(["sudo", "cp", "/dev/null", cronPath])
cronPath = "/var/spool/cron/" + website.externalApp
tempPath = "/home/cyberpanel/" + website.externalApp + str(randint(10000, 99999)) + ".cron.tmp"
finalCron = "%s %s %s %s %s %s" % (minute, hour, monthday, month, weekday, command)
o = subprocess.call(['sudo', 'cp', cronPath, tempPath])
if o is not 0:
data_ret = {'addNewCron': 0, 'error_message': 'Unable to copy to temporary files'}
final_json = json.dumps(data_ret)
return HttpResponse(final_json)
# Confirming that directory is read/writable
o = subprocess.call(['sudo', 'chown', 'cyberpanel:cyberpanel', tempPath])
if o is not 0:
data_ret = {'addNewCron': 0, 'error_message': 'Error Changing Permissions'}
final_json = json.dumps(data_ret)
return HttpResponse(final_json)
with open(tempPath, "a") as file:
file.write(finalCron + "\n")
output = subprocess.call(["sudo", "/usr/bin/crontab", "-u", website.externalApp, tempPath])
os.remove(tempPath)
if output != 0:
data_ret = {'addNewCron': 0, 'error_message': 'Incorrect Syntax cannot be accepted'}
final_json = json.dumps(data_ret)
return HttpResponse(final_json)
data_ret = {"addNewCron": 1,
"user": website.externalApp,
"cron": finalCron}
final_json = json.dumps(data_ret)
return HttpResponse(final_json)
except BaseException, msg:
print msg
dic = {'addNewCron': 0, 'error_message': str(msg)}
json_data = json.dumps(dic)
return HttpResponse(json_data)
def submitAliasCreation(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
self.domain = data['masterDomain']
aliasDomain = data['aliasDomain']
ssl = data['ssl']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('createAliasStatus', 0)
sslpath = "/home/" + self.domain + "/public_html"
## Create Configurations
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " createAlias --masterDomain " + self.domain + " --aliasDomain " + aliasDomain + " --ssl " + str(
ssl) + " --sslPath " + sslpath + " --administratorEmail " + admin.email + ' --websiteOwner ' + admin.userName
output = subprocess.check_output(shlex.split(execPath))
if output.find("1,None") > -1:
pass
else:
data_ret = {'createAliasStatus': 0, 'error_message': output, "existsStatus": 0}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
## Create Configurations ends here
data_ret = {'createAliasStatus': 1, 'error_message': "None", "existsStatus": 0}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'createAliasStatus': 0, 'error_message': str(msg), "existsStatus": 0}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def issueAliasSSL(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
self.domain = data['masterDomain']
aliasDomain = data['aliasDomain']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('sslStatus', 0)
sslpath = "/home/" + self.domain + "/public_html"
## Create Configurations
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " issueAliasSSL --masterDomain " + self.domain + " --aliasDomain " + aliasDomain + " --sslPath " + sslpath + " --administratorEmail " + admin.email
output = subprocess.check_output(shlex.split(execPath))
if output.find("1,None") > -1:
data_ret = {'sslStatus': 1, 'error_message': "None", "existsStatus": 0}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
else:
data_ret = {'sslStatus': 0, 'error_message': output, "existsStatus": 0}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'sslStatus': 0, 'error_message': str(msg), "existsStatus": 0}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def delateAlias(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
self.domain = data['masterDomain']
aliasDomain = data['aliasDomain']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('deleteAlias', 0)
## Create Configurations
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " deleteAlias --masterDomain " + self.domain + " --aliasDomain " + aliasDomain
output = subprocess.check_output(shlex.split(execPath))
if output.find("1,None") > -1:
data_ret = {'deleteAlias': 1, 'error_message': "None", "existsStatus": 0}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
else:
data_ret = {'deleteAlias': 0, 'error_message': output, "existsStatus": 0}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'deleteAlias': 0, 'error_message': str(msg), "existsStatus": 0}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def changeOpenBasedir(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
self.domain = data['domainName']
openBasedirValue = data['openBasedirValue']
if currentACL['admin'] == 1:
pass
else:
return ACLManager.loadErrorJson('changeOpenBasedir', 0)
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " changeOpenBasedir --virtualHostName '" + self.domain + "' --openBasedirValue " + openBasedirValue
output = subprocess.check_output(shlex.split(execPath))
if output.find("1,None") > -1:
pass
else:
data_ret = {'changeOpenBasedir': 0, 'error_message': output}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
data_ret = {'changeOpenBasedir': 1, 'error_message': "None"}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'changeOpenBasedir': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def wordpressInstall(self, request = None, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadError()
return render(request, 'websiteFunctions/installWordPress.html', {'domainName': self.domain})
except BaseException, msg:
return HttpResponse(str(msg))
def installWordpress(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
self.domain = data['domain']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('installStatus', 0)
mailUtilities.checkHome()
extraArgs = {}
extraArgs['admin'] = admin
extraArgs['domainName'] = data['domain']
extraArgs['home'] = data['home']
extraArgs['blogTitle'] = data['blogTitle']
extraArgs['adminUser'] = data['adminUser']
extraArgs['adminPassword'] = data['adminPassword']
extraArgs['adminEmail'] = data['adminEmail']
extraArgs['tempStatusPath'] = "/home/cyberpanel/" + str(randint(1000, 9999))
if data['home'] == '0':
extraArgs['path'] = data['path']
background = ApplicationInstaller('wordpress', extraArgs)
background.start()
time.sleep(2)
data_ret = {'installStatus': 1, 'error_message': 'None',
'tempStatusPath': extraArgs['tempStatusPath']}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'installStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def installWordpressStatus(self, userID = None, data = None):
try:
statusFile = data['statusFile']
statusData = open(statusFile, 'r').readlines()
lastLine = statusData[-1]
if lastLine.find('[200]') > -1:
data_ret = {'abort': 1, 'installStatus': 1, 'installationProgress': "100",
'currentStatus': 'Successfully Installed.'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
elif lastLine.find('[404]') > -1:
data_ret = {'abort': 1, 'installStatus': 0, 'installationProgress': "0",
'error_message': lastLine}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
else:
progress = lastLine.split(',')
currentStatus = progress[0]
installationProgress = progress[1]
data_ret = {'abort': 0, 'installStatus': 0, 'installationProgress': installationProgress,
'currentStatus': currentStatus}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'abort': 1, 'installStatus': 0, 'installationProgress': "0", 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def joomlaInstall(self, request = None, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadError()
return render(request, 'websiteFunctions/installJoomla.html', {'domainName': self.domain})
except BaseException, msg:
return HttpResponse(str(msg))
def installJoomla(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
self.domain = data['domain']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('installStatus', 0)
domainName = data['domain']
home = data['home']
sitename = data['sitename']
username = data['username']
password = data['password']
prefix = data['prefix']
mailUtilities.checkHome()
tempStatusPath = "/home/cyberpanel/" + str(randint(1000, 9999))
statusFile = open(tempStatusPath, 'w')
statusFile.writelines('Setting up paths,0')
statusFile.close()
finalPath = ""
admin = Administrator.objects.get(pk=userID)
## DB Creation
statusFile = open(tempStatusPath, 'w')
statusFile.writelines('Creating database..,10')
statusFile.close()
dbName = randomPassword.generate_pass()
dbUser = dbName
dbPassword = randomPassword.generate_pass()
if Databases.objects.filter(dbName=dbName).exists() or Databases.objects.filter(
dbUser=dbUser).exists():
data_ret = {'installStatus': 0,
'error_message': "0,This database or user is already taken."}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
result = mysqlUtilities.createDatabase(dbName, dbUser, dbPassword)
if result == 1:
pass
else:
data_ret = {'installStatus': 0,
'error_message': "0,Not able to create database."}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
##
try:
website = ChildDomains.objects.get(domain=domainName)
externalApp = website.master.externalApp
if website.master.package.dataBases > website.master.databases_set.all().count():
pass
else:
data_ret = {'installStatus': 0,
'error_message': "0,Maximum database limit reached for this website."}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
if home == '0':
path = data['path']
finalPath = website.path.rstrip('/') + "/" + path + "/"
else:
finalPath = website.path + "/"
db = Databases(website=website.master, dbName=dbName, dbUser=dbUser)
db.save()
except:
website = Websites.objects.get(domain=domainName)
externalApp = website.externalApp
if website.package.dataBases > website.databases_set.all().count():
pass
else:
data_ret = {'installStatus': 0,
'error_message': "0,Maximum database limit reached for this website."}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
if home == '0':
path = data['path']
finalPath = "/home/" + domainName + "/public_html/" + path + "/"
else:
finalPath = "/home/" + domainName + "/public_html/"
db = Databases(website=website, dbName=dbName, dbUser=dbUser)
db.save()
if finalPath.find("..") > -1:
data_ret = {'installStatus': 0,
'error_message': "Specified path must be inside virtual host home!"}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
## Installation
salt = randomPassword.generate_pass(32)
# return salt
password_hash = hashlib.md5(password + salt).hexdigest()
password = password_hash + ":" + salt
statusFile = open(tempStatusPath, 'w')
statusFile.writelines('Downloading Joomla Core..,20')
statusFile.close()
execPath = "sudo python " + virtualHostUtilities.cyberPanel + "/plogical/virtualHostUtilities.py"
execPath = execPath + " installJoomla --virtualHostName " + domainName + \
" --virtualHostUser " + externalApp + " --path " + finalPath + " --dbName " + dbName + \
" --dbUser " + dbUser + " --dbPassword " + dbPassword + " --username " + username + \
" --password " + password + " --prefix " + prefix + " --sitename '" + sitename + "'" \
+ " --tempStatusPath " + tempStatusPath
# return execPath
output = subprocess.Popen(shlex.split(execPath))
data_ret = {"installStatus": 1, 'tempStatusPath': tempStatusPath}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
## Installation ends
except BaseException, msg:
data_ret = {'installStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def setupGit(self, request = None, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadError()
path = '/home/cyberpanel/' + self.domain + '.git'
if os.path.exists(path):
ipFile = "/etc/cyberpanel/machineIP"
f = open(ipFile)
ipData = f.read()
ipAddress = ipData.split('\n', 1)[0]
webhookURL = 'https://' + ipAddress + ':8090/websites/' + self.domain + '/gitNotify'
return render(request, 'websiteFunctions/setupGit.html',
{'domainName': self.domain, 'installed': 1, 'webhookURL': webhookURL})
else:
command = 'sudo cat /root/.ssh/cyberpanel.pub'
deploymentKey = subprocess.check_output(shlex.split(command)).strip('\n')
return render(request, 'websiteFunctions/setupGit.html',
{'domainName': self.domain, 'deploymentKey': deploymentKey, 'installed': 0})
except BaseException, msg:
return HttpResponse(str(msg))
def setupGitRepo(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
self.domain = data['domain']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('installStatus', 0)
mailUtilities.checkHome()
extraArgs = {}
extraArgs['admin'] = admin
extraArgs['domainName'] = data['domain']
extraArgs['username'] = data['username']
extraArgs['reponame'] = data['reponame']
extraArgs['branch'] = data['branch']
extraArgs['tempStatusPath'] = "/home/cyberpanel/" + str(randint(1000, 9999))
extraArgs['defaultProvider'] = data['defaultProvider']
background = ApplicationInstaller('git', extraArgs)
background.start()
time.sleep(2)
data_ret = {'installStatus': 1, 'error_message': 'None',
'tempStatusPath': extraArgs['tempStatusPath']}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'installStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def gitNotify(self, userID = None, data = None):
try:
extraArgs = {}
extraArgs['domain'] = self.domain
background = ApplicationInstaller('pull', extraArgs)
background.start()
data_ret = {'pulled': 1, 'error_message': 'None'}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
except BaseException, msg:
data_ret = {'pulled': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def detachRepo(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
self.domain = data['domain']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson()
mailUtilities.checkHome()
extraArgs = {}
extraArgs['domainName'] = data['domain']
extraArgs['admin'] = admin
background = ApplicationInstaller('detach', extraArgs)
background.start()
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 changeBranch(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
self.domain = data['domain']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson()
mailUtilities.checkHome()
extraArgs = {}
extraArgs['domainName'] = data['domain']
extraArgs['githubBranch'] = data['githubBranch']
extraArgs['admin'] = admin
background = ApplicationInstaller('changeBranch', extraArgs)
background.start()
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 installPrestaShop(self, request = None, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadError()
return render(request, 'websiteFunctions/installPrestaShop.html', {'domainName': self.domain})
except BaseException, msg:
return HttpResponse(str(msg))
def prestaShopInstall(self, userID = None, data = None):
try:
currentACL = ACLManager.loadedACL(userID)
admin = Administrator.objects.get(pk=userID)
self.domain = data['domain']
if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
pass
else:
return ACLManager.loadErrorJson('installStatus', 0)
mailUtilities.checkHome()
extraArgs = {}
extraArgs['admin'] = admin
extraArgs['domainName'] = data['domain']
extraArgs['home'] = data['home']
extraArgs['shopName'] = data['shopName']
extraArgs['firstName'] = data['firstName']
extraArgs['lastName'] = data['lastName']
extraArgs['databasePrefix'] = data['databasePrefix']
extraArgs['email'] = data['email']
extraArgs['password'] = data['password']
extraArgs['tempStatusPath'] = "/home/cyberpanel/" + str(randint(1000, 9999))
if data['home'] == '0':
extraArgs['path'] = data['path']
background = ApplicationInstaller('prestashop', extraArgs)
background.start()
time.sleep(2)
data_ret = {'installStatus': 1, 'error_message': 'None',
'tempStatusPath': extraArgs['tempStatusPath']}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
## Installation ends
except BaseException, msg:
data_ret = {'installStatus': 0, 'error_message': str(msg)}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def createWebsiteAPI(self, data = None):
try:
adminUser = data['adminUser']
adminPass = data['adminPass']
adminEmail = data['ownerEmail']
websiteOwner = data['websiteOwner']
ownerPassword = data['ownerPassword']
data['ssl'] = 0
data['dkimCheck'] = 0
data['openBasedir'] = 1
data['adminEmail'] = data['ownerEmail']
data['phpSelection'] = "PHP 7.0"
data['package'] = data['packageName']
admin = Administrator.objects.get(userName=adminUser)
if hashPassword.check_password(admin.password, adminPass):
if adminEmail is None:
data['adminEmail'] = "usman@cyberpersons.com"
try:
websiteOwn = Administrator(userName=websiteOwner,
password=hashPassword.hash_password(ownerPassword),
email=adminEmail, type=3, owner=admin.pk,
initWebsitesLimit=1)
websiteOwn.save()
except BaseException:
pass
else:
data_ret = {"existsStatus": 0, 'createWebSiteStatus': 0,
'error_message': "Could not authorize access to API"}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
return self.submitWebsiteCreation(admin.pk, data)
except BaseException, msg:
data_ret = {'createWebSiteStatus': 0, 'error_message': str(msg), "existsStatus": 0}
json_data = json.dumps(data_ret)
return HttpResponse(json_data)
def findWebsitesJson(self, currentACL, userID, pageNumber):
finalPageNumber = ((pageNumber * 10)) - 10
endPageNumber = finalPageNumber + 10
websites = ACLManager.findWebsiteObjects(currentACL, userID)[finalPageNumber:endPageNumber]
json_data = "["
checker = 0
try:
ipFile = "/etc/cyberpanel/machineIP"
f = open(ipFile)
ipData = f.read()
ipAddress = ipData.split('\n', 1)[0]
except BaseException, msg:
logging.CyberCPLogFileWriter.writeToFile("Failed to read machine IP, error:" + str(msg))
ipAddress = "192.168.100.1"
for items in websites:
if items.state == 0:
state = "Suspended"
else:
state = "Active"
dic = {'domain': items.domain, 'adminEmail': items.adminEmail, 'ipAddress': ipAddress,
'admin': items.admin.userName, 'package': items.package.packageName, 'state': state}
if checker == 0:
json_data = json_data + json.dumps(dic)
checker = 1
else:
json_data = json_data + ',' + json.dumps(dic)
json_data = json_data + ']'
return json_data