def register(self, gateways):
'''
Register the method override gateways based on the provided gateways.
'''
assert isinstance(gateways, Iterable), 'Invalid gateways %s' % gateways
for gateway in gateways:
assert isinstance(gateway, Gateway), 'Invalid gateway %s' % gateway
yield gateway
if not gateway.Methods: continue
methods, overrides = set(), set()
for method in gateway.Methods:
override = self.methods_override.get(method)
if override:
methods.add(method)
overrides.update(override)
# If the override methods are already declared as methods we don't need to declare them anymore
if methods.union(overrides).issubset(gateway.Methods): continue
ogateway = Gateway()
copy(gateway, ogateway, exclude=('Methods',))
ogateway.Methods = list(overrides)
if Gateway.Headers not in ogateway: ogateway.Headers = []
for method in methods:
ogateway.Headers.append(self.pattern_xmethod_override % method)
yield ogateway
def insert(self, post):
'''
@see: IPostService.insert
'''
assert isinstance(post, Post), 'Invalid post %s' % post
postDb = PostMapped()
copy(post, postDb, exclude=COPY_EXCLUDE)
postDb.typeId = self._typeId(post.Type)
# TODO: implement the proper fix using SQLAlchemy compilation rules
nohigh = { i: None for i in range(0x10000, 0x110000) }
if postDb.Meta: postDb.Meta = postDb.Meta.translate(nohigh)
if postDb.Content: postDb.Content = postDb.Content.translate(nohigh)
if postDb.ContentPlain: postDb.ContentPlain = postDb.ContentPlain.translate(nohigh)
if post.CreatedOn is None: postDb.CreatedOn = current_timestamp()
if not postDb.Author:
colls = self.session().query(CollaboratorMapped).filter(CollaboratorMapped.User == postDb.Creator).all()
if not colls:
coll = CollaboratorMapped()
coll.User = postDb.Creator
src = self.session().query(SourceMapped).filter(SourceMapped.Name == PostServiceAlchemy.default_source_name).one()
coll.Source = src.Id
self.session().add(coll)
self.session().flush((coll,))
colls = (coll,)
postDb.Author = colls[0].Id
self.session().add(postDb)
self.session().flush((postDb,))
post.Id = postDb.Id
return post.Id
def insert(self, post):
'''
@see: IPostService.insert
'''
assert isinstance(post, Post), 'Invalid post %s' % post
postDb = PostMapped()
copy(post, postDb, exclude=COPY_EXCLUDE)
postDb.typeId = self._typeId(post.Type)
postDb = self._adjustTexts(postDb)
if post.CreatedOn is None: postDb.CreatedOn = current_timestamp()
if not postDb.Author:
colls = self.session().query(CollaboratorMapped).filter(
CollaboratorMapped.User == postDb.Creator).all()
if not colls:
coll = CollaboratorMapped()
coll.User = postDb.Creator
src = self.session().query(SourceMapped).filter(
SourceMapped.Name ==
PostServiceAlchemy.default_source_name).one()
coll.Source = src.Id
self.session().add(coll)
self.session().flush((coll, ))
colls = (coll, )
postDb.Author = colls[0].Id
self.session().add(postDb)
self.session().flush((postDb, ))
post.Id = postDb.Id
return post.Id
def insert(self, post):
'''
@see: IPostService.insert
'''
assert isinstance(post, Post), 'Invalid post %s' % post
postDb = PostMapped()
copy(post, postDb, exclude=COPY_EXCLUDE)
postDb.typeId = self._typeId(post.Type)
postDb = self._adjustTexts(postDb)
if post.CreatedOn is None: postDb.CreatedOn = current_timestamp()
if not postDb.Author:
colls = self.session().query(CollaboratorMapped).filter(CollaboratorMapped.User == postDb.Creator).all()
if not colls:
coll = CollaboratorMapped()
coll.User = postDb.Creator
src = self.session().query(SourceMapped).filter(SourceMapped.Name == PostServiceAlchemy.default_source_name).one()
coll.Source = src.Id
self.session().add(coll)
self.session().flush((coll,))
colls = (coll,)
postDb.Author = colls[0].Id
self.session().add(postDb)
self.session().flush((postDb,))
post.Id = postDb.Id
return post.Id
def insert(self, source):
'''
@see: ISourceService.insert
'''
assert isinstance(source, Source), 'Invalid source %s' % source
if source.URI:
list = source.URI.split('//')
source.URI = '//' + list[-1]
if source.OriginURI:
list = source.OriginURI.split('//')
source.OriginURI = '//' + list[-1]
sourceDb = SourceMapped()
sourceDb.typeId = self._typeId(source.Type)
copy(source, sourceDb, exclude=('Type', ))
try:
self.session().add(sourceDb)
self.session().flush((sourceDb, ))
except SQLAlchemyError as e:
handle(e, sourceDb)
source.Id = sourceDb.Id
return sourceDb.Id
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: 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()
copy(post, postDb, exclude=COPY_EXCLUDE)
postDb = self._adjustTexts(postDb)
self.session().flush((postDb, ))
def processChildCount(actions):
'''
Process the child count for the provided actions list.
'''
actions = sorted(actions, key=lambda action: action.Path)
for k, action in enumerate(actions):
actionWithCount = Action()
copy(action, actionWithCount, exclude=('ChildrenCount', ))
childCount, path = 0, action.Path + '.'
for i in range(k + 1, len(actions)):
if actions[i].Path.startswith(path): childCount += 1
else: break
actionWithCount.ChildrenCount = childCount
yield actionWithCount
def processChildCount(actions):
'''
Process the child count for the provided actions list.
'''
actions = sorted(actions, key=lambda action: action.Path)
for k, action in enumerate(actions):
actionWithCount = Action()
copy(action, actionWithCount, exclude=('ChildrenCount',))
childCount, path = 0, action.Path + '.'
for i in range(k + 1, len(actions)):
if actions[i].Path.startswith(path): childCount += 1
else: break
actionWithCount.ChildrenCount = childCount
yield actionWithCount
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: 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()
copy(post, postDb, exclude=COPY_EXCLUDE)
postDb = self._adjustTexts(postDb)
self.session().flush((postDb,))
def insert(self, post):
"""
@see: IPostService.insert
"""
assert isinstance(post, Post), "Invalid post %s" % post
if post.Uuid is None:
post.Uuid = str(uuid4().hex)
if post.WasPublished is None:
if post.PublishedOn is None:
post.WasPublished = 0
else:
post.WasPublished = 1
postDb = PostMapped()
copy(post, postDb, exclude=COPY_EXCLUDE)
postDb.typeId = self._typeId(post.Type)
postDb = self._adjustTexts(postDb)
if post.CreatedOn is None:
postDb.CreatedOn = current_timestamp()
if not postDb.Author:
colls = self.session().query(CollaboratorMapped).filter(CollaboratorMapped.User == postDb.Creator).all()
if not colls:
coll = CollaboratorMapped()
coll.User = postDb.Creator
src = (
self.session()
.query(SourceMapped)
.filter(SourceMapped.Name == PostServiceAlchemy.default_source_name)
.one()
)
coll.Source = src.Id
self.session().add(coll)
self.session().flush((coll,))
colls = (coll,)
postDb.Author = colls[0].Id
self.session().add(postDb)
self.session().flush((postDb,))
post.Id = postDb.Id
postVerification = PostVerification()
postVerification.Id = post.Id
self.postVerificationService.insert(postVerification)
return post.Id
def insert(self, source):
'''
@see: ISourceService.insert
'''
assert isinstance(source, Source), 'Invalid source %s' % source
sourceDb = SourceMapped()
sourceDb.typeId = self._typeId(source.Type)
copy(source, sourceDb, exclude=('Type',))
try:
self.session().add(sourceDb)
self.session().flush((sourceDb,))
except SQLAlchemyError as e: handle(e, sourceDb)
source.Id = sourceDb.Id
return sourceDb.Id
def insert(self, item):
'''
@see: IItemService.insert
'''
assert self.modelType.isValid(
item), 'Invalid item %s, expected %s' % (item, ItemMapped)
assert isinstance(item, Item)
assert item.ItemClass == CLASS_TEXT or item.ItemClass == CLASS_PACKAGE, \
'Invalid item class %s, expected %s or %s' % (item.ItemClass, CLASS_TEXT, CLASS_PACKAGE)
itemDb = copy(item, ItemMapped())
assert isinstance(itemDb, ItemMapped)
# TODO: generate proper guid: generate better itemId, externalise as a service
itemDb.GUId = self.guid_scheme % {
'prefix': self.guid_prefix,
'provider': self.guid_provider,
'dateId': date.today().strftime('%Y%m%d'),
'itemId': itemDb.SlugLine
}
itemDb.FirstCreated = current_timestamp()
try:
self.session().add(itemDb)
self.session().flush((itemDb, ))
except SQLAlchemyError as e:
handle(e, itemDb)
item.GUId = itemDb.GUId
return itemDb.GUId
def update(self, media:BlogMedia):
'''
@see: IBlogMediaService.update
'''
assert isinstance(media, BlogMedia), 'Invalid blog media %s' % media
mediaDb = self.session().query(BlogMediaMapped).get(media.Id)
if not mediaDb: raise InputError(Ref(_('Unknown blog media id'), ref=BlogMedia.Id))
copy(media, mediaDb, exclude=('Type',))
if BlogMedia.Type in media: mediaDb.typeId = self._typeId(media.Type)
if (BlogMedia.Rank in media) and (media.Rank < 1):
mediaDb.Rank = self._nextRank(mediaDb.Id, mediaDb.Blog, mediaDb.typeId)
try:
self.session().flush((mediaDb,))
except SQLAlchemyError as e: handle(e, mediaDb)
def update(self, entity):
'''
@see: IEntityCRUDService.update
'''
assert self.modelType.isValid(entity), 'Invalid entity %s, expected %s' % (entity, self.Entity)
assert isinstance(entity.Id, int), 'Invalid entity %s, with id %s' % (entity, entity.Id)
entityDb = self.session().query(self.Entity).get(entity.Id)
if not entityDb: raise InputError(Ref(_('Unknown id'), ref=self.Entity.Id))
try: self.session().flush((copy(entity, entityDb),))
except SQLAlchemyError as e: handle(e, self.Entity)
def insert(self, media:BlogMedia):
'''
@see: IBlogMediaService.insert
'''
assert isinstance(media, BlogMedia), 'Invalid blog media %s' % media
mediaDb = BlogMediaMapped()
copy(media, mediaDb, exclude=('Type',))
mediaDb.typeId = self._typeId(media.Type)
if (not BlogMedia.Rank in media) or (media.Rank < 1):
mediaDb.Rank = self._nextRank(0, mediaDb.Blog, mediaDb.typeId)
try:
self.session().add(mediaDb)
self.session().flush((mediaDb,))
except SQLAlchemyError as e: handle(e, mediaDb)
media.Id = mediaDb.Id
return media.Id
def update(self, item):
'''
@see: IItemService.update
'''
assert self.modelType.isValid(item), 'Invalid item %s, expected %s' % (item, ItemMapped)
assert isinstance(item.GUId, str), 'Invalid item %s, with id %s' % (item, item.GUId)
itemDb = self.session().query(ItemMapped).get(item.GUId)
if not itemDb: raise InputError(Ref(_('Unknown id'), ref=ItemMapped.GUId))
try: self.session().flush((copy(item, itemDb),))
except SQLAlchemyError as e: handle(e, ItemMapped)
def insert(self, entity):
'''
@see: IEntityCRUDService.insert
'''
assert self.modelType.isValid(entity), 'Invalid entity %s, expected %s' % (entity, self.Entity)
entityDb = copy(entity, self.Entity())
try:
self.session().add(entityDb)
self.session().flush((entityDb,))
except SQLAlchemyError as e: handle(e, entityDb)
return entity.Key
def update(self, media: BlogMedia):
'''
@see: IBlogMediaService.update
'''
assert isinstance(media, BlogMedia), 'Invalid blog media %s' % media
mediaDb = self.session().query(BlogMediaMapped).get(media.Id)
if not mediaDb:
raise InputError(Ref(_('Unknown blog media id'), ref=BlogMedia.Id))
copy(media, mediaDb, exclude=('Type', ))
if BlogMedia.Type in media: mediaDb.typeId = self._typeId(media.Type)
if (BlogMedia.Rank in media) and (media.Rank < 1):
mediaDb.Rank = self._nextRank(mediaDb.Id, mediaDb.Blog,
mediaDb.typeId)
try:
self.session().flush((mediaDb, ))
except SQLAlchemyError as e:
handle(e, mediaDb)
def update(self, user):
'''
@see: IUserService.update
'''
assert isinstance(user, User), 'Invalid user %s' % user
userDb = self.session().query(UserMapped).get(user.Id)
if not userDb: raise InputError(Ref(_('Unknown id'), ref=UserMapped.Id))
try:
self.session().flush((copy(user, userDb),))
except SQLAlchemyError as e: handle(e, userDb)
def insert(self, media: BlogMedia):
'''
@see: IBlogMediaService.insert
'''
assert isinstance(media, BlogMedia), 'Invalid blog media %s' % media
mediaDb = BlogMediaMapped()
copy(media, mediaDb, exclude=('Type', ))
mediaDb.typeId = self._typeId(media.Type)
if (not BlogMedia.Rank in media) or (media.Rank < 1):
mediaDb.Rank = self._nextRank(0, mediaDb.Blog, mediaDb.typeId)
try:
self.session().add(mediaDb)
self.session().flush((mediaDb, ))
except SQLAlchemyError as e:
handle(e, mediaDb)
media.Id = mediaDb.Id
return media.Id
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, entity):
'''
@see: IEntityCRUDService.update
'''
assert self.modelType.isValid(entity), 'Invalid entity %s, expected %s' % (entity, self.Entity)
assert isinstance(entity.Key, str), 'Invalid entity %s, with key %s' % (entity, entity.Key)
try: entityDb = self.session().query(self.Entity).filter(self.Entity.Key == entity.Key)
except NoResultFound: raise InputError(Ref(_('Unknown key'), ref=self.Entity.Key))
try:
self.session().flush((copy(entity, entityDb),))
except SQLAlchemyError as e: handle(e, self.Entity)
def insert(self, entity):
'''
@see: IEntityCRUDService.insert
'''
assert self.modelType.isValid(
entity), 'Invalid entity %s, expected %s' % (entity, self.Entity)
entityDb = copy(entity, self.Entity())
try:
self.session().add(entityDb)
self.session().flush((entityDb, ))
except SQLAlchemyError as e:
handle(e, entityDb)
return entity.Key
def insert(self, postVerification):
'''
@see: IPostVerificationService.insert
'''
assert isinstance(postVerification, PostVerification), 'Invalid post verification %s' % postVerification
postVerificationDb = PostVerificationMapped()
postVerificationDb.statusId = self._verificationStatusId(postVerification.Status)
try:
self.session().add(copy(postVerification, postVerificationDb, exclude=('Status',)))
self.session().flush((postVerificationDb,))
except SQLAlchemyError as e: handle(e, postVerificationDb)
postVerification.Id = postVerificationDb.Id
return postVerification.Id
def insert(self, post):
'''
@see: IPostService.insert
'''
assert isinstance(post, Post), 'Invalid post %s' % post
postDb = PostMapped()
copy(post, postDb, exclude=COPY_EXCLUDE)
postDb.typeId = self._typeId(post.Type)
# TODO: implement the proper fix using SQLAlchemy compilation rules
nohigh = {i: None for i in range(0x10000, 0x110000)}
if postDb.Meta: postDb.Meta = postDb.Meta.translate(nohigh)
if postDb.Content: postDb.Content = postDb.Content.translate(nohigh)
if postDb.ContentPlain:
postDb.ContentPlain = postDb.ContentPlain.translate(nohigh)
if post.CreatedOn is None: postDb.CreatedOn = current_timestamp()
if not postDb.Author:
colls = self.session().query(CollaboratorMapped).filter(
CollaboratorMapped.User == postDb.Creator).all()
if not colls:
coll = CollaboratorMapped()
coll.User = postDb.Creator
src = self.session().query(SourceMapped).filter(
SourceMapped.Name ==
PostServiceAlchemy.default_source_name).one()
coll.Source = src.Id
self.session().add(coll)
self.session().flush((coll, ))
colls = (coll, )
postDb.Author = colls[0].Id
self.session().add(postDb)
self.session().flush((postDb, ))
post.Id = postDb.Id
return post.Id
def update(self, user):
'''
@see: IUserService.update
Should not this be handeled automatically via entity service?
'''
assert isinstance(user, User), 'Invalid user %s' % user
userDb = self.session().query(UserMapped).get(user.Id)
if not userDb:
assert isinstance(userDb, UserMapped), 'Invalid user %s' % userDb
raise InputError(Ref(_('Unknown user id'), ref=User.Id))
try:
userDb.typeId = self._userTypeId(user.Type)
self.session().flush((copy(user, userDb, exclude=('Type',)),))
except SQLAlchemyError as e: handle(e, userDb)
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 update(self, user):
'''
@see: IUserService.update
Should not this be handeled automatically via entity service?
'''
assert isinstance(user, User), 'Invalid user %s' % user
userDb = self.session().query(UserMapped).get(user.Id)
if not userDb:
assert isinstance(userDb, UserMapped), 'Invalid user %s' % userDb
raise InputError(Ref(_('Unknown user id'), ref=User.Id))
try:
userDb.typeId = self._userTypeId(user.Type)
self.session().flush((copy(user, userDb, exclude=('Type', )), ))
except SQLAlchemyError as e:
handle(e, userDb)
def update(self, item):
'''
@see: IItemService.update
'''
assert self.modelType.isValid(
item), 'Invalid item %s, expected %s' % (item, ItemMapped)
assert isinstance(
item.GUId, str), 'Invalid item %s, with id %s' % (item, item.GUId)
itemDb = self.session().query(ItemMapped).get(item.GUId)
if not itemDb:
raise InputError(Ref(_('Unknown id'), ref=ItemMapped.GUId))
try:
self.session().flush((copy(item, itemDb), ))
except SQLAlchemyError as e:
handle(e, ItemMapped)
def update(self, entity):
'''
@see: IEntityCRUDService.update
'''
assert self.modelType.isValid(
entity), 'Invalid entity %s, expected %s' % (entity, self.Entity)
assert isinstance(
entity.Id,
int), 'Invalid entity %s, with id %s' % (entity, entity.Id)
entityDb = self.session().query(self.Entity).get(entity.Id)
if not entityDb:
raise InputError(Ref(_('Unknown id'), ref=self.Entity.Id))
try:
self.session().flush((copy(entity, entityDb), ))
except SQLAlchemyError as e:
handle(e, self.Entity)
def insert(self, user):
'''
@see: IUserService.insert
'''
assert isinstance(user, User), 'Invalid user %s' % user
userDb = UserMapped()
userDb.password = user.Password
userDb.CreatedOn = current_timestamp()
userDb.typeId = self._userTypeId(user.Type)
try:
self.session().add(copy(user, userDb, exclude=('Type',)))
self.session().flush((userDb,))
except SQLAlchemyError as e: handle(e, userDb)
user.Id = userDb.Id
return user.Id
def insert(self, user):
'''
@see: IUserService.insert
'''
assert isinstance(user, User), 'Invalid user %s' % user
userDb = UserMapped()
userDb.password = user.Password
try:
self.session().add(copy(user, userDb))
self.session().flush((userDb,))
except SQLAlchemyError as e: handle(e, userDb)
user.Id = userDb.Id
return user.Id
user.password = user.Password # We set the password value.
return super().insert(user)
def insert(self, user):
'''
@see: IUserService.insert
'''
assert isinstance(user, User), 'Invalid user %s' % user
userDb = UserMapped()
userDb.password = user.Password
userDb.CreatedOn = current_timestamp()
userDb.typeId = self._userTypeId(user.Type)
try:
self.session().add(copy(user, userDb, exclude=('Type', )))
self.session().flush((userDb, ))
except SQLAlchemyError as e:
handle(e, userDb)
user.Id = userDb.Id
return user.Id
def insert(self, parentId, configuration):
'''
@see: IConfigurationService.insert
'''
assert isinstance(parentId, int), 'Invalid parentId'
assert isinstance(configuration, Configuration), 'Invalid configuration'
if not configuration.Name:
raise InputError(Ref(_('No configuration name'),))
configurationDb = copy(configuration, self.ConfigurationMapped())
configurationDb.parent = parentId
try:
self.session().add(configurationDb)
self.session().flush((configurationDb,))
except SQLAlchemyError as e: handle(e, configurationDb)
return configurationDb.Name
def update(self, entity):
'''
@see: IEntityCRUDService.update
'''
assert self.modelType.isValid(
entity), 'Invalid entity %s, expected %s' % (entity, self.Entity)
assert isinstance(
entity.Key,
str), 'Invalid entity %s, with key %s' % (entity, entity.Key)
try:
entityDb = self.session().query(
self.Entity).filter(self.Entity.Key == entity.Key)
except NoResultFound:
raise InputError(Ref(_('Unknown key'), ref=self.Entity.Key))
try:
self.session().flush((copy(entity, entityDb), ))
except SQLAlchemyError as e:
handle(e, self.Entity)
def update(self, user):
'''
@see: IUserService.update
'''
assert isinstance(user, User), 'Invalid user %s' % user
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:
sql = self.session().query(UserMapped)
sql = sql.filter(UserMapped.Id != user.Id)
sql = sql.filter(UserMapped.Name == user.Name)
sql = sql.filter(UserMapped.DeletedOn == None)
if sql.count() > 0: raise InputError(Ref(_('There is already a user with this name'), ref=User.Name))
self.session().flush((copy(user, userDb),))
except SQLAlchemyError as e: handle(e, userDb)
def insert(self, parentId, configuration):
'''
@see: IConfigurationService.insert
'''
assert isinstance(parentId, int), 'Invalid parentId'
assert isinstance(configuration,
Configuration), 'Invalid configuration'
if not configuration.Name:
raise InputError(Ref(_('No configuration name'), ))
configurationDb = copy(configuration, self.ConfigurationMapped())
configurationDb.parent = parentId
try:
self.session().add(configurationDb)
self.session().flush((configurationDb, ))
except SQLAlchemyError as e:
handle(e, configurationDb)
return configurationDb.Name
def insert(self, user):
'''
@see: IUserService.insert
'''
assert isinstance(user, User), 'Invalid user %s' % user
sql = self.session().query(UserMapped)
sql = sql.filter(UserMapped.Name == user.Name)
sql = sql.filter(UserMapped.DeletedOn == None)
if sql.count() > 0: raise InputError(Ref(_('There is already a user with this name'), ref=User.Name))
userDb = UserMapped()
userDb.password = user.Password
userDb.CreatedOn = current_timestamp()
try:
self.session().add(copy(user, userDb))
self.session().flush((userDb,))
except SQLAlchemyError as e: handle(e, userDb)
user.Id = userDb.Id
return user.Id
def insert(self, item):
'''
@see: IItemService.insert
'''
assert self.modelType.isValid(item), 'Invalid item %s, expected %s' % (item, ItemMapped)
assert isinstance(item, Item)
assert item.ItemClass == CLASS_TEXT or item.ItemClass == CLASS_PACKAGE, \
'Invalid item class %s, expected %s or %s' % (item.ItemClass, CLASS_TEXT, CLASS_PACKAGE)
itemDb = copy(item, ItemMapped())
assert isinstance(itemDb, ItemMapped)
# TODO: generate proper guid: generate better itemId, externalise as a service
itemDb.GUId = self.guid_scheme % {'prefix':self.guid_prefix, 'provider':self.guid_provider,
'dateId':date.today().strftime('%Y%m%d'), 'itemId':itemDb.SlugLine}
itemDb.FirstCreated = current_timestamp()
try:
self.session().add(itemDb)
self.session().flush((itemDb,))
except SQLAlchemyError as e: handle(e, itemDb)
item.GUId = itemDb.GUId
return itemDb.GUId
def insert(self, user):
'''
@see: IUserService.insert
'''
assert isinstance(user, User), 'Invalid user %s' % user
sql = self.session().query(UserMapped)
sql = sql.filter(UserMapped.Name == user.Name)
sql = sql.filter(UserMapped.DeletedOn == None)
# if sql.count() > 0: raise InputError(Ref(_('There is already a user with this name'), ref=User.Name))
userDb = UserMapped()
userDb.password = user.Password
userDb.CreatedOn = current_timestamp()
try:
self.session().add(copy(user, userDb))
self.session().flush((userDb, ))
except SQLAlchemyError as e:
handle(e, userDb)
user.Id = userDb.Id
return user.Id
def insert(self, imageInfo, image):
'''
@see: IImagePersistanceService.insert
'''
assert isinstance(imageInfo, api.ImageInfo), 'Invalid image info %s' % imageInfo
assert isinstance(image, Content), 'Invalid image content %s' % image
imageData = ImageData()
imageData.CreatedOn = datetime.now()
imageData.typeId = self._typeId()
try:
self.session().add(imageData)
self.session().flush((imageData,))
reference = self.format_file_name % {'id': imageData.Id, 'file': image.getName() or self.default_file_name}
path = join(self.image_dir_path, reference)
with open(path, 'wb') as fobj: pipe(image, fobj)
assert isinstance(imageData, MetaDataMapped)
imageData.reference = reference
imageData.SizeInBytes = getsize(path)
#TODO: implement read the actual meta data
imageData.Width = 100
imageData.Height = 100
self.session().flush((imageData,))
imageInfoDb = copy(imageInfo, ImageInfo())
imageInfoDb.MetaData = imageData.Id
self.session().add(imageInfoDb)
self.session().flush((imageInfoDb,))
except SQLAlchemyError as e: handle(e, imageInfoDb)
imageInfo.Id = imageInfoDb.Id
return imageInfoDb.Id
def update(self, user):
'''
@see: IUserService.update
'''
assert isinstance(user, User), 'Invalid user %s' % user
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:
sql = self.session().query(UserMapped)
sql = sql.filter(UserMapped.Id != user.Id)
sql = sql.filter(UserMapped.Name == user.Name)
sql = sql.filter(UserMapped.DeletedOn == None)
if sql.count() > 0:
raise InputError(
Ref(_('There is already a user with this name'),
ref=User.Name))
self.session().flush((copy(user, userDb), ))
except SQLAlchemyError as e:
handle(e, userDb)
