events for backups and dns modules

backup/pluginManager.py

@@ -0,0 +1,80 @@
+from signals import *
+from plogical.pluginManagerGlobal import pluginManagerGlobal
+
+class pluginManager:
+
+    @staticmethod
+    def preSubmitBackupCreation(request):
+        return pluginManagerGlobal.globalPlug(request, preSubmitBackupCreation)
+
+    @staticmethod
+    def preDeleteBackup(request):
+        return pluginManagerGlobal.globalPlug(request, preDeleteBackup)
+
+    @staticmethod
+    def postDeleteBackup(request, response):
+        return pluginManagerGlobal.globalPlug(request, postDeleteBackup, response)
+
+    @staticmethod
+    def preSubmitRestore(request):
+        return pluginManagerGlobal.globalPlug(request, preSubmitRestore)
+
+    @staticmethod
+    def preSubmitDestinationCreation(request):
+        return pluginManagerGlobal.globalPlug(request, preSubmitDestinationCreation)
+
+    @staticmethod
+    def postSubmitDestinationCreation(request, response):
+        return pluginManagerGlobal.globalPlug(request, postSubmitDestinationCreation, response)
+
+    @staticmethod
+    def preDeleteDestination(request):
+        return pluginManagerGlobal.globalPlug(request, preDeleteDestination)
+
+    @staticmethod
+    def postDeleteDestination(request, response):
+        return pluginManagerGlobal.globalPlug(request, postDeleteDestination, response)
+
+    @staticmethod
+    def preSubmitBackupSchedule(request):
+        return pluginManagerGlobal.globalPlug(request, preSubmitBackupSchedule)
+
+    @staticmethod
+    def postSubmitBackupSchedule(request, response):
+        return pluginManagerGlobal.globalPlug(request, postSubmitBackupSchedule, response)
+
+    @staticmethod
+    def preScheduleDelete(request):
+        return pluginManagerGlobal.globalPlug(request, preScheduleDelete)
+
+    @staticmethod
+    def postScheduleDelete(request, response):
+        return pluginManagerGlobal.globalPlug(request, postScheduleDelete, response)
+
+    @staticmethod
+    def preSubmitRemoteBackups(request):
+        return pluginManagerGlobal.globalPlug(request, preSubmitRemoteBackups)
+
+    @staticmethod
+    def postSubmitRemoteBackups(request, response):
+        return pluginManagerGlobal.globalPlug(request, postSubmitRemoteBackups, response)
+
+    @staticmethod
+    def preStarRemoteTransfer(request):
+        return pluginManagerGlobal.globalPlug(request, preStarRemoteTransfer)
+
+    @staticmethod
+    def postStarRemoteTransfer(request, response):
+        return pluginManagerGlobal.globalPlug(request, postStarRemoteTransfer, response)
+
+    @staticmethod
+    def preRemoteBackupRestore(request):
+        return pluginManagerGlobal.globalPlug(request, preRemoteBackupRestore)
+
+    @staticmethod
+    def postRemoteBackupRestore(request, response):
+        return pluginManagerGlobal.globalPlug(request, postRemoteBackupRestore, response)
+
+    @staticmethod
+    def postDeleteBackup(request, response):
+        return pluginManagerGlobal.globalPlug(request, postRemoteBackupRestore, response)

backup/signals.py

@@ -0,0 +1,57 @@
+# The world is a prison for the believer.
+
+from django.dispatch import Signal
+
+## This event is fired before CyberPanel core start creating backup of a website
+preSubmitBackupCreation = Signal(providing_args=["request"])
+
+## This event is fired before CyberPanel core start deletion of a backup
+preDeleteBackup = Signal(providing_args=["request"])
+
+## This event is fired after CyberPanel core finished the backup deletion
+postDeleteBackup = Signal(providing_args=["request", "response"])
+
+## This event is fired before CyberPanel core start restoring a backup.
+preSubmitRestore = Signal(providing_args=["request"])
+
+## This event is fired before CyberPanel core starts to add a remote backup destination
+preSubmitDestinationCreation = Signal(providing_args=["request"])
+
+## This event is fired after CyberPanel core is finished adding remote backup destination
+postSubmitDestinationCreation = Signal(providing_args=["request", "response"])
+
+## This event is fired before CyberPanel core starts to delete a backup destination
+preDeleteDestination = Signal(providing_args=["request"])
+
+## This event is fired after CyberPanel core finished deleting a backup destination
+postDeleteDestination = Signal(providing_args=["request", "response"])
+
+## This event is fired before CyberPanel core start adding a backup schedule
+preSubmitBackupSchedule = Signal(providing_args=["request"])
+
+## This event is fired after CyberPanel core finished adding a backup schedule
+postSubmitBackupSchedule = Signal(providing_args=["request", "response"])
+
+## This event is fired before CyberPanel core start the deletion of backup schedule
+preScheduleDelete = Signal(providing_args=["request"])
+
+## This event is fired after CyberPanel core finished the deletion of backup schedule
+postScheduleDelete = Signal(providing_args=["request", "response"])
+
+## This event is fired before CyberPanel core star the remote backup process
+preSubmitRemoteBackups = Signal(providing_args=["request"])
+
+## This event is fired after CyberPanel core finished remote backup process
+postSubmitRemoteBackups = Signal(providing_args=["request", "response"])
+
+## This event is fired before CyberPanel core star the remote backup process
+preStarRemoteTransfer = Signal(providing_args=["request"])
+
+## This event is fired after CyberPanel core finished remote backup process
+postStarRemoteTransfer = Signal(providing_args=["request", "response"])
+
+## This event is fired before CyberPanel core start restore of remote backups
+preRemoteBackupRestore = Signal(providing_args=["request"])
+
+## This event is fired after CyberPanel core finished restoring remote backups in local server
+postRemoteBackupRestore = Signal(providing_args=["request", "response"])

backup/views.py

@@ -6,6 +6,7 @@ from django.shortcuts import redirect
 import json
 from loginSystem.views import loadLoginPage
 from plogical.backupManager import BackupManager
+from backup.pluginManager import pluginManager
 
 
 def loadBackupHome(request):
@@ -43,8 +44,16 @@ def getCurrentBackups(request):
 def submitBackupCreation(request):
     try:
         userID = 1
+
+        result = pluginManager.preSubmitBackupCreation(request)
+        if result != 200:
+            return result
+
         wm = BackupManager()
-        return wm.submitBackupCreation(userID, json.loads(request.body))
+        coreResult =  wm.submitBackupCreation(userID, json.loads(request.body))
+
+        return coreResult
+
     except KeyError:
         return redirect(loadLoginPage)
 
@@ -67,15 +76,33 @@ def cancelBackupCreation(request):
 def deleteBackup(request):
     try:
         userID = request.session['userID']
+
+        result = pluginManager.preDeleteBackup(request)
+        if result != 200:
+            return result
+
         wm = BackupManager()
-        return wm.deleteBackup(userID, json.loads(request.body))
+        coreResult = wm.deleteBackup(userID, json.loads(request.body))
+
+        result = pluginManager.postDeleteBackup(request, coreResult)
+        if result != 200:
+            return result
+
+        return coreResult
+
     except KeyError:
         return redirect(loadLoginPage)
 
 def submitRestore(request):
     try:
+        result = pluginManager.preSubmitRestore(request)
+        if result != 200:
+            return result
+
         wm = BackupManager()
-        return wm.submitRestore(json.loads(request.body))
+        coreResult = wm.submitRestore(json.loads(request.body))
+
+        return coreResult
     except KeyError:
         return redirect(loadLoginPage)
 
@@ -97,8 +124,19 @@ def backupDestinations(request):
 def submitDestinationCreation(request):
     try:
         userID = request.session['userID']
-        bm = BackupManager()
-        return bm.submitDestinationCreation(userID, json.loads(request.body))
+
+        result = pluginManager.preSubmitDestinationCreation(request)
+        if result != 200:
+            return result
+
+        wm = BackupManager()
+        coreResult = wm.submitDestinationCreation(userID, json.loads(request.body))
+
+        result = pluginManager.postSubmitDestinationCreation(request, coreResult)
+        if result != 200:
+            return result
+
+        return coreResult
     except KeyError:
         return redirect(loadLoginPage)
 
@@ -121,8 +159,18 @@ def getConnectionStatus(request):
 def deleteDestination(request):
     try:
         userID = request.session['userID']
-        bm = BackupManager()
-        return bm.deleteDestination(userID, json.loads(request.body))
+        result = pluginManager.preDeleteDestination(request)
+        if result != 200:
+            return result
+
+        wm = BackupManager()
+        coreResult = wm.deleteDestination(userID, json.loads(request.body))
+
+        result = pluginManager.postDeleteDestination(request, coreResult)
+        if result != 200:
+            return result
+
+        return coreResult
     except KeyError:
         return redirect(loadLoginPage)
 
@@ -145,16 +193,36 @@ def getCurrentBackupSchedules(request):
 def submitBackupSchedule(request):
     try:
         userID = request.session['userID']
+        result = pluginManager.preSubmitBackupSchedule(request)
+        if result != 200:
+            return result
+
         wm = BackupManager()
-        return wm.submitBackupSchedule(userID, json.loads(request.body))
+        coreResult = wm.submitBackupSchedule(userID, json.loads(request.body))
+
+        result = pluginManager.postSubmitBackupSchedule(request, coreResult)
+        if result != 200:
+            return result
+
+        return coreResult
     except KeyError:
         return redirect(loadLoginPage)
 
 def scheduleDelete(request):
     try:
         userID = request.session['userID']
+        result = pluginManager.preScheduleDelete(request)
+        if result != 200:
+            return result
+
         wm = BackupManager()
-        return wm.scheduleDelete(userID, json.loads(request.body))
+        coreResult = wm.scheduleDelete(userID, json.loads(request.body))
+
+        result = pluginManager.postScheduleDelete(request, coreResult)
+        if result != 200:
+            return result
+
+        return coreResult
     except KeyError:
         return redirect(loadLoginPage)
 
@@ -169,16 +237,36 @@ def remoteBackups(request):
 def submitRemoteBackups(request):
     try:
         userID = request.session['userID']
+        result = pluginManager.preSubmitRemoteBackups(request)
+        if result != 200:
+            return result
+
         wm = BackupManager()
-        return wm.submitRemoteBackups(userID, json.loads(request.body))
+        coreResult = wm.submitRemoteBackups(userID, json.loads(request.body))
+
+        result = pluginManager.postSubmitRemoteBackups(request, coreResult)
+        if result != 200:
+            return result
+
+        return coreResult
     except KeyError:
         return redirect(loadLoginPage)
 
 def starRemoteTransfer(request):
     try:
         userID = request.session['userID']
+        result = pluginManager.preStarRemoteTransfer(request)
+        if result != 200:
+            return result
+
         wm = BackupManager()
-        return wm.starRemoteTransfer(userID, json.loads(request.body))
+        coreResult = wm.starRemoteTransfer(userID, json.loads(request.body))
+
+        result = pluginManager.postStarRemoteTransfer(request, coreResult)
+        if result != 200:
+            return result
+
+        return coreResult
     except KeyError:
         return redirect(loadLoginPage)
 
@@ -193,8 +281,18 @@ def getRemoteTransferStatus(request):
 def remoteBackupRestore(request):
     try:
         userID = request.session['userID']
+        result = pluginManager.preRemoteBackupRestore(request)
+        if result != 200:
+            return result
+
         wm = BackupManager()
-        return wm.remoteBackupRestore(userID, json.loads(request.body))
+        coreResult = wm.remoteBackupRestore(userID, json.loads(request.body))
+
+        result = pluginManager.postRemoteBackupRestore(request, coreResult)
+        if result != 200:
+            return result
+
+        return coreResult
     except KeyError:
         return redirect(loadLoginPage)
 

dns/dnsManager.py

@@ -0,0 +1,549 @@
+#!/usr/local/CyberCP/bin/python2
+import os.path
+import sys
+import django
+sys.path.append('/usr/local/CyberCP')
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "CyberCP.settings")
+django.setup()
+from django.shortcuts import render
+from django.http import HttpResponse
+import json
+from plogical.dnsUtilities import DNS
+from loginSystem.models import Administrator
+import os
+from models import Domains,Records
+from re import match,I,M
+from plogical.mailUtilities import mailUtilities
+from plogical.acl import ACLManager
+
+class DNSManager:
+
+    def loadDNSHome(self, request = None, userID = None):
+        try:
+            admin = Administrator.objects.get(pk=userID)
+            return render(request, 'dns/index.html', {"type": admin.type})
+        except BaseException, msg:
+            return HttpResponse(str(msg))
+
+    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 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']
+
+            if Domains.objects.filter(name=domainForNS).count() == 0:
+                newZone = Domains(admin=admin, name=domainForNS, type="NATIVE")
+                newZone.save()
+
+                content = "ns1." + domainForNS + " hostmaster." + domainForNS + " 1 10800 3600 604800 3600"
+
+                soaRecord = Records(domainOwner=newZone,
+                                    domain_id=newZone.id,
+                                    name=domainForNS,
+                                    type="SOA",
+                                    content=content,
+                                    ttl=3600,
+                                    prio=0,
+                                    disabled=0,
+                                    auth=1)
+                soaRecord.save()
+
+                ## NS1
+
+                record = Records(domainOwner=newZone,
+                                 domain_id=newZone.id,
+                                 name=domainForNS,
+                                 type="NS",
+                                 content=ns1,
+                                 ttl=3600,
+                                 prio=0,
+                                 disabled=0,
+                                 auth=1)
+                record.save()
+
+                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=domainForNS,
+                                 type="NS",
+                                 content=ns2,
+                                 ttl=3600,
+                                 prio=0,
+                                 disabled=0,
+                                 auth=1)
+                record.save()
+
+                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)
+            else:
+
+                newZone = Domains.objects.get(name=domainForNS)
+
+                ## NS1
+
+                record = Records(domainOwner=newZone,
+                                 domain_id=newZone.id,
+                                 name=domainForNS,
+                                 type="NS",
+                                 content=ns1,
+                                 ttl=3600,
+                                 prio=0,
+                                 disabled=0,
+                                 auth=1)
+                record.save()
+
+                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=domainForNS,
+                                 type="NS",
+                                 content=ns2,
+                                 ttl=3600,
+                                 prio=0,
+                                 disabled=0,
+                                 auth=1)
+                record.save()
+
+                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 createDNSZone(self, request = None, userID = None):
+        try:
+            currentACL = ACLManager.loadedACL(userID)
+            if ACLManager.currentContextPermission(currentACL, 'createDNSZone') == 0:
+                return ACLManager.loadError()
+
+            if os.path.exists('/home/cyberpanel/powerdns'):
+                return render(request, 'dns/createDNSZone.html', {"status": 1})
+            else:
+                return render(request, 'dns/createDNSZone.html', {"status": 0})
+        except BaseException, msg:
+                return HttpResponse(str(msg))
+
+    def 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 addDeleteDNSRecords(self, request = None, userID = None):
+        try:
+
+            currentACL = ACLManager.loadedACL(userID)
+            if ACLManager.currentContextPermission(currentACL, 'addDeleteRecords') == 0:
+                return ACLManager.loadError()
+
+            if not os.path.exists('/home/cyberpanel/powerdns'):
+                return render(request, 'dns/addDeleteDNSRecords.html', {"status": 0})
+
+            domainsList = ACLManager.findAllDomains(currentACL, userID)
+
+            return render(request, 'dns/addDeleteDNSRecords.html', {"domainsList": domainsList, "status": 1})
+
+        except BaseException, msg:
+            return HttpResponse(str(msg))
+
+    def getCurrentRecordsForDomain(self, userID = None, data = None):
+        try:
+
+            currentACL = ACLManager.loadedACL(userID)
+
+            if ACLManager.currentContextPermission(currentACL, 'addDeleteRecords') == 0:
+                return ACLManager.loadErrorJson('fetchStatus', 0)
+
+            zoneDomain = data['selectedZone']
+            currentSelection = data['currentSelection']
+
+            domain = Domains.objects.get(name=zoneDomain)
+            records = Records.objects.filter(domain_id=domain.id)
+
+            fetchType = ""
+
+            if currentSelection == 'aRecord':
+                fetchType = 'A'
+            elif currentSelection == 'aaaaRecord':
+                fetchType = 'AAAA'
+            elif currentSelection == 'cNameRecord':
+                fetchType = 'CNAME'
+            elif currentSelection == 'mxRecord':
+                fetchType = 'MX'
+            elif currentSelection == 'txtRecord':
+                fetchType = 'TXT'
+            elif currentSelection == 'spfRecord':
+                fetchType = 'SPF'
+            elif currentSelection == 'nsRecord':
+                fetchType = 'NS'
+            elif currentSelection == 'soaRecord':
+                fetchType = 'SOA'
+            elif currentSelection == 'srvRecord':
+                fetchType = 'SRV'
+            elif currentSelection == 'caaRecord':
+                fetchType = 'CAA'
+
+            json_data = "["
+            checker = 0
+
+            for items in records:
+                if items.type == fetchType:
+                    dic = {'id': items.id,
+                           'type': items.type,
+                           'name': items.name,
+                           'content': items.content,
+                           'priority': items.prio,
+                           'ttl': items.ttl
+                           }
+
+                    if checker == 0:
+                        json_data = json_data + json.dumps(dic)
+                        checker = 1
+                    else:
+                        json_data = json_data + ',' + json.dumps(dic)
+                else:
+                    continue
+
+            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 addDNSRecord(self, userID = None, data = None):
+        try:
+
+            currentACL = ACLManager.loadedACL(userID)
+
+            if ACLManager.currentContextPermission(currentACL, 'addDeleteRecords') == 0:
+                return ACLManager.loadErrorJson('add_status', 0)
+
+            zoneDomain = data['selectedZone']
+            recordType = data['recordType']
+            recordName = data['recordName']
+            ttl = int(data['ttl'])
+
+            zone = Domains.objects.get(name=zoneDomain)
+            value = ""
+
+            if recordType == "A":
+
+                recordContentA = data['recordContentA']  ## IP or ponting value
+
+                if recordName == "@":
+                    value = zoneDomain
+                ## re.match
+                elif match(r'([\da-z\.-]+\.[a-z\.]{2,12}|[\d\.]+)([\/:?=&#]{1}[\da-z\.-]+)*[\/\?]?', recordName,
+                           M | I):
+                    value = recordName
+                else:
+                    value = recordName + "." + zoneDomain
+
+                DNS.createDNSRecord(zone, value, recordType, recordContentA, 0, ttl)
+
+            elif recordType == "MX":
+
+                if recordName == "@":
+                    value = zoneDomain
+                ## re.match
+                elif match(r'([\da-z\.-]+\.[a-z\.]{2,12}|[\d\.]+)([\/:?=&#]{1}[\da-z\.-]+)*[\/\?]?', recordName,
+                           M | I):
+                    value = recordName
+                else:
+                    value = recordName + "." + zoneDomain
+
+                recordContentMX = data['recordContentMX']
+                priority = data['priority']
+
+                DNS.createDNSRecord(zone, value, recordType, recordContentMX, priority, ttl)
+
+            elif recordType == "AAAA":
+
+                if recordName == "@":
+                    value = zoneDomain
+                ## re.match
+                elif match(r'([\da-z\.-]+\.[a-z\.]{2,12}|[\d\.]+)([\/:?=&#]{1}[\da-z\.-]+)*[\/\?]?', recordName,
+                           M | I):
+                    value = recordName
+                else:
+                    value = recordName + "." + zoneDomain
+
+                recordContentAAAA = data['recordContentAAAA']  ## IP or ponting value
+
+                DNS.createDNSRecord(zone, value, recordType, recordContentAAAA, 0, ttl)
+
+            elif recordType == "CNAME":
+
+                if recordName == "@":
+                    value = zoneDomain
+                ## re.match
+                elif match(r'([\da-z\.-]+\.[a-z\.]{2,12}|[\d\.]+)([\/:?=&#]{1}[\da-z\.-]+)*[\/\?]?', recordName,
+                           M | I):
+                    value = recordName
+                else:
+                    value = recordName + "." + zoneDomain
+
+                recordContentCNAME = data['recordContentCNAME']  ## IP or ponting value
+
+                DNS.createDNSRecord(zone, value, recordType, recordContentCNAME, 0, ttl)
+
+            elif recordType == "SPF":
+
+                if recordName == "@":
+                    value = zoneDomain
+                ## re.match
+                elif match(r'([\da-z\.-]+\.[a-z\.]{2,12}|[\d\.]+)([\/:?=&#]{1}[\da-z\.-]+)*[\/\?]?', recordName,
+                           M | I):
+                    value = recordName
+                else:
+                    value = recordName + "." + zoneDomain
+
+                recordContentSPF = data['recordContentSPF']  ## IP or ponting value
+
+                DNS.createDNSRecord(zone, value, recordType, recordContentSPF, 0, ttl)
+
+            elif recordType == "TXT":
+
+                if recordName == "@":
+                    value = zoneDomain
+                ## re.match
+                elif match(r'([\da-z\.-]+\.[a-z\.]{2,12}|[\d\.]+)([\/:?=&#]{1}[\da-z\.-]+)*[\/\?]?', recordName,
+                           M | I):
+                    value = recordName
+                else:
+                    value = recordName + "." + zoneDomain
+
+                recordContentTXT = data['recordContentTXT']  ## IP or ponting value
+
+                DNS.createDNSRecord(zone, value, recordType, recordContentTXT, 0, ttl)
+
+            elif recordType == "SOA":
+
+                recordContentSOA = data['recordContentSOA']
+
+                DNS.createDNSRecord(zone, value, recordType, recordContentSOA, 0, ttl)
+
+            elif recordType == "NS":
+
+                recordContentNS = data['recordContentNS']
+
+                if recordContentNS == "@":
+                    recordContentNS = "ns1." + zoneDomain
+                ## re.match
+                elif match(r'([\da-z\.-]+\.[a-z\.]{2,12}|[\d\.]+)([\/:?=&#]{1}[\da-z\.-]+)*[\/\?]?',
+                           recordContentNS, M | I):
+                    recordContentNS = recordContentNS
+                else:
+                    recordContentNS = recordContentNS + "." + zoneDomain
+
+                DNS.createDNSRecord(zone, recordName, recordType, recordContentNS, 0, ttl)
+
+            elif recordType == "SRV":
+
+                if recordName == "@":
+                    value = zoneDomain
+                ## re.match
+                elif match(r'([\da-z\.-]+\.[a-z\.]{2,12}|[\d\.]+)([\/:?=&#]{1}[\da-z\.-]+)*[\/\?]?', recordName,
+                           M | I):
+                    value = recordName
+                else:
+                    value = recordName + "." + zoneDomain
+
+                recordContentSRV = data['recordContentSRV']
+                priority = data['priority']
+
+                DNS.createDNSRecord(zone, value, recordType, recordContentSRV, priority, ttl)
+
+            elif recordType == "CAA":
+                if recordName == "@":
+                    value = zoneDomain
+                ## re.match
+                elif match(r'([\da-z\.-]+\.[a-z\.]{2,12}|[\d\.]+)([\/:?=&#]{1}[\da-z\.-]+)*[\/\?]?', recordName,
+                           M | I):
+                    value = recordName
+                else:
+                    value = recordName + "." + zoneDomain
+                recordContentCAA = data['recordContentCAA']  ## IP or ponting value
+                DNS.createDNSRecord(zone, value, recordType, recordContentCAA, 0, ttl)
+
+            final_dic = {'add_status': 1, 'error_message': "None"}
+            final_json = json.dumps(final_dic)
+            return HttpResponse(final_json)
+
+        except BaseException, msg:
+            final_dic = {'add_status': 0, 'error_message': str(msg)}
+            final_json = json.dumps(final_dic)
+            return HttpResponse(final_json)
+
+    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 = {'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 deleteDNSZone(self, request = None, userID = None):
+
+        try:
+            currentACL = ACLManager.loadedACL(userID)
+
+            if ACLManager.currentContextPermission(currentACL, 'deleteZone') == 0:
+                return ACLManager.loadError()
+
+            if not os.path.exists('/home/cyberpanel/powerdns'):
+                return render(request, 'dns/addDeleteDNSRecords.html', {"status": 0})
+
+            domainsList = ACLManager.findAllDomains(currentACL, userID)
+
+            return render(request, 'dns/deleteDNSZone.html', {"domainsList": domainsList, "status": 1})
+
+        except BaseException, msg:
+            return HttpResponse(str(msg))
+
+    def submitZoneDeletion(self, userID = None, data = None):
+        try:
+            zoneDomain = data['zoneDomain']
+
+            currentACL = ACLManager.loadedACL(userID)
+
+            if ACLManager.currentContextPermission(currentACL, 'deleteZone') == 0:
+                return ACLManager.loadErrorJson('delete_status', 0)
+
+            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)

dns/pluginManager.py

@@ -0,0 +1,44 @@
+from signals import *
+from plogical.pluginManagerGlobal import pluginManagerGlobal
+
+class pluginManager:
+
+    @staticmethod
+    def preNSCreation(request):
+        return pluginManagerGlobal.globalPlug(request, preNSCreation)
+
+    @staticmethod
+    def postNSCreation(request, response):
+        return pluginManagerGlobal.globalPlug(request, postNSCreation, response)
+
+    @staticmethod
+    def preZoneCreation(request):
+        return pluginManagerGlobal.globalPlug(request, preZoneCreation)
+
+    @staticmethod
+    def postZoneCreation(request, response):
+        return pluginManagerGlobal.globalPlug(request, postZoneCreation, response)
+
+    @staticmethod
+    def preAddDNSRecord(request):
+        return pluginManagerGlobal.globalPlug(request, preAddDNSRecord)
+
+    @staticmethod
+    def postAddDNSRecord(request, response):
+        return pluginManagerGlobal.globalPlug(request, postAddDNSRecord, response)
+
+    @staticmethod
+    def preDeleteDNSRecord(request):
+        return pluginManagerGlobal.globalPlug(request, preDeleteDNSRecord)
+
+    @staticmethod
+    def postDeleteDNSRecord(request, response):
+        return pluginManagerGlobal.globalPlug(request, postDeleteDNSRecord, response)
+
+    @staticmethod
+    def preSubmitZoneDeletion(request):
+        return pluginManagerGlobal.globalPlug(request, preSubmitZoneDeletion)
+
+    @staticmethod
+    def postSubmitZoneDeletion(request, response):
+        return pluginManagerGlobal.globalPlug(request, postSubmitZoneDeletion, response)

dns/signals.py

@@ -0,0 +1,33 @@
+# The world is a prison for the believer.
+
+from django.dispatch import Signal
+
+## This event is fired before CyberPanel core start creation of NS Records.
+preNSCreation = Signal(providing_args=["request"])
+
+## This event is fired after CyberPanel core finished creation NS Records.
+postNSCreation = Signal(providing_args=["request", "response"])
+
+## This event is fired before CyberPanel core start creation DNS Zone.
+preZoneCreation = Signal(providing_args=["request"])
+
+## This event is fired after CyberPanel core finished creation of DNS Zone.
+postZoneCreation = Signal(providing_args=["request", "response"])
+
+## This event is fired before CyberPanel core start to add an DNS record.
+preAddDNSRecord = Signal(providing_args=["request"])
+
+## This event is fired after CyberPanel core finished adding DNS record.
+postAddDNSRecord = Signal(providing_args=["request", "response"])
+
+## This event is fired before CyberPanel core start deletion of DNS Record.
+preDeleteDNSRecord = Signal(providing_args=["request"])
+
+## This event is fired after CyberPanel core finished deletion DNS Record.
+postDeleteDNSRecord = Signal(providing_args=["request", "response"])
+
+## This event is fired before CyberPanel core start deletion of a DNS Zone.
+preSubmitZoneDeletion = Signal(providing_args=["request"])
+
+## This event is fired after CyberPanel core finished deletion of DNS Zone.
+postSubmitZoneDeletion = Signal(providing_args=["request", "response"])

dns/views.py

@@ -1,674 +1,154 @@
 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
-
-from django.shortcuts import render,redirect
-from django.http import HttpResponse
-import json
-from plogical.dnsUtilities import DNS
-from loginSystem.models import Administrator
-import os
+from django.shortcuts import redirect
 from loginSystem.views import loadLoginPage
-from models import Domains,Records
-from re import match,I,M
-from websiteFunctions.models import Websites
-from plogical.mailUtilities import mailUtilities
-from plogical.acl import ACLManager
+from dnsManager import DNSManager
+from pluginManager import pluginManager
 
 # Create your views here.
 
 def loadDNSHome(request):
     try:
         userID = request.session['userID']
-        admin = Administrator.objects.get(pk=userID)
-
-        return render(request,'dns/index.html',{"type":admin.type})
+        dm = DNSManager()
+        return dm.loadDNSHome(request, userID)
     except KeyError:
         return redirect(loadLoginPage)
 
 def createNameserver(request):
     try:
         userID = request.session['userID']
-
-        currentACL = ACLManager.loadedACL(userID)
-
-        if currentACL['admin'] == 1:
-            pass
-        elif currentACL['createNameServer'] == 1:
-            pass
-        else:
-            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})
-
-
-
+        dm = DNSManager()
+        return dm.createNameserver(request, userID)
     except KeyError:
         return redirect(loadLoginPage)
 
 def NSCreation(request):
     try:
         userID = request.session['userID']
-        try:
-            if request.method == 'POST':
-                admin = Administrator.objects.get(pk=userID)
 
-                currentACL = ACLManager.loadedACL(userID)
+        result = pluginManager.preNSCreation(request)
+        if result != 200:
+            return result
 
-                if currentACL['admin'] == 1:
-                    pass
-                elif currentACL['createNameServer'] == 1:
-                    pass
-                else:
-                    return ACLManager.loadErrorJson('NSCreation', 0)
+        dm = DNSManager()
+        coreResult = dm.NSCreation(userID, request.body)
 
+        result = pluginManager.postNSCreation(request, coreResult)
+        if result != 200:
+            return result
 
-                data = json.loads(request.body)
-                domainForNS = data['domainForNS']
-                ns1 = data['ns1']
-                ns2 = data['ns2']
-                firstNSIP = data['firstNSIP']
-                secondNSIP = data['secondNSIP']
-
-                if Domains.objects.filter(name=domainForNS).count() == 0:
-                    newZone = Domains(admin=admin,name=domainForNS, type="NATIVE")
-                    newZone.save()
-
-                    content = "ns1." + domainForNS + " hostmaster." + domainForNS + " 1 10800 3600 604800 3600"
-
-                    soaRecord = Records(domainOwner=newZone,
-                                        domain_id=newZone.id,
-                                        name=domainForNS,
-                                        type="SOA",
-                                        content=content,
-                                        ttl=3600,
-                                        prio=0,
-                                        disabled=0,
-                                        auth=1)
-                    soaRecord.save()
-
-                    ## NS1
-
-                    record = Records(domainOwner=newZone,
-                                        domain_id=newZone.id,
-                                        name=domainForNS,
-                                        type="NS",
-                                        content=ns1,
-                                        ttl=3600,
-                                        prio=0,
-                                        disabled=0,
-                                        auth=1)
-                    record.save()
-
-
-
-                    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=domainForNS,
-                                     type="NS",
-                                     content=ns2,
-                                     ttl=3600,
-                                     prio=0,
-                                     disabled=0,
-                                     auth=1)
-                    record.save()
-
-
-                    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)
-                else:
-
-                    newZone = Domains.objects.get(name=domainForNS)
-
-                    ## NS1
-
-                    record = Records(domainOwner=newZone,
-                                     domain_id=newZone.id,
-                                     name=domainForNS,
-                                     type="NS",
-                                     content=ns1,
-                                     ttl=3600,
-                                     prio=0,
-                                     disabled=0,
-                                     auth=1)
-                    record.save()
-
-                    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=domainForNS,
-                                     type="NS",
-                                     content=ns2,
-                                     ttl=3600,
-                                     prio=0,
-                                     disabled=0,
-                                     auth=1)
-                    record.save()
-
-                    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)
-
-    except KeyError, msg:
-        final_dic = {'NSCreation': 0, 'error_message': str(msg)}
-        final_json = json.dumps(final_dic)
-        return HttpResponse(final_json)
+        return coreResult
+    except KeyError:
+        return redirect(loadLoginPage)
 
 def createDNSZone(request):
     try:
         userID = request.session['userID']
-
-        currentACL = ACLManager.loadedACL(userID)
-
-        if currentACL['admin'] == 1:
-            pass
-        elif currentACL['createDNSZone'] == 1:
-            pass
-        else:
-            return ACLManager.loadError()
-
-        if os.path.exists('/home/cyberpanel/powerdns'):
-            return render(request,'dns/createDNSZone.html', {"status": 1})
-        else:
-            return render(request,'dns/createDNSZone.html', {"status": 0})
-
+        dm = DNSManager()
+        return dm.createDNSZone(request, userID)
     except KeyError:
         return redirect(loadLoginPage)
 
 def zoneCreation(request):
     try:
         userID = request.session['userID']
-        try:
-            if request.method == 'POST':
 
-                admin = Administrator.objects.get(pk=userID)
-                currentACL = ACLManager.loadedACL(userID)
+        result = pluginManager.preZoneCreation(request)
+        if result != 200:
+            return result
 
-                if currentACL['admin'] == 1:
-                    pass
-                elif currentACL['createDNSZone'] == 1:
-                    pass
-                else:
-                    return ACLManager.loadErrorJson('zoneCreation', 0)
+        dm = DNSManager()
+        coreResult =  dm.zoneCreation(userID, request.body)
 
-                data = json.loads(request.body)
-                zoneDomain = data['zoneDomain']
+        result = pluginManager.postZoneCreation(request, coreResult)
+        if result != 200:
+            return result
 
-                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)
-
-    except KeyError,msg:
-        final_dic = {'zoneCreation': 0, 'error_message': str(msg)}
-        final_json = json.dumps(final_dic)
-        return HttpResponse(final_json)
+        return coreResult
+    except KeyError:
+        return redirect(loadLoginPage)
 
 def addDeleteDNSRecords(request):
     try:
         userID = request.session['userID']
-
-        currentACL = ACLManager.loadedACL(userID)
-
-        if currentACL['admin'] == 1:
-            pass
-        elif currentACL['addDeleteRecords'] == 1:
-            pass
-        else:
-            return ACLManager.loadError()
-
-        if not os.path.exists('/home/cyberpanel/powerdns'):
-            return render(request,'dns/addDeleteDNSRecords.html', {"status": 0})
-
-        domainsList = ACLManager.findAllDomains(currentACL, userID)
-
-        return render(request, 'dns/addDeleteDNSRecords.html',{"domainsList":domainsList, "status": 1})
-
+        dm = DNSManager()
+        return dm.addDeleteDNSRecords(request, userID)
     except KeyError:
         return redirect(loadLoginPage)
 
 def getCurrentRecordsForDomain(request):
     try:
         userID = request.session['userID']
-        try:
-            if request.method == 'POST':
-
-                data = json.loads(request.body)
-                zoneDomain = data['selectedZone']
-                currentSelection = data['currentSelection']
-
-                currentACL = ACLManager.loadedACL(userID)
-
-                if currentACL['admin'] == 1:
-                    pass
-                elif currentACL['addDeleteRecords'] == 1:
-                    pass
-                else:
-                    return ACLManager.loadErrorJson('fetchStatus', 1)
-
-                if not os.path.exists('/home/cyberpanel/powerdns'):
-                    return render(request, 'dns/addDeleteDNSRecords.html', {"status": 0})
-
-
-                domain = Domains.objects.get(name=zoneDomain)
-                records = Records.objects.filter(domain_id=domain.id)
-
-
-                fetchType = ""
-
-                if currentSelection == 'aRecord':
-                    fetchType = 'A'
-                elif currentSelection == 'aaaaRecord':
-                    fetchType = 'AAAA'
-                elif currentSelection == 'cNameRecord':
-                    fetchType = 'CNAME'
-                elif currentSelection == 'mxRecord':
-                    fetchType = 'MX'
-                elif currentSelection == 'txtRecord':
-                    fetchType = 'TXT'
-                elif currentSelection == 'spfRecord':
-                    fetchType = 'SPF'
-                elif currentSelection == 'nsRecord':
-                    fetchType = 'NS'
-                elif currentSelection == 'soaRecord':
-                    fetchType = 'SOA'
-                elif currentSelection == 'srvRecord':
-                    fetchType = 'SRV'
-                elif currentSelection == 'caaRecord':
-                    fetchType = 'CAA'
-
-                json_data = "["
-                checker = 0
-
-
-                for items in records:
-                    if items.type == fetchType:
-                        dic = {'id': items.id,
-                               'type': items.type,
-                               'name': items.name,
-                               'content': items.content,
-                               'priority': items.prio,
-                               'ttl':items.ttl
-                               }
-
-
-                        if checker == 0:
-                            json_data = json_data + json.dumps(dic)
-                            checker = 1
-                        else:
-                            json_data = json_data + ',' + json.dumps(dic)
-                    else:
-                        continue
-
-
-                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)
+        dm = DNSManager()
+        return dm.getCurrentRecordsForDomain(userID, request.body)
     except KeyError:
-        final_dic = {'fetchStatus': 0, 'error_message': "Not Logged In, please refresh the page or login again."}
-        final_json = json.dumps(final_dic)
-        return HttpResponse(final_json)
+        return redirect(loadLoginPage)
 
 def addDNSRecord(request):
     try:
         userID = request.session['userID']
-        try:
-            if request.method == 'POST':
 
-                data = json.loads(request.body)
-                zoneDomain = data['selectedZone']
-                recordType = data['recordType']
-                recordName = data['recordName']
-                ttl = int(data['ttl'])
+        result = pluginManager.preAddDNSRecord(request)
+        if result != 200:
+            return result
 
-                currentACL = ACLManager.loadedACL(userID)
+        dm = DNSManager()
+        coreResult =  dm.addDNSRecord(userID, request.body)
 
-                if currentACL['admin'] == 1:
-                    pass
-                elif currentACL['addDeleteRecords'] == 1:
-                    pass
-                else:
-                    return ACLManager.loadErrorJson('add_status', 0)
+        result = pluginManager.postAddDNSRecord(request, coreResult)
+        if result != 200:
+            return result
 
+        return coreResult
 
-                zone = Domains.objects.get(name=zoneDomain)
-                value = ""
-
-
-                if recordType == "A":
-
-                    recordContentA = data['recordContentA']  ## IP or ponting value
-
-                    if recordName == "@":
-                        value = zoneDomain
-                    ## re.match
-                    elif match(r'([\da-z\.-]+\.[a-z\.]{2,12}|[\d\.]+)([\/:?=&#]{1}[\da-z\.-]+)*[\/\?]?', recordName, M | I):
-                        value = recordName
-                    else:
-                        value = recordName + "." + zoneDomain
-
-
-                    DNS.createDNSRecord(zone, value, recordType, recordContentA, 0, ttl )
-
-                elif recordType == "MX":
-
-                    if recordName == "@":
-                        value = zoneDomain
-                    ## re.match
-                    elif match(r'([\da-z\.-]+\.[a-z\.]{2,12}|[\d\.]+)([\/:?=&#]{1}[\da-z\.-]+)*[\/\?]?', recordName, M | I):
-                        value = recordName
-                    else:
-                        value = recordName + "." + zoneDomain
-
-                    recordContentMX = data['recordContentMX']
-                    priority = data['priority']
-
-                    DNS.createDNSRecord(zone, value, recordType, recordContentMX, priority, ttl)
-
-                elif recordType == "AAAA":
-
-
-                    if recordName == "@":
-                        value = zoneDomain
-                    ## re.match
-                    elif match(r'([\da-z\.-]+\.[a-z\.]{2,12}|[\d\.]+)([\/:?=&#]{1}[\da-z\.-]+)*[\/\?]?', recordName, M | I):
-                        value = recordName
-                    else:
-                        value = recordName + "." + zoneDomain
-
-                    recordContentAAAA = data['recordContentAAAA']  ## IP or ponting value
-
-                    DNS.createDNSRecord(zone, value, recordType, recordContentAAAA, 0, ttl)
-
-                elif recordType == "CNAME":
-
-                    if recordName == "@":
-                        value = zoneDomain
-                    ## re.match
-                    elif match(r'([\da-z\.-]+\.[a-z\.]{2,12}|[\d\.]+)([\/:?=&#]{1}[\da-z\.-]+)*[\/\?]?', recordName, M | I):
-                        value = recordName
-                    else:
-                        value = recordName + "." + zoneDomain
-
-
-                    recordContentCNAME = data['recordContentCNAME']  ## IP or ponting value
-
-                    DNS.createDNSRecord(zone, value, recordType, recordContentCNAME, 0, ttl)
-
-                elif recordType == "SPF":
-
-                    if recordName == "@":
-                        value = zoneDomain
-                    ## re.match
-                    elif match(r'([\da-z\.-]+\.[a-z\.]{2,12}|[\d\.]+)([\/:?=&#]{1}[\da-z\.-]+)*[\/\?]?', recordName, M | I):
-                        value = recordName
-                    else:
-                        value = recordName + "." + zoneDomain
-
-                    recordContentSPF = data['recordContentSPF']  ## IP or ponting value
-
-                    DNS.createDNSRecord(zone, value, recordType, recordContentSPF, 0, ttl)
-
-                elif recordType == "TXT":
-
-                    if recordName == "@":
-                        value = zoneDomain
-                    ## re.match
-                    elif match(r'([\da-z\.-]+\.[a-z\.]{2,12}|[\d\.]+)([\/:?=&#]{1}[\da-z\.-]+)*[\/\?]?', recordName, M | I):
-                        value = recordName
-                    else:
-                        value = recordName + "." + zoneDomain
-
-                    recordContentTXT = data['recordContentTXT']  ## IP or ponting value
-
-                    DNS.createDNSRecord(zone, value, recordType, recordContentTXT, 0, ttl)
-
-                elif recordType == "SOA":
-
-                    recordContentSOA = data['recordContentSOA']
-
-                    DNS.createDNSRecord(zone, value, recordType, recordContentSOA, 0, ttl)
-
-                elif recordType == "NS":
-
-                    recordContentNS = data['recordContentNS']
-
-                    if recordContentNS == "@":
-                        recordContentNS = "ns1." + zoneDomain
-                    ## re.match
-                    elif match(r'([\da-z\.-]+\.[a-z\.]{2,12}|[\d\.]+)([\/:?=&#]{1}[\da-z\.-]+)*[\/\?]?', recordContentNS, M | I):
-                        recordContentNS = recordContentNS
-                    else:
-                        recordContentNS = recordContentNS + "." + zoneDomain
-
-                    DNS.createDNSRecord(zone, recordName, recordType, recordContentNS, 0, ttl)
-
-                elif recordType == "SRV":
-
-                    if recordName == "@":
-                        value = zoneDomain
-                    ## re.match
-                    elif match(r'([\da-z\.-]+\.[a-z\.]{2,12}|[\d\.]+)([\/:?=&#]{1}[\da-z\.-]+)*[\/\?]?', recordName, M | I):
-                        value = recordName
-                    else:
-                        value = recordName + "." + zoneDomain
-
-                    recordContentSRV = data['recordContentSRV']
-                    priority = data['priority']
-
-                    DNS.createDNSRecord(zone, value, recordType, recordContentSRV, priority, ttl)
-
-                elif recordType == "CAA":
-                    if recordName == "@":
-                        value = zoneDomain
-                    ## re.match
-                    elif match(r'([\da-z\.-]+\.[a-z\.]{2,12}|[\d\.]+)([\/:?=&#]{1}[\da-z\.-]+)*[\/\?]?', recordName,
-                               M | I):
-                        value = recordName
-                    else:
-                        value = recordName + "." + zoneDomain
-                    recordContentCAA = data['recordContentCAA']  ## IP or ponting value
-                    DNS.createDNSRecord(zone, value, recordType, recordContentCAA, 0, ttl)
-
-
-                final_dic = {'add_status': 1, 'error_message': "None"}
-                final_json = json.dumps(final_dic)
-                return HttpResponse(final_json)
-
-
-        except BaseException,msg:
-            final_dic = {'add_status': 0, 'error_message': str(msg)}
-            final_json = json.dumps(final_dic)
-            return HttpResponse(final_json)
-    except KeyError,msg:
-        final_dic = {'add_status': 0, 'error_message': "Not Logged In, please refresh the page or login again."}
-        final_json = json.dumps(final_dic)
-        return HttpResponse(final_json)
+    except KeyError:
+        return redirect(loadLoginPage)
 
 def deleteDNSRecord(request):
     try:
         userID = request.session['userID']
-        try:
-            if request.method == 'POST':
 
-                data = json.loads(request.body)
-                id = data['id']
+        result = pluginManager.preDeleteDNSRecord(request)
+        if result != 200:
+            return result
 
-                currentACL = ACLManager.loadedACL(userID)
+        dm = DNSManager()
+        coreResult =  dm.deleteDNSRecord(userID, request.body)
 
-                if currentACL['admin'] == 1:
-                    pass
-                elif currentACL['addDeleteRecords'] == 1:
-                    pass
-                else:
-                    return ACLManager.loadErrorJson('delete_status', 0)
+        result = pluginManager.postDeleteDNSRecord(request, coreResult)
+        if result != 200:
+            return result
 
-                delRecord = Records.objects.get(id=id)
-                delRecord.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)
-    except KeyError,msg:
-        final_dic = {'delete_status': 0, 'error_message': "Not Logged In, please refresh the page or login again."}
-        final_json = json.dumps(final_dic)
-        return HttpResponse(final_json)
+        return coreResult
+    except KeyError:
+        return redirect(loadLoginPage)
 
 def deleteDNSZone(request):
-
     try:
         userID = request.session['userID']
-        currentACL = ACLManager.loadedACL(userID)
-
-        if currentACL['admin'] == 1:
-            pass
-        elif currentACL['deleteZone'] == 1:
-            pass
-        else:
-            return ACLManager.loadError()
-
-        if not os.path.exists('/home/cyberpanel/powerdns'):
-            return render(request, 'dns/addDeleteDNSRecords.html', {"status": 0})
-
-        domainsList = ACLManager.findAllDomains(currentACL, userID)
-
-        return render(request, 'dns/deleteDNSZone.html',{"domainsList":domainsList, "status": 1})
-
+        dm = DNSManager()
+        return dm.getCurrentRecordsForDomain(request, userID)
     except KeyError:
         return redirect(loadLoginPage)
 
 def submitZoneDeletion(request):
     try:
         userID = request.session['userID']
-        try:
-            if request.method == 'POST':
-                data = json.loads(request.body)
-                zoneDomain = data['zoneDomain']
+        result = pluginManager.preSubmitZoneDeletion(request)
+        if result != 200:
+            return result
 
-                currentACL = ACLManager.loadedACL(userID)
+        dm = DNSManager()
+        coreResult = dm.submitZoneDeletion(userID, request.body)
 
-                if currentACL['admin'] == 1:
-                    pass
-                elif currentACL['deleteZone'] == 1:
-                    pass
-                else:
-                    return ACLManager.loadErrorJson('delete_status', 0)
+        result = pluginManager.postSubmitZoneDeletion(request, coreResult)
+        if result != 200:
+            return result
 
-                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)
-    except KeyError,msg:
-        final_dic = {'delete_status': 0, 'error_message': "Not Logged In, please refresh the page or login again."}
-        final_json = json.dumps(final_dic)
-        return HttpResponse(final_json)
+        return coreResult
+    except KeyError:
+        return redirect(loadLoginPage)
 
 
 

examplePlugin/meta.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<cyberpanelPluginConfig>
+  <name>examplePlugin</name>
+  <type>plugin</type>
+  <description>This is an example plugin</description>
+  <version>0</version>
+</cyberpanelPluginConfig>

plogical/pluginManagerGlobal.py

@@ -4,8 +4,11 @@ from CyberCPLogFileWriter import CyberCPLogFileWriter as logging
 
 class pluginManagerGlobal:
     @staticmethod
-    def globalPlug(request, eventInQuest):
-        hookReturn = eventInQuest.send(sender=None, request=request)
+    def globalPlug(request, eventInQuest, response = None):
+        if response == None:
+            hookReturn = eventInQuest.send(sender=None, request=request)
+        else:
+            hookReturn = eventInQuest.send(sender=None, request=request, response = response)
         for items in hookReturn:
             if type(items[1] == HttpResponse):
                 return items[1]

websiteFunctions/pluginManager.py

@@ -8,117 +8,117 @@ class pluginManager:
         return pluginManagerGlobal.globalPlug(request, preWebsiteCreation)
 
     @staticmethod
-    def postWebsiteCreation(request):
-        return pluginManagerGlobal.globalPlug(request, postWebsiteCreation)
+    def postWebsiteCreation(request, response):
+        return pluginManagerGlobal.globalPlug(request, postWebsiteCreation, response)
 
     @staticmethod
     def preDomainCreation(request):
         return pluginManagerGlobal.globalPlug(request, preDomainCreation)
 
     @staticmethod
-    def postDomainCreation(request):
-        return pluginManagerGlobal.globalPlug(request, postDomainCreation)
+    def postDomainCreation(request, response):
+        return pluginManagerGlobal.globalPlug(request, postDomainCreation, response)
 
     @staticmethod
     def preWebsiteDeletion(request):
         return pluginManagerGlobal.globalPlug(request, preWebsiteDeletion)
 
     @staticmethod
-    def postWebsiteDeletion(request):
-        return pluginManagerGlobal.globalPlug(request, postWebsiteDeletion)
+    def postWebsiteDeletion(request, response):
+        return pluginManagerGlobal.globalPlug(request, postWebsiteDeletion, response)
 
     @staticmethod
     def preDomainDeletion(request):
         return pluginManagerGlobal.globalPlug(request, preDomainDeletion)
 
     @staticmethod
-    def postDomainDeletion(request):
-        return pluginManagerGlobal.globalPlug(request, postDomainDeletion)
+    def postDomainDeletion(request, response):
+        return pluginManagerGlobal.globalPlug(request, postDomainDeletion, response)
 
     @staticmethod
     def preWebsiteSuspension(request):
         return pluginManagerGlobal.globalPlug(request, preWebsiteSuspension)
 
     @staticmethod
-    def postWebsiteSuspension(request):
-        return pluginManagerGlobal.globalPlug(request, postWebsiteSuspension)
+    def postWebsiteSuspension(request, response):
+        return pluginManagerGlobal.globalPlug(request, postWebsiteSuspension, response)
 
     @staticmethod
     def preWebsiteModification(request):
         return pluginManagerGlobal.globalPlug(request, preWebsiteModification)
 
     @staticmethod
-    def postWebsiteModification(request):
-        return pluginManagerGlobal.globalPlug(request, postWebsiteModification)
+    def postWebsiteModification(request, response):
+        return pluginManagerGlobal.globalPlug(request, postWebsiteModification, response)
 
     @staticmethod
     def preSaveConfigsToFile(request):
         return pluginManagerGlobal.globalPlug(request, preSaveConfigsToFile)
 
     @staticmethod
-    def postSaveConfigsToFile(request):
-        return pluginManagerGlobal.globalPlug(request, postSaveConfigsToFile)
+    def postSaveConfigsToFile(request, response):
+        return pluginManagerGlobal.globalPlug(request, postSaveConfigsToFile, response)
 
     @staticmethod
     def preSaveRewriteRules(request):
         return pluginManagerGlobal.globalPlug(request, preSaveRewriteRules)
 
     @staticmethod
-    def postSaveRewriteRules(request):
-        return pluginManagerGlobal.globalPlug(request, postSaveRewriteRules)
+    def postSaveRewriteRules(request, response):
+        return pluginManagerGlobal.globalPlug(request, postSaveRewriteRules, response)
 
     @staticmethod
     def preSaveSSL(request):
         return pluginManagerGlobal.globalPlug(request, preSaveSSL)
 
     @staticmethod
-    def postSaveSSL(request):
-        return pluginManagerGlobal.globalPlug(request, postSaveSSL)
+    def postSaveSSL(request, response):
+        return pluginManagerGlobal.globalPlug(request, postSaveSSL, response)
 
     @staticmethod
     def preChangePHP(request):
         return pluginManagerGlobal.globalPlug(request, preChangePHP)
 
     @staticmethod
-    def postChangePHP(request):
-        return pluginManagerGlobal.globalPlug(request, postChangePHP)
+    def postChangePHP(request, response):
+        return pluginManagerGlobal.globalPlug(request, postChangePHP, response)
 
     @staticmethod
     def preChangeOpenBasedir(request):
         return pluginManagerGlobal.globalPlug(request, preChangeOpenBasedir)
 
     @staticmethod
-    def postChangeOpenBasedir(request):
-        return pluginManagerGlobal.globalPlug(request, postChangeOpenBasedir)
+    def postChangeOpenBasedir(request, response):
+        return pluginManagerGlobal.globalPlug(request, postChangeOpenBasedir, response)
 
     @staticmethod
     def preAddNewCron(request):
         return pluginManagerGlobal.globalPlug(request, preAddNewCron)
 
     @staticmethod
-    def postAddNewCron(request):
-        return pluginManagerGlobal.globalPlug(request, postAddNewCron)
+    def postAddNewCron(request, response):
+        return pluginManagerGlobal.globalPlug(request, postAddNewCron, response)
 
     @staticmethod
     def preRemCronbyLine(request):
         return pluginManagerGlobal.globalPlug(request, preRemCronbyLine)
 
     @staticmethod
-    def postRemCronbyLine(request):
-        return pluginManagerGlobal.globalPlug(request, postRemCronbyLine)
+    def postRemCronbyLine(request, response):
+        return pluginManagerGlobal.globalPlug(request, postRemCronbyLine, response)
 
     @staticmethod
     def preSubmitAliasCreation(request):
         return pluginManagerGlobal.globalPlug(request, preSubmitAliasCreation)
 
     @staticmethod
-    def postSubmitAliasCreation(request):
-        return pluginManagerGlobal.globalPlug(request, postSubmitAliasCreation)
+    def postSubmitAliasCreation(request, response):
+        return pluginManagerGlobal.globalPlug(request, postSubmitAliasCreation, response)
 
     @staticmethod
     def preDelateAlias(request):
         return pluginManagerGlobal.globalPlug(request, preDelateAlias)
 
     @staticmethod
-    def postDelateAlias(request):
-        return pluginManagerGlobal.globalPlug(request, postDelateAlias)
+    def postDelateAlias(request, response):
+        return pluginManagerGlobal.globalPlug(request, postDelateAlias, response)

websiteFunctions/signals.py

@@ -6,88 +6,88 @@ from django.dispatch import Signal
 preWebsiteCreation = Signal(providing_args=["request"])
 
 ## This event is fired after CyberPanel core finished creation of website.
-postWebsiteCreation = Signal(providing_args=["request"])
+postWebsiteCreation = Signal(providing_args=["request", "response"])
 
 ## This event is fired before CyberPanel core start creation of child-domain
 preDomainCreation = Signal(providing_args=["request"])
 
 ## This event is fired after CyberPanel core finished creation of child-domain.
-postDomainCreation = Signal(providing_args=["request"])
+postDomainCreation = Signal(providing_args=["request", "response"])
 
 ## This event is fired before CyberPanel core start deletion of website
 preWebsiteDeletion = Signal(providing_args=["request"])
 
 ## This event is fired after CyberPanel core finished deletion of website
-postWebsiteDeletion = Signal(providing_args=["request"])
+postWebsiteDeletion = Signal(providing_args=["request", "response"])
 
 ## This event is fired before CyberPanel core start deletion of child-domain
 preDomainDeletion = Signal(providing_args=["request"])
 
 ## This event is fired after CyberPanel core finished deletion of child-domain
-postDomainDeletion = Signal(providing_args=["request"])
+postDomainDeletion = Signal(providing_args=["request", "response"])
 
 ## This event is fired before CyberPanel core start suspension of website
 preWebsiteSuspension = Signal(providing_args=["request"])
 
 ## This event is fired after CyberPanel core finished suspension of website
-postWebsiteSuspension = Signal(providing_args=["request"])
+postWebsiteSuspension = Signal(providing_args=["request", "response"])
 
 ## This event is fired before CyberPanel core start suspension of website
 preWebsiteModification = Signal(providing_args=["request"])
 
 ## This event is fired after CyberPanel core finished suspension of website
-postWebsiteModification = Signal(providing_args=["request"])
+postWebsiteModification = Signal(providing_args=["request", "response"])
 
 ## This event is fired before CyberPanel core start saving changes to vhost conf
 preSaveConfigsToFile = Signal(providing_args=["request"])
 
 ## This event is fired after CyberPanel core finished saving changes to vhost conf
-postSaveConfigsToFile = Signal(providing_args=["request"])
+postSaveConfigsToFile = Signal(providing_args=["request", "response"])
 
 ## This event is fired before CyberPanel core start saving changes to vhost rewrite file
 preSaveRewriteRules = Signal(providing_args=["request"])
 
 ## This event is fired after CyberPanel core finished saving changes to vhost rewrite file
-postSaveRewriteRules = Signal(providing_args=["request"])
+postSaveRewriteRules = Signal(providing_args=["request", "response"])
 
 ## This event is fired before CyberPanel core start saving custom SSL
 preSaveSSL = Signal(providing_args=["request"])
 
 ## This event is fired after CyberPanel core finished saving saving custom SSL
-postSaveSSL = Signal(providing_args=["request"])
+postSaveSSL = Signal(providing_args=["request", "response"])
 
 ## This event is fired before CyberPanel core start changing php version of domain or website
 preChangePHP = Signal(providing_args=["request"])
 
 ## This event is fired after CyberPanel core finished change php version of domain or website
-postChangePHP = Signal(providing_args=["request"])
+postChangePHP = Signal(providing_args=["request", "response"])
 
 ## This event is fired before CyberPanel core start changing open_basdir status for domain or website
 preChangeOpenBasedir = Signal(providing_args=["request"])
 
 ## This event is fired after CyberPanel core finished changing open_basdir status for domain or website
-postChangeOpenBasedir = Signal(providing_args=["request"])
+postChangeOpenBasedir = Signal(providing_args=["request", "response"])
 
 ## This event is fired before CyberPanel core start adding new cron
 preAddNewCron = Signal(providing_args=["request"])
 
 ## This event is fired after CyberPanel core is finished adding new cron
-postAddNewCron = Signal(providing_args=["request"])
+postAddNewCron = Signal(providing_args=["request", "response"])
 
 ## This event is fired before CyberPanel core start removing cron
 preRemCronbyLine = Signal(providing_args=["request"])
 
 ## This event is fired after CyberPanel core is finished removing cron
-postRemCronbyLine = Signal(providing_args=["request"])
+postRemCronbyLine = Signal(providing_args=["request", "response"])
 
 ## This event is fired before CyberPanel core start creating domain alias
 preSubmitAliasCreation = Signal(providing_args=["request"])
 
 ## This event is fired after CyberPanel core is finished creating domain alias
-postSubmitAliasCreation = Signal(providing_args=["request"])
+postSubmitAliasCreation = Signal(providing_args=["request", "response"])
 
 ## This event is fired before CyberPanel core start deleting domain alais
 preDelateAlias = Signal(providing_args=["request"])
 
 ## This event is fired after CyberPanel core is finished deleting domain alias
-postDelateAlias = Signal(providing_args=["request"])
+postDelateAlias = Signal(providing_args=["request", "response"])

websiteFunctions/views.py

@@ -5,7 +5,6 @@ from django.shortcuts import render,redirect
 from django.http import HttpResponse
 from loginSystem.models import Administrator
 from loginSystem.views import loadLoginPage
-import plogical.CyberCPLogFileWriter as logging
 import json
 from plogical.website import WebsiteManager
 from websiteFunctions.pluginManager import pluginManager
@@ -73,7 +72,7 @@ def submitWebsiteCreation(request):
         wm = WebsiteManager()
         coreResult = wm.submitWebsiteCreation(userID, json.loads(request.body))
 
-        result = pluginManager.postWebsiteCreation(request)
+        result = pluginManager.postWebsiteCreation(request, coreResult)
         if result != 200:
             return result
 
@@ -93,7 +92,7 @@ def submitDomainCreation(request):
         wm = WebsiteManager()
         coreResult = wm.submitDomainCreation(userID, json.loads(request.body))
 
-        result = pluginManager.postDomainCreation(request)
+        result = pluginManager.postDomainCreation(request, coreResult)
         if result != 200:
             return result
 
@@ -128,7 +127,7 @@ def submitWebsiteDeletion(request):
         wm = WebsiteManager()
         coreResult = wm.submitWebsiteDeletion(userID, json.loads(request.body))
 
-        result = pluginManager.postWebsiteDeletion(request)
+        result = pluginManager.postWebsiteDeletion(request, coreResult)
         if result != 200:
             return result
 
@@ -148,7 +147,7 @@ def submitDomainDeletion(request):
         wm = WebsiteManager()
         coreResult = wm.submitDomainDeletion(userID, json.loads(request.body))
 
-        result = pluginManager.postDomainDeletion(request)
+        result = pluginManager.postDomainDeletion(request, coreResult)
         if result != 200:
             return result
 
@@ -169,7 +168,7 @@ def submitWebsiteStatus(request):
         wm = WebsiteManager()
         coreResult = wm.submitWebsiteStatus(userID, json.loads(request.body))
 
-        result = pluginManager.postWebsiteSuspension(request)
+        result = pluginManager.postWebsiteSuspension(request, coreResult)
         if result != 200:
             return result
 
@@ -200,7 +199,7 @@ def saveWebsiteChanges(request):
         wm = WebsiteManager()
         coreResult = wm.saveWebsiteChanges(userID, json.loads(request.body))
 
-        result = pluginManager.postWebsiteModification(request)
+        result = pluginManager.postWebsiteModification(request, coreResult)
         if result != 200:
             return result
 
@@ -263,7 +262,7 @@ def saveConfigsToFile(request):
         wm = WebsiteManager()
         coreResult = wm.saveConfigsToFile(userID, json.loads(request.body))
 
-        result = pluginManager.postSaveConfigsToFile(request)
+        result = pluginManager.postSaveConfigsToFile(request, coreResult)
         if result != 200:
             return result
 
@@ -292,7 +291,7 @@ def saveRewriteRules(request):
         wm = WebsiteManager()
         coreResult = wm.saveRewriteRules(userID, json.loads(request.body))
 
-        result = pluginManager.postSaveRewriteRules(request)
+        result = pluginManager.postSaveRewriteRules(request, coreResult)
         if result != 200:
             return result
 
@@ -313,7 +312,7 @@ def saveSSL(request):
         wm = WebsiteManager()
         coreResult = wm.saveSSL(userID, json.loads(request.body))
 
-        result = pluginManager.postSaveSSL(request)
+        result = pluginManager.postSaveSSL(request, coreResult)
         if result != 200:
             return result
 
@@ -334,7 +333,7 @@ def changePHP(request):
         wm = WebsiteManager()
         coreResult = wm.changePHP(userID, json.loads(request.body))
 
-        result = pluginManager.postChangePHP(request)
+        result = pluginManager.postChangePHP(request, coreResult)
         if result != 200:
             return result
 
@@ -386,7 +385,7 @@ def remCronbyLine(request):
         wm = WebsiteManager()
         coreResult = wm.remCronbyLine(userID, json.loads(request.body))
 
-        result = pluginManager.postRemCronbyLine(request)
+        result = pluginManager.postRemCronbyLine(request, coreResult)
         if result != 200:
             return result
 
@@ -405,7 +404,7 @@ def addNewCron(request):
         wm = WebsiteManager()
         coreResult = wm.addNewCron(userID, json.loads(request.body))
 
-        result = pluginManager.postAddNewCron(request)
+        result = pluginManager.postAddNewCron(request, coreResult)
         if result != 200:
             return result
 
@@ -432,7 +431,7 @@ def submitAliasCreation(request):
         wm = WebsiteManager()
         coreResult = wm.submitAliasCreation(userID, json.loads(request.body))
 
-        result = pluginManager.postSubmitAliasCreation(request)
+        result = pluginManager.postSubmitAliasCreation(request, coreResult)
         if result != 200:
             return result
 
@@ -459,7 +458,7 @@ def delateAlias(request):
         wm = WebsiteManager()
         coreResult = wm.delateAlias(userID, json.loads(request.body))
 
-        result = pluginManager.postDelateAlias(request)
+        result = pluginManager.postDelateAlias(request, coreResult)
         if result != 200:
             return result
 
@@ -479,7 +478,7 @@ def changeOpenBasedir(request):
         wm = WebsiteManager()
         coreResult = wm.changeOpenBasedir(userID, json.loads(request.body))
 
-        result = pluginManager.postChangeOpenBasedir(request)
+        result = pluginManager.postChangeOpenBasedir(request, coreResult)
         if result != 200:
             return result