def read(self, nbytes=None): ''' @see: Content.read ''' if not self._response: try: req = Request(self._url, headers={'User-Agent': 'Magic Browser'}) self._response = urlopen(req) except (HTTPError, socket.error) as e: log.error('Can not read icon image data %s' % e) raise InputError(Ref(_('Can not open icon URL'), )) if not self._response: log.error('Can not read icon image data %s' % e) raise InputError(Ref(_('Can not open icon URL'), )) if str(self._response.status) != '200': raise InputError(Ref(_('Can not open icon URL'), )) self.type = self._response.getheader('Content-Type') if not self.type: self.type = 'image' self.length = self._response.getheader('Content-Length') if not self.length: self.length = 0 if (not self._response) or self._response.closed: return '' try: if nbytes: return self._response.read(nbytes) return self._response.read() except (HTTPError, socket.error) as e: log.error('Can not read icon image data %s' % e) raise InputError(Ref(_('Can not read from icon URL'), ))
def handle(e, entity): ''' Handles the SQL alchemy exception while inserting or updating. ''' if isinstance(e, IntegrityError): raise InputError( Ref(_('Cannot persist, failed unique constraints on entity'), model=typeFor(entity).container)) if isinstance(e, OperationalError): raise InputError( Ref(_('A foreign key is not valid'), model=typeFor(entity).container)) raise e
def onPropertyForeignKey(mapped, foreignColumn, prop, obj, errors): ''' Validation of a sql alchemy fpreign key property. @param mapped: class The mapped model class. @param foreignColumn: Column The foreign column used for checking. @param prop: string The property name tthat contains the foreign key. @param obj: object The entity to check for the property value. @param errors: list[Ref] The list of errors. ''' assert isclass(mapped), 'Invalid class %s' % mapped assert isinstance(foreignColumn, Column), 'Invalid foreign column %s' % foreignColumn assert isinstance(prop, str), 'Invalid property name %s' % prop assert obj is not None, 'None is not a valid object' assert isinstance(errors, list), 'Invalid errors list %s' % errors propRef = getattr(mapped, prop) if propRef in obj: val = getattr(obj, prop) if val is not None: count = openSession().query(foreignColumn).filter( foreignColumn == val).count() if count == 0: errors.append(Ref(_('Unknown foreign id'), ref=propRef)) return False
def onPropertyUnique(mapped, prop, obj, errors): ''' Validation of a sql alchemy unique property. @param mapped: class The mapped model class. @param prop: string The property name to be checked if unique. @param obj: object The entity to check for the property value. @param errors: list[Ref] The list of errors. ''' assert isclass(mapped), 'Invalid class %s' % mapped assert isinstance(prop, str), 'Invalid property name %s' % prop assert obj is not None, 'None is not a valid object' assert isinstance(errors, list), 'Invalid errors list %s' % errors propRef = getattr(mapped, prop) if propRef in obj: try: db = openSession().query(mapped).filter( propRef == getattr(obj, prop)).one() except NoResultFound: return propId = typeFor(mapped).container.propertyId if getattr(obj, propId) != getattr(db, propId): errors.append( Ref(_('Already an entry with this value'), ref=propRef)) return False
def getById(self, id, scheme, thumbSize=None): ''' @see: IMetaDataService.getById ''' metaData = self.session().query(self.MetaData).get(id) if metaData is None: raise InputError(Ref(_('Unknown meta data'), ref=self.MetaData.Id)) return self.referencer.populate(metaData, scheme, thumbSize)
def getByCode(self, code, locales): ''' @see: ILanguageService.getByCode ''' locale = self._localeOf(code) if not locale: raise InputError(Ref(_('Unknown language code'), ref=Language.Code)) return self._populate(Language(code), self._translator(locale, self._localesOf(locales)))
def deleteSource(self, blogId, sourceId): ''' @see: IBlogSourceService.deleteSource ''' assert isinstance(blogId, int), 'Invalid blog identifier %s' % blogId assert isinstance(sourceId, int), 'Invalid source identifier %s' % sourceId try: res = self.session().query(BlogSourceDB).filter( BlogSourceDB.blog == blogId).filter( BlogSourceDB.source == sourceId).delete() > 0 if res: sourceTypeKey, = self.session().query( SourceTypeMapped.Key).join( SourceMapped, SourceTypeMapped.id == SourceMapped.typeId).filter( SourceMapped.Id == sourceId).one() if sourceTypeKey in self.sources_auto_delete: self.sourceService.delete(sourceId) return res except OperationalError: assert log.debug( 'Could not delete blog source with blog id \'%s\' and source id \'%s\'', blogId, sourceId, exc_info=True) or True raise InputError(Ref(_('Cannot delete because is in use'), ))
def reorder(self, blogId, postId, refPostId, before=True): ''' @see: IBlogPostService.reorder ''' sql = self.session().query(BlogPostMapped.Order) sql = sql.filter(BlogPostMapped.Blog == blogId) sql = sql.filter(BlogPostMapped.Id == refPostId) order = sql.scalar() if not order: raise InputError(Ref(_('Invalid before post'))) sql = self.session().query(BlogPostMapped.Order) sql = sql.filter(BlogPostMapped.Blog == blogId) sql = sql.filter(BlogPostMapped.Id != postId) if before: sql = sql.filter(BlogPostMapped.Order > order) sql = sql.order_by(BlogPostMapped.Order) else: sql = sql.filter(BlogPostMapped.Order < order) sql = sql.order_by(desc_op(BlogPostMapped.Order)) sql = sql.limit(1) orderPrev = sql.scalar() if orderPrev: order = (order + orderPrev) / 2 elif before: order += 1 else: order -= 1 post = self.getById(blogId, postId) assert isinstance(post, BlogPostMapped) post.Order = order post.CId = self._nextCId() self.session().merge(post)
def reorder(self, blogTypeId, postId, refPostId, before=True): ''' @see: IBlogPostService.reorder ''' sql = self.session().query(BlogTypePostMapped.Order) sql = sql.filter(BlogTypePostMapped.BlogType == blogTypeId) sql = sql.filter(BlogTypePostMapped.Id == refPostId) order = sql.scalar() if order is None: raise InputError(Ref(_('Invalid before post'))) sql = self.session().query(BlogTypePostMapped.Order) sql = sql.filter(BlogTypePostMapped.BlogType == blogTypeId) sql = sql.filter(BlogTypePostMapped.Id != postId) if before: sql = sql.filter(BlogTypePostMapped.Order < order) sql = sql.order_by(desc_op(BlogTypePostMapped.Order)) else: sql = sql.filter(BlogTypePostMapped.Order > order) sql = sql.order_by(BlogTypePostMapped.Order) sql = sql.limit(1) orderPrev = sql.scalar() if orderPrev is not None: order = (order + orderPrev) / 2 else: order = order - 1 if before else order + 1 post = self.getById(blogTypeId, postId) assert isinstance(post, BlogTypePostMapped) post.Order = order self.session().merge(post) self.session().flush((post, ))
def getRequest(self, id): ''' @see: IRequestService.getRequest ''' self._refresh() if id not in self._requests: raise InputError(Ref(_('Invalid request id'), ref=Request.Id)) return self._requests[id]
def getMethod(self, id): ''' @see: IRequestService.getMethod ''' self._refresh() if id not in self._methods: raise InputError(Ref(_('Invalid method id'), ref=Method.Id)) return self._methods[id]
def getByCode(self, code, locales): ''' @see: ICountryService.getByCode ''' if code not in self.countries: raise InputError(Ref(_('Unknown country code'), ref=Country.Code)) return Country(code, self._translate(code, self._localesOf(locales)))
def addCollaborator(self, blogId, collaboratorId, typeName): ''' @see: IBlogCollaboratorService.addCollaborator ''' typeId = self.collaboratorTypeIds()[typeName] if typeId is None: raise InputError( Ref(_('Invalid collaborator type'), ref=BlogCollaborator.Type)) sql = self.session().query(BlogCollaboratorEntry) sql = sql.filter(BlogCollaboratorEntry.Blog == blogId) sql = sql.filter( BlogCollaboratorEntry.blogCollaboratorId == collaboratorId) if sql.update({BlogCollaboratorEntry.typeId: typeId}) > 0: return sql = self.session().query(BlogCollaboratorMapped.Id) sql = sql.join(BlogMapped) sql = sql.filter(BlogCollaboratorMapped.User == BlogMapped.Creator) sql = sql.filter(BlogMapped.Id == blogId) sql = sql.filter(BlogCollaboratorMapped.Id == collaboratorId) if sql.count() > 0: raise InputError( _('The blog creator cannot be assigned as a collaborator')) bgc = BlogCollaboratorEntry() bgc.Blog = blogId bgc.blogCollaboratorId = collaboratorId bgc.typeId = typeId self.session().add(bgc) self.session().flush((bgc, ))
def getById(self, id, locales): ''' @see: ILanguageService.getById ''' locales = self._localesOf(locales) language = self.session().query(LanguageEntity).get(id) if not language: raise InputError(Ref(_('Unknown language id'), ref=LanguageEntity.Id)) return self._populate(language, self._translator(self._localeOf(language.Code), locales))
def getById(self, id): ''' @see: IUserService.getById ''' user = self.session().query(UserMapped).get(id) if not user: raise InputError(Ref(_('Unknown user id'), ref=User.Id)) assert isinstance(user, UserMapped), 'Invalid user %s' % user return user
def getById(self, guid): ''' Implementation for @see: IItemService.getById ''' item = self.session().query(ItemMapped).get(guid) if not item: raise InputError(Ref(_('Unknown id'), ref=ItemMapped.GUId)) return item
def getAllInputs(self, id): ''' @see: IRequestService.getAllInputs ''' self._refresh() if not id: return self._inputs.values() if id not in self._patternInputs: raise InputError(Ref(_('Invalid request id'), ref=Request.Id)) return (self._inputs[inpId] for inpId in self._patternInputs[id])
def detachIcon(self, personIconId): ''' @see: IPersonIconService.detachIcon ''' try: return self.session().query(PersonIconMapped).filter(PersonIconMapped.Id == personIconId).delete() > 0 except (OperationalError, IntegrityError): raise InputError(Ref(_('Can not detach person icon because in use'),))
def getById(self, id): ''' @see: IEntityGetService.getById ''' entity = self.session().query(self.Entity).get(id) if not entity: raise InputError(Ref(_('Unknown id'), ref=self.Entity.Id)) return entity
def getByKey(self, key): ''' @see: IEntityGetService.getByKey ''' try: return self.session().query( self.Entity).filter(self.Entity.Key == key).one() except NoResultFound: raise InputError(Ref(_('Unknown key'), ref=self.Entity.Key))
def getByName(self, name): ''' @see: IRoleService.getByName ''' try: return self.session().query(RoleMapped).filter( RoleMapped.Name == name).one() except NoResultFound: raise InputError(Ref(_('Unknown name'), ref=Role.Name))
def getById(self, id): ''' @see: IComponentService.getById ''' assert isinstance(id, str), 'Invalid id %s' % id modules = modulesIn('%s.%s' % (self.package, id)).asList() if len(modules) != 1: raise InputError(Ref(_('Invalid component id'), ref=Component.Id)) return self.componentFor(modules[0])
def getById(self, id): ''' @see: IPluginService.getById ''' assert isinstance(id, str), 'Invalid id %s' % id modules = modulesIn('%s.%s' % ('__plugin__', id)).asList() if len(modules) != 1: raise InputError(Ref(_('Invalid plugin id'), ref=Plugin.Id)) return self.pluginFor(modules[0])
def _typeId(self, key): ''' Provides the source type id that has the provided key. ''' try: sql = self.session().query(SourceTypeMapped.id).filter(SourceTypeMapped.Key == key) return sql.one()[0] except NoResultFound: raise InputError(Ref(_('Invalid source type %(type)s') % dict(type=key), ref=Source.Type))
def updateLastAccessOn(session, groupId): sql = session.query(BlogCollaboratorGroupMapped) sql = sql.filter(BlogCollaboratorGroupMapped.Id == groupId) try: group = sql.one() except NoResultFound: raise InputError(Ref(_('No collaborator group'), ref=BlogCollaboratorGroupMapped.Id)) group.LastAccessOn = current_timestamp() session.add(group) session.flush((group,))
def getById(self, blogId, postId): ''' @see: IBlogPostService.getById ''' sql = self.session().query(BlogPostMapped) sql = sql.filter(BlogPostMapped.Blog == blogId) sql = sql.filter(BlogPostMapped.Id == postId) try: return sql.one() except NoResultFound: raise InputError(Ref(_('No such blog post'), ref=BlogPostMapped.Id))
def getById(self, blogId, userId): ''' @see: IBlogAdminService.getById ''' sql = self.session().query(AdminMapped) sql = sql.filter(AdminMapped.Blog == blogId) sql = sql.filter(AdminMapped.Id == userId) try: return sql.one() except NoResultFound: raise InputError(Ref(_('No administrator'), ref=AdminMapped.Id))
def getByPersonId(self, id, scheme='http', thumbSize=None): ''' @see: IPersonIconService.getById ''' personIcon = self.session().query(PersonIconMapped).get(id) if not personIcon: raise InputError(Ref(_('Invalid person icon'), ref=PersonIconMapped.Id)) assert isinstance(personIcon, PersonIconMapped) assert isinstance(self.metaDataService, IMetaDataService) metaData = self.metaDataService.getById(personIcon.MetaData, scheme, thumbSize) return metaData
def getById(self, id): ''' @see: IMetaTypeService.getById ''' try: return self.session().query(MetaTypeMapped).filter( MetaTypeMapped.Id == id).one() except NoResultFound: raise InputError( Ref(_('Unknown meta type id'), ref=MetaTypeMapped.Id))
def delete(self, id): ''' @see: IEntityCRUDService.delete ''' try: return self.session().query( self.Entity).filter(self.Entity.Id == id).delete() > 0 except OperationalError: raise InputError( Ref(_('Cannot delete because is in use'), model=self.model))