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)