# -*- coding: utf-8 -*-

"""

    rhodecode.controllers.admin.repos

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    Admin controller for RhodeCode

    :created_on: Apr 7, 2010

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

import traceback

import formencode

from formencode import htmlfill

from paste.httpexceptions import HTTPInternalServerError

from pylons import request, session, tmpl_context as c, url

from pylons.controllers.util import redirect

from pylons.i18n.translation import _

from sqlalchemy.exc import IntegrityError

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, \

    HasPermissionAnyDecorator, HasRepoPermissionAllDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import invalidate_cache, action_logger, repo_name_slug

from rhodecode.lib.helpers import get_token

from rhodecode.model.meta import Session

from rhodecode.model.db import User, Repository, UserFollowing, RepoGroup

from rhodecode.model.forms import RepoForm

from rhodecode.model.scm import ScmModel

from rhodecode.model.repo import RepoModel

log = logging.getLogger(__name__)

class ReposController(BaseController):

    """

    REST Controller styled on the Atom Publishing Protocol"""

    # To properly map this controller, ensure your config/routing.py

    # file has a resource setup:

    #     map.resource('repo', 'repos')

    @LoginRequired()

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

    def __before__(self):

        c.admin_user = session.get('admin_user')

        c.admin_username = session.get('admin_username')

        super(ReposController, self).__before__()

    def __load_defaults(self):

        c.repo_groups = RepoGroup.groups_choices()

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

    def __load_data(self, repo_name=None):

        """

        Load defaults settings for edit, and update

        :param repo_name:

        """

        self.__load_defaults()

        c.repo_info = db_repo = Repository.get_by_repo_name(repo_name)

        repo = db_repo.scm_instance

        if c.repo_info is None:

            h.flash(_('%s repository is not mapped to db perhaps'

                      ' it was created or renamed from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('repos'))

        c.default_user_id = User.get_by_username('default').user_id

        c.in_public_journal = UserFollowing.query()\

            .filter(UserFollowing.user_id == c.default_user_id)\

            .filter(UserFollowing.follows_repository == c.repo_info).scalar()

        if c.repo_info.stats:

            # this is on what revision we ended up so we add +1 for count

            last_rev = c.repo_info.stats.stat_on_revision + 1

        else:

            last_rev = 0

        c.stats_revision = last_rev

        c.repo_last_rev = repo.count() if repo.revisions else 0

        if last_rev == 0 or c.repo_last_rev == 0:

            c.stats_percentage = 0

        else:

            c.stats_percentage = '%.2f' % ((float((last_rev)) /

                                            c.repo_last_rev) * 100)

        defaults = RepoModel()._get_defaults(repo_name)

        c.repos_list = [('', _('--REMOVE FORK--'))]

        c.repos_list += [(x.repo_id, x.repo_name) for x in

                   Repository.query().order_by(Repository.repo_name).all()]

        return defaults

    @HasPermissionAllDecorator('hg.admin')

    def index(self, format='html'):

        """GET /repos: All items in the collection"""

        # url('repos')

        c.repos_list = ScmModel().get_repos(Repository.query()

                                            .order_by(Repository.repo_name)

                                            .all(), sort_key='name_sort')

        return render('admin/repos/repos.html')

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

    def create(self):

        """

        POST /repos: Create a new item"""

        # url('repos')

        self.__load_defaults()

        form_result = {}

        try:

            form_result = RepoForm(repo_groups=c.repo_groups_choices)()\

                            .to_python(dict(request.POST))

            RepoModel().create(form_result, self.rhodecode_user)

            if form_result['clone_uri']:

                h.flash(_('created repository %s from %s') \

                    % (form_result['repo_name'], form_result['clone_uri']),

                    category='success')

            else:

                h.flash(_('created repository %s') % form_result['repo_name'],

                    category='success')

            if request.POST.get('user_created'):

                # created by regular non admin user

                action_logger(self.rhodecode_user, 'user_created_repo',

                              form_result['repo_name_full'], '', self.sa)

            else:

                action_logger(self.rhodecode_user, 'admin_created_repo',

                              form_result['repo_name_full'], '', self.sa)

            Session.commit()

        except formencode.Invalid, errors:

            c.new_repo = errors.value['repo_name']

            if request.POST.get('user_created'):

                r = render('admin/repos/repo_add_create_repository.html')

            else:

                r = render('admin/repos/repo_add.html')

            return htmlfill.render(

                r,

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            msg = _('error occurred during creation of repository %s') \

                    % form_result.get('repo_name')

            h.flash(msg, category='error')

        if request.POST.get('user_created'):

            return redirect(url('home'))

        return redirect(url('repos'))

    @HasPermissionAllDecorator('hg.admin')

    def new(self, format='html'):

        """GET /repos/new: Form to create a new item"""

        new_repo = request.GET.get('repo', '')

        c.new_repo = repo_name_slug(new_repo)

        self.__load_defaults()

        return render('admin/repos/repo_add.html')

    @HasPermissionAllDecorator('hg.admin')

    def update(self, repo_name):

        """

        PUT /repos/repo_name: Update an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('repo', repo_name=ID),

        #           method='put')

        # url('repo', repo_name=ID)

        self.__load_defaults()

        repo_model = RepoModel()

        changed_name = repo_name

        _form = RepoForm(edit=True, old_data={'repo_name': repo_name},

                         repo_groups=c.repo_groups_choices)()

        try:

            form_result = _form.to_python(dict(request.POST))

            repo = repo_model.update(repo_name, form_result)

            invalidate_cache('get_repo_cached_%s' % repo_name)

            h.flash(_('Repository %s updated successfully' % repo_name),

                    category='success')

            changed_name = repo.repo_name

            action_logger(self.rhodecode_user, 'admin_updated_repo',

                              changed_name, '', self.sa)

            Session.commit()

        except formencode.Invalid, errors:

            defaults = self.__load_data(repo_name)

            defaults.update(errors.value)

            return htmlfill.render(

                render('admin/repos/repo_edit.html'),

                defaults=defaults,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during update of repository %s') \

                    % repo_name, category='error')

        return redirect(url('edit_repo', repo_name=changed_name))

    @HasPermissionAllDecorator('hg.admin')

    def delete(self, repo_name):

        """

        DELETE /repos/repo_name: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('repo', repo_name=ID),

        #           method='delete')

        # url('repo', repo_name=ID)

        repo_model = RepoModel()

        repo = repo_model.get_by_repo_name(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps'

                      ' it was moved or renamed  from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('repos'))

        try:

            action_logger(self.rhodecode_user, 'admin_deleted_repo',

                              repo_name, '', self.sa)

            repo_model.delete(repo)

            invalidate_cache('get_repo_cached_%s' % repo_name)

            h.flash(_('deleted repository %s') % repo_name, category='success')

            Session.commit()

        except IntegrityError, e:

            if e.message.find('repositories_fork_id_fkey') != -1:

                log.error(traceback.format_exc())

                h.flash(_('Cannot delete %s it still contains attached '

                          'forks') % repo_name,

                        category='warning')

            else:

                log.error(traceback.format_exc())

                h.flash(_('An error occurred during '

                          'deletion of %s') % repo_name,

                        category='error')

        except Exception, e:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of %s') % repo_name,

                    category='error')

        return redirect(url('repos'))

    def delete_perm_user(self, repo_name):

        """

        DELETE an existing repository permission user

        :param repo_name:

        """

        try:

            repo_model = RepoModel()

            repo_model.delete_perm_user(request.POST, repo_name)

            Session.commit()

        except Exception, e:

            h.flash(_('An error occurred during deletion of repository user'),

                    category='error')

            raise HTTPInternalServerError()

    @HasRepoPermissionAllDecorator('repository.admin')

    def delete_perm_users_group(self, repo_name):

        """

        DELETE an existing repository permission users group

        :param repo_name:

        """

        try:

            repo_model = RepoModel()

            repo_model.delete_perm_users_group(request.POST, repo_name)

            Session.commit()

        except Exception, e:

            h.flash(_('An error occurred during deletion of repository'

                      ' users groups'),

                    category='error')

            raise HTTPInternalServerError()

    @HasPermissionAllDecorator('hg.admin')

    def repo_stats(self, repo_name):

        """

        DELETE an existing repository statistics

        :param repo_name:

        """

        try:

            repo_model = RepoModel()

            repo_model.delete_stats(repo_name)

            Session.commit()

        except Exception, e:

            h.flash(_('An error occurred during deletion of repository stats'),

                    category='error')

        return redirect(url('edit_repo', repo_name=repo_name))

    @HasPermissionAllDecorator('hg.admin')

    def repo_cache(self, repo_name):

        """

        INVALIDATE existing repository cache

        :param repo_name:

        """

        try:

            ScmModel().mark_for_invalidation(repo_name)

            Session.commit()

        except Exception, e:

            h.flash(_('An error occurred during cache invalidation'),

                    category='error')

        return redirect(url('edit_repo', repo_name=repo_name))

    @HasPermissionAllDecorator('hg.admin')

    def repo_public_journal(self, repo_name):

        """

        Set's this repository to be visible in public journal,

        in other words assing default user to follow this repo

        :param repo_name:

        """

        cur_token = request.POST.get('auth_token')

        token = get_token()

        if cur_token == token:

            try:

                repo_id = Repository.get_by_repo_name(repo_name).repo_id

                user_id = User.get_by_username('default').user_id

                self.scm_model.toggle_following_repo(repo_id, user_id)

                h.flash(_('Updated repository visibility in public journal'),

                        category='success')

                Session.commit()

            except:

                h.flash(_('An error occurred during setting this'

                          ' repository in public journal'),

                        category='error')

        else:

            h.flash(_('Token mismatch'), category='error')

        return redirect(url('edit_repo', repo_name=repo_name))

    @HasPermissionAllDecorator('hg.admin')

    def repo_pull(self, repo_name):

        """

        Runs task to update given repository with remote changes,

        ie. make pull on remote location

        :param repo_name:

        """

        try:

            ScmModel().pull_changes(repo_name, self.rhodecode_user.username)

            h.flash(_('Pulled from remote location'), category='success')

        except Exception, e:

            h.flash(_('An error occurred during pull from remote location'),

                    category='error')

        return redirect(url('edit_repo', repo_name=repo_name))

    @HasPermissionAllDecorator('hg.admin')

    def repo_as_fork(self, repo_name):

        """

        Mark given repository as a fork of another

        :param repo_name:

        """

        try:

            fork_id = request.POST.get('id_fork_of')

            repo = ScmModel().mark_as_fork(repo_name, fork_id,

                                    self.rhodecode_user.username)

            fork = repo.fork.repo_name if repo.fork else _('Nothing')

            Session.commit()

            h.flash(_('Marked repo %s as fork of %s' % (repo_name,fork)),

                    category='success')

        except Exception, e:

            raise

            h.flash(_('An error occurred during this operation'),

                    category='error')

        return redirect(url('edit_repo', repo_name=repo_name))

    @HasPermissionAllDecorator('hg.admin')

    def show(self, repo_name, format='html'):

        """GET /repos/repo_name: Show a specific item"""

        # url('repo', repo_name=ID)

    @HasPermissionAllDecorator('hg.admin')

    def edit(self, repo_name, format='html'):

        """GET /repos/repo_name/edit: Form to edit an existing item"""

        # url('edit_repo', repo_name=ID)

        defaults = self.__load_data(repo_name)

        return htmlfill.render(

            render('admin/repos/repo_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

# The code in this module is entirely lifted from the Lamson project

# (http://lamsonproject.org/).  Its copyright is:

# Copyright (c) 2008, Zed A. Shaw

# All rights reserved.

# It is provided under this license:

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions are met:

# * Redistributions of source code must retain the above copyright notice, this

#   list of conditions and the following disclaimer.

# * Redistributions in binary form must reproduce the above copyright notice,

#   this list of conditions and the following disclaimer in the documentation

#   and/or other materials provided with the distribution.

# * Neither the name of the Zed A. Shaw nor the names of its contributors may

#   be used to endorse or promote products derived from this software without

#   specific prior written permission.

# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,

# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

import os

import mimetypes

import string

from email import encoders

from email.charset import Charset

from email.utils import parseaddr

from email.mime.base import MIMEBase

ADDRESS_HEADERS_WHITELIST = ['From', 'To', 'Delivered-To', 'Cc', 'Bcc']

DEFAULT_ENCODING = "utf-8"

VALUE_IS_EMAIL_ADDRESS = lambda v: '@' in v

def normalize_header(header):

    return string.capwords(header.lower(), '-')

class EncodingError(Exception):

    """Thrown when there is an encoding error."""

    pass

class MailBase(object):

    """MailBase is used as the basis of lamson.mail and contains the basics of

    encoding an email.  You actually can do all your email processing with this

    class, but it's more raw.

    """

    def __init__(self, items=()):

        self.headers = dict(items)

        self.parts = []

        self.body = None

        self.content_encoding = {'Content-Type': (None, {}),

                                 'Content-Disposition': (None, {}),

                                 'Content-Transfer-Encoding': (None, {})}

    def __getitem__(self, key):

        return self.headers.get(normalize_header(key), None)

    def __len__(self):

        return len(self.headers)

    def __iter__(self):

        return iter(self.headers)

    def __contains__(self, key):

        return normalize_header(key) in self.headers

    def __setitem__(self, key, value):

        self.headers[normalize_header(key)] = value

    def __delitem__(self, key):

        del self.headers[normalize_header(key)]

    def __nonzero__(self):

        return self.body != None or len(self.headers) > 0 or len(self.parts) > 0

    def keys(self):

        """Returns the sorted keys."""

        return sorted(self.headers.keys())

    def attach_file(self, filename, data, ctype, disposition):

        """

        A file attachment is a raw attachment with a disposition that

        indicates the file name.

        """

        assert filename, "You can't attach a file without a filename."

        ctype = ctype.lower()

        part = MailBase()

        part.body = data

        part.content_encoding['Content-Type'] = (ctype, {'name': filename})

        part.content_encoding['Content-Disposition'] = (disposition,

                                                        {'filename': filename})

        self.parts.append(part)

    def attach_text(self, data, ctype):

        """

        This attaches a simpler text encoded part, which doesn't have a

        filename.

        """

        ctype = ctype.lower()

        part = MailBase()

        part.body = data

        part.content_encoding['Content-Type'] = (ctype, {})

        self.parts.append(part)

    def walk(self):

        for p in self.parts:

            yield p

            for x in p.walk():

                yield x

class MailResponse(object):

    """

    You are given MailResponse objects from the lamson.view methods, and

    whenever you want to generate an email to send to someone.  It has the

    same basic functionality as MailRequest, but it is designed to be written

    to, rather than read from (although you can do both).

    You can easily set a Body or Html during creation or after by passing it

    as __init__ parameters, or by setting those attributes.

    You can initially set the From, To, and Subject, but they are headers so

    use the dict notation to change them: msg['From'] = 'joe@test.com'.

    The message is not fully crafted until right when you convert it with

    MailResponse.to_message.  This lets you change it and work with it, then

    send it out when it's ready.

    """

                 separator="; "):

        self.Body = Body

        self.Html = Html

        self.base = MailBase([('To', To), ('From', From), ('Subject', Subject)])

        self.multipart = self.Body and self.Html

        self.attachments = []

        self.separator = separator

    def __contains__(self, key):

        return self.base.__contains__(key)

    def __getitem__(self, key):

        return self.base.__getitem__(key)

    def __setitem__(self, key, val):

        return self.base.__setitem__(key, val)

    def __delitem__(self, name):

        del self.base[name]

    def attach(self, filename=None, content_type=None, data=None,

               disposition=None):

        """

        Simplifies attaching files from disk or data as files.  To attach

        simple text simple give data and a content_type.  To attach a file,

        give the data/content_type/filename/disposition combination.

        For convenience, if you don't give data and only a filename, then it

        will read that file's contents when you call to_message() later.  If

        you give data and filename then it will assume you've filled data

        with what the file's contents are and filename is just the name to

        use.

        """

        assert filename or data, ("You must give a filename or some data to "

                                  "attach.")

        assert data or os.path.exists(filename), ("File doesn't exist, and no "

                                                  "data given.")

        self.multipart = True

        if filename and not content_type:

            content_type, encoding = mimetypes.guess_type(filename)

        assert content_type, ("No content type given, and couldn't guess "

                              "from the filename: %r" % filename)

        self.attachments.append({'filename': filename,

                                 'content_type': content_type,

                                 'data': data,

                                 'disposition': disposition,})

    def attach_part(self, part):

        """

        Attaches a raw MailBase part from a MailRequest (or anywhere)

        so that you can copy it over.

        """

        self.multipart = True

        self.attachments.append({'filename': None,

                                 'content_type': None,

                                 'data': None,

                                 'disposition': None,

                                 'part': part,

                                 })

    def attach_all_parts(self, mail_request):

        """

        Used for copying the attachment parts of a mail.MailRequest

        object for mailing lists that need to maintain attachments.

        """

        for part in mail_request.all_parts():

            self.attach_part(part)

        self.base.content_encoding = mail_request.base.content_encoding.copy()

    def clear(self):

        """

        Clears out the attachments so you can redo them.  Use this to keep the

        headers for a series of different messages with different attachments.

        """

        del self.attachments[:]

        del self.base.parts[:]

        self.multipart = False

    def update(self, message):

        """

        Used to easily set a bunch of heading from another dict

        like object.

        """

        for k in message.keys():

            self.base[k] = message[k]

    def __str__(self):

        """

        Converts to a string.

        """

        return self.to_message().as_string()

    def _encode_attachment(self, filename=None, content_type=None, data=None,

                           disposition=None, part=None):

        """

        Used internally to take the attachments mentioned in self.attachments

        and do the actual encoding in a lazy way when you call to_message.

        """

        if part:

            self.base.parts.append(part)

        elif filename:

            if not data:

                data = open(filename).read()

            self.base.attach_file(filename, data, content_type,

                                  disposition or 'attachment')

        else:

            self.base.attach_text(data, content_type)

        ctype = self.base.content_encoding['Content-Type'][0]

        if ctype and not ctype.startswith('multipart'):

            self.base.content_encoding['Content-Type'] = ('multipart/mixed', {})

    def to_message(self):

        """

        Figures out all the required steps to finally craft the

        message you need and return it.  The resulting message

        is also available as a self.base attribute.

        What is returned is a Python email API message you can

        use with those APIs.  The self.base attribute is the raw

        lamson.encoding.MailBase.

        """

        del self.base.parts[:]

        if self.Body and self.Html:

            self.multipart = True

            self.base.content_encoding['Content-Type'] = (

                'multipart/alternative', {})

        if self.multipart:

            self.base.body = None

            if self.Body:

                self.base.attach_text(self.Body, 'text/plain')

            if self.Html:

                self.base.attach_text(self.Html, 'text/html')

            for args in self.attachments:

                self._encode_attachment(**args)

        elif self.Body:

            self.base.body = self.Body

            self.base.content_encoding['Content-Type'] = ('text/plain', {})

        elif self.Html:

            self.base.body = self.Html

            self.base.content_encoding['Content-Type'] = ('text/html', {})

        return to_message(self.base, separator=self.separator)

    def all_parts(self):

        """

        Returns all the encoded parts.  Only useful for debugging

        or inspecting after calling to_message().

        """

        return self.base.parts

    def keys(self):

        return self.base.keys()

def to_message(mail, separator="; "):

    """

    Given a MailBase message, this will construct a MIMEPart

    that is canonicalized for use with the Python email API.

    """

    ctype, params = mail.content_encoding['Content-Type']

    if not ctype:

        if mail.parts:

            ctype = 'multipart/mixed'

        else:

            ctype = 'text/plain'

    else:

        if mail.parts:

            assert ctype.startswith(("multipart", "message")), \

                   "Content type should be multipart or message, not %r" % ctype

    # adjust the content type according to what it should be now

    mail.content_encoding['Content-Type'] = (ctype, params)

    try:

        out = MIMEPart(ctype, **params)

    except TypeError, exc: # pragma: no cover

        raise EncodingError("Content-Type malformed, not allowed: %r; "

                            "%r (Python ERROR: %s" %

                            (ctype, params, exc.message))

    for k in mail.keys():

        if k in ADDRESS_HEADERS_WHITELIST:

            out[k.encode('ascii')] = header_to_mime_encoding(

                                         mail[k],

                                         not_email=False,

                                         separator=separator

                                     )

        else:

            out[k.encode('ascii')] = header_to_mime_encoding(

                                         mail[k],

                                         not_email=True

                                    )

    out.extract_payload(mail)

    # go through the children

    for part in mail.parts:

        out.attach(to_message(part))

    return out

class MIMEPart(MIMEBase):

    """

    A reimplementation of nearly everything in email.mime to be more useful

    for actually attaching things.  Rather than one class for every type of

    thing you'd encode, there's just this one, and it figures out how to

    encode what you ask it.

    """

    def __init__(self, type, **params):

        self.maintype, self.subtype = type.split('/')

        MIMEBase.__init__(self, self.maintype, self.subtype, **params)

    def add_text(self, content):

        # this is text, so encode it in canonical form

        try:

            encoded = content.encode('ascii')

            charset = 'ascii'

        except UnicodeError:

            encoded = content.encode('utf-8')

            charset = 'utf-8'

        self.set_payload(encoded, charset=charset)

    def extract_payload(self, mail):

        if mail.body == None: return  # only None, '' is still ok

        ctype, ctype_params = mail.content_encoding['Content-Type']

        cdisp, cdisp_params = mail.content_encoding['Content-Disposition']

        assert ctype, ("Extract payload requires that mail.content_encoding "

                       "have a valid Content-Type.")

        if ctype.startswith("text/"):

            self.add_text(mail.body)

        else:

            if cdisp:

                # replicate the content-disposition settings

                self.add_header('Content-Disposition', cdisp, **cdisp_params)

            self.set_payload(mail.body)

            encoders.encode_base64(self)

    def __repr__(self):

        return "<MIMEPart '%s/%s': %r, %r, multipart=%r>" % (

            self.subtype,

            self.maintype,

            self['Content-Type'],

            self['Content-Disposition'],

            self.is_multipart())

def header_to_mime_encoding(value, not_email=False, separator=", "):

    if not value: return ""

    encoder = Charset(DEFAULT_ENCODING)

    if type(value) == list:

        return separator.join(properly_encode_header(

            v, encoder, not_email) for v in value)

    else:

        return properly_encode_header(value, encoder, not_email)

def properly_encode_header(value, encoder, not_email):

    """

    The only thing special (weird) about this function is that it tries

    to do a fast check to see if the header value has an email address in

    it.  Since random headers could have an email address, and email addresses

    have weird special formatting rules, we have to check for it.

    Normally this works fine, but in Librelist, we need to "obfuscate" email

    addresses by changing the '@' to '-AT-'.  This is where

    VALUE_IS_EMAIL_ADDRESS exists.  It's a simple lambda returning True/False

    to check if a header value has an email address.  If you need to make this

    check different, then change this.

    """

    try:

        return value.encode("ascii")

    except UnicodeEncodeError:

        if not_email is False and VALUE_IS_EMAIL_ADDRESS(value):

            # this could have an email address, make sure we don't screw it up