File: //proc/self/root/usr/local/CyberCP/emailMarketing/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()
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 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()
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 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)
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 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()
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 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)
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 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 as 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)
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()
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 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
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 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)
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 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 as 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 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.')