def generatePreview(self, width, height, mt="image/jpeg", quality=88):
        name = "%sx%s" % (width, height)
        if name in self:
            return self[name]

        image = self.__parent__

        if not image:
            return

        try:
            data = convert(
                image.data.data,
                "image/jpeg",
                sourceMimetype=image.data.mimeType,
                width=width,
                height=height,
                quality=quality,
            )
        except ConverterException:
            logger.warning("Conversion Error:", exc_info=True)
            return

        preview = File()
        preview.data = data
        preview.filename = name
        preview.mimeType = u"image/jpeg"
        event.notify(ObjectCreatedEvent(preview))

        self[name] = preview
        return self[name]
 def handleApply(self, action):
     data, errors = self.extractData()
     if not errors:
         self.context.avatar = data['avatar']
         if data.get('avatarImage') is not None:
             image = Image()
             image.data = data['avatarImage'].data
             image.mimeType = data['avatarImage'].mimeType
             
             configlet = getUtility(IAvatarConfiglet)
             if (image.width > configlet.maxWidth or
                 image.height > configlet.maxHeight):
                 try:
                     image.data = convert(
                         image.data, 'image/jpeg',
                         sourceMimetype = image.mimeType,
                         width = configlet.maxWidth,
                         height = configlet.maxHeight, quality=88)
                 except ConverterException, err:
                     log = logging.getLogger('zojax.profile')
                     log.log(logging.WARNING, str(err))
                     IStatusMessage(self.request).add(err, 'error')
                     return
                 else:
                     self.context.avatarImage = image
             else:
                 self.context.avatarImage = image
             
             self.context.avatar = 0
    def applyChanges(self, data):
        changes = list(self.context.setProfileData(data))
        self.context.timezone = data['timezone']

        if 'profileImage' in data and \
                not IFileDataNoValue.providedBy(data['profileImage']) and \
                data['profileImage'] is not None:
            image = Image()
            image.data = data['profileImage'].data
            image.mimeType = data['profileImage'].mimeType

            configlet = getUtility(IProfilesCategory)
            if (image.width > configlet.profileImageWidth or
                image.height > configlet.profileImageHeight):
                try:
                    image.data = convert(
                        image.data, 'image/jpeg',
                        sourceMimetype = image.mimeType,
                        width = configlet.profileImageWidth,
                        height = configlet.profileImageHeight, quality=88)

                except ConverterException, err:
                    log = logging.getLogger('zojax.profile')
                    log.log(logging.WARNING, str(err))
                    IStatusMessage(self.request).add(err, 'error')
                else:
                    self.context.profileImage = image
            else:
                self.context.profileImage = image
            changes.append('profileImage')
def principalProfileModified(profile, event):
    profile.modified = parseDatetimetz(str(datetime.datetime.now()))

    configlet = getUtility(IProfilesCategory)
    if configlet.photoAsAvatar and profile.profileImage:
        image = copy(profile.profileImage)
        configlet = getUtility(IAvatarConfiglet)
        if (image.width > configlet.maxWidth or
            image.height > configlet.maxHeight):
            try:
                image.data = convert(
                    image.data, 'image/jpeg',
                    sourceMimetype = image.mimeType,
                    width = configlet.maxWidth,
                    height = configlet.maxHeight, quality=88)
            except ConverterException, err:
                log = logging.getLogger('zojax.personal.profile')
                log.log(logging.WARNING, str(err))
                return
            else:
                profile.avatarImage = image
        else:
            profile.avatarImage = image

        profile.avatar = 0
    def handleUpload(self, action):
        data, errors = self.extractData()
        if errors:
            pass
        else:
            file = data['data']

            image = Image()
            image.data = file.data
            image.mimeType = file.mimeType

            if (image.width > self.container.maxWidth or
                image.height > self.container.maxHeight):
                try:
                    image.data = convert(
                        image.data, 'image/jpeg',
                        sourceMimetype = image.mimeType,
                        width = self.container.maxWidth,
                        height = self.container.maxHeight, quality=88)
                except ConverterException, err:
                    log = logging.getLogger('zojax.profile.avatar')
                    log.log(logging.WARNING, str(err))
                    IStatusMessage(self.request).add(err, 'error')
                    return

            if not data['title']:
                data['title'] = file.filename

            avatar = self.context.create(title=data['title'], data=image)
            self.context.add(avatar)
            IStatusMessage(self.request).add(_(u'Avatar sccessully uploaded.'))
            self.redirect('.')
Beispiel #6
0
    def generatePreview(self, width, height, quality=88):
        name = '%sx%s'%(width, height)
        if name in self:
            return self[name]

        photoFile = self.__parent__.data
        if photoFile is None:
            return

        try:
            data = convert(photoFile.data, 'image/jpeg',
                           sourceMimetype=photoFile.mimeType,
                           width=width, height=height, quality=quality)
        except ConverterException, err:
            log = logging.getLogger('zojax.photoalbum')
            log.log(logging.WARNING, str(err))
            return
Beispiel #7
0
    def generatePreview(self):
        MAX_VALUE = getUtility(IPreviewsCatalog).maxValue * 1024 * 1024
        size = 0

        if self.parent.size < MAX_VALUE and not self.parent.disablePreview:
            logger.info(
                "Start generating preview for: %s" % self.parent.filename)
            fp = self.openPreview('w')
            ff = self.parent.open()
            try:
                fp.write(api.convert(
                    ff, 'application/x-shockwave-flash', self.parent.mimeType,
                    filename=self.parent.filename))
                size = int(fp.tell())
            except (ConverterException, OSError), e:
                logger.warning(
                    'Error generating preview for %s: %s',
                    self.parent.filename, e)
            except:
    def generatePreview(self, width, height, mt="image/jpeg", quality=88):
        name = "%sx%s" % (width, height)
        if name in self:
            return self[name]

        media = self.__parent__

        if not media:
            return

        try:
            data = convert(
                open(os.path.join(browser.__path__[0], "media_icon.gif")).read(),
                "image/jpeg",
                sourceMimetype="image/gif",
                width=width,
                height=height,
                quality=quality,
            )
        except (ConverterException, ConverterNotFound), e:
            logger.warning("Conversion Error:", exc_info=True)
            return
Beispiel #9
0
 def scale(self, width, height, quality=88):
     self.data = api.convert(
         self.data, self.mimeType, self.mimeType,
         width=width, height=height, quality=quality)