~launchpad-pqm/launchpad/devel

# Copyright 2009 Canonical Ltd.  This software is licensed under the
# GNU Affero General Public License version 3 (see the file LICENSE).

# pylint: disable-msg=E0211,E0213

"""Product release interfaces."""

__metaclass__ = type

__all__ = [
    'IProductRelease',
    'IProductReleaseEditRestricted',
    'IProductReleaseFile',
    'IProductReleaseFileAddForm',
    'IProductReleaseFileEditRestricted',
    'IProductReleaseFilePublic',
    'IProductReleasePublic',
    'IProductReleaseSet',
    'UpstreamFileType',
    ]

from lazr.enum import (
    DBEnumeratedType,
    DBItem,
    )
from lazr.restful.declarations import (
    call_with,
    export_as_webservice_entry,
    export_factory_operation,
    export_operation_as,
    export_write_operation,
    exported,
    operation_parameters,
    REQUEST_USER,
    )
from lazr.restful.fields import (
    CollectionField,
    Reference,
    ReferenceChoice,
    )
from lazr.restful.interface import copy_field
from zope.component import getUtility
from zope.interface import Interface
from zope.schema import (
    Bytes,
    Choice,
    Datetime,
    Int,
    Text,
    TextLine,
    )

from lp.services.config import config
from lp import _
from lp.app.validators import LaunchpadValidationError
from lp.app.validators.version import sane_version
from lp.services.fields import (
    ContentNameField,
    PersonChoice,
    )


def file_size_constraint(value, max_size):
    """Check constraints.

    The file cannot be empty and must be <= max_size.
    """
    size = len(value)
    if size == 0:
        raise LaunchpadValidationError(u'Cannot upload empty file.')
    elif max_size > 0 and size > max_size:
        raise LaunchpadValidationError(
            u'Cannot upload files larger than %i bytes' % max_size)
    else:
        return True


def productrelease_file_size_constraint(value):
    """Constraint for a product release file's size."""
    max_size = config.launchpad.max_productrelease_file_size
    return file_size_constraint(value, max_size)


def productrelease_signature_size_constraint(value):
    """Constraint for a product release signature's size."""
    max_size = config.launchpad.max_productrelease_signature_size
    return file_size_constraint(value, max_size)


class UpstreamFileType(DBEnumeratedType):
    """Upstream File Type

    When upstream open source project release a product they will
    include several files in the release. All of these files are
    stored in Launchpad (we throw nothing away ;-). This schema
    gives the type of files that we know about.
    """

    CODETARBALL = DBItem(1, """
        Code Release Tarball

        This file contains code in a compressed package like
        a tar.gz or tar.bz or .zip file.
        """)

    README = DBItem(2, """
        README File

        This is a README associated with the upstream
        release. It might be in .txt or .html format, the
        filename would be an indicator.
        """)

    RELEASENOTES = DBItem(3, """
        Release Notes

        This file contains the release notes of the new
        upstream release. Again this could be in .txt or
        in .html format.
        """)

    CHANGELOG = DBItem(4, """
        ChangeLog File

        This file contains information about changes in this
        release from the previous release in the series. This
        is usually not a detailed changelog, but a high-level
        summary of major new features and fixes.
        """)

    INSTALLER = DBItem(5, """
        Installer file

        This file contains an installer for a product.  It may
        be a Debian package, an RPM file, an OS X disk image, a
        Windows installer, or some other type of installer.
        """)


class ProductReleaseVersionField(ContentNameField):

    errormessage = _(
        "%s is already in use by another version in this release series.")

    @property
    def _content_iface(self):
        return IProductRelease

    def _getByName(self, version):
        """Return the content object for the specified version.

        The version is specified either by the context directly or by the
        context's referenced productseries.  Overridden from
        `ContentFieldName`.
        """
        # Import locally to avoid circular imports.
        from lp.registry.interfaces.productseries import (
            IProductSeries)
        if IProductSeries.providedBy(self.context):
            productseries = self.context
        else:
            productseries = self.context.productseries
        releaseset = getUtility(IProductReleaseSet)
        release = releaseset.getBySeriesAndVersion(productseries, version)
        if release == self.context:
            # A ProductRelease may edit itself; do not report that another
            # ProductRelease exists with the same version.
            return None
        return release


class IProductReleaseFileEditRestricted(Interface):
    """`IProductReleaseFile` properties which require `launchpad.Edit`."""

    @export_write_operation()
    @export_operation_as('delete')
    def destroySelf():
        """Delete the product release file."""


class IProductReleaseFilePublic(Interface):
    """Public properties for `IProductReleaseFile`."""

    id = Int(title=_('ID'), required=True, readonly=True)
    productrelease = exported(
        ReferenceChoice(title=_('Project release'),
                        description=_("The parent product release."),
                        schema=Interface, # Defined later.
                        required=True,
                        vocabulary='ProductRelease'),
        exported_as='project_release')
    libraryfile = exported(
        Bytes(title=_("File"),
              description=_("The file contents."),
              readonly=True,
              required=True),
        exported_as='file')
    signature = exported(
        Bytes(title=_("File signature"),
              description=_("The file signature."),
              readonly=True,
              required=False))
    filetype = exported(
        Choice(title=_("Upstream file type"), required=True,
               vocabulary=UpstreamFileType,
               default=UpstreamFileType.CODETARBALL),
        exported_as='file_type')
    description = exported(
        Text(title=_("Description"), required=False,
             description=_('A detailed description of the file contents')))
    date_uploaded = exported(
        Datetime(title=_('Upload date'),
                 description=_('The date this file was uploaded'),
                 required=True, readonly=True))


class IProductReleaseFile(IProductReleaseFileEditRestricted,
                          IProductReleaseFilePublic):
    """A file associated with a ProductRelease."""
    export_as_webservice_entry("project_release_file", publish_web_link=False)


class IProductReleaseEditRestricted(Interface):
    """`IProductRelease` properties which require `launchpad.Edit`."""

    @call_with(uploader=REQUEST_USER)
    @operation_parameters(
        filename=TextLine(),
        signature_filename=TextLine(),
        content_type=TextLine(),
        file_content=Bytes(constraint=productrelease_file_size_constraint),
        signature_content=Bytes(
            constraint=productrelease_signature_size_constraint),
        file_type=copy_field(IProductReleaseFile['filetype'], required=False)
        )
    @export_factory_operation(
        IProductReleaseFile, ['description'])
    @export_operation_as('add_file')
    def addReleaseFile(filename, file_content, content_type,
                       uploader, signature_filename=None,
                       signature_content=None,
                       file_type=UpstreamFileType.CODETARBALL,
                       description=None):
        """Add file to the library and link to this `IProductRelease`.

        The signature file will also be added if available.

        :param filename: Name of the file being uploaded.
        :param file_content: StringIO or file object.
        :param content_type: A MIME content type string.
        :param uploader: The person who uploaded the file.
        :param signature_filename: Name of the uploaded gpg signature file.
        :param signature_content: StringIO or file object.
        :param file_type: An `UpstreamFileType` enum value.
        :param description: Info about the file.
        :returns: `IProductReleaseFile` object.
        """

    @export_write_operation()
    @export_operation_as('delete')
    def destroySelf():
        """Delete this product release.

        This method must not be used if this product release has any
        release files associated with it.
        """


class IProductReleasePublic(Interface):
    """Public `IProductRelease` properties."""

    id = Int(title=_('ID'), required=True, readonly=True)

    datereleased = exported(
        Datetime(
            title=_('Date released'), required=True,
            readonly=False,
            description=_('The date this release was published. Before '
                          'release, this should have an estimated '
                          'release date.')),
        exported_as="date_released"
        )

    version = exported(
        ProductReleaseVersionField(
            title=_('Version'),
            description= u'The specific version number assigned to this '
            'release. Letters and numbers are acceptable, for releases like '
            '"1.2rc3".',
            constraint=sane_version)
        )

    owner = exported(
        PersonChoice(
            title=u"The owner of this release.",
            required=True,
            vocabulary='ValidOwner',
            description=_("The person or team who owns  his product release.")
            )
        )

    productseries = Choice(
        title=_('Release series'), readonly=True,
        vocabulary='FilteredProductSeries')

    codename = TextLine(
        title=u'Code name', required=False, readonly=True,
        description=_('The release code-name. This is deprecated, '
                      'since it was moved to the milestone.'))

    summary = Text(
        title=_("Summary"), required=False, readonly=True,
        description=_('A brief summary of the release highlights, to '
                      'be shown at the top of the release page, and in '
                      'listings.'))

    release_notes = exported(
        Text(
            title=_("Release notes"), required=False,
            description=_('A description of important new features '
                          '(though the changelog below might repeat some of '
                          'this information).'))
        )

    changelog = exported(
        Text(
            title=_('Changelog'), required=False,
            description=_('A description of every change in the release.'))
        )

    datecreated = exported(
        Datetime(title=_('Date Created'),
                 description=_("The date this project release was created in "
                               "Launchpad."),
                 required=True, readonly=True),
        exported_as="date_created")

    displayname = exported(
        Text(title=u'Constructed display name for a project release.',
             readonly=True),
        exported_as="display_name")

    title = exported(
        Text(title=u'Constructed title for a project release.', readonly=True)
        )

    product = exported(
        Reference(title=u'The upstream project of this release.',
                  schema=Interface, readonly=True),
         exported_as="project")

    files = exported(
        CollectionField(
            title=_('Project release files'),
            description=_('A list of files for this release.'),
            readonly=True,
            value_type=Reference(schema=IProductReleaseFile)))

    milestone = exported(
        ReferenceChoice(
            title=u"Milestone for this release",
            description=_("A release requires a corresponding milestone "
                          "that is not attached to another release."),
            # Schema is set to IMilestone in interfaces/milestone.py.
            schema=Interface,
            vocabulary='Milestone',
            required=True))

    def getFileAliasByName(name):
        """Return the `LibraryFileAlias` by file name.

        Raises a NotFoundError if no matching ProductReleaseFile exists.
        """

    def getProductReleaseFileByName(name):
        """Return the `ProductReleaseFile` by file name.

        Raises a NotFoundError if no matching ProductReleaseFile exists.
        """


class IProductRelease(IProductReleaseEditRestricted,
                      IProductReleasePublic):
    """A specific release (i.e. version) of a product.

    For example: Mozilla 1.7.2 or Apache 2.0.48.
    """

    export_as_webservice_entry('project_release')


# Set the schema for IProductReleaseFile now that IProductRelease is defined.
IProductReleaseFile['productrelease'].schema = IProductRelease


class IProductReleaseFileAddForm(Interface):
    """Schema for adding ProductReleaseFiles to a project."""
    description = Text(title=_("Description"), required=True,
        description=_('A short description of the file contents'))

    filecontent = Bytes(
        title=u"File", required=True,
        constraint=productrelease_file_size_constraint)

    signature = Bytes(
        title=u"GPG signature (recommended)", required=False,
        constraint=productrelease_signature_size_constraint)

    contenttype = Choice(title=_("File content type"), required=True,
                         vocabulary=UpstreamFileType,
                         default=UpstreamFileType.CODETARBALL)


class IProductReleaseSet(Interface):
    """Auxiliary class for ProductRelease handling."""

    def getBySeriesAndVersion(productseries, version, default=None):
        """Get a release by its version and productseries.

        If no release is found, default will be returned.
        """

    def getReleasesForSeries(series):
        """Get all releases for the series."""

    def getFilesForReleases(releases):
        """Get all files for the releases."""