def insertSource(name):
sourcesService = entityFor(ISourceService)
assert isinstance(sourcesService, ISourceService)
srcs = sourcesService.getAll(q=QSource(name=name))
if srcs: src = next(iter(srcs)).Id
else:
src = Source()
src.Name = name
src.IsModifiable, src.URI, src.Type, src.Key = False, '', '', ''
src = sourcesService.insert(src)
collaboratorService = entityFor(ICollaboratorService)
assert isinstance(collaboratorService, ICollaboratorService)
colls = collaboratorService.getAll(qs=QSource(name=name))
if not colls:
coll = Collaborator()
coll.User = None
coll.Source = src
collaboratorService.insert(coll)
def getSourcesIds():
sourcesService = entityFor(ISourceService)
assert isinstance(sourcesService, ISourceService)
sources = {}
for name in SOURCES:
srcs = sourcesService.getAll(q=QSource(name=name))
if srcs: sources[name] = next(iter(srcs)).Id
else:
src = Source()
src.Name = name
src.IsModifiable, src.URI, src.Type, src.Key = SOURCES[name]
createSourceType(src.Type)
sources[name] = sourcesService.insert(src)
return sources
def _getCollaboratorForAuthor(self, author, source):
'''
Returns a collaborator identifier for the user/source defined in the post.
If the post was not created by a user it returns a collaborator for the
source identified in the post and the default user. The default user should
be the sync entry creator. If the source from the post does not exist
locally raises Exception.
@param author: dict
The author data in JSON decoded format
@param source: Source
The source from which the blog synchronization is done
@return: integer
The collaborator identifier.
'''
assert isinstance(source, Source)
try:
userJSON = author['User']
user = User()
user.Name = sha1((userJSON.get('Name', '') + source.URI).encode(
self.encodingType)).hexdigest()
user.FirstName, user.LastName = userJSON.get('FirstName',
''), userJSON.get(
'LastName', '')
user.EMail, user.Password = userJSON.get('EMail', ''), '*'
user.Type = self.user_type_key
try:
userId = self.userService.insert(user)
except InputError:
localUser = self.userService.getAll(q=QUser(name=user.Name))
userId = localUser[0].Id
c = Collaborator()
c.User, c.Source = userId, source.Id
try:
return [self.collaboratorService.insert(c), userId]
except InputError:
collabs = self.collaboratorService.getAll(userId, source.Id)
return [collabs[0].Id, userId]
except KeyError:
q = QSource(name=author['Source']['Name'], isModifiable=False)
sources = self.sourceService.getAll(q=q)
if not sources: raise Exception('Invalid source %s' % q.name)
collabs = self.collaboratorService.getAll(userId=None,
sourceId=sources[0].Id)
if collabs: return [collabs[0].Id, None]
else:
c = Collaborator()
c.Source = sources[0].Id
return [self.collaboratorService.insert(c), None]
def getCollaboratorsIds():
collaboratorService = entityFor(ICollaboratorService)
assert isinstance(collaboratorService, ICollaboratorService)
if not _cache_collaborators:
collaborators = _cache_collaborators
for uname, source in COLLABORATORS.items():
try:
person = getUsersIds()[uname]
except KeyError:
person = None
colls, index = collaboratorService.getAll(qs=QSource(
name=source)), source
else:
colls, index = collaboratorService.getAll(qp=QPerson(
firstName=USERS[uname][0])), uname
if colls: collaborators[index] = colls[0].Id
else:
coll = Collaborator()
coll.Person = person
coll.Source = getSourcesIds()[source]
collaborators[index] = collaboratorService.insert(coll)
return _cache_collaborators
def getCollaboratorsIds():
collaboratorService = entityFor(ICollaboratorService)
assert isinstance(collaboratorService, ICollaboratorService)
collaborators = {}
for source, id in getSourcesIds().items():
colls = collaboratorService.getAll(qs=QSource(name=source))
if colls: collaborators[source] = colls[0].Id
else:
coll = Collaborator()
coll.User = None
coll.Source = getSourcesIds()[source]
collaborators[source] = collaboratorService.insert(coll)
for user, id in getUsersIds().items():
colls = collaboratorService.getAll(qu=QUser(name=user))
if colls: collaborators[user] = colls[0].Id
else:
coll = Collaborator()
coll.User = id
coll.Source = getSourcesIds()['internal']
collaborators[user] = collaboratorService.insert(coll)
return collaborators
def addSource(self, blogId, source):
'''
@see: IBlogSourceService.addSource
NB: The source must have the correct type set in.
This way, we can reuse it for other purposes, apart from the chained blogs.
'''
assert isinstance(blogId, int), 'Invalid blog identifier %s' % blogId
assert isinstance(source, Source), 'Invalid source %s' % source
# insert source if it didn't exist yet
q = QSource(name=source.Name)
sources = self.sourceService.getAll(typeKey=source.Type, q=q)
if not sources: sourceId = self.sourceService.insert(source)
else: sourceId = sources[0].Id
ent = BlogSourceDB()
ent.blog = blogId
ent.source = sourceId
try:
self.session().add(ent)
self.session().flush((ent, ))
except SQLAlchemyError as e:
handle(e, ent)
return sourceId
def _getCollaboratorForAuthor(self, author, creator, source):
'''
Returns a collaborator identifier for the user/source defined in the post.
If the post was not created by a user (it is twitter, facebook, etc. post)
it returns a collaborator for the user that has added the post.
@param author: dict
The author data in JSON decoded format
@param creator: dict
The creator data in JSON decoded format
@param source: Source
The source from which the blog synchronization is done
@return: integer
The collaborator identifier.
'''
assert isinstance(source, Source)
user = User()
isAuthor = False
if 'User' in author:
userJSON = author['User']
isAuthor = True
else:
userJSON = creator
#To support old instances that don't have Uuid attribute
if 'Uuid' in userJSON: user.Uuid = userJSON.get('Uuid', '')
else: user.Uuid = str(uuid4().hex)
if 'Cid' in userJSON: cid = int(userJSON.get('Cid', ''))
else: cid = None
user.Name = user.Uuid
user.FirstName, user.LastName = userJSON.get('FirstName',
''), userJSON.get(
'LastName', '')
user.Address, user.PhoneNumber = userJSON.get('Address',
''), userJSON.get(
'PhoneNumber', '')
user.EMail, user.Password = userJSON.get('EMail', ''), '~'
user.Type = self.user_type_key
needUpdate = True
try:
userId = self.userService.insert(user)
except InputError:
localUser = self.userService.getByUuid(user.Uuid)
userId = localUser.Id
if localUser.Type == self.user_type_key and (cid is None or
localUser.Cid < cid):
user.Id = localUser.Id
user.Type = localUser.Type
user.Cid = cid
self.userService.update(user)
else:
needUpdate = False
collaborator = Collaborator()
collaborator.User, collaborator.Source = userId, source.Id
try:
collaboratorId = self.collaboratorService.insert(collaborator)
except InputError:
collaborators = self.collaboratorService.getAll(userId, source.Id)
collaboratorId = collaborators[0].Id
if isAuthor:
return [collaboratorId, userId, needUpdate, isAuthor]
else:
q = QSource(name=author['Source']['Name'], isModifiable=False)
sources = self.sourceService.getAll(q=q)
if not sources: raise Exception('Invalid source %s' % q.name)
collaborators = self.collaboratorService.getAll(
userId=None, sourceId=sources[0].Id)
if collaborators:
return [collaborators[0].Id, userId, needUpdate, isAuthor]
else:
collaborator = Collaborator()
collaborator.Source = sources[0].Id
return [
self.collaboratorService.insert(collaborator), userId,
needUpdate, isAuthor
]