source: trunk/plugins/mailmanplugin/mailinglists/admin.py @ 816

# -*- coding: iso-8859-1 -*-
#
# Copyright (C) 2007 Optaros, Inc.
#

import os

from genshi.builder import tag

from trac.admin.api import IAdminPanelProvider
from trac.core import *
from trac.config import Option
from trac.notification import NotifyEmail
from trac.perm import IPermissionRequestor
from trac.util.translation import _
from trac.web.chrome import ITemplateProvider

# Local imports
from mailinglists import errors
from mailinglists.api import MailingListAPI

class MailingListAdminPanel(Component):
    implements(IPermissionRequestor, ITemplateProvider, IAdminPanelProvider)

    _listcreator_pwd = Option('mailing_lists', 'listcreator_pwd', 
                              doc="""Password for mailman listcreator""")
    
    def __init__(self):
        self._mlapi = MailingListAPI(self.env)

    # IPermissionRequestor methods
    def get_permission_actions(self):
        return ['MAIL_ADMIN']

    # ITemplateProvider methods
    def get_htdocs_dirs(self):
        return []

    def get_templates_dirs(self):
        from pkg_resources import resource_filename
        return [resource_filename(__name__, 'templates')]

    # IAdminPanelProvider
    def get_admin_panels(self, req):
        if req.perm.has_permission('MAIL_ADMIN'):
            yield ('maillist', _('Mailing Lists'), 'lists', _('Lists'))

    def render_admin_panel(self, req, cat_id, panel_id, path_info):

        req.perm.require('MAIL_ADMIN')

        errors = None
        if req.method == 'POST':
            if 'newlist' in req.args:
                errors=self._do_newlist(req, path_info)
            elif 'add_user' in req.args:
                errors=self._do_add(req, path_info)
            elif 'manage_users' in req.args:
                errors=self._do_manage(req, path_info)
            if not errors:
                req.redirect(req.href.admin(cat_id, panel_id, path_info))
            self.log.warning(errors)

        return self._render_view(req, path_info, errors)
        
    def _render_view(self, req, email_list, errors):

        error_msg = []
        if errors:
            error_msg.append(errors)
        if not self._listcreator_pwd:
            error_msg.append('The list-creator password is not configured.  Please contact your system administrator.')

        # get the mailing lists from the configuration
        data = {'lists': self.config.getlist('mailing_lists', 'lists'),
                'project_shortname': os.path.basename(self.env.path),
                'email_list': email_list,
                'email_host': self._mlapi.get_email_host(),
                'mm_script_url': self._mlapi.script_url('admin'),
                'errors': error_msg }
        if email_list:
            userlist = self._get_userlist(email_list)
            data['userlist']= userlist.values()

        return 'mailinglists_admin.html', data

    def _do_newlist(self, req, pathinfo):
        # always convert request arguments into pure strings since they get passed back as unicode
        list_name = str(req.args.get('new_list_name', None))
        list_password = str(req.args.get('list_password', None))
        conf_list_password = str(req.args.get('conf_list_password', None))

        error_msg=None
        # now check for possible error conditions
        if not list_name:
            error_msg = "'List Name' cannot be empty."
        elif not list_password:
            error_msg = "'List Password' cannot be empty."
        elif list_password != conf_list_password:
            error_msg = "Password does not match confirmation."

        user_name = str(req.authname)
        user_email = self._get_user_email(req)
        project_name = self.config.get('project','name')
        
        if not error_msg:
            # we have no error condition, so we can call the api
            error = self._mlapi.create_new_mailing_list(list_name, user_name, user_email, list_password, self._listcreator_pwd, project_name)
            if error:
                self.log.error(error)
                error_msg = error
            else:
                mailing_lists=self.config.getlist('mailing_lists', 'lists')
                mailing_lists.append(list_name)
                self.config.set('mailing_lists', 'lists', ','.join(mailing_lists))
                self.config.save()
        return error_msg
                
    def _do_add(self, req, email_list):

        newuser_email = str(req.args.get('newuser_email'))
        if len(newuser_email) > 0:
            error = self._mlapi.verify_email(newuser_email)
            if error:
                self.log.error(error)
                raise TracError(error)
            project_name = self.config.get('project', 'name')
            subscribe = [{'email':newuser_email, 'name':str(req.args.get('newuser_name',''))}]
            error = self._mlapi.subscribe_list_members(email_list, subscribe, project_name, req.args.has_key('notify_flag'))
            if error:
                self.log.error(error)
                raise TracError(error)
        
    def _do_manage(self, req, email_list):
        
        subscribe = []
        unsubscribe = []
        sel = req.args.getlist('sel_user')
        
        userlist = self._get_userlist(email_list)
        
        # let's process the new subscriptions first
        selected_map = {}
        for user in sel:
            # only process the list if it is different from 'None'
            if user:
                user = str(user)
                # add the selected users to a map for later use
                selected_map[user] = user
                user_profile = userlist[user]
                # only subscribe users that are not yet subscribed
                if not user_profile['subscribed']:
                    subscribe.append( {'email':user, 'name': user_profile['name']} )

        subscribe = [ {'email':user, 'name': userlist[user]['name']} 
                      for user in sel 
                      if not userlist[user]['subscribed']]
        # self.log.warning(userlist)
        unsubcribe = [ {'email':user, 'name': userlist[user]['name']} 
                      for user, user_profile in userlist.items() if user_profile['subscribed'] and not user in sel]
        # get a list of the keys (email addresses) from our userlist
        allusers = userlist.keys()
        # now loop over it and determine who has been unselected
        for user in allusers:
            user_profile = userlist[user]
            if user_profile['subscribed']:
                if not selected_map.has_key(user):
                    # the user has been unselected in the list,
                    # so mark for unsubscription
                    unsubscribe.append( {'email':user, 'name': user_profile['name']} )
                    
        # we are ready now to process the subscriptions
        project_name = self.config.get('project', 'name')
        if len(subscribe) > 0:
            error = self._mlapi.subscribe_list_members(email_list, subscribe, project_name, req.args.has_key('notify_flag'))
            if error:
                self.log.error(error)
                raise TracError(error)
        # and the un-subscriptions, but only we did not get an error message before
        if len(unsubscribe) > 0:
            error = self._mlapi.unsubscribe_list_members(email_list, unsubscribe, project_name, req.args.has_key('notify_flag'))
            if error:
                self.log.error(error)
                raise TracError(error)

    # method that will return a data structure containing the team of this project
    # currently, it will return the "known user', but
    # in the future, we will interface with the team roster plugin
    def _get_team(self):
        userlist = []
        try:
            for username, name, email in self.env.get_known_users():    
                # we consider any user that has a username and email address here
                # but we need at least an email address,
                # otherwise we could not subscribe this user to a mail list
                
                if username and email:
                    userlist.append( {'username':username, 'name':name, 'email':email} )

        except:
            userlist.append( dict( username='error',name='error', email='error'))
        return userlist

    def _get_userlist(self, email_list):
        userlist={}
        # and get the member list from Mailman
        mail_subscribers = self._mlapi.get_list_members(email_list)
        
        if mail_subscribers.has_key('error'):
            error_msg = mail_subscribers['error']
            # TODO: this is currently failing silently
            self.log.error("Problem getting member list for mailing list %s : %s"%(email_list,error_msg))
            raise TracError(error_msg)
        
        # now we need to merge the two lists without having duplicates
        # first iterate over the trac user list and add them to a dict with the email as key
        for tracuser in self._get_team():
            email=tracuser.get('email')
            # only add it if we have an email address
            if email:
                # now create a dict with the email as key
                # but only add it once in case we have the same email address twice
                email=email.lower()
                if not userlist.has_key(email):
                    userlist[email] = {'username':str(tracuser.get('username','')),
                                       'name':tracuser.get('name',''),
                                       'email':email,
                                       'subscribed':0 }
                
        # now iterate over the subscriber list from Mailman
        for mailuser in mail_subscribers['memberlist']:
            # DG: how would a mailman member not have an email?
            if mailuser.has_key('email'):
                email = mailuser['email']
                # check if we have this user already in trac -> set to subscribed and leave unchanged
                if userlist.has_key(email):
                    userlist[email]['subscribed']=1
                else:
                    # otherwise add to userlist
                    userlist[email] = {'username':'',
                                       'name':mailuser['name'],
                                       'email':email,
                                       'subscribed':1}
        return userlist

    def _get_user_email(self, req):
        address = req.session.get('email')
        if not address:
            domain = self.config.get('notification', 'smtp_default_domain')
            if not domain:
                domain = self.config.get('announcer', 'email_default_domain')
            if domain:
                address = "%s@%s" % (req.authname, domain)
        
        return address