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

"""

    rhodecode.controllers.changeset

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

    changeset controller for pylons showoing changes beetween 

    revisions

    :created_on: Apr 25, 2010

    :author: marcink

    :copyright: (C) 2009-2011 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; version 2

# of the License or (at your opinion) any later version of the license.

# 

# 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, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

import logging

import traceback

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

from pylons.i18n.translation import _

from pylons.controllers.util import redirect

import rhodecode.lib.helpers as h

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import EmptyChangeset

from rhodecode.model.scm import ScmModel

from vcs.exceptions import RepositoryError, ChangesetError, \

ChangesetDoesNotExistError

from vcs.nodes import FileNode

from vcs.utils import diffs as differ

from vcs.utils.ordered_dict import OrderedDict

log = logging.getLogger(__name__)

class ChangesetController(BaseController):

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def __before__(self):

        super(ChangesetController, self).__before__()

    def index(self, revision):

        hg_model = ScmModel()

        def wrap_to_table(str):

            return '''<table class="code-difftable">

                        <tr class="line">

                        <td class="lineno new"></td>

                        <td class="code"><pre>%s</pre></td>

                        </tr>

                      </table>''' % str

            """

            Temp fix function until VCS will handle that

            see issue #48

            :param rev_start:

            :param rev_end:

            """

            start_cs = repo.get_changeset(rev_start)

            end_cs = repo.get_changeset(rev_end)

            if start_cs.revision >= end_cs.revision:

                raise Exception('Start revision cannot be after End')

            yield start_cs

            while 1:

                next = start_cs.next()

                yield next

                start_cs = next

                if next == end_cs:

                    break

        #======================================================================

        # REAL CODE BELOW

        #======================================================================

        #get ranges of revisions if preset

        rev_range = revision.split('...')[:2]

        try:

            repo = hg_model.get_repo(c.repo_name)

            if len(rev_range) == 2:

                rev_start = rev_range[0]

                rev_end = rev_range[1]

            else:

                rev_ranges = [repo.get_changeset(revision)]

            c.cs_ranges = list(rev_ranges)

        except (RepositoryError, ChangesetDoesNotExistError, Exception), e:

            log.error(traceback.format_exc())

            h.flash(str(e), category='warning')

            return redirect(url('home'))

        c.changes = OrderedDict()

        c.sum_added = 0

        c.sum_removed = 0

        for changeset in c.cs_ranges:

            c.changes[changeset.raw_id] = []

            try:

                changeset_parent = changeset.parents[0]

            except IndexError:

                changeset_parent = None

            #==================================================================

            # ADDED FILES

            #==================================================================

            for node in changeset.added:

                filenode_old = FileNode(node.path, '', EmptyChangeset())

                if filenode_old.is_binary or node.is_binary:

                    diff = wrap_to_table(_('binary file'))

                else:

                    c.sum_added += node.size

                    if c.sum_added < self.cut_off_limit:

                        f_udiff = differ.get_udiff(filenode_old, node)

                        diff = differ.DiffProcessor(f_udiff).as_html()

                    else:

                        diff = wrap_to_table(_('Changeset is to big and was cut'

                                            ' off, see raw changeset instead'))

                cs1 = None

                cs2 = node.last_changeset.raw_id

                c.changes[changeset.raw_id].append(('added', node, diff, cs1, cs2))

            #==================================================================

            # CHANGED FILES

            #==================================================================

            for node in changeset.changed:

                try:

                    filenode_old = changeset_parent.get_node(node.path)

                except ChangesetError:

                    filenode_old = FileNode(node.path, '', EmptyChangeset())

                if filenode_old.is_binary or node.is_binary:

                    diff = wrap_to_table(_('binary file'))

                else:

                    if c.sum_removed < self.cut_off_limit:

                        f_udiff = differ.get_udiff(filenode_old, node)

                        diff = differ.DiffProcessor(f_udiff).as_html()

                        if diff:

                            c.sum_removed += len(diff)

                    else:

                        diff = wrap_to_table(_('Changeset is to big and was cut'

                                            ' off, see raw changeset instead'))

                cs1 = filenode_old.last_changeset.raw_id

                cs2 = node.last_changeset.raw_id

                c.changes[changeset.raw_id].append(('changed', node, diff, cs1, cs2))

            #==================================================================

            # REMOVED FILES    

            #==================================================================

            for node in changeset.removed:

                c.changes[changeset.raw_id].append(('removed', node, None, None, None))

        if len(c.cs_ranges) == 1:

            c.changeset = c.cs_ranges[0]

            c.changes = c.changes[c.changeset.raw_id]

            return render('changeset/changeset.html')

        else:

            return render('changeset/changeset_range.html')

    def raw_changeset(self, revision):

        hg_model = ScmModel()

        method = request.GET.get('diff', 'show')

        try:

            r = hg_model.get_repo(c.repo_name)

            c.scm_type = r.alias

            c.changeset = r.get_changeset(revision)

        except RepositoryError:

            log.error(traceback.format_exc())

            return redirect(url('home'))

        else:

            try:

                c.changeset_parent = c.changeset.parents[0]

            except IndexError:

                c.changeset_parent = None

            c.changes = []

            for node in c.changeset.added:

                filenode_old = FileNode(node.path, '')

                if filenode_old.is_binary or node.is_binary:

                    diff = _('binary file') + '\n'

                else:

                    f_udiff = differ.get_udiff(filenode_old, node)

                    diff = differ.DiffProcessor(f_udiff).raw_diff()

                cs1 = None

                cs2 = node.last_changeset.raw_id

                c.changes.append(('added', node, diff, cs1, cs2))

            for node in c.changeset.changed:

                filenode_old = c.changeset_parent.get_node(node.path)

                if filenode_old.is_binary or node.is_binary:

                    diff = _('binary file')

                else:

                    f_udiff = differ.get_udiff(filenode_old, node)

                    diff = differ.DiffProcessor(f_udiff).raw_diff()

                cs1 = filenode_old.last_changeset.raw_id

                cs2 = node.last_changeset.raw_id

                c.changes.append(('changed', node, diff, cs1, cs2))

        response.content_type = 'text/plain'

        if method == 'download':

            response.content_disposition = 'attachment; filename=%s.patch' % revision

        parent = True if len(c.changeset.parents) > 0 else False

        c.parent_tmpl = 'Parent  %s' % c.changeset.parents[0].raw_id if parent else ''

        c.diffs = ''

        for x in c.changes:

            c.diffs += x[2]

        return render('changeset/raw_changeset.html')

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

"""

    rhodecode.lib.smtp_mailer

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

    Simple smtp mailer used in RhodeCode

    :copyright: (c) 2011 by marcink.

    :license: LICENSE_NAME, see LICENSE_FILE for more details.

"""

import logging

import smtplib

import mimetypes

from socket import sslerror

from email.mime.multipart import MIMEMultipart

from email.mime.image import MIMEImage

from email.mime.audio import MIMEAudio

from email.mime.base import MIMEBase

from email.mime.text import MIMEText

from email.utils import formatdate

from email import encoders

class SmtpMailer(object):

    """SMTP mailer class

    mailer = SmtpMailer(mail_from, user, passwd, mail_server, mail_port, ssl, tls)

    mailer.send(recipients, subject, body, attachment_files)    

    :param recipients might be a list of string or single string

    :param attachment_files is a dict of {filename:location} 

        it tries to guess the mimetype and attach the file 

    """

    def __init__(self, mail_from, user, passwd, mail_server,

                    mail_port=None, ssl=False, tls=False):

        self.mail_from = mail_from

        self.mail_server = mail_server

        self.mail_port = mail_port

        self.user = user

        self.passwd = passwd

        self.ssl = ssl

        self.tls = tls

        self.debug = False

    def send(self, recipients=[], subject='', body='', attachment_files={}):

        if isinstance(recipients, basestring):

            recipients = [recipients]

        if self.ssl:

            smtp_serv = smtplib.SMTP_SSL(self.mail_server, self.mail_port)

        else:

            smtp_serv = smtplib.SMTP(self.mail_server, self.mail_port)

        if self.tls:

            smtp_serv.ehlo()

            smtp_serv.starttls()

        if self.debug:

            smtp_serv.set_debuglevel(1)

        smtp_serv.ehlo()

        #if server requires authorization you must provide login and password

        #but only if we have them

        if self.user and self.passwd:

            smtp_serv.login(self.user, self.passwd)

        date_ = formatdate(localtime=True)

        msg = MIMEMultipart()

        msg['From'] = self.mail_from

        msg['To'] = ','.join(recipients)

        msg['Date'] = date_

        msg['Subject'] = subject

        msg.preamble = 'You will not see this in a MIME-aware mail reader.\n'

        msg.attach(MIMEText(body))

        if attachment_files:

            self.__atach_files(msg, attachment_files)

        smtp_serv.sendmail(self.mail_from, recipients, msg.as_string())

        logging.info('MAIL SEND TO: %s' % recipients)

        try:

            smtp_serv.quit()

        except sslerror:

            # sslerror is raised in tls connections on closing sometimes

            pass

    def __atach_files(self, msg, attachment_files):

        if isinstance(attachment_files, dict):

            for f_name, msg_file in attachment_files.items():

                ctype, encoding = mimetypes.guess_type(f_name)

                logging.info("guessing file %s type based on %s" , ctype, f_name)

                if ctype is None or encoding is not None:

                    # No guess could be made, or the file is encoded (compressed), so

                    # use a generic bag-of-bits type.

                    ctype = 'application/octet-stream'

                maintype, subtype = ctype.split('/', 1)

                if maintype == 'text':

                    # Note: we should handle calculating the charset

                    file_part = MIMEText(self.get_content(msg_file),

                                         _subtype=subtype)

                elif maintype == 'image':

                    file_part = MIMEImage(self.get_content(msg_file),

                                          _subtype=subtype)

                elif maintype == 'audio':

                    file_part = MIMEAudio(self.get_content(msg_file),

                                          _subtype=subtype)

                else:

                    file_part = MIMEBase(maintype, subtype)

                    file_part.set_payload(self.get_content(msg_file))

                    # Encode the payload using Base64

                    encoders.encode_base64(msg)

                # Set the filename parameter

                file_part.add_header('Content-Disposition', 'attachment',

                                     filename=f_name)

                file_part.add_header('Content-Type', ctype, name=f_name)

                msg.attach(file_part)

        else:

            raise Exception('Attachment files should be'

                            'a dict in format {"filename":"filepath"}')

    def get_content(self, msg_file):

        '''

        Get content based on type, if content is a string do open first

        else just read because it's a probably open file object

        :param msg_file:

        '''

        if isinstance(msg_file, str):

            return open(msg_file, "rb").read()

        else:

            #just for safe seek to 0

            msg_file.seek(0)

            return msg_file.read()