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))
