diff --git a/CyberCP/settings.py b/CyberCP/settings.py
index 6114fe32e..ca3aabb5d 100644
--- a/CyberCP/settings.py
+++ b/CyberCP/settings.py
@@ -61,6 +61,7 @@ INSTALLED_APPS = [
'manageServices',
'pluginHolder',
'emailPremium',
+ 'emailMarketing',
]
MIDDLEWARE = [
diff --git a/CyberCP/urls.py b/CyberCP/urls.py
index b6d2dc005..eb30b90d0 100644
--- a/CyberCP/urls.py
+++ b/CyberCP/urls.py
@@ -38,4 +38,5 @@ urlpatterns = [
url(r'^emailPremium/',include('emailPremium.urls')),
url(r'^manageservices/',include('manageServices.urls')),
url(r'^plugins/',include('pluginHolder.urls')),
+ url(r'^emailMarketing/', include('emailMarketing.urls')),
]
diff --git a/baseTemplate/templates/baseTemplate/index.html b/baseTemplate/templates/baseTemplate/index.html
index 0a5ebaa97..a46330835 100755
--- a/baseTemplate/templates/baseTemplate/index.html
+++ b/baseTemplate/templates/baseTemplate/index.html
@@ -624,6 +624,7 @@
+
diff --git a/emailMarketing/__init__.py b/emailMarketing/__init__.py
new file mode 100644
index 000000000..d33aad86a
--- /dev/null
+++ b/emailMarketing/__init__.py
@@ -0,0 +1 @@
+default_app_config = 'emailMarketing.apps.EmailmarketingConfig'
\ No newline at end of file
diff --git a/emailMarketing/admin.py b/emailMarketing/admin.py
new file mode 100644
index 000000000..13be29d96
--- /dev/null
+++ b/emailMarketing/admin.py
@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.contrib import admin
+
+# Register your models here.
diff --git a/emailMarketing/apps.py b/emailMarketing/apps.py
new file mode 100644
index 000000000..dafe02fc4
--- /dev/null
+++ b/emailMarketing/apps.py
@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.apps import AppConfig
+
+
+class EmailmarketingConfig(AppConfig):
+ name = 'emailMarketing'
+ def ready(self):
+ import signals
diff --git a/emailMarketing/emACL.py b/emailMarketing/emACL.py
new file mode 100644
index 000000000..e68571c8f
--- /dev/null
+++ b/emailMarketing/emACL.py
@@ -0,0 +1,66 @@
+from .models import EmailMarketing, EmailTemplate, SMTPHosts, EmailLists, EmailJobs
+from websiteFunctions.models import Websites
+
+class emACL:
+
+ @staticmethod
+ def checkIfEMEnabled(userName):
+ try:
+ user = EmailMarketing.objects.get(userName=userName)
+ return 0
+ except:
+ return 1
+
+ @staticmethod
+ def getEmailsLists(domain):
+ website = Websites.objects.get(domain=domain)
+ emailLists = website.emaillists_set.all()
+ listNames = []
+
+ for items in emailLists:
+ listNames.append(items.listName)
+
+ return listNames
+
+ @staticmethod
+ def allTemplates(currentACL, admin):
+ if currentACL['admin'] == 1:
+ allTemplates = EmailTemplate.objects.all()
+ else:
+ allTemplates = admin.emailtemplate_set.all()
+
+ templateNames = []
+ for items in allTemplates:
+ templateNames.append(items.name)
+ return templateNames
+
+ @staticmethod
+ def allSMTPHosts(currentACL, admin):
+ if currentACL['admin'] == 1:
+ allHosts = SMTPHosts.objects.all()
+ else:
+ allHosts = admin.smtphosts_set.all()
+ hostNames = []
+
+ for items in allHosts:
+ hostNames.append(items.host)
+
+ return hostNames
+
+ @staticmethod
+ def allEmailsLists(currentACL, admin):
+ listNames = []
+ emailLists = EmailLists.objects.all()
+
+ if currentACL['admin'] == 1:
+ for items in emailLists:
+ listNames.append(items.listName)
+ else:
+ for items in emailLists:
+ if items.owner.admin == admin:
+ listNames.append(items.listName)
+
+ return listNames
+
+
+
diff --git a/emailMarketing/emailMarketing.py b/emailMarketing/emailMarketing.py
new file mode 100644
index 000000000..ff6485d06
--- /dev/null
+++ b/emailMarketing/emailMarketing.py
@@ -0,0 +1,212 @@
+#!/usr/local/CyberCP/bin/python2
+from __future__ import absolute_import
+import os
+import time
+import csv
+import re
+import plogical.CyberCPLogFileWriter as logging
+from emailMarketing.models import EmailMarketing, EmailLists, EmailsInList, EmailTemplate, EmailJobs, SMTPHosts
+from websiteFunctions.models import Websites
+import threading as multi
+import socket, smtplib
+import DNS
+
+class emailMarketing(multi.Thread):
+ def __init__(self, function, extraArgs):
+ multi.Thread.__init__(self)
+ self.function = function
+ self.extraArgs = extraArgs
+
+ def run(self):
+ try:
+ if self.function == 'createEmailList':
+ self.createEmailList()
+ elif self.function == 'verificationJob':
+ self.verificationJob()
+ elif self.function == 'startEmailJob':
+ self.startEmailJob()
+ except BaseException, msg:
+ logging.CyberCPLogFileWriter.writeToFile(str(msg) + ' [emailMarketing.run]')
+
+ def createEmailList(self):
+ try:
+ website = Websites.objects.get(domain=self.extraArgs['domain'])
+ try:
+ newList = EmailLists(owner=website, listName=self.extraArgs['listName'], dateCreated=time.strftime("%I-%M-%S-%a-%b-%Y"))
+ newList.save()
+ except:
+ newList = EmailLists.objects.get(listName=self.extraArgs['listName'])
+
+ counter = 0
+
+ if self.extraArgs['path'].endswith('.csv'):
+ with open(self.extraArgs['path'], 'r') as emailsList:
+ data = csv.reader(emailsList, delimiter=',')
+ for items in data:
+ for value in items:
+ if re.match('^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,4})$', value) != None:
+ try:
+ getEmail = EmailsInList.objects.get(owner=newList, email=value)
+ except:
+ newEmail = EmailsInList(owner=newList, email=value,
+ verificationStatus='NOT CHECKED',
+ dateCreated=time.strftime("%I-%M-%S-%a-%b-%Y"))
+ newEmail.save()
+ logging.CyberCPLogFileWriter.statusWriter(self.extraArgs['tempStatusPath'], str(counter) + ' emails read.')
+ counter = counter + 1
+ elif self.extraArgs['path'].endswith('.txt'):
+ with open(self.extraArgs['path'], 'r') as emailsList:
+ emails = emailsList.readline()
+ while emails:
+ email = emails.strip('\n')
+ if re.match('^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,4})$', email) != None:
+ try:
+ getEmail = EmailsInList.objects.get(owner=newList, email=email)
+ except BaseException, msg:
+ newEmail = EmailsInList(owner=newList, email=email, verificationStatus='NOT CHECKED',
+ dateCreated=time.strftime("%I-%M-%S-%a-%b-%Y"))
+ newEmail.save()
+ logging.CyberCPLogFileWriter.statusWriter(self.extraArgs['tempStatusPath'],str(counter) + ' emails read.')
+ counter = counter + 1
+ emails = emailsList.readline()
+
+ logging.CyberCPLogFileWriter.statusWriter(self.extraArgs['tempStatusPath'], str(counter) + 'Successfully read all emails. [200]')
+ except BaseException, msg:
+ logging.CyberCPLogFileWriter.statusWriter(self.extraArgs['tempStatusPath'], str(msg) +'. [404]')
+ return 0
+
+ def verificationJob(self):
+ try:
+
+ verificationList = EmailLists.objects.get(listName=self.extraArgs['listName'])
+ domain = verificationList.owner.domain
+
+
+ if not os.path.exists('/home/cyberpanel/' + domain):
+ os.mkdir('/home/cyberpanel/' + domain)
+
+ tempStatusPath = '/home/cyberpanel/' + domain + "/" + self.extraArgs['listName']
+ logging.CyberCPLogFileWriter.statusWriter(tempStatusPath, 'Starting verification job..')
+
+ counter = 1
+ allEmailsInList = verificationList.emailsinlist_set.all()
+
+
+ for items in allEmailsInList:
+ if items.verificationStatus != 'Verified':
+ try:
+ email = items.email
+ domainName = email.split('@')[1]
+ records = DNS.dnslookup(domainName, 'MX')
+
+ for mxRecord in records:
+ # Get local server hostname
+ host = socket.gethostname()
+
+ server = smtplib.SMTP()
+ server.set_debuglevel(0)
+
+ # SMTP Conversation
+ server.connect(mxRecord[1])
+ server.helo(host)
+ server.mail('host' + "@" + host)
+ code, message = server.rcpt(str(email))
+ server.quit()
+
+ # Assume 250 as Success
+ if code == 250:
+ items.verificationStatus = 'Verified'
+ items.save()
+ break
+ else:
+ items.verificationStatus = 'Verification Failed'
+ logging.CyberCPLogFileWriter.writeToFile(email + " verification failed with error: " + message)
+ items.save()
+
+ logging.CyberCPLogFileWriter.statusWriter(tempStatusPath, str(counter) + ' emails verified so far..')
+ counter = counter + 1
+ except BaseException, msg:
+ items.verificationStatus = 'Verification Failed'
+ items.save()
+ counter = counter + 1
+ logging.CyberCPLogFileWriter.writeToFile(str(msg))
+
+ logging.CyberCPLogFileWriter.statusWriter(tempStatusPath, str(counter) + ' emails successfully verified. [200]')
+ except BaseException, msg:
+ verificationList = EmailLists.objects.get(listName=self.extraArgs['listName'])
+ domain = verificationList.owner.domain
+ tempStatusPath = '/home/cyberpanel/' + domain + "/" + self.extraArgs['listName']
+ logging.CyberCPLogFileWriter.statusWriter(tempStatusPath, str(msg) +'. [404]')
+ return 0
+
+ def startEmailJob(self):
+ try:
+ try:
+ if self.extraArgs['host'] == 'localhost':
+ smtpServer = smtplib.SMTP(self.extraArgs['host'])
+ else:
+ verifyHost = SMTPHosts.objects.get(host=self.extraArgs['host'])
+ smtpServer = smtplib.SMTP(verifyHost.host, int(verifyHost.port))
+ smtpServer.login(verifyHost.userName, verifyHost.password)
+ except smtplib.SMTPHeloError:
+ logging.CyberCPLogFileWriter.statusWriter(self.extraArgs['tempStatusPath'],
+ 'The server didnt reply properly to the HELO greeting.')
+ return
+ except smtplib.SMTPAuthenticationError:
+ logging.CyberCPLogFileWriter.statusWriter(self.extraArgs['tempStatusPath'],
+ 'Username and password combination not accepted.')
+ return
+ except smtplib.SMTPException:
+ logging.CyberCPLogFileWriter.statusWriter(self.extraArgs['tempStatusPath'],
+ 'No suitable authentication method was found.')
+ return
+
+ emailList = EmailLists.objects.get(listName=self.extraArgs['listName'])
+ allEmails = emailList.emailsinlist_set.all()
+ emailMessage = EmailTemplate.objects.get(name=self.extraArgs['selectedTemplate'])
+
+ totalEmails = allEmails.count()
+ sent = 0
+ failed = 0
+
+ ## Compose Message
+ from email.mime.multipart import MIMEMultipart
+ from email.mime.text import MIMEText
+ import re
+
+ message = MIMEMultipart('alternative')
+ message['Subject'] = emailMessage.subject
+ message['From'] = emailMessage.fromEmail
+
+ if re.search('', emailMessage.emailMessage, re.IGNORECASE):
+ html = MIMEText(emailMessage.emailMessage, 'html')
+ message.attach(html)
+ else:
+ html = MIMEText(emailMessage.emailMessage, 'plain')
+ message.attach(html)
+
+ for items in allEmails:
+ if items.verificationStatus == 'Verified' or self.extraArgs['verificationCheck']:
+ try:
+
+ smtpServer.sendmail(message['From'], items.email, message.as_string())
+ sent = sent + 1
+ logging.CyberCPLogFileWriter.statusWriter(self.extraArgs['tempStatusPath'],
+ 'Successfully sent: ' + str(sent) + ' Failed: ' + str(failed))
+ except BaseException, msg:
+ failed = failed + 1
+ logging.CyberCPLogFileWriter.statusWriter(self.extraArgs['tempStatusPath'],
+ 'Successfully sent: ' + str(
+ sent) + ', Failed: ' + str(failed))
+
+
+ emailJob = EmailJobs(owner=emailMessage, date=time.strftime("%I-%M-%S-%a-%b-%Y"),
+ host=self.extraArgs['host'], totalEmails=totalEmails,
+ sent=sent, failed=failed
+ )
+ emailJob.save()
+
+ logging.CyberCPLogFileWriter.statusWriter(self.extraArgs['tempStatusPath'],'Email job completed. [200]')
+ except BaseException, msg:
+ logging.CyberCPLogFileWriter.statusWriter(self.extraArgs['tempStatusPath'], str(msg) +'. [404]')
+ return 0
\ No newline at end of file
diff --git a/emailMarketing/emailMarketingManager.py b/emailMarketing/emailMarketingManager.py
new file mode 100644
index 000000000..9acfb2a68
--- /dev/null
+++ b/emailMarketing/emailMarketingManager.py
@@ -0,0 +1,733 @@
+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 .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):
+ try:
+ userID = self.request.session['userID']
+ currentACL = ACLManager.loadedACL(userID)
+
+ if currentACL['admin'] == 1:
+ pass
+ else:
+ return ACLManager.loadError()
+
+ return render(self.request, 'emailMarketing/emailMarketing.html')
+ except KeyError, msg:
+ return redirect(loadLoginPage)
+
+ 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, 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, 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()
+
+ return render(self.request, 'emailMarketing/createEmailList.html', {'domain': self.domain})
+ except KeyError, 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']
+ 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, 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)
+
+ return render(self.request, 'emailMarketing/manageLists.html', {'listNames': listNames, 'domain': self.domain})
+ except KeyError, msg:
+ return redirect(loadLoginPage)
+
+ 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:
+ 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, 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:
+ ACLManager.loadErrorJson()
+
+ delList.delete()
+
+ data_ret = {"status": 1}
+ json_data = json.dumps(data_ret)
+ return HttpResponse(json_data)
+ except BaseException, msg:
+ final_dic = {'status': 0, 'error_message': str(msg)}
+ final_json = json.dumps(final_dic)
+ return HttpResponse(final_json)
+
+ def 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:
+ ACLManager.loadErrorJson()
+
+ em = EM('verificationJob', extraArgs)
+ em.start()
+
+ time.sleep(2)
+
+ data_ret = {"status": 1}
+ json_data = json.dumps(data_ret)
+ return HttpResponse(json_data)
+ except BaseException, msg:
+ final_dic = {'status': 0, 'error_message': str(msg)}
+ final_json = json.dumps(final_dic)
+ return HttpResponse(final_json)
+
+ def 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:
+ ACLManager.loadErrorJson()
+
+ delEmail.delete()
+
+ data_ret = {"status": 1}
+ json_data = json.dumps(data_ret)
+ return HttpResponse(json_data)
+ except BaseException, msg:
+ final_dic = {'status': 0, 'error_message': str(msg)}
+ final_json = json.dumps(final_dic)
+ return HttpResponse(final_json)
+
+ def 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)
+ return render(self.request, 'emailMarketing/manageSMTPHosts.html', {'listNames': listNames, 'domain': self.domain})
+ except KeyError, 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(pk=1)
+ defaultHost = SMTPHosts(owner=admin, host='localhost', port=25, userName='None', password='None')
+ defaultHost.save()
+
+ try:
+ verifyLogin = smtplib.SMTP(smtpHost, int(smtpPort))
+ verifyLogin.login(smtpUserName, 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)
+
+ data_ret = {"status": 1}
+ json_data = json.dumps(data_ret)
+ return HttpResponse(json_data)
+ except BaseException, msg:
+ final_dic = {'status': 0, 'error_message': str(msg)}
+ final_json = json.dumps(final_dic)
+ return HttpResponse(final_json)
+
+ def fetchSMTPHosts(self):
+ try:
+
+ userID = self.request.session['userID']
+ admin = Administrator.objects.get(pk=userID)
+
+ if emACL.checkIfEMEnabled(admin.userName) == 0:
+ return ACLManager.loadErrorJson()
+
+ currentACL = ACLManager.loadedACL(userID)
+
+ if currentACL['admin'] == 1:
+ allHosts = SMTPHosts.objects.all()
+ else:
+ admin = Administrator.objects.get(pk=userID)
+ allHosts = admin.smtphosts_set.all()
+
+ json_data = "["
+ checker = 0
+ counter = 1
+
+ for items in allHosts:
+
+ dic = {'id': items.id, 'owner': items.owner.userName, 'host': items.host, 'port': items.port,
+ 'userName': items.userName}
+
+ if checker == 0:
+ json_data = json_data + json.dumps(dic)
+ checker = 1
+ else:
+ json_data = json_data + ',' + json.dumps(dic)
+
+ counter = counter + 1
+
+ json_data = json_data + ']'
+ data_ret = {"status": 1, 'data': json_data}
+ json_data = json.dumps(data_ret)
+ return HttpResponse(json_data)
+ except BaseException, msg:
+ final_dic = {'status': 0, 'error_message': str(msg)}
+ final_json = json.dumps(final_dic)
+ return HttpResponse(final_json)
+
+ def smtpHostOperations(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']
+ operation = data['operation']
+
+ if operation == 'delete':
+ delHost = SMTPHosts.objects.get(id=id)
+ currentACL = ACLManager.loadedACL(userID)
+ if currentACL['admin'] == 1:
+ pass
+ elif delHost.owner.id != userID:
+ 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)
+ verifyLogin = smtplib.SMTP(verifyHost.host, int(verifyHost.port))
+ verifyLogin.login(verifyHost.userName, 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, 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()
+
+ return render(self.request, 'emailMarketing/composeMessages.html')
+ except KeyError, 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']
+
+ admin = Administrator.objects.get(pk=userID)
+ newTemplate = EmailTemplate(owner=admin, name=name, subject=subject, fromName=fromName, fromEmail=fromEmail,
+ replyTo=replyTo, emailMessage=emailMessage)
+ newTemplate.save()
+
+ data_ret = {"status": 1}
+ json_data = json.dumps(data_ret)
+ return HttpResponse(json_data)
+ except BaseException, msg:
+ final_dic = {'status': 0, 'error_message': str(msg)}
+ final_json = json.dumps(final_dic)
+ return HttpResponse(final_json)
+
+ def sendEmails(self):
+ try:
+ userID = self.request.session['userID']
+ admin = Administrator.objects.get(pk=userID)
+
+ if emACL.checkIfEMEnabled(admin.userName) == 0:
+ return ACLManager.loadErrorJson()
+
+ currentACL = ACLManager.loadedACL(userID)
+ templateNames = emACL.allTemplates(currentACL, admin)
+ hostNames = emACL.allSMTPHosts(currentACL, admin)
+ listNames = emACL.allEmailsLists(currentACL, admin)
+
+
+ Data = {}
+ Data['templateNames'] = templateNames
+ Data['hostNames'] = hostNames
+ Data['listNames'] = listNames
+ return render(self.request, 'emailMarketing/sendEmails.html', Data)
+ except KeyError, msg:
+ return redirect(loadLoginPage)
+
+ def 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, 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
+
+ json_data = json_data + ']'
+ data_ret = {"status": 1, 'data': json_data}
+ json_data = json.dumps(data_ret)
+ return HttpResponse(json_data)
+ except BaseException, msg:
+ final_dic = {'status': 0, 'error_message': str(msg)}
+ final_json = json.dumps(final_dic)
+ return HttpResponse(final_json)
+
+ def 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']
+ extraArgs['verificationCheck'] = data['verificationCheck']
+ extraArgs['unsubscribeCheck'] = data['unsubscribeCheck']
+ 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(2)
+
+ data_ret = {"status": 1, 'tempStatusPath': extraArgs['tempStatusPath']}
+ json_data = json.dumps(data_ret)
+ return HttpResponse(json_data)
+ except BaseException, msg:
+ final_dic = {'status': 0, 'error_message': str(msg)}
+ final_json = json.dumps(final_dic)
+ return HttpResponse(final_json)
+
+ def 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()
+
+ data_ret = {"status": 1}
+ json_data = json.dumps(data_ret)
+ return HttpResponse(json_data)
+ except BaseException, msg:
+ final_dic = {'status': 0, 'error_message': str(msg)}
+ final_json = json.dumps(final_dic)
+ return HttpResponse(final_json)
+
+ def 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, msg:
+ final_dic = {'status': 0, 'error_message': str(msg)}
+ final_json = json.dumps(final_dic)
+ return HttpResponse(final_json)
\ No newline at end of file
diff --git a/emailMarketing/meta.xml b/emailMarketing/meta.xml
new file mode 100644
index 000000000..c2abe51a7
--- /dev/null
+++ b/emailMarketing/meta.xml
@@ -0,0 +1,7 @@
+
+
{% trans "On this page you can compose email message to be sent out later." %}
+
+ {% trans "Create email list, to send out news letters and marketing emails." %}
+
+ {% trans "Select users to Enable/Disable Email Marketing feature!" %}
+
+ | {% trans 'ID' %} | +{% trans 'Username' %} | +{% trans 'Status' %} | +
|---|---|---|
|
+ |
+
+
+
+
+
+ |
+
{% trans "On this page you can manage your email lists (Delete, Verify, Add More Emails)." %}
+
+ {% trans "On this page you can manage STMP Host. (SMTP hosts are used to send emails)" %}
+
+ {% trans "On this page you can send emails to the lists you created using SMTP Hosts." %}
+
+ {% trans "All functions related to a particular site." %}
+
+ | {% trans "Resource" %} | +{% trans "Usage" %} | +{% trans "Allowed" %} | +
|---|---|---|
{% trans "FTP" %} |
+ {{ ftpUsed }} | +{{ ftpTotal }} | +
{% trans "Databases" %} |
+ {{ databasesUsed }} | +{{ databasesTotal }} | +
{% trans "Disk Usage" %} |
+ {{ diskInMB }} (MB) | +{{ diskInMBTotal }} (MB) | +
{% trans "Bandwidth Usage" %} |
+ {{ bwInMB }} (MB) | +{{ bwInMBTotal }} (MB) | +
+
+
+
+
+
+ {% trans "Create Lists" %}
+
+
+
+
+
+ {% trans "Manage Lists" %}
+
+
+
+
+
+ {% trans "SMTP Hosts" %}
+
+
+
+
+
+ {% trans "Compose" %}
+
+
+
+
+
+ {% trans "Send Emails" %}
+
+
+
+ {{ domain }}
+