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 unhide(self, blogId):
'''
@see: IBlogService.unhide
'''
blog = self.session().query(BlogMapped).get(blogId)
if not blog: raise InputError(_('Invalid blog or credentials'))
assert isinstance(blog, Blog), 'Invalid blog %s' % blog
blog.DeletedOn = None
self.session().merge(blog)
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: 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 putLive(self, blogId):
'''
@see: IBlogService.putLive
'''
blog = self.session().query(BlogMapped).get(blogId)
if not blog: raise InputError(_('Invalid blog or credentials'))
assert isinstance(blog, Blog), 'Invalid blog %s' % blog
blog.LiveOn = current_timestamp() if blog.LiveOn is None else None
self.session().merge(blog)
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 _typeId(self, key):
'''
Provides the post type id that has the provided key.
'''
try:
sql = self.session().query(PostTypeMapped.id).filter(PostTypeMapped.Key == key)
return sql.one()[0]
except NoResultFound:
raise InputError(Ref(_('Invalid post type %(type)s') % dict(type=key), ref=Post.Type))
def getById(self, id):
'''
@see: IUserService.getById
'''
user = self.session().query(UserMapped).get(id)
if not user or user.DeletedOn is not None:
raise InputError(Ref(_('Unknown user id'), ref=User.Id))
assert isinstance(user, UserMapped), 'Invalid user %s' % user
return user
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 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, collaboratorId):
'''
@see: IBlogCollaboratorService.getById
'''
sql = self.session().query(BlogCollaboratorMapped)
sql = sql.filter(BlogCollaboratorMapped.Blog == blogId)
sql = sql.filter(BlogCollaboratorMapped.Id == collaboratorId)
try: return sql.one()
except NoResultFound: raise InputError(Ref(_('No collaborator'), ref=BlogCollaboratorMapped.Id))
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 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 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 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 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))
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 getBlog(self, blogId):
'''
@see: IBlogService.getBlog
'''
sql = self.session().query(BlogMapped)
sql = sql.filter(BlogMapped.Id == blogId)
try:
return sql.one()
except NoResultFound:
raise InputError(Ref(_('Unknown id'), ref=Blog.Id))
def getSource(self, blogId, sourceId):
'''
@see: IBlogSourceService.getSource
'''
source = self.session().query(SourceMapped).get(sourceId)
if not source:
raise InputError(Ref(_('Unknown source'), ))
sql = self.session().query(BlogSourceDB)
sql = sql.filter(BlogSourceDB.blog == blogId).filter(
BlogSourceDB.source == sourceId)
return source
def removeCollaborator(self, blogId, collaboratorId):
'''
@see: IBlogCollaboratorService.removeCollaborator
'''
try:
sql = self.session().query(BlogCollaboratorEntry)
sql = sql.filter(BlogCollaboratorEntry.Blog == blogId)
sql = sql.filter(BlogCollaboratorEntry.blogCollaboratorId == collaboratorId)
return sql.delete() > 0
except OperationalError:
raise InputError(Ref(_('Cannot remove'), model=BlogCollaboratorMapped))
def getByName(self, parentId, name):
'''
@see: IConfigurationService.getByName
'''
sql = self.session().query(self.ConfigurationMapped)
sql = sql.filter(self.ConfigurationMapped.parent == parentId)
sql = sql.filter(self.ConfigurationMapped.Name == name)
try:
return sql.one()
except NoResultFound:
raise InputError(Ref(_('No configuration'), ))
def getById(self, groupId):
'''
@see IBlogCollaboratorGroupService.getById
'''
sql = self.session().query(BlogCollaboratorGroupMapped)
sql = sql.filter(BlogCollaboratorGroupMapped.Id == groupId)
try:
group = sql.one()
return group
except NoResultFound: raise InputError(Ref(_('No collaborator group'), ref=BlogCollaboratorGroupMapped.Id))
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 getBySlug(self, slug):
'''
@see:
'''
sql = self.session().query(ArticleMapped)
sql = sql.filter(ArticleMapped.Slug == slug)
try:
return sql.one()
except NoResultFound:
raise InputError(Ref(_('Unknown id'), ref=Article.Id))
def removeAdmin(self, blogId, userId):
'''
@see: IBlogAdminService.removeAdmin
'''
try:
sql = self.session().query(AdminEntry)
sql = sql.filter(AdminEntry.Blog == blogId)
sql = sql.filter(AdminEntry.adminId == userId)
return sql.delete() > 0
except OperationalError:
raise InputError(Ref(_('Cannot remove'), model=AdminMapped))
def _verificationStatusId(self, key):
'''
Provides the verification status id that has the provided key.
'''
if not key: key = self.default_verification_status_key
try:
sql = self.session().query(VerificationStatusMapped.id).filter(VerificationStatusMapped.Key == key)
return sql.one()[0]
except NoResultFound:
raise InputError(Ref(_('Invalid verification status %(verificationStatus)s') % dict(verificationStatus=key), ref=PostVerificationMapped.Status))
def update(self, source):
'''
@see: ISourceService.update
'''
assert isinstance(source, Source), 'Invalid source %s' % source
sourceDb = self.session().query(SourceMapped).get(source.Id)
if not sourceDb: raise InputError(Ref(_('Unknown source id'), ref=Source.Id))
if Source.Type in source: sourceDb.typeId = self._typeId(source.Type)
try:
self.session().flush((copy(source, sourceDb, exclude=('Type',)),))
except SQLAlchemyError as e: handle(e, SourceMapped)
def update(self, post):
'''
@see: IPostService.update
'''
assert isinstance(post, Post), 'Invalid post %s' % post
postDb = self.session().query(PostMapped).get(post.Id)
if not postDb or postDb.DeletedOn is not None: raise InputError(Ref(_('Unknown post id'), ref=Post.Id))
if Post.Type in post: postDb.typeId = self._typeId(post.Type)
if post.UpdatedOn is None: postDb.UpdatedOn = current_timestamp()
self.session().flush((copy(post, postDb, exclude=COPY_EXCLUDE),))
def changePassword(self, adminId, user):
'''
@see: IUserService.changePassword
'''
userDb = self.session().query(UserMapped).get(user.Id)
if not userDb or userDb.DeletedOn is not None:
assert isinstance(userDb, UserMapped), 'Invalid user %s' % userDb
raise InputError(Ref(_('Unknown user id'), ref=User.Id))
try:
userDb.password = user.Password
self.session().flush((userDb, ))
except SQLAlchemyError as e:
handle(e, userDb)
def _onPersistMessage(message):
'''
Called when a message is persisted.
'''
assert isinstance(message, Message), 'Invalid message %s' % message
if message.Plural:
if len(message.Plural) > 4:
raise InputError(
Ref(
_('Only a maximum of four plural forms is accepted, got %(nplurals)i'
) % dict(nplurals=len(message.Plural))))
for k, plural in enumerate(message.Plural, 1):
setattr(message, 'plural%s' % k, plural)