def wrapped(message, host=None, address=None):
"""processes forwarding rules, and run the handler
in the case of error, send a bounce email
"""
try:
for rule in django_settings.LAMSON_FORWARD:
if re.match(rule['pattern'], message.base['to']):
relay = Relay(host=rule['host'],
port=rule['port'],
debug=1)
relay.deliver(message)
return
except AttributeError:
pass
error = None
try:
reply_address = ReplyAddress.objects.get(
address=address, allowed_from_email=message.From)
#here is the business part of this function
func(from_address=message.From,
subject_line=message['Subject'],
parts=get_parts(message),
reply_address_object=reply_address)
except ReplyAddress.DoesNotExist:
error = _("You were replying to an email address\
unknown to the system or you were replying from a different address from the one where you\
received the notification.")
except Exception, e:
import sys
sys.stderr.write(str(e))
import traceback
sys.stderr.write(traceback.format_exc())
def PROCESS(message, address = None, host = None):
"""handler to process the emailed message
and make a post to askbot based on the contents of
the email, including the text body and the file attachments"""
try:
for rule in django_settings.LAMSON_FORWARD:
if re.match(rule['pattern'], message.base['to']):
relay = Relay(host=rule['host'],
port=rule['port'], debug=1)
relay.deliver(message)
return
except AttributeError:
pass
error = None
try:
reply_address = ReplyAddress.objects.get(
address = address,
allowed_from_email = message.From
)
parts = get_parts(message)
if reply_address.was_used:
reply_address.edit_post(parts)
else:
reply_address.create_reply(parts)
except ReplyAddress.DoesNotExist:
error = _("You were replying to an email address\
unknown to the system or you were replying from a different address from the one where you\
received the notification.")
except Exception, e:
import sys
sys.stderr.write(str(e))
import traceback
sys.stderr.write(traceback.format_exc())
def PROCESS(message, address = None, host = None):
"""handler to process the emailed message
and make a post to askbot based on the contents of
the email, including the text body and the file attachments"""
try:
for rule in settings.LAMSON_FORWARD:
if re.match(rule['pattern'], message.base['to']):
relay = Relay(host=rule['host'],
port=rule['port'], debug=1)
relay.deliver(message)
return
except AttributeError:
pass
error = None
try:
reply_address = ReplyAddress.objects.get(
address = address,
allowed_from_email = message.From
)
separator = _("======= Reply above this line. ====-=-=")
parts = get_body(message).split(separator)
attachments = get_attachments(message)
if len(parts) != 2 :
error = _("Your message was malformed. Please make sure to qoute \
the original notification you received at the end of your reply.")
else:
reply_part = parts[0]
reply_part = '\n'.join(reply_part.splitlines(True)[:-3])
#the function below actually posts to the forum
if reply_address.was_used:
reply_address.edit_post(
reply_part.strip(),
attachments = attachments
)
else:
reply_address.create_reply(
reply_part.strip(),
attachments = attachments
)
except ReplyAddress.DoesNotExist:
error = _("You were replying to an email address\
unknown to the system or you were replying from a different address from the one where you\
received the notification.")
except Exception, e:
import sys
sys.stderr.write(str(e))
import traceback
sys.stderr.write(traceback.format_exc())
def wrapped(message, host = None, address = None):
"""processes forwarding rules, and run the handler
in the case of error, send a bounce email
"""
try:
for rule in django_settings.LAMSON_FORWARD:
if re.match(rule['pattern'], message.base['to']):
relay = Relay(host=rule['host'],
port=rule['port'], debug=1)
relay.deliver(message)
return
except AttributeError:
pass
error = None
try:
reply_address = ReplyAddress.objects.get(
address = address,
allowed_from_email = message.From
)
#here is the business part of this function
parts = get_parts(message)
for part_type, content in parts:
if part_type == 'body':
print '==============================='
print 'message :', content
break
else:
continue
func(
from_address = message.From,
subject_line = message['Subject'],
parts = parts,
reply_address_object = reply_address
)
except ReplyAddress.DoesNotExist:
error = _("You were replying to an email address\
unknown to the system or you were replying from a different address from the one where you\
received the notification.")
except Exception, e:
import sys
sys.stderr.write(str(e))
import traceback
sys.stderr.write(traceback.format_exc())
def wrapped(message, host = None, address = None):
"""processes forwarding rules, and run the handler
in the case of error, send a bounce email
"""
try:
for rule in django_settings.LAMSON_FORWARD:
if re.match(rule['pattern'], message.base['to']):
relay = Relay(host=rule['host'],
port=rule['port'], debug=1)
relay.deliver(message)
return
except AttributeError:
pass
error = None
try:
reply_address = ReplyAddress.objects.get(address = address)
#allowed_from_email = message.From <- used to have this filter too
#here is the business part of this function
parts = get_parts(message)
func(
from_address = message.From,
subject_line = message['Subject'],
parts = parts,
reply_address_object = reply_address
)
except ReplyAddress.DoesNotExist:
error = _("You were replying to an email address\
unknown to the system or you were replying from a different address from the one where you\
received the notification.")
except Exception as e:
import sys
sys.stderr.write(unicode(e).encode('utf-8'))
import traceback
sys.stderr.write(unicode(traceback.format_exc()).encode('utf-8'))
if error is not None:
from askbot.mail.messages import ReplyByEmailError
email = ReplyByEmailError({'error': error})
email.send([message.From])
def wrapped(message, host=None, address=None):
"""processes forwarding rules, and run the handler
in the case of error, send a bounce email
"""
try:
for rule in django_settings.LAMSON_FORWARD:
if re.match(rule['pattern'], message.base['to']):
relay = Relay(host=rule['host'],
port=rule['port'],
debug=1)
relay.deliver(message)
return
except AttributeError:
pass
error = None
try:
reply_address = ReplyAddress.objects.get(address=address)
# allowed_from_email = message.From <- used to have this filter too
# here is the business part of this function
parts = get_parts(message)
func(from_address=message.From,
subject_line=message['Subject'],
parts=parts,
reply_address_object=reply_address)
except ReplyAddress.DoesNotExist:
error = _("You were replying to an email address\
unknown to the system or you were replying from a different address from the one where you\
received the notification.")
except Exception:
import traceback
traceback.print_exc()
if error is not None:
from askbot.mail.messages import ReplyByEmailError
email = ReplyByEmailError({'error': error})
email.send([message.From])
def PROCESS(message, address = None, host = None):
try:
for rule in settings.LAMSON_FORWARD:
if re.match(rule['pattern'], message.base['to']):
relay = Relay(host=rule['host'],
port=rule['port'], debug=1)
relay.deliver(message)
return
except AttributeError:
pass
error = None
try:
reply_address = ReplyAddress.objects.get_unused(address, message.From)
separator = _("======= Reply above this line. ====-=-=")
parts = message.body().split(separator)
if len(parts) != 2 :
error = _("Your message was malformed. Please make sure to qoute \
the original notification you received at the end of your reply.")
else:
reply_part = parts[0]
reply_part = '\n'.join(reply_part.splitlines(True)[:-3])
reply_address.create_reply(reply_part.strip())
except ReplyAddress.DoesNotExist:
error = _("You were replying to an email address\
unknown to the system or you were replying from a different address from the one where you\
received the notification.")
if error is not None:
from askbot.utils import mail
from django.template import Context
from askbot.skins.loaders import get_template
template = get_template('reply_by_email_error.html')
body_text = template.render(Context({'error':error}))
mail.send_mail(
subject_line = "Error posting your reply",
body_text = body_text,
recipient_list = [message.From],
)
def _settings_loader():
from lamson.routing import Router
from lamson.server import Relay, SMTPReceiver
from lamson import view, queue
import logging
import logging.config
import jinja2
settings = Settings()
for attr_name in dir(django_settings):
if attr_name.startswith("LAMSON_"):
setattr(settings,
attr_name.split("LAMSON_")[1].lower(),
getattr(django_settings, attr_name))
#logging.config.fileConfig("logging.conf")
# the relay host to actually send the final message to
#TODO make debug a parameter to the command
if hasattr(settings, 'relay_config'):
settings.relay = Relay(host=settings.relay_config['host'],
port=settings.relay_config['port'],
debug=1)
# where to listen for incoming messages
settings.receiver = SMTPReceiver(settings.receiver_config['host'],
settings.receiver_config['port'])
Router.defaults(**settings.router_defaults)
Router.load(settings.handlers)
#TODO make this a parameter to the command
Router.RELOAD = True
#TODO make run a parameter to the command
Router.UNDELIVERABLE_QUEUE = queue.Queue("run/undeliverable")
if hasattr(settings, 'template_config'):
view.LOADER = jinja2.Environment(
loader=jinja2.PackageLoader(settings.template_config['dir'],
settings.template_config['module']))
return settings
import os
import logging
import logging.config
from django.conf import settings
from lamson.routing import Router
from lamson.server import Relay, SMTPReceiver
from lamson import queue
import ecs.ecsmail.monkey
relay = Relay(host= settings.EMAIL_HOST, port= settings.EMAIL_PORT, starttls= settings.EMAIL_USE_TLS,
username = settings.EMAIL_HOST_USER, password= settings.EMAIL_HOST_PASSWORD)
# Monkey Patch deliver so it will use ecsmail settings (and django backends)
relay.deliver = ecs.ecsmail.monkey.deliver
receiver = SMTPReceiver(settings.ECSMAIL ['listen'], settings.ECSMAIL ['port'])
Router.defaults(host= '.+')
Router.load(settings.ECSMAIL ['handlers'])
Router.RELOAD = False
Router.UNDELIVERABLE_QUEUE = queue.Queue(settings.ECSMAIL ['queue_dir'])
from config import settings
from lamson.routing import Router
from lamson.server import Relay, SMTPReceiver, QueueReceiver
from lamson import view, queue
import logging
import logging.config
import jinja2
logging.config.fileConfig("config/logging.conf")
# the relay host to actually send the final message to
settings.relay = Relay(host=settings.relay_config['host'],
port=settings.relay_config['port'],
debug=1)
# where to listen for incoming messages
#settings.receiver = SMTPReceiver(settings.receiver_config['host'],
# settings.receiver_config['port'])
# b0nd - include the maildir option we've set in settings.py
settings.receiver = QueueReceiver(settings.receiver_config['maildir'])
Router.defaults(**settings.router_defaults)
Router.load(settings.handlers)
Router.RELOAD = True
Router.UNDELIVERABLE_QUEUE = queue.Queue("run/undeliverable")
view.LOADER = jinja2.Environment(loader=jinja2.PackageLoader(
settings.template_config['dir'], settings.template_config['module']))
PERMALINK_POST = 'http://%s/thread?tid=%s&post_id=%s'
HTML_SUBHEAD = '<div style="border-top:solid thin;padding-top:5px;margin-top:10px">'
HTML_SUBTAIL = '</div>'
if WEBSITE == 'murmur':
PLAIN_SUBHEAD = '***\nMurmur\n'
elif WEBSITE == 'squadbox':
PLAIN_SUBHEAD = '***\nSquadbox\n'
PLAIN_SUBTAIL = '\n***\n'
RESERVED = ['+create', '+activate', '+deactivate', '+subscribe', '+unsubscribe', '+admins', '+info', 'help', 'no-reply', 'all', POST_SUFFIX, FOLLOW_SUFFIX, UNFOLLOW_SUFFIX, MUTE_SUFFIX, UNMUTE_SUFFIX, UPVOTE_SUFFIX, DOWNVOTE_SUFFIX, FETCH_SUFFIX]
relay_mailer = Relay(host=relay_config['host'], port=relay_config['port'], debug=1)
ALLOWED_MIMETYPES = ["image/jpeg", "image/bmp", "image/gif", "image/png", "application/pdf", "application/mspowerpoint",
"application/x-mspowerpoint", "application/powerpoint", "application/vnd.ms-powerpoint",
"application/msword", "text/plain", "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
"application/vnd.ms-excel", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
"application/vnd.openxmlformats-officedocument.presentationml.presentation", "application/pkcs7-signature"]
ALLOWED_MIMETYPES_STR = 'images (JPEG, BMP, GIF, PNG), PDFs, and Microsoft Office (Word, Excel, Powerpoint) files'
MAX_ATTACHMENT_SIZE = 10000000
# for creating squadbox ps
SQUADBOX_REASONS = {
'whitelist' : "This message was auto-approved because the sender %s is on your whitelist.",
'blacklist' : "This message was auto-rejected because the sender %s is on your blacklist.",
from lamson.server import Relay, SMTPReceiver
from lamson import view, queue
import logging
import logging.config
import jinja2
# Uncomment to persist state between runs:
#from lamson.routing import ShelveStorage
#Router.STATE_STORE = ShelveStorage("run/states")
logging.config.fileConfig("config/logging.conf")
# the relay host to actually send the final message to
settings.relay = Relay(host=settings.relay_config['host'],
port=settings.relay_config['port'],
username=settings.relay_config.get('username', None),
password=settings.relay_config.get('password', None),
debug=1)
# where to listen for incoming messages
settings.receiver = SMTPReceiver(settings.receiver_config['host'],
settings.receiver_config['port'])
Router.defaults(**settings.router_defaults)
Router.load(settings.handlers)
Router.RELOAD = True
Router.UNDELIVERABLE_QUEUE = queue.Queue("run/undeliverable")
view.LOADER = jinja2.Environment(loader=jinja2.PackageLoader(
settings.template_config['dir'], settings.template_config['module']))
