Gecko [ aodai.devttt.com ]

Name	Size	Permission
__pycache__	[ DIR ]	drwxr-xr-x
migrations	[ DIR ]	drwxr-xr-x
static	[ DIR ]	drwxr-xr-x
templates	[ DIR ]	drwxr-xr-x
.DS_Store	6 KB	-rw-r--r--
__init__.py	63 B	-rw-r--r--
admin.py	89 B	-rw-r--r--
apps.py	180 B	-rw-r--r--
emACL.py	1.7 KB	-rw-r--r--
emailMarketing.py	21.24 KB	-rw-r--r--
emailMarketingManager.py	31.13 KB	-rw-r--r--
meta.xml	235 B	-rw-r--r--
models.py	2.08 KB	-rw-r--r--
signals.py	0 B	-rw-r--r--
tests.py	86 B	-rw-r--r--
urls.py	2.04 KB	-rw-r--r--
views.py	5.92 KB	-rw-r--r--

Code Editor : emailMarketingManager.py

from django.shortcuts import render, HttpResponse, redirect
from plogical.acl import ACLManager
from loginSystem.views import loadLoginPage
import json
from random import randint
import time
from plogical.httpProc import httpProc
from .models import EmailMarketing, EmailLists, EmailsInList, EmailJobs
from websiteFunctions.models import Websites
from .emailMarketing import emailMarketing as EM
from math import ceil
import smtplib
from .models import SMTPHosts, EmailTemplate
from loginSystem.models import Administrator
from .emACL import emACL

class EmailMarketingManager:

def __init__(self, request = None, domain = None):
        self.request = request
        self.domain = domain

def emailMarketing(self):
        proc = httpProc(self.request, 'emailMarketing/emailMarketing.html', None, 'admin')
        return proc.render()

def fetchUsers(self):
        try:

userID = self.request.session['userID']
            currentACL = ACLManager.loadedACL(userID)

if currentACL['admin'] == 1:
                pass
            else:
                return ACLManager.loadError()

allUsers = ACLManager.findAllUsers()
            disabledUsers = EmailMarketing.objects.all()
            disabled = []
            for items in disabledUsers:
                disabled.append(items.userName)

json_data = "["
            checker = 0
            counter = 1

for items in allUsers:
                if items in disabled:
                    status = 0
                else:
                    status = 1

dic = {'id': counter, 'userName': items, 'status': status}

if checker == 0:
                    json_data = json_data + json.dumps(dic)
                    checker = 1
                else:
                    json_data = json_data + ',' + json.dumps(dic)

counter = counter + 1

json_data = json_data + ']'
            data_ret = {"status": 1, 'data': json_data}
            json_data = json.dumps(data_ret)
            return HttpResponse(json_data)
        except BaseException as msg:
            final_dic = {'status': 0, 'error_message': str(msg)}
            final_json = json.dumps(final_dic)
            return HttpResponse(final_json)

def enableDisableMarketing(self):
        try:

userID = self.request.session['userID']
            currentACL = ACLManager.loadedACL(userID)

if currentACL['admin'] == 1:
                pass
            else:
                return ACLManager.loadErrorJson()

data = json.loads(self.request.body)
            userName = data['userName']

try:
                disableMarketing = EmailMarketing.objects.get(userName=userName)
                disableMarketing.delete()
            except:
                enableMarketing = EmailMarketing(userName=userName)
                enableMarketing.save()

data_ret = {"status": 1}
            json_data = json.dumps(data_ret)
            return HttpResponse(json_data)
        except BaseException as msg:
            final_dic = {'status': 0, 'error_message': str(msg)}
            final_json = json.dumps(final_dic)
            return HttpResponse(final_json)

def createEmailList(self):
        try:
            userID = self.request.session['userID']
            currentACL = ACLManager.loadedACL(userID)
            admin = Administrator.objects.get(pk=userID)

if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
                pass
            else:
                return ACLManager.loadError()

if emACL.checkIfEMEnabled(admin.userName) == 0:
                return ACLManager.loadError()

proc = httpProc(self.request, 'emailMarketing/createEmailList.html', {'domain': self.domain})
            return proc.render()
        except KeyError as msg:
            return redirect(loadLoginPage)

def submitEmailList(self):
        try:

data = json.loads(self.request.body)

extraArgs = {}
            extraArgs['domain'] = data['domain']
            extraArgs['path'] = data['path']
            extraArgs['listName'] = data['listName'].replace(' ', '')
            extraArgs['tempStatusPath'] = "/home/cyberpanel/" + str(randint(1000, 9999))

userID = self.request.session['userID']
            currentACL = ACLManager.loadedACL(userID)
            admin = Administrator.objects.get(pk=userID)

if ACLManager.checkOwnership(data['domain'], admin, currentACL) == 1:
                pass
            else:
                return ACLManager.loadErrorJson()

if emACL.checkIfEMEnabled(admin.userName) == 0:
                return ACLManager.loadErrorJson()

# em = EM('createEmailList', extraArgs)
            # em.start()

time.sleep(2)

data_ret = {"status": 1, 'tempStatusPath': extraArgs['tempStatusPath']}
            json_data = json.dumps(data_ret)
            return HttpResponse(json_data)
        except BaseException as msg:
            final_dic = {'status': 0, 'error_message': str(msg)}
            final_json = json.dumps(final_dic)
            return HttpResponse(final_json)

def manageLists(self):
        try:
            userID = self.request.session['userID']
            currentACL = ACLManager.loadedACL(userID)
            admin = Administrator.objects.get(pk=userID)

if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
                pass
            else:
                return ACLManager.loadError()

if emACL.checkIfEMEnabled(admin.userName) == 0:
                return ACLManager.loadError()

listNames = emACL.getEmailsLists(self.domain)

proc = httpProc(self.request, 'emailMarketing/manageLists.html', {'listNames': listNames, 'domain': self.domain})
            return proc.render()

except KeyError as msg:
            return redirect(loadLoginPage)

def configureVerify(self):
        try:

userID = self.request.session['userID']
            currentACL = ACLManager.loadedACL(userID)
            admin = Administrator.objects.get(pk=userID)

if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
                pass
            else:
                return ACLManager.loadError()

if emACL.checkIfEMEnabled(admin.userName) == 0:
                return ACLManager.loadError()

proc = httpProc(self.request, 'emailMarketing/configureVerify.html',
                            {'domain': self.domain})
            return proc.render()

except KeyError as msg:
            return redirect(loadLoginPage)

def fetchVerifyLogs(self):
        try:

userID = self.request.session['userID']
            currentACL = ACLManager.loadedACL(userID)
            admin = Administrator.objects.get(pk=userID)

data = json.loads(self.request.body)

self.listName = data['listName']
            recordsToShow = int(data['recordsToShow'])
            page = int(str(data['page']).strip('\n'))

emailList = EmailLists.objects.get(listName=self.listName)

if ACLManager.checkOwnership(emailList.owner.domain, admin, currentACL) == 1:
                pass
            else:
                return ACLManager.loadErrorJson('status', 0)

logsLen = emailList.validationlog_set.all().count()

from s3Backups.s3Backups import S3Backups

pagination = S3Backups.getPagination(logsLen, recordsToShow)
            endPageNumber, finalPageNumber = S3Backups.recordsPointer(page, recordsToShow)
            finalLogs = emailList.validationlog_set.all()[finalPageNumber:endPageNumber]

json_data = "["
            checker = 0
            counter = 0

from plogical.backupSchedule import backupSchedule

for log in emailList.validationlog_set.all()[finalPageNumber:endPageNumber]:
                if log.status == backupSchedule.INFO:
                    status = 'INFO'
                else:
                    status = 'ERROR'

dic = {
                    'status': status, "message": log.message
                }

if checker == 0:
                    json_data = json_data + json.dumps(dic)
                    checker = 1
                else:
                    json_data = json_data + ',' + json.dumps(dic)

counter = counter + 1

json_data = json_data + ']'

totalEmail = emailList.emailsinlist_set.all().count()
            verified = emailList.verified
            notVerified = emailList.notVerified

data_ret = {'status': 1, 'logs': json_data, 'pagination': pagination, 'totalEmails': totalEmail, 'verified': verified, 'notVerified': notVerified}
            json_data = json.dumps(data_ret)
            return HttpResponse(json_data)

except BaseException as msg:
            data_ret = {'status': 0, 'error_message': str(msg)}
            json_data = json.dumps(data_ret)
            return HttpResponse(json_data)

def saveConfigureVerify(self):
        try:

userID = self.request.session['userID']
            admin = Administrator.objects.get(pk=userID)

if emACL.checkIfEMEnabled(admin.userName) == 0:
                return ACLManager.loadErrorJson()

data = json.loads(self.request.body)

domain = data['domain']

configureVerifyPath = '/home/cyberpanel/configureVerify'

import os

if not os.path.exists(configureVerifyPath):
                os.mkdir(configureVerifyPath)

finalPath = '%s/%s' % (configureVerifyPath, domain)

writeToFile = open(finalPath, 'w')
            writeToFile.write(self.request.body.decode())
            writeToFile.close()

def fetchEmails(self):
        try:

userID = self.request.session['userID']
            admin = Administrator.objects.get(pk=userID)

if emACL.checkIfEMEnabled(admin.userName) == 0:
                return ACLManager.loadErrorJson()

data = json.loads(self.request.body)

listName = data['listName']
            recordstoShow = int(data['recordstoShow'])
            page = int(data['page'])

finalPageNumber = ((page * recordstoShow)) - recordstoShow
            endPageNumber = finalPageNumber + recordstoShow

emailList = EmailLists.objects.get(listName=listName)
            currentACL = ACLManager.loadedACL(userID)

if currentACL['admin'] == 1:
                pass
            elif emailList.owner.id != userID:
                return ACLManager.loadErrorJson()

emails = emailList.emailsinlist_set.all()

## Pagination value

pages = float(len(emails)) / float(recordstoShow)
            pagination = []
            counter = 1

if pages <= 1.0:
                pages = 1
                pagination.append(counter)
            else:
                pages = ceil(pages)
                finalPages = int(pages) + 1

for i in range(1, finalPages):
                    pagination.append(counter)
                    counter = counter + 1

## Pagination value

emails = emails[finalPageNumber:endPageNumber]

json_data = "["
            checker = 0
            counter = 1

for items in emails:

dic = {'id': items.id, 'email': items.email, 'verificationStatus': items.verificationStatus,
                       'dateCreated': items.dateCreated}

if checker == 0:
                    json_data = json_data + json.dumps(dic)
                    checker = 1
                else:
                    json_data = json_data + ',' + json.dumps(dic)

counter = counter + 1

json_data = json_data + ']'
            data_ret = {"status": 1, 'data': json_data, 'pagination': pagination}
            json_data = json.dumps(data_ret)
            return HttpResponse(json_data)
        except BaseException as msg:
            final_dic = {'status': 0, 'error_message': str(msg)}
            final_json = json.dumps(final_dic)
            return HttpResponse(final_json)

def deleteList(self):
        try:

userID = self.request.session['userID']
            admin = Administrator.objects.get(pk=userID)

if emACL.checkIfEMEnabled(admin.userName) == 0:
                return ACLManager.loadErrorJson()

data = json.loads(self.request.body)

listName = data['listName']

delList = EmailLists.objects.get(listName=listName)
            currentACL = ACLManager.loadedACL(userID)
            if currentACL['admin'] == 1:
                pass
            elif delList.owner.id != userID:
                return ACLManager.loadErrorJson()

delList.delete()

def emailVerificationJob(self):
        try:

userID = self.request.session['userID']
            admin = Administrator.objects.get(pk=userID)

if emACL.checkIfEMEnabled(admin.userName) == 0:
                return ACLManager.loadErrorJson()

data = json.loads(self.request.body)
            extraArgs = {}
            extraArgs['listName'] = data['listName']

delList = EmailLists.objects.get(listName=extraArgs['listName'])
            currentACL = ACLManager.loadedACL(userID)
            if currentACL['admin'] == 1:
                pass
            elif delList.owner.id != userID:
                return ACLManager.loadErrorJson()

em = EM('verificationJob', extraArgs)
            em.start()

time.sleep(2)

def deleteEmail(self):
        try:
            userID = self.request.session['userID']
            admin = Administrator.objects.get(pk=userID)

if emACL.checkIfEMEnabled(admin.userName) == 0:
                return ACLManager.loadErrorJson()

data = json.loads(self.request.body)

id = data['id']

delEmail = EmailsInList.objects.get(id=id)

currentACL = ACLManager.loadedACL(userID)
            if currentACL['admin'] == 1:
                pass
            elif delEmail.owner.owner.id != userID:
                return ACLManager.loadErrorJson()

delEmail.delete()

def manageSMTP(self):
        try:
            userID = self.request.session['userID']
            currentACL = ACLManager.loadedACL(userID)
            admin = Administrator.objects.get(pk=userID)

if ACLManager.checkOwnership(self.domain, admin, currentACL) == 1:
                pass
            else:
                return ACLManager.loadError()

if emACL.checkIfEMEnabled(admin.userName) == 0:
                return ACLManager.loadError()

website = Websites.objects.get(domain=self.domain)
            emailLists = website.emaillists_set.all()
            listNames = []

for items in emailLists:
                listNames.append(items.listName)

proc = httpProc(self.request, 'emailMarketing/manageSMTPHosts.html',
                            {'listNames': listNames, 'domain': self.domain})
            return proc.render()
        except KeyError as msg:
            return redirect(loadLoginPage)

def saveSMTPHost(self):
        try:
            userID = self.request.session['userID']
            admin = Administrator.objects.get(pk=userID)

if emACL.checkIfEMEnabled(admin.userName) == 0:
                return ACLManager.loadErrorJson()

data = json.loads(self.request.body)

smtpHost = data['smtpHost']
            smtpPort = data['smtpPort']
            smtpUserName = data['smtpUserName']
            smtpPassword = data['smtpPassword']

if SMTPHosts.objects.count() == 0:
                admin = Administrator.objects.get(userName='admin')
                defaultHost = SMTPHosts(owner=admin, host='localhost', port=25, userName='None', password='None')
                defaultHost.save()

try:
                verifyLogin = smtplib.SMTP(str(smtpHost), int(smtpPort))

if int(smtpPort) == 587:
                    verifyLogin.starttls()

verifyLogin.login(str(smtpUserName), str(smtpPassword))

admin = Administrator.objects.get(pk=userID)

newHost = SMTPHosts(owner=admin, host=smtpHost, port=smtpPort, userName=smtpUserName,
                                    password=smtpPassword)
                newHost.save()

except smtplib.SMTPHeloError:
                data_ret = {"status": 0, 'error_message': 'The server did not reply properly to the HELO greeting.'}
                json_data = json.dumps(data_ret)
                return HttpResponse(json_data)
            except smtplib.SMTPAuthenticationError:
                data_ret = {"status": 0, 'error_message': 'Username and password combination not accepted.'}
                json_data = json.dumps(data_ret)
                return HttpResponse(json_data)
            except smtplib.SMTPException:
                data_ret = {"status": 0, 'error_message': 'No suitable authentication method was found.'}
                json_data = json.dumps(data_ret)
                return HttpResponse(json_data)

def fetchSMTPHosts(self):
        try:

userID = self.request.session['userID']
            admin = Administrator.objects.get(pk=userID)

if emACL.checkIfEMEnabled(admin.userName) == 0:
                return ACLManager.loadErrorJson()

currentACL = ACLManager.loadedACL(userID)

if currentACL['admin'] == 1:
                allHosts = SMTPHosts.objects.all()
            else:
                admin = Administrator.objects.get(pk=userID)
                allHosts = admin.smtphosts_set.all()

json_data = "["
            checker = 0
            counter = 1

for items in allHosts:

dic = {'id': items.id, 'owner': items.owner.userName, 'host': items.host, 'port': items.port,
                       'userName': items.userName}

if checker == 0:
                    json_data = json_data + json.dumps(dic)
                    checker = 1
                else:
                    json_data = json_data + ',' + json.dumps(dic)

counter = counter + 1

def smtpHostOperations(self):
        try:

userID = self.request.session['userID']
            admin = Administrator.objects.get(pk=userID)
            currentACL = ACLManager.loadedACL(userID)

if emACL.checkIfEMEnabled(admin.userName) == 0:
                return ACLManager.loadErrorJson()

data = json.loads(self.request.body)

id = data['id']
            operation = data['operation']

if operation == 'delete':
                delHost = SMTPHosts.objects.get(id=id)

if ACLManager.VerifySMTPHost(currentACL, delHost.owner, admin) == 0:
                    return ACLManager.loadErrorJson()

currentACL = ACLManager.loadedACL(userID)
                if currentACL['admin'] == 1:
                    pass
                elif delHost.owner.id != userID:
                    return ACLManager.loadErrorJson()
                delHost.delete()
                data_ret = {"status": 1, 'message': 'Successfully deleted.'}
                json_data = json.dumps(data_ret)
                return HttpResponse(json_data)
            else:
                try:
                    verifyHost = SMTPHosts.objects.get(id=id)

if ACLManager.VerifySMTPHost(currentACL, verifyHost.owner, admin) == 0:
                        return ACLManager.loadErrorJson()

verifyLogin = smtplib.SMTP(str(verifyHost.host), int(verifyHost.port))

if int(verifyHost.port) == 587:
                        verifyLogin.starttls()

verifyLogin.login(str(verifyHost.userName), str(verifyHost.password))

data_ret = {"status": 1, 'message': 'Login successful.'}
                    json_data = json.dumps(data_ret)
                    return HttpResponse(json_data)
                except smtplib.SMTPHeloError:
                    data_ret = {"status": 0, 'error_message': 'The server did not reply properly to the HELO greeting.'}
                    json_data = json.dumps(data_ret)
                    return HttpResponse(json_data)
                except smtplib.SMTPAuthenticationError:
                    data_ret = {"status": 0, 'error_message': 'Username and password combination not accepted.'}
                    json_data = json.dumps(data_ret)
                    return HttpResponse(json_data)
                except smtplib.SMTPException:
                    data_ret = {"status": 0, 'error_message': 'No suitable authentication method was found.'}
                    json_data = json.dumps(data_ret)
                    return HttpResponse(json_data)

except BaseException as msg:
            final_dic = {'status': 0, 'error_message': str(msg)}
            final_json = json.dumps(final_dic)
            return HttpResponse(final_json)

def composeEmailMessage(self):
        try:
            userID = self.request.session['userID']
            admin = Administrator.objects.get(pk=userID)

if emACL.checkIfEMEnabled(admin.userName) == 0:
                return ACLManager.loadErrorJson()

proc = httpProc(self.request, 'emailMarketing/composeMessages.html',
                            None)
            return proc.render()
        except KeyError as msg:
            return redirect(loadLoginPage)

def saveEmailTemplate(self):
        try:
            userID = self.request.session['userID']
            admin = Administrator.objects.get(pk=userID)

if emACL.checkIfEMEnabled(admin.userName) == 0:
                return ACLManager.loadErrorJson()

data = json.loads(self.request.body)

name = data['name']
            subject = data['subject']
            fromName = data['fromName']
            fromEmail = data['fromEmail']
            replyTo = data['replyTo']
            emailMessage = data['emailMessage']

if ACLManager.CheckRegEx('[\w\d\s]+$', name) == 0:
                return ACLManager.loadErrorJson()

admin = Administrator.objects.get(pk=userID)
            newTemplate = EmailTemplate(owner=admin, name=name.replace(' ', ''), subject=subject, fromName=fromName, fromEmail=fromEmail,
                                        replyTo=replyTo, emailMessage=emailMessage)
            newTemplate.save()

def sendEmails(self):
        try:
            userID = self.request.session['userID']
            admin = Administrator.objects.get(pk=userID)

if emACL.checkIfEMEnabled(admin.userName) == 0:
                return ACLManager.loadErrorJson()

currentACL = ACLManager.loadedACL(userID)
            templateNames = emACL.allTemplates(currentACL, admin)
            hostNames = emACL.allSMTPHosts(currentACL, admin)
            listNames = emACL.allEmailsLists(currentACL, admin)

Data = {}
            Data['templateNames'] = templateNames
            Data['hostNames'] = hostNames
            Data['listNames'] = listNames

proc = httpProc(self.request, 'emailMarketing/sendEmails.html',
                            Data)
            return proc.render()

except KeyError as msg:
            return redirect(loadLoginPage)

def templatePreview(self):
        try:
            userID = self.request.session['userID']
            admin = Administrator.objects.get(pk=userID)
            template = EmailTemplate.objects.get(name=self.domain)
            currentACL = ACLManager.loadedACL(userID)

if currentACL['admin'] == 1:
                pass
            elif template.owner != admin:
                return ACLManager.loadError()

return HttpResponse(template.emailMessage)
        except KeyError as msg:
            return redirect(loadLoginPage)

def fetchJobs(self):
        try:

userID = self.request.session['userID']
            admin = Administrator.objects.get(pk=userID)

if emACL.checkIfEMEnabled(admin.userName) == 0:
                return ACLManager.loadErrorJson()

data = json.loads(self.request.body)
            selectedTemplate = data['selectedTemplate']

template = EmailTemplate.objects.get(name=selectedTemplate)
            currentACL = ACLManager.loadedACL(userID)

if currentACL['admin'] == 1:
                pass
            elif template.owner != admin:
                return ACLManager.loadErrorJson()

allJobs = EmailJobs.objects.filter(owner=template)

json_data = "["
            checker = 0
            counter = 1

for items in allJobs:

dic = {'id': items.id,
                       'date': items.date,
                       'host': items.host,
                       'totalEmails': items.totalEmails,
                       'sent': items.sent,
                       'failed': items.failed}

if checker == 0:
                    json_data = json_data + json.dumps(dic)
                    checker = 1
                else:
                    json_data = json_data + ',' + json.dumps(dic)

counter = counter + 1

def startEmailJob(self):
        try:
            userID = self.request.session['userID']
            admin = Administrator.objects.get(pk=userID)
            data = json.loads(self.request.body)

extraArgs = {}
            extraArgs['selectedTemplate'] = data['selectedTemplate']
            extraArgs['listName'] = data['listName']
            extraArgs['host'] = data['host']
            try:
                extraArgs['verificationCheck'] = data['verificationCheck']
            except:
                extraArgs['verificationCheck'] = False
            try:
                extraArgs['unsubscribeCheck'] = data['unsubscribeCheck']
            except:
                extraArgs['unsubscribeCheck'] = False

extraArgs['tempStatusPath'] = "/home/cyberpanel/" + data['selectedTemplate'] + '_pendingJob'

currentACL = ACLManager.loadedACL(userID)
            template = EmailTemplate.objects.get(name=extraArgs['selectedTemplate'])

if currentACL['admin'] == 1:
                pass
            elif template.owner != admin:
                return ACLManager.loadErrorJson()

em = EM('startEmailJob', extraArgs)
            em.start()

time.sleep(5)

def deleteTemplate(self):
        try:
            userID = self.request.session['userID']
            admin = Administrator.objects.get(pk=userID)
            data = json.loads(self.request.body)

selectedTemplate = data['selectedTemplate']

delTemplate = EmailTemplate.objects.get(name=selectedTemplate)
            currentACL = ACLManager.loadedACL(userID)

if currentACL['admin'] == 1:
                pass
            elif delTemplate.owner != admin:
                return ACLManager.loadErrorJson()
            delTemplate.delete()

def deleteJob(self):
        try:
            userID = self.request.session['userID']
            admin = Administrator.objects.get(pk=userID)

if emACL.checkIfEMEnabled(admin.userName) == 0:
                return ACLManager.loadErrorJson()

data = json.loads(self.request.body)
            id = data['id']
            delJob = EmailJobs(id=id)
            delJob.delete()
            data_ret = {"status": 1}
            json_data = json.dumps(data_ret)
            return HttpResponse(json_data)
        except BaseException as msg:
            final_dic = {'status': 0, 'error_message': str(msg)}
            final_json = json.dumps(final_dic)
            return HttpResponse(final_json)

def remove(self, listName, emailAddress):
        try:
            eList = EmailLists.objects.get(listName=listName)
            removeEmail = EmailsInList.objects.get(owner=eList, email=emailAddress)
            removeEmail.verificationStatus = 'REMOVED'
            removeEmail.save()
        except:
            pass

return HttpResponse('Email Address Successfully removed from the list.')

${this.title}

Code Editor : emailMarketingManager.py