Merge lp:~openerp-dev/openobject-addons/trunk-campaign-tracking-jri into lp:openobject-addons

[Juan Rial (OpenERP)]

Tracking & improved reporting for marketing campaigns.

[lp:~openerp-dev/openobject-addons/trunk-campaign-tracking-jri]

7086. By Juan Rial (OpenERP) on 2012-07-23

Removed some print statements

7087. By Juan Rial (OpenERP) on 2012-07-23

Change one small customer-specific piece of code

7088. By Juan Rial (OpenERP) on 2012-08-27

Marketing Campaign: separate return path from sender and fix small bug when running in normal mode

Unmerged revisions

7088. By Juan Rial (OpenERP) on 2012-08-27

Marketing Campaign: separate return path from sender and fix small bug when running in normal mode

7087. By Juan Rial (OpenERP) on 2012-07-23

Change one small customer-specific piece of code

7086. By Juan Rial (OpenERP) on 2012-07-23

Removed some print statements

7085. By Juan Rial (OpenERP) on 2012-07-23

Marketing Campaign: tracking

=== modified file 'marketing_campaign/__init__.py'
--- marketing_campaign/__init__.py	2011-01-14 00:11:01 +0000
+++ marketing_campaign/__init__.py	2012-08-27 10:03:27 +0000
@@ -20,6 +20,9 @@
 ##############################################################################
 
 import marketing_campaign
+import email_template
+import ir_mail_server
+import mail_message
 import res_partner
 import report
 
 
=== modified file 'marketing_campaign/__openerp__.py'
--- marketing_campaign/__openerp__.py	2012-08-22 13:02:32 +0000
+++ marketing_campaign/__openerp__.py	2012-08-27 10:03:27 +0000
@@ -57,15 +57,29 @@
     'website': 'http://www.openerp.com',
     'data': [
         'marketing_campaign_view.xml',
+        'email_template_view.xml',
         'marketing_campaign_data.xml',
         'marketing_campaign_workflow.xml',
         'res_partner_view.xml',
         'report/campaign_analysis_view.xml',
+<<<<<<< TREE
         'security/marketing_campaign_security.xml',
         'security/ir.model.access.csv'
     ],
     'demo': ['marketing_campaign_demo.xml'],
     'test': ['test/marketing_campaign.yml'],
+=======
+        'report/campaign_tracking_view.xml',
+        "security/marketing_campaign_security.xml",
+        "security/ir.model.access.csv"
+    ],
+    'demo_xml': [
+        'marketing_campaign_demo.xml',
+    ],
+    'test': [
+        'test/marketing_campaign.yml',
+     ],
+>>>>>>> MERGE-SOURCE
     'installable': True,
     'auto_install': False,
     'certificate': '00421723279617928365',
 
=== added file 'marketing_campaign/email_template.py'
--- marketing_campaign/email_template.py	1970-01-01 00:00:00 +0000
+++ marketing_campaign/email_template.py	2012-08-27 10:03:27 +0000
@@ -0,0 +1,212 @@
+import netsvc
+import base64
+from osv import osv
+from osv import fields
+import re
+import urllib
+
+
+# Helper functions to transform template fields for campaign tracking
+def insert_html_tracking(template, track_str, get_char):
+    retval = template['body_html']
+    if 'tracker_url' in template:
+        re_str = ['href="([^"]*)"', '(?:img[^<>]*)src="([^"]*)"']
+        for i in range(2):
+            m = re.compile(re_str[i]).finditer(retval)
+            startpos = 0
+            body_html = ''
+            for x in m:
+                body_html += retval[startpos:x.start(1)] \
+                        + template['tracker_url'] + get_char + 'url=' \
+                        + urllib.quote_plus(x.group(1)) \
+                        + '&' + track_str
+                startpos = x.end(1)
+            body_html += retval[startpos:]
+            retval = body_html
+    else:
+        re_str = [
+                'href="([^"]*\?[^"]*)"',
+                'href="([^"\?]*)"',
+                '(img[^<>]*)src="([^"]*\?[^"]*)"',
+                '(img[^<>]*)src="([^"\?]*)"',
+        ]
+        get_chars = ['&', '?'] * 2
+        for i in range(0, 2):
+            expr = re.compile(re_str[i])
+            retval = expr.sub('href="\\1' + get_chars[i] + track_str + '"', retval)
+        for i in range(2, 4):
+            expr = re.compile(re_str[i])
+            retval = expr.sub('\\1 src="\\2' + get_chars[i] + track_str + '"', retval)
+    return retval
+
+
+def insert_text_tracking(template, track_str, get_char):
+    retval = template['body_text']
+    if 'tracker_url' in template:
+        expr1 = re.compile('http(s?://([^\s]*?))([,\.]?\s)')
+        m = expr1.finditer(retval)
+        startpos = 0
+        body_text = ''
+        for x in m:
+            body_text += retval[startpos:x.start()] \
+                    + template['tracker_url'] + get_char + 'url=' \
+                    + urllib.quote_plus('http' + x.group(1)) \
+                    + '&' + track_str + x.group(3)
+            startpos = x.end()
+        body_text += retval[startpos:]
+        retval = body_text
+    else:
+        re_str = ['http(s?://([^\s]*?\?[^\s]*?))([,\.]?\s)', 'http(s?://([^\s\?]*?))([,\.]?\s)']
+        get_chars = ['&', '?']
+        for i in range(2):
+            expr = re.compile(re_str[i])
+            retval = expr.sub('http\\1' + get_chars[i] + track_str + '\\3', retval)
+    return retval
+# End helper functions for campaign tracking
+
+
+class email_template(osv.osv):
+    _name = 'email.template'
+    _inherit = 'email.template'
+
+    def generate_email(self, cr, uid, template_id, res_id, context=None):
+        """Generates an email from the template for given (model, res_id) pair.
+
+           :param template_id: id of the template to render.
+           :param res_id: id of the record to use for rendering the template (model
+                          is taken from template definition)
+           :returns: a dict containing all relevant fields for creating a new
+                     mail.message entry, with the addition one additional
+                     special key ``attachments`` containing a list of
+        """
+        if context is None:
+            context = {}
+        values = {
+                  'subject': False,
+                  'body_text': False,
+                  'body_html': False,
+                  'email_from': False,
+                  'return_path': False,  # MODIF
+                  'email_to': False,
+                  'email_cc': False,
+                  'email_bcc': False,
+                  'reply_to': False,
+                  'auto_delete': False,
+                  'model': False,
+                  'res_id': False,
+                  'mail_server_id': False,
+                  'attachments': False,
+                  'attachment_ids': False,
+                  'message_id': False,
+                  'state': 'outgoing',
+                  'subtype': 'plain',
+        }
+        if not template_id:
+            return values
+
+        report_xml_pool = self.pool.get('ir.actions.report.xml')
+        template = self.get_email_template(cr, uid, template_id, res_id, context)
+
+        # BEGIN MODIF
+        fieldnames = ['subject', 'body_text', 'body_html', 'email_from',
+                      'email_to', 'email_cc', 'email_bcc', 'reply_to',
+                      'return_path', 'message_id']
+        render_src = {}
+        for field in fieldnames:
+            render_src[field] = getattr(template, field)
+        if 'campaign_track_str' in context \
+                and 'activity_track_str' in context \
+                and 'res_track_str' in context:
+            track_str = 'c=' + context['campaign_track_str'] \
+                    + '&a=' + context['activity_track_str'] \
+                    + '&r=' + context['res_track_str']
+            get_char = None
+            if 'tracker_url' in template:
+                if re.search('\?', template['tracker_url']):
+                    get_char = '&'
+                else:
+                    get_char = '?'
+
+            # Body text
+            if 'body_text' in template and template['body_text']:
+                render_src['body_text'] = insert_text_tracking(template, track_str, get_char)
+
+            # Body HTML
+            if 'body_html' in template and template['body_html']:
+                render_src['body_html'] = insert_html_tracking(template, track_str, get_char)
+
+        for field in fieldnames:
+            values[field] = self.render_template(cr, uid, render_src.get(field),
+                                                 template.model, res_id, context=context) \
+                                                 or False
+
+        # Variable Sender
+        if values['return_path']:
+            bounce_split = values['return_path'].split('@')
+        else:
+            bounce_split = values['email_from'].split('@')
+        # If we have campaign tracking info
+        if 'campaign_track_str' in context \
+            and 'activity_track_str' in context \
+            and 'res_track_str' in context:
+            values['return_path'] = bounce_split[0] + '+' \
+                    + context['campaign_track_str'] + '-' \
+                    + context['activity_track_str'] + '-' \
+                    + context['res_track_str'] \
+                    + '@' + bounce_split[1]
+        # If we don't have campaign tracking info
+        else:
+            values['return_path'] = bounce_split[0] + '+' \
+                    + re.sub('@', '=', values['email_to']) \
+                    + '@' + bounce_split[1]
+        # END MODIF
+
+        if values['body_html']:
+            values.update(subtype='html')
+
+        if template.user_signature:
+            signature = self.pool.get('res.users').browse(cr, uid, uid, context).signature
+            values['body_text'] += '\n\n' + signature
+
+        values.update(mail_server_id=template.mail_server_id.id or False,
+                      auto_delete=template.auto_delete,
+                      model=template.model,
+                      res_id=res_id or False)
+
+        attachments = {}
+        # Add report as a Document
+        if template.report_template:
+            report_name = self.render_template(cr, uid, template.report_name, template.model, res_id, context=context)
+            report_service = 'report.' + report_xml_pool.browse(cr, uid, template.report_template.id, context).report_name
+            # Ensure report is rendered using template's language
+            ctx = context.copy()
+            if template.lang:
+                ctx['lang'] = self.render_template(cr, uid, template.lang, template.model, res_id, context)
+            service = netsvc.LocalService(report_service)
+            (result, format) = service.create(cr, uid, [res_id], {'model': template.model}, ctx)
+            result = base64.b64encode(result)
+            if not report_name:
+                report_name = report_service
+            ext = "." + format
+            if not report_name.endswith(ext):
+                report_name += ext
+            attachments[report_name] = result
+
+        # Add document attachments
+        for attach in template.attachment_ids:
+            # keep the bytes as fetched from the db, base64 encoded
+            attachments[attach.datas_fname] = attach.datas
+
+        values['attachments'] = attachments
+        return values
+
+    _columns = {
+        'tracker_url': fields.char('Tracker URL', None, help='The URL of the campaign tracker'),
+        'return_path': fields.char('Return path', None, help='Email address to send mail delivery reports to'),
+     }
+
+    _defaults = {
+        'model_id': lambda obj, cr, uid, context: context.get('object_id',False),
+    }
+
+email_template()
 
=== added file 'marketing_campaign/email_template_view.xml'
--- marketing_campaign/email_template_view.xml	1970-01-01 00:00:00 +0000
+++ marketing_campaign/email_template_view.xml	2012-08-27 10:03:27 +0000
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<openerp>
+    <data>
+
+        <record model="ir.ui.view" id="email_template_form_inherit">
+            <field name="name">email.template.form</field>
+            <field name="inherit_id" ref='email_template.email_template_form' />
+            <field name="model">email.template</field>
+            <field name="type">form</field>
+            <field name="arch" type="xml">
+                <field name="reply_to" position="after">
+                    <field name="return_path"/>
+                </field>
+                <field name="track_campaign_item" position="after">
+                    <field name="tracker_url" />
+                </field>
+            </field>
+        </record>
+    </data>
+</openerp>
 \ No newline at end of file
 
=== added file 'marketing_campaign/ir_mail_server.py'
--- marketing_campaign/ir_mail_server.py	1970-01-01 00:00:00 +0000
+++ marketing_campaign/ir_mail_server.py	2012-08-27 10:03:27 +0000
@@ -0,0 +1,260 @@
+from email.MIMEText import MIMEText
+from email.MIMEBase import MIMEBase
+from email.MIMEMultipart import MIMEMultipart
+from email.Charset import Charset
+from email.Header import Header
+from email.Utils import formatdate, make_msgid, COMMASPACE
+from email import Encoders
+import logging
+import re
+# import smtplib
+# import threading
+
+# Just here to satisfy code requirements, but unmodified from original
+from osv import osv
+# from osv import fields
+# from openerp.tools.translate import _
+from openerp.tools import html2text
+import openerp.tools as tools
+
+# ustr was originally from tools.misc.
+# it is moved to loglevels until we refactor tools.
+from openerp.loglevels import ustr
+
+_logger = logging.getLogger(__name__)
+name_with_email_pattern = re.compile(r'("[^<@>]+")\s*<([^ ,<@]+@[^> ,]+)>')
+address_pattern = re.compile(r'([^ ,<@]+@[^> ,]+)')
+
+
+def try_coerce_ascii(string_utf8):
+    """Attempts to decode the given utf8-encoded string
+       as ASCII after coercing it to UTF-8, then return
+       the confirmed 7-bit ASCII string.
+
+       If the process fails (because the string
+       contains non-ASCII characters) returns ``None``.
+    """
+    try:
+        string_utf8.decode('ascii')
+    except UnicodeDecodeError:
+        return
+    return string_utf8
+
+
+def extract_rfc2822_addresses(text):
+    """Returns a list of valid RFC2822 addresses
+       that can be found in ``source``, ignoring
+       malformed ones and non-ASCII ones.
+    """
+    if not text:
+        return []
+    candidates = address_pattern.findall(tools.ustr(text).encode('utf-8'))
+    return filter(try_coerce_ascii, candidates)
+
+
+def encode_header_param(param_text):
+    """Returns an appropriate RFC2047 encoded representation of the given
+       header parameter value, suitable for direct assignation as the
+       param value (e.g. via Message.set_param() or Message.add_header())
+       RFC2822 assumes that headers contain only 7-bit characters,
+       so we ensure it is the case, using RFC2047 encoding when needed.
+
+       :param param_text: unicode or utf-8 encoded string with header value
+       :rtype: string
+       :return: if ``param_text`` represents a plain ASCII string,
+                return the same 7-bit string, otherwise returns an
+                ASCII string containing the RFC2047 encoded text.
+    """
+    # For details see the encode_header() method that uses the same logic
+    if not param_text:
+        return ""
+    param_text_utf8 = tools.ustr(param_text).encode('utf-8')
+    param_text_ascii = try_coerce_ascii(param_text_utf8)
+    return param_text_ascii if param_text_ascii\
+         else Charset('utf8').header_encode(param_text_utf8)
+
+
+def encode_rfc2822_address_header(header_text):
+    """If ``header_text`` contains non-ASCII characters,
+       attempts to locate patterns of the form
+       ``"Name" <address@domain>`` and replace the
+       ``"Name"`` portion by the RFC2047-encoded
+       version, preserving the address part untouched.
+    """
+    header_text_utf8 = tools.ustr(header_text).encode('utf-8')
+    header_text_ascii = try_coerce_ascii(header_text_utf8)
+    if header_text_ascii:
+        return header_text_ascii
+    # non-ASCII characters are present, attempt to
+    # replace all "Name" patterns with the RFC2047-
+    # encoded version
+
+    def replace(match_obj):
+        name, email = match_obj.group(1), match_obj.group(2)
+        name_encoded = str(Header(name, 'utf-8'))
+        return "%s <%s>" % (name_encoded, email)
+    header_text_utf8 = name_with_email_pattern.sub(replace,
+                                                   header_text_utf8)
+    # try again after encoding
+    header_text_ascii = try_coerce_ascii(header_text_utf8)
+    if header_text_ascii:
+        return header_text_ascii
+    # fallback to extracting pure addresses only, which could
+    # still cause a failure downstream if the actual addresses
+    # contain non-ASCII characters
+    return COMMASPACE.join(extract_rfc2822_addresses(header_text_utf8))
+
+
+def encode_header(header_text):
+    """Returns an appropriate representation of the given header value,
+       suitable for direct assignment as a header value in an
+       email.message.Message. RFC2822 assumes that headers contain
+       only 7-bit characters, so we ensure it is the case, using
+       RFC2047 encoding when needed.
+
+       :param header_text: unicode or utf-8 encoded string with header value
+       :rtype: string | email.header.Header
+       :return: if ``header_text`` represents a plain ASCII string,
+                return the same 7-bit string, otherwise returns an email.header.Header
+                that will perform the appropriate RFC2047 encoding of
+                non-ASCII values.
+    """
+    if not header_text:
+        return ""
+    # convert anything to utf-8, suitable for testing ASCIIness, as 7-bit chars are
+    # encoded as ASCII in utf-8
+    header_text_utf8 = tools.ustr(header_text).encode('utf-8')
+    header_text_ascii = try_coerce_ascii(header_text_utf8)
+    # if this header contains non-ASCII characters,
+    # we'll need to wrap it up in a message.header.Header
+    # that will take care of RFC2047-encoding it as
+    # 7-bit string.
+    return header_text_ascii if header_text_ascii\
+         else Header(header_text_utf8, 'utf-8')
+# End "Just here ..."
+
+
+class ir_mail_server(osv.osv):
+    _name = "ir.mail_server"
+    _inherit = "ir.mail_server"
+
+    # _columns = {
+    #     'variable_sender': fields.boolean('Variable Sender'),
+    # }
+
+    # MODIF signature
+    def build_email(self, email_from, email_to, subject, body, email_cc=None, email_bcc=None, reply_to=False,
+               attachments=None, message_id=None, references=None, object_id=False, subtype='plain', headers=None,
+               body_alternative=None, subtype_alternative='plain', return_path=False):
+        """Constructs an RFC2822 email.message.Message object based on the keyword arguments passed, and returns it.
+
+           :param string email_from: sender email address
+           :param list email_to: list of recipient addresses (to be joined with commas)
+           :param string subject: email subject (no pre-encoding/quoting necessary)
+           :param string body: email body, of the type ``subtype`` (by default, plaintext).
+                               If html subtype is used, the message will be automatically converted
+                               to plaintext and wrapped in multipart/alternative, unless an explicit
+                               ``body_alternative`` version is passed.
+           :param string body_alternative: optional alternative body, of the type specified in ``subtype_alternative``
+           :param string reply_to: optional value of Reply-To header
+           :param string object_id: optional tracking identifier, to be included in the message-id for
+                                    recognizing replies. Suggested format for object-id is "res_id-model",
+                                    e.g. "12345-crm.lead".
+           :param string subtype: optional mime subtype for the text body (usually 'plain' or 'html'),
+                                  must match the format of the ``body`` parameter. Default is 'plain',
+                                  making the content part of the mail "text/plain".
+           :param string subtype_alternative: optional mime subtype of ``body_alternative`` (usually 'plain'
+                                              or 'html'). Default is 'plain'.
+           :param list attachments: list of (filename, filecontents) pairs, where filecontents is a string
+                                    containing the bytes of the attachment
+           :param list email_cc: optional list of string values for CC header (to be joined with commas)
+           :param list email_bcc: optional list of string values for BCC header (to be joined with commas)
+           :param dict headers: optional map of headers to set on the outgoing mail (may override the
+                                other headers, including Subject, Reply-To, Message-Id, etc.)
+           :rtype: email.message.Message (usually MIMEMultipart)
+           :return: the new RFC2822 email message
+        """
+        email_from = email_from or tools.config.get('email_from')
+        assert email_from, "You must either provide a sender address explicitly or configure "\
+                           "a global sender address in the server configuration or with the "\
+                           "--email-from startup parameter."
+
+        # Note: we must force all strings to to 8-bit utf-8 when crafting message,
+        #       or use encode_header() for headers, which does it automatically.
+
+        headers = headers or {}  # need valid dict later
+
+        if not email_cc:
+            email_cc = []
+        if not email_bcc:
+            email_bcc = []
+        if not body:
+            body = u''
+
+        email_body_utf8 = ustr(body).encode('utf-8')
+        email_text_part = MIMEText(email_body_utf8, _subtype=subtype, _charset='utf-8')
+        msg = MIMEMultipart()
+
+        if not message_id:
+            if object_id:
+                message_id = tools.generate_tracking_message_id(object_id)
+            else:
+                message_id = make_msgid()
+        msg['Message-Id'] = encode_header(message_id)
+        if references:
+            msg['references'] = encode_header(references)
+        msg['Subject'] = encode_header(subject)
+        msg['From'] = encode_rfc2822_address_header(email_from)
+        # del msg['Reply-To']  # MODIF: unnecessary., given what preceeds and what follows.
+        if reply_to:
+            msg['Reply-To'] = encode_rfc2822_address_header(reply_to)
+        else:
+            msg['Reply-To'] = msg['From']
+        # BEGIN MODIF
+        if return_path:
+            msg['Return-Path'] = encode_rfc2822_address_header(return_path)
+        else:
+            msg['Return-Path'] = msg['From']
+        # END MODIF
+        msg['To'] = encode_rfc2822_address_header(COMMASPACE.join(email_to))
+        if email_cc:
+            msg['Cc'] = encode_rfc2822_address_header(COMMASPACE.join(email_cc))
+        if email_bcc:
+            msg['Bcc'] = encode_rfc2822_address_header(COMMASPACE.join(email_bcc))
+        msg['Date'] = formatdate()
+        # Custom headers may override normal headers or provide additional ones
+        for key, value in headers.iteritems():
+            msg[ustr(key).encode('utf-8')] = encode_header(value)
+
+        if subtype == 'html' and not body_alternative and html2text:
+            # Always provide alternative text body ourselves if possible.
+            text_utf8 = tools.html2text(email_body_utf8.decode('utf-8')).encode('utf-8')
+            alternative_part = MIMEMultipart(_subtype="alternative")
+            alternative_part.attach(MIMEText(text_utf8, _charset='utf-8', _subtype='plain'))
+            alternative_part.attach(email_text_part)
+            msg.attach(alternative_part)
+        elif body_alternative:
+            # Include both alternatives, as specified, within a multipart/alternative part
+            alternative_part = MIMEMultipart(_subtype="alternative")
+            body_alternative_utf8 = ustr(body_alternative).encode('utf-8')
+            alternative_body_part = MIMEText(body_alternative_utf8, _subtype=subtype_alternative, _charset='utf-8')
+            alternative_part.attach(alternative_body_part)
+            alternative_part.attach(email_text_part)
+            msg.attach(alternative_part)
+        else:
+            msg.attach(email_text_part)
+
+        if attachments:
+            for (fname, fcontent) in attachments:
+                filename_rfc2047 = encode_header_param(fname)
+                part = MIMEBase('application', "octet-stream")
+
+                # The default RFC2231 encoding of Message.add_header() works in Thunderbird but not GMail
+                # so we fix it by using RFC2047 encoding for the filename instead.
+                part.set_param('name', filename_rfc2047)
+                part.add_header('Content-Disposition', 'attachment', filename=filename_rfc2047)
+
+                part.set_payload(fcontent)
+                Encoders.encode_base64(part)
+                msg.attach(part)
+        return msg
 
=== added file 'marketing_campaign/mail_message.py'
--- marketing_campaign/mail_message.py	1970-01-01 00:00:00 +0000
+++ marketing_campaign/mail_message.py	2012-08-27 10:03:27 +0000
@@ -0,0 +1,365 @@
+import ast
+import base64
+import dateutil.parser
+import email
+import logging
+import re
+import time
+from email.header import decode_header
+from email.message import Message
+
+import tools
+from osv import osv
+from osv import fields
+# from tools.translate import _
+# from openerp import SUPERUSER_ID
+
+# Just here to satisfy code requirements, but unmodified from original
+_logger = logging.getLogger('mail')
+
+
+def decode(text):
+    """Returns unicode() string conversion of the the given encoded smtp header text"""
+    if text:
+        text = decode_header(text.replace('\r', ''))
+        return ''.join([tools.ustr(x[0], x[1]) for x in text])
+
+
+def to_email(text):
+    """Return a list of the email addresses found in ``text``"""
+    if not text:
+        return []
+    return re.findall(r'([^ ,<@]+@[^> ,]+)', text)
+# End "Just here ..."
+
+
+class mail_message(osv.osv):
+    _name = 'mail.message'
+    _inherit = 'mail.message'
+
+    _columns = {
+        'return_path': fields.char('Return-Path', size=None, readonly=True),
+        'workitem_id': fields.many2one('marketing.campaign.workitem', 'Workitem'),
+    }
+
+    # MODIF signature
+    def schedule_with_attach(self, cr, uid, email_from, email_to, subject, body, model=False, email_cc=None,
+                             email_bcc=None, reply_to=False, attachments=None, message_id=False, references=False,
+                             res_id=False, subtype='plain', headers=None, mail_server_id=False, auto_delete=False,
+                             context=None, return_path=False):
+        """Schedule sending a new email message, to be sent the next time the mail scheduler runs, or
+           the next time :meth:`process_email_queue` is called explicitly.
+
+           :param string email_from: sender email address
+           :param string return_path: bounce return path
+           :param list email_to: list of recipient addresses (to be joined with commas)
+           :param string subject: email subject (no pre-encoding/quoting necessary)
+           :param string body: email body, according to the ``subtype`` (by default, plaintext).
+                               If html subtype is used, the message will be automatically converted
+                               to plaintext and wrapped in multipart/alternative.
+           :param list email_cc: optional list of string values for CC header (to be joined with commas)
+           :param list email_bcc: optional list of string values for BCC header (to be joined with commas)
+           :param string model: optional model name of the document this mail is related to (this will also
+                                be used to generate a tracking id, used to match any response related to the
+                                same document)
+           :param int res_id: optional resource identifier this mail is related to (this will also
+                              be used to generate a tracking id, used to match any response related to the
+                              same document)
+           :param string reply_to: optional value of Reply-To header
+           :param string subtype: optional mime subtype for the text body (usually 'plain' or 'html'),
+                                  must match the format of the ``body`` parameter. Default is 'plain',
+                                  making the content part of the mail "text/plain".
+           :param dict attachments: map of filename to filecontents, where filecontents is a string
+                                    containing the bytes of the attachment
+           :param dict headers: optional map of headers to set on the outgoing mail (may override the
+                                other headers, including Subject, Reply-To, Message-Id, etc.)
+           :param int mail_server_id: optional id of the preferred outgoing mail server for this mail
+           :param bool auto_delete: optional flag to turn on auto-deletion of the message after it has been
+                                    successfully sent (default to False)
+
+        """
+        if context is None:
+            context = {}
+        if attachments is None:
+            attachments = {}
+        attachment_obj = self.pool.get('ir.attachment')
+        for param in (email_to, email_cc, email_bcc):
+            if param and not isinstance(param, list):
+                param = [param]
+        msg_vals = {
+                'subject': subject,
+                'date': time.strftime('%Y-%m-%d %H:%M:%S'),
+                'user_id': uid,
+                'model': model,
+                'res_id': res_id,
+                'body_text': body if subtype != 'html' else False,
+                'body_html': body if subtype == 'html' else False,
+                'email_from': email_from,
+                'return_path': return_path or email_from,  # MODIF
+                'email_to': email_to and ','.join(email_to) or '',
+                'email_cc': email_cc and ','.join(email_cc) or '',
+                'email_bcc': email_bcc and ','.join(email_bcc) or '',
+                'reply_to': reply_to,
+                'message_id': message_id,
+                'references': references,
+                'subtype': subtype,
+                'headers': headers,  # serialize the dict on the fly
+                'mail_server_id': mail_server_id,
+                'state': 'outgoing',
+                'auto_delete': auto_delete
+            }
+        if 'workitem_id' in context and context['workitem_id']:
+            msg_vals.update({'workitem_id': context['workitem_id']})
+        email_msg_id = self.create(cr, uid, msg_vals, context)
+        attachment_ids = []
+        for fname, fcontent in attachments.iteritems():
+            attachment_data = {
+                    'name': fname,
+                    'datas_fname': fname,
+                    'datas': fcontent and fcontent.encode('base64'),
+                    'res_model': self._name,
+                    'res_id': email_msg_id,
+            }
+            if 'default_type' in context:
+                del context['default_type']
+            attachment_ids.append(attachment_obj.create(cr, uid, attachment_data, context))
+        if attachment_ids:
+            self.write(cr, uid, email_msg_id, {'attachment_ids': [(6, 0, attachment_ids)]}, context=context)
+        return email_msg_id
+
+    def parse_message(self, message, save_original=False):
+        """Parses a string or email.message.Message representing an
+           RFC-2822 email, and returns a generic dict holding the
+           message details.
+
+           :param message: the message to parse
+           :type message: email.message.Message | string | unicode
+           :param bool save_original: whether the returned dict
+               should include an ``original`` entry with the base64
+               encoded source of the message.
+           :rtype: dict
+           :return: A dict with the following structure, where each
+                    field may not be present if missing in original
+                    message::
+
+                    { 'message-id': msg_id,
+                      'subject': subject,
+                      'from': from,
+                      'to': to,
+                      'cc': cc,
+                      'headers' : { 'X-Mailer': mailer,
+                                    #.. all X- headers...
+                                  },
+                      'subtype': msg_mime_subtype,
+                      'body_text': plaintext_body
+                      'body_html': html_body,
+                      'attachments': [('file1', 'bytes'),
+                                       ('file2', 'bytes') }
+                       # ...
+                       'original': source_of_email,
+                    }
+        """
+        msg_txt = message
+        if isinstance(message, str):
+            msg_txt = email.message_from_string(message)
+
+        # Warning: message_from_string doesn't always work correctly on unicode,
+        # we must use utf-8 strings here :-(
+        if isinstance(message, unicode):
+            message = message.encode('utf-8')
+            msg_txt = email.message_from_string(message)
+
+        message_id = msg_txt.get('message-id', False)
+        msg = {}
+
+        if save_original:
+            # save original, we need to be able to read the original email sometimes
+            msg['original'] = message.as_string() if isinstance(message, Message) \
+                                                  else message
+            msg['original'] = base64.b64encode(msg['original'])  # binary fields are b64
+
+        if not message_id:
+            # Very unusual situation, be we should be fault-tolerant here
+            message_id = time.time()
+            msg_txt['message-id'] = message_id
+            _logger.info('Parsing Message without message-id, generating a random one: %s', message_id)
+
+        fields = msg_txt.keys()
+        msg['id'] = message_id
+        msg['message-id'] = message_id
+
+        if 'Subject' in fields:
+            msg['subject'] = decode(msg_txt.get('Subject'))
+
+        if 'Content-Type' in fields:
+            msg['content-type'] = msg_txt.get('Content-Type')
+
+        if 'From' in fields:
+            msg['from'] = decode(msg_txt.get('From') or msg_txt.get_unixfrom())
+
+        # MODIF
+        if 'Return-Path' in fields:
+            msg['return_path'] = decode(msg_txt.get('Return-Path')) or msg['from']
+        # END MODIF
+
+        if 'To' in fields:
+            msg['to'] = decode(msg_txt.get('To'))
+
+        if 'Delivered-To' in fields:
+            msg['to'] = decode(msg_txt.get('Delivered-To'))
+
+        if 'CC' in fields:
+            msg['cc'] = decode(msg_txt.get('CC'))
+
+        if 'Cc' in fields:
+            msg['cc'] = decode(msg_txt.get('Cc'))
+
+        if 'Reply-To' in fields:
+            msg['reply'] = decode(msg_txt.get('Reply-To'))
+
+        if 'Date' in fields:
+            date_hdr = decode(msg_txt.get('Date'))
+            msg['date'] = dateutil.parser.parse(date_hdr).strftime("%Y-%m-%d %H:%M:%S")
+
+        if 'Content-Transfer-Encoding' in fields:
+            msg['encoding'] = msg_txt.get('Content-Transfer-Encoding')
+
+        if 'References' in fields:
+            msg['references'] = msg_txt.get('References')
+
+        if 'In-Reply-To' in fields:
+            msg['in-reply-to'] = msg_txt.get('In-Reply-To')
+
+        msg['headers'] = {}
+        msg['subtype'] = 'plain'
+        for item in msg_txt.items():
+            if item[0].startswith('X-'):
+                msg['headers'].update({item[0]: item[1]})
+        if not msg_txt.is_multipart() or 'text/plain' in msg.get('content-type', ''):
+            encoding = msg_txt.get_content_charset()
+            body = msg_txt.get_payload(decode=True)
+            if 'text/html' in msg.get('content-type', ''):
+                msg['body_html'] = body
+                msg['subtype'] = 'html'
+                body = tools.html2plaintext(body)
+            msg['body_text'] = tools.ustr(body, encoding)
+
+        attachments = []
+        if msg_txt.is_multipart() or 'multipart/alternative' in msg.get('content-type', ''):
+            body = ""
+            if 'multipart/alternative' in msg.get('content-type', ''):
+                msg['subtype'] = 'alternative'
+            else:
+                msg['subtype'] = 'mixed'
+            for part in msg_txt.walk():
+                if part.get_content_maintype() == 'multipart':
+                    continue
+
+                encoding = part.get_content_charset()
+                filename = part.get_filename()
+                if part.get_content_maintype()=='text':
+                    content = part.get_payload(decode=True)
+                    if filename:
+                        attachments.append((filename, content))
+                    content = tools.ustr(content, encoding)
+                    if part.get_content_subtype() == 'html':
+                        msg['body_html'] = content
+                        msg['subtype'] = 'html'  # html version prevails
+                        body = tools.ustr(tools.html2plaintext(content))
+                        body = body.replace('&#13;', '')
+                    elif part.get_content_subtype() == 'plain':
+                        body = content
+                elif part.get_content_maintype() in ('application', 'image'):
+                    if filename :
+                        attachments.append((filename,part.get_payload(decode=True)))
+                    else:
+                        res = part.get_payload(decode=True)
+                        body += tools.ustr(res, encoding)
+
+            msg['body_text'] = body
+        msg['attachments'] = attachments
+
+        # for backwards compatibility:
+        msg['body'] = msg['body_text']
+        msg['sub_type'] = msg['subtype'] or 'plain'
+        return msg
+
+    def send(self, cr, uid, ids, auto_commit=False, context=None):
+        """Sends the selected emails immediately, ignoring their current
+           state (mails that have already been sent should not be passed
+           unless they should actually be re-sent).
+           Emails successfully delivered are marked as 'sent', and those
+           that fail to be deliver are marked as 'exception', and the
+           corresponding error message is output in the server logs.
+
+           :param bool auto_commit: whether to force a commit of the message
+                                    status after sending each message (meant
+                                    only for processing by the scheduler),
+                                    should never be True during normal
+                                    transactions (default: False)
+           :return: True
+        """
+        if context is None:
+            context = {}
+        ir_mail_server = self.pool.get('ir.mail_server')
+        self.write(cr, uid, ids, {'state': 'outgoing'}, context=context)
+        for message in self.browse(cr, uid, ids, context=context):
+            try:
+                attachments = []
+                for attach in message.attachment_ids:
+                    attachments.append((attach.datas_fname, base64.b64decode(attach.datas)))
+
+                body = message.body_html if message.subtype == 'html' else message.body_text
+                body_alternative = None
+                subtype_alternative = None
+                if message.subtype == 'html' and message.body_text:
+                    # we have a plain text alternative prepared, pass it to
+                    # build_message instead of letting it build one
+                    body_alternative = message.body_text
+                    subtype_alternative = 'plain'
+
+                msg = ir_mail_server.build_email(
+                    email_from=message.email_from,
+                    return_path=message.return_path,  # MODIF
+                    email_to=to_email(message.email_to),
+                    subject=message.subject,
+                    body=body,
+                    body_alternative=body_alternative,
+                    email_cc=to_email(message.email_cc),
+                    email_bcc=to_email(message.email_bcc),
+                    reply_to=message.reply_to,
+                    attachments=attachments, message_id=message.message_id,
+                    references=message.references,
+                    object_id=message.res_id and ('%s-%s' % (message.res_id,message.model)),
+                    subtype=message.subtype,
+                    subtype_alternative=subtype_alternative,
+                    headers=message.headers and ast.literal_eval(message.headers))
+                res = ir_mail_server.send_email(cr, uid, msg,
+                                                mail_server_id=message.mail_server_id.id,
+                                                context=context)
+                if res:
+                    message.write({'state':'sent', 'message_id': res})
+                else:
+                    message.write({'state':'exception'})
+
+                # if auto_delete=True then delete that sent messages as well as attachments
+                message.refresh()
+                if message.state == 'sent' and message.auto_delete:
+                    self.pool.get('ir.attachment').unlink(cr, uid,
+                                                          [x.id for x in message.attachment_ids \
+                                                                if x.res_model == self._name and \
+                                                                   x.res_id == message.id],
+                                                          context=context)
+                    message.unlink()
+            except Exception:
+                _logger.exception('failed sending mail.message %s', message.id)
+                message.write({'state':'exception'})
+
+            if auto_commit == True:
+                cr.commit()
+        return True
+
+    def create(self, cr, uid, values, context=None):
+        if 'workitem_id' in context:
+            values.update({'workitem_id': context['workitem_id']})
+        return super(mail_message, self).create(cr, uid, values, context)
 
=== modified file 'marketing_campaign/marketing_campaign.py'
--- marketing_campaign/marketing_campaign.py	2012-08-14 14:10:40 +0000
+++ marketing_campaign/marketing_campaign.py	2012-08-27 10:03:27 +0000
@@ -21,7 +21,7 @@
 
 import time
 import base64
-import itertools
+import hashlib
 from datetime import datetime
 from dateutil.relativedelta import relativedelta
 from operator import itemgetter
@@ -44,9 +44,11 @@
 
 DT_FMT = '%Y-%m-%d %H:%M:%S'
 
+
 def dict_map(f, d):
     return dict((k, f(v)) for k,v in d.items())
 
+
 def _find_fieldname(model, field):
     inherit_columns = dict_map(itemgetter(2), model._inherit_fields)
     all_columns = dict(inherit_columns, **model._columns)
@@ -55,6 +57,14 @@
             return fn
     raise ValueError('Field not found: %r' % (field,))
 
+
+def compute_track_str(cr, uid, string, context=None):
+    db_uuid = osv.pooler.get_pool(cr.dbname).get('ir.config_parameter').get_param(cr, uid, 'database.uuid')
+    m = hashlib.md5()
+    m.update(db_uuid + '_' + string)
+    return m.hexdigest()
+
+
 class selection_converter(object):
     """Format the selection in the browse record objects"""
     def __init__(self, value):
@@ -88,6 +98,7 @@
 
     _columns = {
         'name': fields.char('Name', size=64, required=True),
+        'track_str': fields.char('Tracking String', 32),
         'object_id': fields.many2one('ir.model', 'Resource', required=True,
                                       help="Choose the resource on which you want \
 this campaign to be run"),
@@ -128,6 +139,13 @@
         'mode': lambda *a: 'test',
     }
 
+    def create(self, cr, uid, vals, context=None):
+        res_id = super(marketing_campaign, self).create(cr, uid, vals, context)
+        track_str = compute_track_str(cr, uid, self._name + '_' + str(res_id))
+        vals = {'track_str': track_str}
+        self.pool.get(self._name).write(cr, uid, res_id, vals)
+        return res_id
+
     def state_running_set(self, cr, uid, ids, *args):
         # TODO check that all subcampaigns are running
         campaign = self.browse(cr, uid, ids[0])
@@ -386,6 +404,7 @@
 
 marketing_campaign_segment()
 
+
 class marketing_campaign_activity(osv.osv):
     _name = "marketing.campaign.activity"
     _order = "name"
@@ -403,6 +422,7 @@
 
     _columns = {
         'name': fields.char('Name', size=128, required=True),
+        'track_str': fields.char('Tracking String', 32),
         'campaign_id': fields.many2one('marketing.campaign', 'Campaign',
                                             required = True, ondelete='cascade', select=1),
         'object_id': fields.related('campaign_id','object_id',
@@ -417,6 +437,8 @@
                                  "   - resource: the resource object this campaign item represents\n"
                                  "   - transitions: list of campaign transitions outgoing from this activity\n"
                                  "...- re: Python regular expression module"),
+        'parent_response_cond': fields.char('Response to previous action', None),
+        'parent_no_response': fields.boolean('Run only when no response to previous action', help='This does not include "mail sent", "mail opened" or "url viewed" responses.'),
         'type': fields.selection(_action_types, 'Type', required=True,
                                   help="""The type of action to execute when an item enters this activity, such as:
    - Email: send an email using a predefined email template
@@ -446,6 +468,7 @@
     _defaults = {
         'type': lambda *a: 'email',
         'condition': lambda *a: 'True',
+        'parent_no_response': False,
     }
 
     def search(self, cr, uid, args, offset=0, limit=None, order=None,
@@ -479,10 +502,40 @@
         return True
 
     def _process_wi_email(self, cr, uid, activity, workitem, context=None):
-        return self.pool.get('email.template').send_mail(cr, uid,
+        retval = None
+        send_mail = True
+
+        target_model = self.pool.get(activity.object_id['model'])
+        target = target_model.browse(cr, uid, workitem.res_id, context)
+        # TODO: make sure opt_out is called opt_out in all possible mail-receiving models
+        send_mail &= 'opt_out' in target and not target.opt_out
+
+        if activity.campaign_id.partner_field_id:
+            partner_id_field = activity.campaign_id.partner_field_id.name
+            partner = target.__getattr__(partner_id_field)
+            send_mail &= not partner.opt_out
+
+        if send_mail:
+            retval = self.pool.get('email.template').send_mail(cr, uid,
                                             activity.email_template_id.id,
                                             workitem.res_id, context=context)
 
+        if retval:
+            self.pool.get('marketing.campaign.workitem').write(cr, uid, workitem.id, {'mail_sent': True})
+            tracklog_vals = {
+                    'workitem_id': workitem.id,
+                    'activity_id': workitem.activity_id.id,
+                    'res_track_id': workitem.trackitem_id.id,
+                    'mail_message_id': retval,
+                    'log_date': datetime.now().strftime(DT_FMT),
+                    'log_ip': '0.0.0.0',
+                    'log_type': 'mail_sent',
+                    'revenue': 0.0,
+                    'log_url': 'N/A',
+            }
+            self.pool.get('marketing.campaign.tracklog').create(cr, uid, tracklog_vals)
+        return retval
+
     #dead code
     def _process_wi_action(self, cr, uid, activity, workitem, context=None):
         if context is None:
@@ -511,6 +564,26 @@
         workitem = workitem_obj.browse(cr, uid, wi_id, context=context)
         return action(cr, uid, activity, workitem, context=context)
 
+    def onchange_parent_no_response(self, cr, uid, ids, value, context=None):
+        parent_response_cond = None
+        if not value:
+            activities = self.pool.get(self._name).browse(cr, uid, ids, context)
+            if len(activities):
+                parent_response_cond = activities[0].parent_response_cond
+        return {'value': {'parent_response_cond': parent_response_cond}}
+
+    def write(self, cr, uid, ids, vals, context=None):
+        if 'parent_no_response' in vals and vals['parent_no_response']:
+            vals['parent_response_cond'] = None
+        return super(marketing_campaign_activity, self).write(cr, uid, ids, vals, context=context)
+
+    def create(self, cr, uid, vals, context=None):
+        res_id = super(marketing_campaign_activity, self).create(cr, uid, vals, context)
+        track_str = compute_track_str(cr, uid, self._name + '_' + str(res_id))
+        vals = {'track_str': track_str}
+        self.pool.get(self._name).write(cr, uid, res_id, vals, context=context)
+        return res_id
+
 marketing_campaign_activity()
 
 class marketing_campaign_transition(osv.osv):
@@ -637,6 +710,7 @@
         return [('id', 'in', list(set(matching_workitems)))]
 
     _columns = {
+        'parent_id': fields.many2one('marketing.campaign.workitem', 'Parent'),
         'segment_id': fields.many2one('marketing.campaign.segment', 'Segment', readonly=True),
         'activity_id': fields.many2one('marketing.campaign.activity','Activity',
              required=True, readonly=True),
@@ -646,6 +720,8 @@
              type='many2one', relation='ir.model', string='Resource', select=1, readonly=True, store=True),
         'res_id': fields.integer('Resource ID', select=1, readonly=True),
         'res_name': fields.function(_res_name_get, string='Resource Name', fnct_search=_resource_search, type="char", size=64),
+        'trackitem_id': fields.many2one('marketing.campaign.trackitem', 'Tracking Tag'),
+        'tracklog_ids': fields.one2many('marketing.campaign.tracklog', 'workitem_id', 'Tracking Logs'),
         'date': fields.datetime('Execution Date', help='If date is not set, this workitem has to be run manually', readonly=True),
         'partner_id': fields.many2one('res.partner', 'Partner', select=1, readonly=True),
         'state': fields.selection([ ('todo', 'To Do'),
@@ -653,7 +729,15 @@
                                     ('exception', 'Exception'),
                                     ('done', 'Done'),
                                    ], 'Status', readonly=True),
-        'error_msg' : fields.text('Error Message', readonly=True)
+        'error_msg' : fields.text('Error Message', readonly=True),
+        # Come from the tracklogs, but here for ease of reporting..
+        'mail_sent': fields.boolean('Mail Sent'),
+        'mail_opened': fields.boolean('Mail Opened'),
+        'mail_forwarded': fields.boolean('Mail Forwarded'),
+        'mail_bounced': fields.boolean('Mail Bounced'),
+        'subscribers': fields.integer('Subscribers'),
+        'unsubscribed': fields.boolean('Unsubscribed'),
+        'clicks': fields.integer('Page Views'),
     }
     _defaults = {
         'state': lambda *a: 'todo',
@@ -698,6 +782,35 @@
                     else:
                         workitem.unlink(context=context)
                     return
+            # Make it easy for the user to express conditions
+            # First: absense of response
+            if activity.parent_no_response:
+                searchvals = [
+                    ('workitem_id', '=', workitem.parent_id.id),
+                    ('log_type', 'not in', ['mail_sent', 'mail_opened', 'url_viewed']),
+                ]
+                parent_responses = self.pool.get('marketing.campaign.tracklog').search(cr, uid, searchvals, context=context)
+                if len(parent_responses):
+                    if activity.keep_if_condition_not_met:
+                        workitem.write({'state': 'cancelled'}, context=context)
+                    else:
+                        workitem.unlink(context=context)
+                    return
+            # Next, specific response
+            parent_response_cond = activity.parent_response_cond
+            if parent_response_cond and workitem.parent_id:
+                searchvals = [
+                        ('workitem_id', '=', workitem.parent_id.id),
+                        ('log_type', '=', parent_response_cond),
+                ]
+                parent_responses = self.pool.get('marketing.campaign.tracklog').search(cr, uid, searchvals, context=context)
+                if not len(parent_responses):
+                    if activity.keep_if_condition_not_met:
+                        workitem.write({'state': 'cancelled'}, context=context)
+                    else:
+                        workitem.unlink(context=context)
+                    return
+            # End modif
             result = True
             if campaign_mode in ('manual', 'active'):
                 Activities = self.pool.get('marketing.campaign.activity')
@@ -711,7 +824,7 @@
 
             if result:
                 # process _chain
-                workitem = workitem.browse(context=context)[0] # reload
+                workitem = workitem.browse(context=context)[0]  # reload
                 date = datetime.strptime(workitem.date, DT_FMT)
 
                 for transition in activity.to_ids:
@@ -732,6 +845,7 @@
                         'partner_id': workitem.partner_id.id,
                         'res_id': workitem.res_id,
                         'state': 'todo',
+                        'parent_id': workitem.id,  # Keep track of parent workitem so we can use that for condition lookups
                     }
                     wi_id = self.create(cr, uid, values, context=context)
 
@@ -760,7 +874,18 @@
                      context=context)
 
     def process(self, cr, uid, workitem_ids, context=None):
+        if context is None:
+            context = {}
         for wi in self.browse(cr, uid, workitem_ids, context=context):
+            campaign_track_str = wi.campaign_id.track_str
+            activity_track_str = wi.activity_id.track_str
+            res_track_str = wi.trackitem_id.track_str
+            context.update({
+                    'campaign_track_str': campaign_track_str,
+                    'activity_track_str': activity_track_str,
+                    'res_track_str': res_track_str,
+                    'workitem_id': wi.id,
+                    })
             self._process_one(cr, uid, wi, context=context)
         return True
 
@@ -819,17 +944,55 @@
             raise osv.except_osv(_('No preview'),_('The current step for this item has no email or report to preview.'))
         return res
 
+    def create(self, cr, uid, vals, context=None):
+        # Get model we're working on via our associated activity
+        activity_obj = self.pool.get('marketing.campaign.activity').browse(cr, uid, vals['activity_id'])
+        search_domain = [
+            ('model_id', '=', activity_obj.object_id.id),
+            ('res_id', '=', vals['res_id']),
+        ]
+        trackitem_obj = self.pool.get('marketing.campaign.trackitem')
+        found_trackitems = trackitem_obj.search(cr, uid, search_domain)
+        # And if no trackitem is fond, corresponding the criteria, create one
+        if len(found_trackitems):
+            trackitem_id = found_trackitems[0]
+        else:
+            wvals = {
+                'model_id': activity_obj.object_id.id,
+                'res_id': vals['res_id'],
+            }
+            trackitem_id = trackitem_obj.create(cr, uid, wvals, context)
+        vals.update({'trackitem_id': trackitem_id})
+        return super(marketing_campaign_workitem, self).create(cr, uid, vals, context)
+
 marketing_campaign_workitem()
 
-class email_template(osv.osv):
-    _inherit = "email.template"
-    _defaults = {
-        'model_id': lambda obj, cr, uid, context: context.get('object_id',False),
+
+class marketing_campaign_trackitem(osv.osv):
+    _name = 'marketing.campaign.trackitem'
+    _rec_name = 'track_str'
+    _description = 'Tracking Tags'
+
+    _columns = {
+        'model_id': fields.many2one('ir.model', 'Resource', required=True),
+        'res_id': fields.integer('Resource ID', required=True),
+        'track_str': fields.char('Resource Code', 32),
     }
 
-    # TODO: add constraint to prevent disabling / disapproving an email account used in a running campaign
-
-email_template()
+    def create(self, cr, uid, vals, context=None):
+        res_id = super(marketing_campaign_trackitem, self).create(cr, uid, vals, context)
+        ir_model = self.pool.get('ir.model').browse(cr, uid, vals['model_id'], context=context)
+        model_name = ir_model.model
+        if 'track_str' not in vals:
+            res_track_str = compute_track_str(cr, uid, model_name + '_' + str(vals['res_id']))
+            wvals = {
+                'track_str': res_track_str,
+            }
+            self.pool.get('marketing.campaign.trackitem').write(cr, uid, res_id, wvals, context)
+        return res_id
+
+marketing_campaign_trackitem()
+
 
 class report_xml(osv.osv):
     _inherit = 'ir.actions.report.xml'
 
=== modified file 'marketing_campaign/marketing_campaign_view.xml'
--- marketing_campaign/marketing_campaign_view.xml	2012-08-08 13:06:14 +0000
+++ marketing_campaign/marketing_campaign_view.xml	2012-08-27 10:03:27 +0000
@@ -261,6 +261,8 @@
                 </group>
                 <group >
                     <group>
+                        <field name="parent_response_cond" attrs="{'readonly': [('parent_no_response', '=', True)]}"/>
+                        <field name="parent_no_response" on_change="onchange_parent_no_response(parent_no_response)"/>
                         <field name="condition" widget="char"/>
                         <field name="keep_if_condition_not_met"/>
                     </group>
 
=== modified file 'marketing_campaign/report/__init__.py'
--- marketing_campaign/report/__init__.py	2011-01-14 00:11:01 +0000
+++ marketing_campaign/report/__init__.py	2012-08-27 10:03:27 +0000
@@ -20,5 +20,6 @@
 ##############################################################################
 
 import campaign_analysis
+import campaign_tracking
 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
 
 
=== modified file 'marketing_campaign/report/campaign_analysis.py'
--- marketing_campaign/report/campaign_analysis.py	2012-07-10 12:34:00 +0000
+++ marketing_campaign/report/campaign_analysis.py	2012-08-27 10:03:27 +0000
@@ -43,6 +43,7 @@
                                 ((ca_obj.campaign_id.fixed_cost or 1.00) / len(wi_ids))
             result[ca_obj.id] = total_cost
         return result
+
     _columns = {
         'res_id' : fields.integer('Resource', readonly=True),
         'year': fields.char('Year', size=4, readonly=True),
@@ -66,17 +67,32 @@
                                     type="float", digits_compute=dp.get_precision('Account')),
         'revenue': fields.float('Revenue', readonly=True, digits_compute=dp.get_precision('Account')),
         'count' : fields.integer('# of Actions', readonly=True),
-        'state': fields.selection([('todo', 'To Do'),
-                                   ('exception', 'Exception'), ('done', 'Done'),
-                                   ('cancelled', 'Cancelled')], 'Status', readonly=True),
+        # 'state': fields.selection([('todo', 'To Do'),
+        #                            ('exception', 'Exception'), ('done', 'Done'),
+        #                            ('cancelled', 'Cancelled')], 'Status', readonly=True),
+        # TODO: clean these up; don't think we still use them all
+        'mail_sent': fields.integer('Mail Sent'),
+        'mail_sent_bool': fields.boolean('Mail Sent B'),
+        'mail_opened': fields.integer('Mail Opened'),
+        'mail_opened_bool': fields.boolean('Mail Opened B'),
+        'mail_forwarded': fields.integer('Mail Forwarded'),
+        'mail_forwarded_bool': fields.boolean('Mail Forwarded B'),
+        'mail_bounced': fields.integer('Mail Bounced'),
+        'mail_bounced_bool': fields.boolean('Mail Bounced B'),
+        # 'subscribers': fields.integer('Subscribers'),
+        'unsubscribed': fields.integer('Unsubscribed'),
+        'unsubscribed_bool': fields.boolean('Unsubscribed B'),
+        'clicks': fields.integer('Page Views'),
     }
+
     def init(self, cr):
-        tools.drop_view_if_exists(cr, 'campaign_analysis')
-        cr.execute("""
-            create or replace view campaign_analysis as (
+        tools.drop_view_if_exists(cr, self._table)
+        args = (self._table)
+        query = """
+            create or replace view %s as (
             select
-                min(wi.id) as id,
-                min(wi.res_id) as res_id,
+                wi.id as id,
+                wi.res_id as res_id,
                 to_char(wi.date::date, 'YYYY') as year,
                 to_char(wi.date::date, 'MM') as month,
                 to_char(wi.date::date, 'YYYY-MM-DD') as day,
@@ -85,19 +101,82 @@
                 wi.activity_id as activity_id,
                 wi.segment_id as segment_id,
                 wi.partner_id as partner_id ,
-                wi.state as state,
-                sum(act.revenue) as revenue,
-                count(*) as count
+                wi.mail_sent as mail_sent_bool,
+                wi.mail_sent::int as mail_sent,
+                wi.mail_opened as mail_opened_bool,
+                wi.mail_opened::int as mail_opened,
+                wi.mail_forwarded as mail_forwarded_bool,
+                wi.mail_forwarded::int as mail_forwarded,
+                wi.mail_bounced as mail_bounced_bool,
+                wi.mail_bounced::int as mail_bounced,
+                wi.unsubscribed as unsubscribed_bool,
+                wi.unsubscribed::int as unsubscribed,
+                (select count(*) from marketing_campaign_tracklog tl
+                        where tl.log_type = 'url_viewed'
+                        and tl.workitem_id = wi.id)
+                        as clicks,
+                coalesce(act.revenue + 
+                        (select sum(revenue) from marketing_campaign_tracklog tl
+                                where tl.workitem_id = wi.id),
+                    0.0) as revenue
             from
                 marketing_campaign_workitem wi
                 left join res_partner p on (p.id=wi.partner_id)
                 left join marketing_campaign_segment s on (s.id=wi.segment_id)
                 left join marketing_campaign_activity act on (act.id= wi.activity_id)
             group by
-                s.campaign_id,wi.activity_id,wi.segment_id,wi.partner_id,wi.state,
-                wi.date::date
+                wi.id,wi.res_id,wi.date,wi.activity_id,wi.segment_id,wi.partner_id,wi.mail_sent,wi.mail_opened,wi.mail_forwarded,wi.mail_bounced,wi.unsubscribed,act.revenue,s.campaign_id,act.id
             )
-        """)
+        """ % args
+        cr.execute(query)
+
 campaign_analysis()
 
+class campaign_click_analysis(osv.osv):
+    _name = "campaign.click_analysis"
+    _inherit = "campaign.analysis"
+    _description = 'Click Analysis'
+    _auto = False
+
+    _columns = {
+        # 'subscribers': fields.integer('Subscribers'),
+        'log_url': fields.char('URL', None),
+        'clicks': fields.integer('Page Views'),
+    }
+
+    def init(self, cr):
+        tools.drop_view_if_exists(cr, self._table)
+        args = (self._table)
+        query = """
+            create or replace view %s as (
+            select
+                tl.id as id,
+                wi.id as wi_id,
+                tl.res_id as res_id,
+                to_char(tl.log_date::date, 'YYYY') as year,
+                to_char(tl.log_date::date, 'MM') as month,
+                to_char(tl.log_date::date, 'YYYY-MM-DD') as day,
+                tl.log_date::date as date,
+                s.campaign_id as campaign_id,
+                wi.activity_id as activity_id,
+                wi.segment_id as segment_id,
+                wi.partner_id as partner_id ,
+                1 as clicks,
+                coalesce(tl.log_url, 'N/A') as log_url,
+                coalesce(act.revenue + tl.revenue, 0.0) as revenue
+            from
+                marketing_campaign_tracklog tl
+                left join marketing_campaign_workitem wi on (tl.workitem_id = wi.id)
+                left join res_partner p on (p.id=wi.partner_id)
+                left join marketing_campaign_segment s on (s.id=wi.segment_id)
+                left join marketing_campaign_activity act on (act.id= wi.activity_id)
+            where tl.log_type = 'url_viewed'
+            group by
+                tl.id,wi.id,tl.res_id,tl.log_date,s.campaign_id,wi.activity_id,wi.segment_id,wi.partner_id,tl.log_url,act.revenue,tl.revenue,act.id
+            )
+        """ % args
+        cr.execute(query)
+
+campaign_click_analysis()
+
 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
 
=== modified file 'marketing_campaign/report/campaign_analysis_view.xml'
--- marketing_campaign/report/campaign_analysis_view.xml	2012-08-08 13:06:14 +0000
+++ marketing_campaign/report/campaign_analysis_view.xml	2012-08-27 10:03:27 +0000
@@ -10,14 +10,24 @@
                 <field name="month" invisible="1"/>
                 <field name="day" invisible="1"/>
                 <field name="date" invisible="1"/>
-                <field name="state" invisible="1"/>
+                <!-- <field name="state" invisible="1"/> -->
                 <field name="campaign_id" invisible="1"/>
                 <field name="activity_id" invisible="1"/>
                 <field name="segment_id" invisible="1"/>
                 <field name="partner_id" invisible="1"/>
                 <field name="country_id" invisible="1"/>
                 <field name="res_id" invisible="1"/>
-                <field name="count"/>
+                <field name="mail_sent"/>
+                <field name="mail_sent_bool" invisible="1"/>
+                <field name="mail_opened"/>
+                <field name="mail_opened_bool" invisible="1"/>
+                <field name="mail_forwarded"/>
+                <field name="mail_forwarded_bool" invisible="1"/>
+                <field name="mail_bounced"/>
+                <field name="mail_bounced_bool" invisible="1"/>
+                <field name="unsubscribed"/>
+                <field name="unsubscribed_bool" invisible="1"/>
+                <field name="clicks"/>
                 <field name="total_cost" string="Cost"/><!-- sum="Cost"/-->
                 <field name="revenue"/>
             </tree>
@@ -29,6 +39,7 @@
         <field name="model">campaign.analysis</field>
         <field name="arch" type="xml">
             <search string="Campaign Analysis">
+<<<<<<< TREE
                 <field name="date"/>
                 <filter icon="terp-gtk-go-back-rtl" string="To Do" domain="[('state','=','todo')]"/>
                 <filter icon="terp-dialog-close" string="Done" domain="[('state','=','done')]"/>
@@ -38,12 +49,45 @@
                 <field name="segment_id"/>
                 <field name="partner_id"/>
                 <field name="country_id"/>
+=======
+                <group>
+                    <field name="date"/>
+<!--                     <separator orientation="vertical"/>
+                    <filter icon="terp-gtk-go-back-rtl"
+                            string="To Do"
+                            domain="[('state','=','todo')]"/>
+                    <filter icon="terp-dialog-close"
+                            string="Done"
+                            domain="[('state','=','done')]"/>
+                    <filter icon="terp-emblem-important"
+                            string="Exceptions"
+                            domain="[('state','=','exception')]"/>
+ -->                    <separator orientation="vertical"/>
+                    <field name="campaign_id"/>
+                    <field name="activity_id"/>
+                    <field name="segment_id"/>
+                    <field name="partner_id"/>
+                    <field name="country_id"/>
+                </group>
+                <newline/>
+>>>>>>> MERGE-SOURCE
                 <group expand="0" string="Group By...">
                     <filter string="Campaign" name="Campaign" icon="terp-gtk-jump-to-rtl" context="{'group_by':'campaign_id'}" />
                     <filter string="Segment" name="Segment" icon="terp-stock_symbol-selection" context="{'group_by':'segment_id'}"/>
                     <filter string="Activity" name="activity" icon="terp-stock_align_left_24" context="{'group_by':'activity_id'}"/>
                     <filter string="Resource" icon="terp-accessories-archiver" context="{'group_by':'res_id'}"/>
+<<<<<<< TREE
                     <filter string="Status" icon="terp-stock_effects-object-colorize" context="{'group_by':'state'}"/>
+=======
+                    <separator orientation="vertical"/>
+                    <filter string="Mail Sent" icon="terp-mail-" context="{'group_by':'mail_sent_bool'}"/>
+                    <filter string="Mail Opened" icon="terp-mail-message-new" context="{'group_by':'mail_opened_bool'}"/>
+                    <filter string="Mail Forwarded" icon="terp-mail-forward" context="{'group_by':'mail_forwarded_bool'}"/>
+                    <filter string="Mail Bounced" icon="terp-mail_delete" context="{'group_by':'mail_bounced_bool'}"/>
+                    <filter string="Unsubscribed" icon="terp-mail_delete" context="{'group_by':'unsubscribed_bool'}"/>
+
+                    <separator orientation="vertical"/>
+>>>>>>> MERGE-SOURCE
                     <filter string="Partner" icon="terp-partner" context="{'group_by':'partner_id'}"/>
                     <filter string="Day" icon="terp-go-today" context="{'group_by':'day'}"/>
                     <filter string="Month" icon="terp-go-month" context="{'group_by':'month'}"/>
@@ -53,17 +97,97 @@
         </field>
     </record>
 
-    <record id="action_campaign_analysis_all" model="ir.actions.act_window">
-        <field name="name">Campaign Analysis</field>
-        <field name="res_model">campaign.analysis</field>
-        <field name="view_type">form</field>
-        <field name="view_mode">tree</field>
-        <field name="context">{'search_default_year': 1,"search_default_This Month":1,'group_by': [], 'search_default_Campaign': 1, 'search_default_Segment': 1, 'group_by_no_leaf':1}</field>
-        <field name="search_view_id" ref="view_campaign_analysis_search"/>
-    </record>
+
+        <record id="view_campaign_click_analysis_tree" model="ir.ui.view">
+            <field name="name">campaign.click_analysis.tree</field>
+            <field name="model">campaign.click_analysis</field>
+            <field name="type">tree</field>
+            <field name="arch" type="xml">
+                <tree string="Marketing Reports">
+                    <field name="year" invisible="1"/>
+                    <field name="month" invisible="1"/>
+                    <field name="day" invisible="1"/>
+                    <field name="date" invisible="1"/>
+                    <!-- <field name="state" invisible="1"/> -->
+                    <field name="campaign_id" invisible="1"/>
+                    <field name="activity_id" invisible="1"/>
+                    <field name="segment_id" invisible="1"/>
+                    <field name="partner_id" invisible="1"/>
+                    <!-- <field name="country_id" invisible="1"/> -->
+                    <field name="res_id" invisible="1"/>
+                    <field name="log_url" invisible="1"/>
+                    <field name="total_cost" string="Cost"/><!-- sum="Cost"/-->
+                    <field name="revenue"/>
+                </tree>
+            </field>
+        </record>
+
+        <record id="view_campaign_click_analysis_search" model="ir.ui.view">
+            <field name="name">campaign.click_analysis.search</field>
+            <field name="model">campaign.click_analysis</field>
+            <field name="type">search</field>
+            <field name="arch" type="xml">
+            <search string="Click Analysis">
+                   <group>
+                    <filter icon="terp-go-year" name="year"
+                            string="Year"
+                            domain="[('year','=',time.strftime('%%Y'))]"/>
+                    <separator orientation="vertical"/>
+
+                    <filter icon="terp-go-month"
+                            string="Month" name="This Month"
+                            domain="[('month','=',time.strftime('%%m'))]"/>
+                    <filter icon="terp-go-month" string="    Month-1    "
+                            domain="[('create_date','&lt;=', (datetime.date.today() - relativedelta(day=31, months=1)).strftime('%%Y-%%m-%%d')),('create_date','&gt;=',(datetime.date.today() - relativedelta(day=1,months=1)).strftime('%%Y-%%m-%%d'))]"/>
+
+                    <filter icon="terp-go-today"
+                            string="Today"
+                            domain="[('date','=',time.strftime('%%Y/%%m/%%d'))]"/>
+                    <separator orientation="vertical"/>
+                    <field name="campaign_id"/>
+                    <field name="activity_id"/>
+                    <field name="segment_id"/>
+                    <field name="partner_id"/>
+                    <field name="country_id"/>
+                </group>
+                <newline/>
+                <group expand="0" string="Group By...">
+                    <filter string="Campaign" name="Campaign" icon="terp-gtk-jump-to-rtl" context="{'group_by':'campaign_id'}" />
+                    <filter string="Segment" name="Segment" icon="terp-stock_symbol-selection" context="{'group_by':'segment_id'}" />
+                    <filter string="Activity" name="activity" icon="terp-stock_align_left_24" context="{'group_by':'activity_id'}" />
+                    <filter string="Resource" icon="terp-accessories-archiver" context="{'group_by':'res_id'}"/>
+                    <filter string="url" name="URL" icon="STOCK_FILE" context="{'group_by':'log_url'}"/>
+                    <separator orientation="vertical"/>
+                    <filter string="Partner" icon="terp-partner" context="{'group_by':'partner_id'}"/>
+                    <separator orientation="vertical"/>
+                    <filter string="Day" icon="terp-go-today" context="{'group_by':'day'}"/>
+                    <filter string="Month" icon="terp-go-month" context="{'group_by':'month'}"/>
+                    <filter string="Year" icon="terp-go-year" context="{'group_by':'year'}"/>
+                </group>
+            </search>
+            </field>
+        </record>
+
+        <record id="action_campaign_analysis_all" model="ir.actions.act_window">
+            <field name="name">E-Mail Analysis</field>
+            <field name="res_model">campaign.analysis</field>
+            <field name="view_type">form</field>
+            <field name="view_mode">tree</field>
+            <field name="context">{'search_default_year': 1,"search_default_This Month":1,'group_by': [], 'search_default_Campaign': 1, 'search_default_Segment': 1, 'group_by_no_leaf':1}</field>
+            <field name="search_view_id" ref="view_campaign_analysis_search"/>
+        </record>
+
+        <record id="action_campaign_click_analysis" model="ir.actions.act_window">
+            <field name="name">Click Analysis</field>
+            <field name="res_model">campaign.click_analysis</field>
+            <field name="view_type">form</field>
+            <field name="view_mode">tree</field>
+            <field name="context">{'search_default_year': 1,"search_default_This Month":1,'group_by': [], 'search_default_Campaign': 1, 'search_default_Segment': 1, 'search_default_URL': 1, 'group_by_no_leaf':1}</field>
+            <field name="search_view_id" ref="view_campaign_click_analysis_search"/>
+        </record>
 
     <menuitem name="Marketing" id="base.menu_report_marketing" parent="base.menu_reporting" sequence="45"/>
     <menuitem action="action_campaign_analysis_all" id="menu_action_campaign_analysis_all" parent="base.menu_report_marketing" sequence="2"/>
-
+    <menuitem action="action_campaign_click_analysis" id="menu_action_campaign_click_analysis" parent="base.menu_report_marketing" sequence="3"/>
     </data>
 </openerp>
 
=== added file 'marketing_campaign/report/campaign_tracking.py'
--- marketing_campaign/report/campaign_tracking.py	1970-01-01 00:00:00 +0000
+++ marketing_campaign/report/campaign_tracking.py	2012-08-27 10:03:27 +0000
@@ -0,0 +1,188 @@
+from osv import osv, fields
+import re
+from datetime import datetime
+
+
+class campaign_tracklog(osv.osv):
+    _name = 'marketing.campaign.tracklog'
+    _description = 'Campaign Logs'
+
+    # These are copy/pasted from marketing.campaign.workitem
+    def _res_name_get(self, cr, uid, ids, field_name, arg, context=None):
+        res = dict.fromkeys(ids, 'N/A')
+        for tl in self.browse(cr, uid, ids, context=context):
+            if not tl.workitem_id:
+                continue
+            for wi in self.pool.get('marketing.campaign.workitem').browse(cr, uid, [tl.workitem_id.id], context=context):
+                if not wi.res_id:
+                    continue
+
+                proxy = self.pool.get(wi.object_id.model)
+                if not proxy.exists(cr, uid, [wi.res_id]):
+                    continue
+                ng = proxy.name_get(cr, uid, [wi.res_id], context=context)
+                if ng:
+                    res[tl.id] = ng[0][1]
+        return res
+
+    def _resource_search(self, cr, uid, obj, name, args, domain=None, context=None):
+        """Returns id of tracklogs whose resource_name matches  with the given name"""
+        if not len(args):
+            return []
+
+        condition_name = None
+        for domain_item in args:
+            # we only use the first domain criterion and ignore all the rest including operators
+            if isinstance(domain_item, (list,tuple)) and len(domain_item) == 3 and domain_item[0] == 'res_name':
+                condition_name = [None, domain_item[1], domain_item[2]]
+                break
+
+        assert condition_name, "Invalid search domain for marketing_campaign_workitem.res_name. It should use 'res_name'"
+
+        cr.execute("""select w.id, w.res_id, m.model  \
+                                from marketing_campaign_workitem w \
+                                    left join marketing_campaign_activity a on (a.id=w.activity_id)\
+                                    left join marketing_campaign c on (c.id=a.campaign_id)\
+                                    left join ir_model m on (m.id=c.object_id)
+                                    """)
+        res = cr.fetchall()
+        workitem_map = {}
+        matching_workitems = []
+        for id, res_id, model in res:
+            workitem_map.setdefault(model,{}).setdefault(res_id,set()).add(id)
+        for model, id_map in workitem_map.iteritems():
+            model_pool = self.pool.get(model)
+            condition_name[0] = model_pool._rec_name
+            condition = [('id', 'in', id_map.keys()), condition_name]
+            for res_id in model_pool.search(cr, uid, condition, context=context):
+                matching_workitems.extend(id_map[res_id])
+        return [('workitem_id', 'in', list(set(matching_workitems)))]
+    # end copy/paste
+
+    _columns = {
+        'workitem_id': fields.many2one('marketing.campaign.workitem', 'Work Item', ondelete="cascade"),
+        'activity_id': fields.many2one('marketing.campaign.activity', 'Campaign Activity', ondelete="cascade"),
+        'campaign_id': fields.related('activity_id', 'campaign_id', type='many2one', relation='marketing.campaign', string='Campaign', store=True),
+        'res_track_id': fields.many2one('marketing.campaign.trackitem', 'Tracking Tag'),
+        'model_id': fields.related('res_track_id', 'model_id', type='many2one', relation='ir.model', string='Resource Type', store=True),
+        'res_id': fields.related('res_track_id', 'res_id', type='integer', string='Resource ID', store=True),
+        'res_name': fields.function(_res_name_get, string='Resource Name', fnct_search=_resource_search, type="char", size=None),
+        'mail_message_id': fields.many2one('mail.message', 'Mail Message'),
+        'log_date': fields.datetime('Logged Date'),
+        'log_ip': fields.char('Logged IP', None),
+        'log_type': fields.char('Access Type', None),
+        'revenue': fields.float('Revenue', digits=(0,2)),
+        'log_url': fields.char('Logged URL', None),
+    }
+
+    _defaults = {
+        'log_ip': '0.0.0.0',
+        'log_date': lambda *a: datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+        'revenue': 0,
+        'log_url': 'N/A',
+    }
+
+    def onchange_activity(self, cr, uid, ids, activity_id, context=None):
+        value = {}
+        if activity_id:
+            activity = self.pool.get('marketing.campaign.activity').browse(cr, uid, activity_id, context)
+            value['campaign_id'] = activity.campaign_id.id
+            value['model_id'] = activity.object_id.id
+        return {'value': value}
+
+    def onchange_trackitem(self, cr, uid, ids, res_track_id, context=None):
+        value = {}
+        if res_track_id:
+            trackitem = self.pool.get('marketing.campaign.trackitem').browse(cr, uid, res_track_id, context)
+            value['model_id'] = trackitem.model_id.id
+            value['res_id'] = trackitem.res_id
+            if trackitem.res_id:
+                target_model = self.pool.get(trackitem.model_id['model'])
+                discard, value['res_name'] = target_model.name_get(cr, uid, [trackitem.res_id], context=context)[0]
+        return {'value': value}
+
+    def message_new(self, cr, uid, msg_dict, custom_values=None, context=None):
+        my_id = campaign_id = activity_id = trackitem_id = None
+        to_user = msg_dict['to'].split('@')[0]
+        if len(to_user.split('+')) > 1:
+            # Track string encoded in return-path's address tag
+            track_str = re.sub('=', '@', to_user.split('+')[1])
+            if len(track_str.split('-')) == 3:
+                campaign_str, activity_str, trackitem_str = track_str.split('-')
+                # Campaign
+                campaign_ids = self.pool.get('marketing.campaign').search(cr, uid, [('track_str', '=', campaign_str)])
+                if len(campaign_ids):
+                    campaign_id = campaign_ids[0]
+                # Activity
+                activity_ids = self.pool.get('marketing.campaign.activity').search(cr, uid, [('track_str', '=', activity_str)])
+                if len(activity_ids):
+                    activity_id = activity_ids[0]
+                # Trackitem
+                trackitem_ids = self.pool.get('marketing.campaign.trackitem').search(cr, uid, [('track_str', '=', trackitem_str)])
+                if len(trackitem_ids):
+                    trackitem_id = trackitem_ids[0]
+                if campaign_id is not None and activity_id is not None and trackitem_id is not None:
+                    wi_search_vals = [('campaign_id', '=', campaign_id),
+                                        ('activity_id', '=', activity_id),
+                                        ('trackitem_id', '=', trackitem_id)]
+                    workitem_ids = self.pool.get('marketing.campaign.workitem').search(cr, uid, wi_search_vals)
+                    if len(workitem_ids):
+                        workitem_id = workitem_ids[0]
+                        my_create_vals = {
+                                'res_track_id': trackitem_id,
+                                'log_type': 'mail_bounced',
+                                'activity_id': activity_id,
+                                'workitem_id': workitem_id,
+                        }
+                        my_id = self.create(cr, uid, my_create_vals)
+        return my_id
+
+    def create(self, cr, uid, vals, context=None):
+        # Check which workitem we belong to
+        res_id = self.pool.get('marketing.campaign.trackitem').browse(cr, uid, vals['res_track_id']).res_id
+        args = [
+            ('activity_id', '=', vals['activity_id']),
+            ('res_id', '=', res_id),
+        ]
+        wi_obj = self.pool.get('marketing.campaign.workitem')
+        wi_id = wi_obj.search(cr, uid, args, context=context)[0]
+        vals.update({'workitem_id': wi_id})
+        # Check which mail message we belong to
+        mail_msg_obj = self.pool.get('mail.message')
+        mail_msg_ids = mail_msg_obj.search(cr, uid, [('workitem_id', '=', wi_id)])
+        if len(mail_msg_ids):
+            vals.update({'mail_message_id': mail_msg_ids[0]})
+        retval = super(campaign_tracklog, self).create(cr, uid, vals, context=context)
+
+        # Update related workitem if necessary
+        wvals = {}
+        if vals['log_type'] in ['mail_opened', 'mail_forwarded']:
+            wvals.update({'mail_opened': True})
+            # If opened from multiple IPs, consider it a forward.
+            # We're probably never gonna see "mail_forwarded" in the wild
+            fwd_search = [
+                    ('workitem_id', '=', wi_id),
+                    ('log_type', '=', 'mail_opened'),
+                    ('log_ip', '!=', vals['log_ip']),
+            ]
+            if len(self.pool.get(self._name).search(cr, uid, fwd_search)) \
+                or vals['log_type'] == 'mail_forwarded':
+                wvals.update({'mail_forwarded': True})
+        # We're probably never gonna see "mail_bounced" in the wild.
+        # TODO: implement logic for bounces, unsubscribes
+        if vals['log_type'] == 'mail_bounced':
+            wvals.update({'mail_bounced': True})
+        if vals['log_type'] == 'unsubscribe':
+            wvals.update({'unsubscribed': True})
+            # Check if target has optin or optout stuffi
+            wi = wi_obj.browse(cr, uid, wi_id, context)
+            target_model = self.pool.get(wi.object_id['model'])
+            target = target_model.browse(cr, uid, res_id, context)
+            # TODO: check it's opt_out everywhere
+            if 'opt_out' in target:
+                target_wvals = {
+                        'opt_out': True,
+                }
+                target_model.write(cr, uid, res_id, target_wvals)
+        wi_obj.write(cr, uid, [wi_id], wvals, context)
+        return retval
 
=== added file 'marketing_campaign/report/campaign_tracking_view.xml'
--- marketing_campaign/report/campaign_tracking_view.xml	1970-01-01 00:00:00 +0000
+++ marketing_campaign/report/campaign_tracking_view.xml	2012-08-27 10:03:27 +0000
@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="utf-8"?>
+<openerp>
+    <data>
+        <record model="ir.actions.act_window" id="action_marketing_campaign_log">
+            <field name="name">Campaign Logs</field>
+            <field name="res_model">marketing.campaign.tracklog</field>
+            <field name="view_type">form</field>
+            <field name="view_mode">tree,form</field>
+            <field name="help">Marketing Campaign Response Logs</field>
+        </record>
+
+        <record id="view_marketing_campaign_log_form" model="ir.ui.view">
+            <field name="name">marketing.campaign.log.form</field>
+            <field name="model">marketing.campaign.tracklog</field>
+            <field name="type">form</field>
+            <field name="arch" type="xml">
+                <form string="Logs">
+                    <field name="campaign_id" readonly="True"/>
+                    <field name="model_id" readonly="True"/>
+                    <field name="activity_id" on_change="onchange_activity(activity_id)"/>
+                    <field name="res_name" readonly="True"/>
+                    <field name="res_track_id" on_change="onchange_trackitem(res_track_id)"/>
+                    <field name="res_id" readonly="True"/>
+                    <field name="log_date"/>
+                    <field name="log_type"/>
+                    <field name="log_ip"/>
+                    <field name="revenue"/>
+                    <field name="log_url"/>
+                </form>
+            </field>
+        </record>
+
+        <record id="view_marketing_campaign_log_list" model="ir.ui.view">
+            <field name="name">marketing.campaign.log.list</field>
+            <field name="model">marketing.campaign.tracklog</field>
+            <field name="type">tree</field>
+            <field name="arch" type="xml">
+                <form string="Logs">
+                    <field name="log_date"/>
+                    <field name="campaign_id"/>
+                    <field name="activity_id"/>
+                    <field name="model_id"/>
+                    <field name="res_name"/>
+                    <field name="log_type"/>
+                    <field name="log_ip"/>
+                    <field name="revenue"/>
+                </form>
+            </field>
+        </record>
+
+        <menuitem parent="base.menu_report_marketing" id="menu_marketing_campaign_log" action="action_marketing_campaign_log" />
+    </data>
+</openerp>