Initial commit for v2.4.3

CLScript/CLMain.py

@@ -0,0 +1,17 @@
+import json
+
+class CLMain():
+    def __init__(self):
+        self.path = '/usr/local/CyberCP/version.txt'
+        #versionInfo = json.loads(open(self.path, 'r').read())
+        self.version = '2.4'
+        self.build = '2'
+
+        ipFile = "/etc/cyberpanel/machineIP"
+        f = open(ipFile)
+        ipData = f.read()
+        self.ipAddress = ipData.split('\n', 1)[0]
+
+        self.initialMeta = {
+            "result": "ok"
+        }

CLScript/CloudLinuxAdmins.py

@@ -0,0 +1,85 @@
+#!/usr/local/CyberCP/bin/python
+import sys
+import os.path
+import django
+sys.path.append('/usr/local/CyberCP')
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "CyberCP.settings")
+try:
+    django.setup()
+except:
+    pass
+from loginSystem.models import Administrator, ACL
+import argparse
+import json
+from CLScript.CLMain import CLMain
+
+
+class CloudLinuxAdmins(CLMain):
+
+    def __init__(self, name, isMain):
+        CLMain.__init__(self)
+        self.name = name
+        if isMain == 'true':
+            self.isMain = 1
+        else:
+            self.isMain = 0
+
+    def listAll(self):
+        users = []
+        acl = ACL.objects.get(name='admin')
+        for items in Administrator.objects.filter(acl=acl):
+
+            if items.userName == 'admin':
+                isMain = True
+            else:
+                isMain = False
+
+            if self.isMain:
+                if isMain == False:
+                    continue
+
+            if self.name != None:
+                if self.name != items.userName:
+                    continue
+
+            user = {'name': items.userName,
+                    "locale_code": "EN_us",
+                    "unix_user": None,
+                     "email": items.email,
+                     "is_main": isMain
+                    }
+
+            users.append(user)
+
+
+        ## Add root users
+
+        admin = Administrator.objects.get(userName='admin')
+
+        user = {'name': 'root',
+                "locale_code": "EN_us",
+                "unix_user": 'root',
+                "email": admin.email,
+                "is_main": True
+                }
+
+        ##
+
+        users.append(user)
+
+        final = {'data': users, 'metadata': self.initialMeta}
+        print(json.dumps(final))
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='CyberPanel CloudLinux Manager')
+    parser.add_argument('-n','--name', help='Owner')
+    parser.add_argument('-m', '--is-main', help='Owner')
+
+    args = vars(parser.parse_args())
+
+    pi = CloudLinuxAdmins(args['name'], args['is_main'])
+    try:
+        pi.listAll()
+    except:
+        pi.listAll()

CLScript/CloudLinuxDB.py

@@ -0,0 +1,25 @@
+#!/usr/local/CyberCP/bin/python
+import sys
+sys.path.append('/usr/local/CyberCP')
+import json
+from CLScript.CLMain import CLMain
+
+
+class PanelInfo(CLMain):
+    def __init__(self):
+        CLMain.__init__(self)
+
+    def emit(self):
+
+        initial = {
+            "mysql": None
+        }
+
+        final = {'data': initial, 'metadata': self.initialMeta}
+
+        print(json.dumps(final))
+
+
+if __name__ == '__main__':
+    pi = PanelInfo()
+    pi.emit()

CLScript/CloudLinuxDomains.py

@@ -0,0 +1,104 @@
+#!/usr/local/CyberCP/bin/python
+import sys
+import os.path
+import django
+
+sys.path.append('/usr/local/CyberCP')
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "CyberCP.settings")
+try:
+    django.setup()
+except:
+    pass
+from websiteFunctions.models import Websites
+import argparse
+import json
+from CLScript.CLMain import CLMain
+
+
+class CloudLinuxDomains(CLMain):
+
+    def __init__(self, name, owner, with_php):
+        CLMain.__init__(self)
+        self.owner = owner
+        self.name = name
+        self.with_php = with_php
+
+    def listAll(self):
+        data = {}
+
+        if self.owner != None:
+            websites = Websites.objects.filter(externalApp=self.owner)
+        else:
+            websites = Websites.objects.all()
+
+        for webs in websites:
+            if self.name != None:
+                if self.name != webs.domain:
+                    continue
+
+            if self.with_php:
+                completePathToConfigFile = f'/usr/local/lsws/conf/vhosts/{webs.domain}/vhost.conf'
+                from plogical.phpUtilities import phpUtilities
+                from managePHP.phpManager import PHPManager
+                phpVersion = phpUtilities.WrapGetPHPVersionFromFileToGetVersionWithPHP(completePathToConfigFile)
+                php = PHPManager.getPHPString(phpVersion)
+
+                data[webs.domain] = {
+                    "owner": webs.externalApp,
+                    "document_root": "/home/%s/public_html/" % (webs.domain),
+                    "is_main": True,
+                    "php": {
+                        "version": php[:2],
+                        "ini_path": f"/usr/local/lsws/lsphp{php[:2]}/etc/php.d",
+                        "is_native": False
+                    }
+
+                }
+
+                for webs in webs.childdomains_set.all():
+                    completePathToConfigFile = f'/usr/local/lsws/conf/vhosts/{webs.domain}/vhost.conf'
+                    from plogical.phpUtilities import phpUtilities
+                    from managePHP.phpManager import PHPManager
+                    phpVersion = phpUtilities.WrapGetPHPVersionFromFileToGetVersionWithPHP(completePathToConfigFile)
+                    php = PHPManager.getPHPString(phpVersion)
+
+                    data[webs.domain] = {"owner": webs.master.externalApp,
+                                         "document_root": webs.path,
+                                         "is_main": False,
+                                         "php": {
+                                             "version": php[:2],
+                                             "ini_path": f"/usr/local/lsws/lsphp{php[:2]}/etc/php.d",
+                                             "is_native": False
+                                         }
+
+                                         }
+
+            else:
+                data[webs.domain] = {"owner": webs.externalApp,
+                                     "document_root": "/home/%s/public_html/" % (webs.domain),
+                                     "is_main": True}
+                for webs in webs.childdomains_set.all():
+                    data[webs.domain] = {"owner": webs.master.externalApp,
+                                         "document_root": webs.path,
+                                         "is_main": False}
+
+        final = {'data': data, 'metadata': self.initialMeta}
+        print(json.dumps(final))
+
+
+import argparse
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='CyberPanel CloudLinux Manager')
+    parser.add_argument('-o', '--owner', help='Owner')
+    parser.add_argument('-n', '--name', help='Owner')
+    parser.add_argument('-p', '--with-php', action='store_true', help='False (X-Ray support only)')
+
+    args = parser.parse_args()
+
+    # Assuming CloudLinuxDomains class exists
+    pi = CloudLinuxDomains(args.name, args.owner, args.with_php)
+    try:
+        pi.listAll()
+    except:
+        pi.listAll()

CLScript/CloudLinuxPackages.py

@@ -0,0 +1,53 @@
+#!/usr/local/CyberCP/bin/python
+import sys
+import os.path
+import django
+sys.path.append('/usr/local/CyberCP')
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "CyberCP.settings")
+try:
+    django.setup()
+except:
+    pass
+from packages.models import Package
+import argparse
+import json
+from CLScript.CLMain import CLMain
+from loginSystem.models import Administrator
+
+
+class CloudLinuxPackages(CLMain):
+    def __init__(self):
+        CLMain.__init__(self)
+
+    def listAll(self, owner=None):
+        packages = []
+
+        if owner == None:
+            for items in Package.objects.all():
+                try:
+                    packages.append({'name': items.packageName, 'owner': items.admin.userName})
+                except:
+                    pass
+        else:
+            admin = Administrator.objects.get(userName=owner)
+            for items in Package.objects.filter(admin=admin):
+                try:
+                    packages.append({'name': items.packageName, 'owner': items.admin.userName})
+                except:
+                    pass
+
+        final = {'data': packages, 'metadata': self.initialMeta}
+        print(json.dumps(final))
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='CyberPanel CloudLinux Manager')
+    parser.add_argument('-o', '--owner', help='Owner')
+
+    args = parser.parse_args()
+
+    pi = CloudLinuxPackages()
+    try:
+        pi.listAll(args.owner)
+    except:
+        pi.listAll()

CLScript/CloudLinuxResellers.py

@@ -0,0 +1,64 @@
+#!/usr/local/CyberCP/bin/python
+import sys
+import os.path
+import django
+
+sys.path.append('/usr/local/CyberCP')
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "CyberCP.settings")
+try:
+    django.setup()
+except:
+    pass
+from loginSystem.models import Administrator, ACL
+import argparse
+import json
+from CLScript.CLMain import CLMain
+
+class CloudLinuxResellers(CLMain):
+
+    def __init__(self, id, name):
+        CLMain.__init__(self)
+        self.id = id
+        self.name = name
+
+    def listAll(self, owner=None):
+        import pwd
+        users = []
+        acl = ACL.objects.get(name='reseller')
+        from plogical.vhost import vhost
+        for items in Administrator.objects.filter(acl=acl):
+            if self.name != None:
+                if self.name != items.userName:
+                    continue
+
+
+            try:
+                uid = pwd.getpwnam(items.userName).pw_uid
+            except:
+                vhost.addUser(items.userName, '/home/%s' % (items.userName))
+                uid = pwd.getpwnam(items.userName).pw_uid
+
+            user = {'name': items.userName,
+                    "locale_code": "EN_us",
+                     "email": items.email,
+                    "id": uid
+                    }
+
+            users.append(user)
+
+        final = {'data': users, 'metadata': self.initialMeta}
+        print(json.dumps(final))
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='CyberPanel CloudLinux Manager')
+    parser.add_argument('--id', help='Owner')
+    parser.add_argument('-n', '--name', help='Owner')
+
+    args = parser.parse_args()
+
+    pi = CloudLinuxResellers(args.id, args.name)
+    try:
+        pi.listAll()
+    except:
+        pi.listAll()

CLScript/CloudLinuxUsers.py

@@ -0,0 +1,170 @@
+#!/usr/local/CyberCP/bin/python
+import sys
+import os.path
+import django
+
+sys.path.append('/usr/local/CyberCP')
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "CyberCP.settings")
+try:
+    django.setup()
+except:
+    pass
+from websiteFunctions.models import Websites
+import argparse
+import pwd
+import json
+from CLScript.CLMain import CLMain
+
+
+class CloudLinuxUsers(CLMain):
+
+    def __init__(self, owner, username, packageName, packageOwner, fields, uid):
+
+        CLMain.__init__(self)
+        self.owner = owner
+        self.username = username
+        self.packageName = packageName
+        self.packageOwner = packageOwner
+        self.fields = fields
+        if uid!=None:
+            self.uid = int(uid)
+        else:
+            self.uid = uid
+
+        if self.fields == None:
+            self.id = 1
+            self.un = 1
+            self.ow = 1
+            self.domain = 1
+            self.package = 1
+            self.email = 1
+            self.localecode = 1
+        else:
+            if self.fields.find('id') > -1:
+                self.id = 1
+            else:
+                self.id = 0
+            if self.fields.find('username') > -1:
+                self.un = 1
+            else:
+                self.un = 0
+
+            if self.fields.find('owner') > -1:
+                self.ow = 1
+            else:
+                self.ow = 0
+
+            if self.fields.find('domain') > -1:
+                self.domain = 1
+            else:
+                self.domain = 0
+
+            if self.fields.find('package') > -1:
+                self.package = 1
+            else:
+                self.package = 0
+
+            if self.fields.find('email') > -1:
+                self.email = 1
+            else:
+                self.email = 0
+
+            if self.fields.find('locale_code') > -1:
+                self.localecode = 1
+            else:
+                self.localecode = 0
+
+
+
+    def fetchJson(self, websites):
+        users = []
+        for webs in websites:
+            try:
+                itemPackage = webs.package
+                package = {'name': itemPackage.packageName, 'owner': webs.admin.userName}
+
+                user = {}
+
+                if self.id:
+                    user['id'] = pwd.getpwnam(webs.externalApp).pw_uid
+
+                if self.un:
+                    user['username'] = webs.externalApp
+
+                if self.ow:
+                    if webs.admin.owner == 1:
+                        user['owner'] = webs.admin.userName
+                    else:
+                        from loginSystem.models import Administrator
+                        oAdmin = Administrator.objects.get(pk=webs.admin.owner)
+                        user['owner'] = oAdmin.userName
+
+                if self.domain:
+                    user['domain'] = webs.domain
+
+                if self.package:
+                    user['package'] = package
+
+                if self.email:
+                    user['email'] = webs.adminEmail
+
+                if self.localecode:
+                    user['locale_code'] = "EN_us"
+
+
+                if self.packageName != None:
+                    if self.package:
+                        if self.packageName == user['package']['name'] and self.packageOwner == user['package']['owner']:
+                            pass
+                        else:
+                            continue
+
+                if self.uid !=None:
+                    if self.id:
+                        if self.uid == user['id']:
+                            users.append(user)
+                    else:
+                        users.append(user)
+                else:
+                    users.append(user)
+            except BaseException as msg:
+                pass
+
+        final = {'data': users, 'metadata': self.initialMeta}
+        print(json.dumps(final))
+
+    def listAll(self):
+
+        if self.owner == None:
+            websites = Websites.objects.all()
+        else:
+            from loginSystem.models import Administrator
+            from plogical.acl import ACLManager
+            oAdmin = Administrator.objects.get(userName=self.owner)
+            currentACL = ACLManager.loadedACL(oAdmin.pk)
+            websites = ACLManager.findWebsiteObjects(currentACL, oAdmin.pk)
+
+        if self.username != None:
+            websites = websites.filter(externalApp=self.username)
+
+        self.fetchJson(websites)
+
+
+def main():
+    parser = argparse.ArgumentParser(description='CyberPanel CloudLinux Manager')
+    parser.add_argument('-o', '--owner', help='Owner')
+    parser.add_argument('--fields', help='Fields to output!')
+    parser.add_argument('--username', help='Fields to output!')
+    parser.add_argument('--package-name', help='Fields to output!')
+    parser.add_argument('--package-owner', help='Fields to output!')
+    parser.add_argument('--unix-id', help='Fields to output!')
+
+    args = vars(parser.parse_args())
+
+    pi = CloudLinuxUsers(args['owner'], args['username'], args['package_name'], args['package_owner'], args['fields'], args['unix_id'])
+    pi.listAll()
+
+
+
+if __name__ == '__main__':
+    main()

CLScript/UserInfo.py

@@ -0,0 +1,27 @@
+#!/usr/local/CyberCP/bin/python
+import getpass
+
+def main():
+    import pwd
+    if getpass.getuser() == 'root':
+        userType = "admin"
+    else:
+        try:
+            uid = pwd.getpwnam(getpass.getuser()).pw_uid
+            userType = 'reseller'
+        except:
+            userType = 'user'
+
+    data = """{
+    "userName": "%s",
+    "userType": "%s",
+    "lang": "en",
+    "assetsUri": "/usr/local/lvemanager",
+    "baseUri": "/usr/local/lvemanager",
+    "defaultDomain": "cyberpanel.net"
+}""" % (getpass.getuser(), userType)
+
+    print(data)
+
+if __name__ == '__main__':
+    main()

CLScript/panel_info.py

@@ -0,0 +1,40 @@
+#!/usr/local/CyberCP/bin/python
+import sys
+sys.path.append('/usr/local/CyberCP')
+import json
+from CLScript.CLMain import CLMain
+
+
+class PanelInfo(CLMain):
+    def __init__(self):
+        CLMain.__init__(self)
+
+    def emit(self):
+
+        initial = {
+            "name": "CyberPanel",
+            "version": "%s.%s" % (self.version, self.build),
+            "user_login_url": "https://%s:8090/" % (self.ipAddress),
+            # "supported_cl_features": {
+            #     "php_selector": True,
+            #     "ruby_selector": True,
+            #     "python_selector": True,
+            #     "nodejs_selector": True,
+            #     "mod_lsapi": True,
+            #     "mysql_governor": True,
+            #     "cagefs": True,
+            #     "reseller_limits": True,
+            #     "xray": True,
+            #     "accelerate_wp": True,
+            #     "autotracing": True
+            # }
+        }
+
+        final = {'data': initial, 'metadata': self.initialMeta}
+
+        print(json.dumps(final))
+
+
+if __name__ == '__main__':
+    pi = PanelInfo()
+    pi.emit()