def untag(itemId, item, tagId, tag, myId, orgId):
if "parent" in item:
raise errors.InvalidRequest(_("Tags cannot be applied or removed from comments"))
if tagId not in item.get("tags", {}):
raise errors.InvalidRequest(_("No such tag on the item")) # No such tag on item
d1 = db.remove(itemId, "items", tagId, "tags")
d2 = db.remove(tagId, "tagItems", item["meta"]["uuid"])
d3 = db.get_slice(tagId, "tagFollowers")
try:
itemsCountCol = yield db.get(orgId, "orgTags", "itemsCount", tagId)
tagItemsCount = int(itemsCountCol.column.value) - 1
if tagItemsCount % 10 == 7:
tagItemsCount = yield db.get_count(tagId, "tagItems")
tagItemsCount = tagItemsCount - 1
db.insert(orgId, "orgTags", "%s" % tagItemsCount, "itemsCount", tagId)
except ttypes.NotFoundException:
pass
result = yield defer.DeferredList([d1, d2, d3])
followers = utils.columnsToDict(result[2][1]).keys()
feedUpdateVal = "T:%s:%s::%s" % (myId, itemId, tagId)
yield Feed.unpush(myId, orgId, itemId, item,
feedUpdateVal, followers + [myId])
def tag(itemId, item, tagName, myId, orgId):
if "parent" in item["meta"]:
raise errors.InvalidRequest(_("Tag cannot be applied on a comment"))
(tagId, tag) = yield tags._ensureTag(tagName, myId, orgId)
if tagId in item.get("tags", {}):
raise errors.InvalidRequest(_("Tag already exists on the choosen item"))
d1 = db.insert(itemId, "items", myId, tagId, "tags")
d2 = db.insert(tagId, "tagItems", itemId, item["meta"]["uuid"])
d3 = db.get_slice(tagId, "tagFollowers")
tagItemsCount = int(tag.get("itemsCount", "0")) + 1
if tagItemsCount % 10 == 7:
tagItemsCount = yield db.get_count(tagId, "tagItems")
tagItemsCount += 1
db.insert(orgId, "orgTags", "%s" % tagItemsCount, "itemsCount", tagId)
result = yield defer.DeferredList([d1, d2, d3])
followers = utils.columnsToDict(result[2][1]).keys()
if followers:
timeUUID = uuid.uuid1().bytes
feedUpdateVal = "T:%s:%s::%s" % (myId, itemId, tagId)
yield Feed.push(myId, orgId, itemId, item, timeUUID,
feedUpdateVal, feeds=followers)
defer.returnValue((tagId, tag))
def _follow(self, request):
authInfo = request.getSession(IAuthInfo)
myId = authInfo.username
orgId = authInfo.organization
tagId, tag = yield utils.getValidTagId(request, "id")
count = int(tag[tagId].get('followersCount', 0))
if count % 5 == 3:
count = yield db.get_count(tagId, "tagFollowers")
count = count + 1
yield db.insert(tagId, "tagFollowers", '', myId)
yield db.insert(orgId, "orgTags", str(count), "followersCount", tagId)
args = {'tags': tag}
args['tagsFollowing'] = [tagId]
tag[tagId]['followersCount'] = count
fromListTags = (utils.getRequestArg(request, '_pg') == '/tags/list')
if fromListTags:
t.renderScriptBlock(request, "tags.mako", "_displayTag",
False, "#tag-%s" % tagId, "replace",
args=[tagId], **args)
else:
t.renderScriptBlock(request, 'tags.mako', "tag_actions", False,
"#tag-actions-%s" % (tagId), "set",
args=[tagId, True, False])
def block(group, user, me):
"""Block user from joining a group/ sending further group-join requests.
Keyword params:
@me: entity object with my info
@user: entity object of the user
@group: entity object of the group
"""
if me.id not in group.admins:
raise errors.PermissionDenied('Access Denied')
if me.id == user.id:
raise errors.InvalidRequest(_("An administrator cannot ban himself/herself from the group"))
try:
yield db.get(group.id, "pendingConnections", "GI:%s" % (user.id))
yield _removeFromPending(group, user)
# Add user to blocked users
yield db.insert(group.id, "blockedUsers", '', user.id)
defer.returnValue(True)
except ttypes.NotFoundException:
# If the users is already a member, remove the user from the group
colname = _entityGroupMapColName(group)
yield db.remove(group.id, "groupMembers", user.id)
yield db.remove(group.id, "followers", user.id)
yield db.remove(user.id, "entityGroupsMap", colname)
# Add user to blocked users
yield db.insert(group.id, "blockedUsers", '', user.id)
defer.returnValue(False)
def _vote(self, request):
convId, conv = yield utils.getValidItemId(request, 'id', 'poll', ['options'])
vote = utils.getRequestArg(request, 'option')
if not vote or vote not in conv.get("options", {}):
raise errors.MissingParams(["Option"])
optionCounts = {}
myId = request.getSession(IAuthInfo).username
prevVote = yield db.get_slice(myId, "userVotes", [convId])
prevVote = prevVote[0].column.value if prevVote else False
if prevVote == vote:
yield self._results(request)
return
if prevVote:
yield db.remove(convId, "votes", myId, prevVote)
prevOptionCount = yield db.get_count(convId, "votes", prevVote)
optionCounts[prevVote] = str(prevOptionCount)
yield db.insert(myId, "userVotes", vote, convId)
yield db.insert(convId, "votes", '', myId, vote)
voteCount = yield db.get_count(convId, "votes", vote)
optionCounts[vote] = str(voteCount)
yield db.batch_insert(convId, "items", {"counts": optionCounts})
yield self._results(request)
def pushfileinfo(myId, orgId, itemId, item, conv=None):
if 'parent' in item['meta']:
if not conv:
conv = yield db.get_slice(item['meta']['parent'], "items", ["meta"])
conv = utils.supercolumnsToDict(conv)
convId = item['meta']['parent']
else:
convId = itemId
conv = item
acl = pickle.loads(conv['meta']['acl'])
allowedGroups = acl.get('accept', {}).get('groups', [])
deniedGroups = acl.get('deny', {}).get('groups', [])
groups = [x for x in allowedGroups if x not in deniedGroups]
allowedOrgs = acl.get('accept', {}).get('orgs', [])
ownerId = conv['meta']['owner']
entityIds = [myId]
entityIds.extend(groups)
entityIds.extend(allowedOrgs)
entityIds_ = yield utils.expandAcl(myId, orgId, conv['meta']['acl'], convId, ownerId, True)
entityIds.extend(entityIds_)
for attachmentId in item.get('attachments', {}):
name, size, ftype = item['attachments'][attachmentId].split(':')
cols = yield db.get_slice(attachmentId, "attachmentVersions", count=1)
tuuid = cols[0].column.name
value = '%s:%s:%s:%s' % (attachmentId, name, itemId, ownerId)
#TODO: use batch remove/batch mutate
yield db.insert(myId, "user_files", value, tuuid)
for entityId in entityIds:
yield db.insert(entityId, "entityFeed_files", value, tuuid)
def _editCompany(self, request):
(appchange, script, args, myId) = yield self._getBasicArgs(request)
remove = utils.getRequestArg(request, 'action') == 'd'
encodedCompanyId = utils.getRequestArg(request, 'id', sanitize=False)
companyId = utils.decodeKey(encodedCompanyId) if encodedCompanyId else None
if companyId and remove:
db.remove(myId, "entities", companyId, "companies")
request.write('$("#%s").remove();' % encodedCompanyId)
return
today = datetime.date.today()
try:
startYear = int(utils.getRequestArg(request, 'startyear'))
startMonth = int(utils.getRequestArg(request, 'startmonth'))
startDay = datetime.date(startYear, startMonth, 1)
except (ValueError, TypeError):
raise errors.InvalidRequest('Please give a valid start month and year')
try:
endYear = utils.getRequestArg(request, 'endyear')
if not endYear:
endYear = 9999
endMonth = 12
else:
endYear = int(endYear)
endMonth = int(utils.getRequestArg(request, 'endmonth'))
endDay = datetime.date(endYear, endMonth, 1)
except (ValueError, TypeError):
raise errors.InvalidRequest('Please give a valid end month and year')
if startDay > today or startDay > endDay or (endDay > today and endYear != 9999):
raise errors.InvalidRequest('The start month/year and end month/year are invalid!')
name = utils.getRequestArg(request, 'company')
title = utils.getRequestArg(request, 'title')
if not remove and not name:
errors.MissingParams(['Name'])
if companyId:
db.remove(myId, "entities", companyId, "companies")
newCompanyId = "%s%s:%s%s:%s" % (endYear, endMonth, startYear, startMonth, name)
newCompanyVal = title
db.insert(myId, "entities", newCompanyVal, newCompanyId, "companies")
if companyId:
yield t.renderScriptBlock(request, "settings.mako", "companyItem",
False, "#"+encodedCompanyId, "replace",
args=[newCompanyId, newCompanyVal])
else:
onload = """$('#company-empty-msg').remove();"""+\
"""$('#addemp-wrap').replaceWith('<div id="addemp-wrap"><button class="button ajax" id="addedu-button" data-ref="/settings/company">Add Company</button></div>');"""
yield t.renderScriptBlock(request, "settings.mako", "companyItem",
False, "#companies-wrapper", "append", True,
handlers={'onload': onload},
args=[newCompanyId, newCompanyVal])
def makeAdmin(emailId):
userAuth = yield db.get_slice(emailId, "userAuth")
if not userAuth:
raise Exception('User does not exist')
userAuth = utils.columnsToDict(userAuth)
orgId = userAuth["org"]
userId = userAuth["user"]
yield db.insert(orgId, "entities", "", userId, "admins")
yield db.insert(emailId, "userAuth", "True", "isAdmin")
def _follow(self, myId, targetId):
d1 = db.insert(myId, "subscriptions", "", targetId)
d2 = db.insert(targetId, "followers", "", myId)
entities = base.EntitySet([myId, targetId])
d3 = entities.fetchData()
def notifyFollow(res):
data = {'entities': entities}
return notifications.notify([targetId], ":NF", myId, **data)
d3.addCallback(notifyFollow)
yield defer.DeferredList([d1, d2, d3])
def _registerClient(self, request):
(appchange, script, args, myId) = yield self._getBasicArgs(request)
landing = not self._ajax
myOrgId = args["orgId"]
name = utils.getRequestArg(request, "name")
desc = utils.getRequestArg(request, "desc")
scope = utils.getRequestArg(request, "scope", multiValued=True)
category = utils.getRequestArg(request, "category")
redirect = utils.getRequestArg(request, "redirect", sanitize=False)
if not name:
raise errors.MissingParams(["Name"])
if not scope:
raise errors.MissingParams(["Permissions"])
if category != "apikey" and not redirect:
raise errors.MissingParams(["Redirect URL"])
knownScopes = globals().get("scopes")
unknownScopes = [x for x in scope if x not in knownScopes.keys()]
if category not in ["webapp", "native", "apikey"] or unknownScopes:
raise errors.BaseError("Invalid value sent for Type/Permissions")
clientId = utils.getUniqueKey()
clientSecret = utils.getRandomKey()
meta = {
"author": myId,
"name": name,
"org": myOrgId,
"secret": utils.hashpass(clientSecret),
"scope": " ".join(scope),
"category": category,
}
if category != "apikey":
meta["redirect"] = b64encode(redirect)
meta["desc"] = desc
yield db.batch_insert(clientId, "apps", {"meta": meta})
yield db.insert(myId, "appsByOwner", "", clientId)
yield db.insert(myOrgId, "appsByOwner", "", clientId)
else:
yield db.batch_insert(clientId, "apps", {"meta": meta})
yield db.insert(myId, "entities", "", clientId, "apikeys")
self.setTitle(request, name)
args["clientId"] = clientId
args["client"] = meta
args["client"]["secret"] = clientSecret
t.renderScriptBlock(request, "apps.mako", "registrationResults", landing, "#apps-contents", "set", **args)
def _moveConversation(self, request, convIds, toFolder):
"""Move a conversation or conversations from one folder to another.
Keyword Arguments:
convIds: List of conversation ids which need to be moved.
toFolder: The final destination of the above conversations
CF Changes:
mConvFolders
mUnreadConversations
mAllConversations
mDeletedConversations
"""
myId = request.getSession(IAuthInfo).username
convs = yield db.multiget_slice(convIds, "mConversations")
convs = utils.multiSuperColumnsToDict(convs)
for convId in convs:
conv = convs.get(convId, {})
if not conv:
raise errors.InvalidMessage(convId)
if myId not in conv.get('participants', {}):
raise errors.MessageAccessDenied(convId)
timeUUID = conv['meta']['uuid']
val = "%s:%s" % ('u' if toFolder == 'unread' else 'r', convId)
cols = yield db.get_slice(convId, 'mConvFolders', [myId])
cols = utils.supercolumnsToDict(cols)
for folder in cols[myId]:
cf = self._folders[folder] if folder in self._folders else folder
if toFolder != 'unread':
if folder != 'mUnreadConversations':
col = yield db.get(myId, cf, timeUUID)
val = col.column.value
yield db.remove(myId, cf, timeUUID)
yield db.remove(convId, "mConvFolders", cf, myId)
else:
yield db.insert(myId, cf, "u:%s" % (convId), timeUUID)
if toFolder == 'unread':
val = "u:%s" % (convId)
yield db.insert(convId, 'mConvFolders', '', 'mUnreadConversations', myId)
yield db.insert(myId, 'mUnreadConversations', val, timeUUID)
else:
folder = self._folders[toFolder]
yield db.insert(myId, folder, val, timeUUID)
yield db.insert(convId, 'mConvFolders', '', folder, myId)
def invite(group, me, user):
"""Invite an user to join a group.
Only group-member can invite others to the group. Ignore if invited user
is already a member of the group.
Keyword params:
@me:
@user: user object
@group: group object
"""
try:
yield db.get(group.id, "groupMembers", me.id)
except ttypes.NotFoundException as e:
raise e
try:
yield db.get(group.id, "groupMembers", user.id)
except ttypes.NotFoundException:
try:
yield db.get(user.id, "pendingConnections", "GO:%s" % (group.id))
except ttypes.NotFoundException:
cols = yield db.get_slice(user.id, "pendingConnections",
["GI:%s" % (group.id)])
invited_by = set()
if cols:
invited_by.update(cols[0].column.value.split(','))
invited_by.add(me.id)
yield db.insert(user.id, "pendingConnections",
",".join(invited_by), "GI:%s" % (group.id))
data = {"entities": {group.id: group, user.id: user, me.id: me},
"groupName": group.basic["name"]}
yield notifications.notify([user.id], ":GI:%s" % (group.id),
me.id, **data)
def _updateExpertise(self, request, remove=False):
myId = request.getSession(IAuthInfo).username
orgId = request.getSession(IAuthInfo).organization
expertise = utils.getRequestArg(request, 'expertise', False)
if not expertise:
raise errors.MissingParams(['Expertise'])
if not remove:
decoded = expertise.decode('utf-8', 'replace')
if len(decoded) > 50 or not re.match('^[\w-]*$', decoded):
raise errors.InvalidRequest('Expertise can only be upto 50 characters long and can include numerals, alphabet and hyphens (-) only.')
yield db.insert(myId, "entities", '', expertise, "expertise")
else:
yield db.remove(myId, "entities", utils.decodeKey(expertise), "expertise")
me = base.Entity(myId)
yield me.fetchData([])
expertise = me.get('expertise')
onload = "$('#expertise-textbox').val('');"
yield t.renderScriptBlock(request, "settings.mako", "_expertise",
False, "#expertise-container", "set", True,
handlers={"onload": onload}, args=[expertise])
yield search.solr.updatePeopleIndex(myId, me, orgId)
def _uploadDone(self, request):
SKey = config.get('CloudFiles', 'SecretKey')
AKey = config.get('CloudFiles', 'AccessKey')
creds = AWSCredentials(AKey, SKey)
client = s3Client.S3Client(creds)
bucket = utils.getRequestArg(request, "bucket")
key = utils.getRequestArg(request, "key")
file_info = yield client.head_object(bucket, key)
tmp_files_info = {}
name = file_info['x-amz-meta-filename'][0]
size = file_info['content-length'][0]
fileType = file_info['content-type'][0]
fileId = file_info['x-amz-meta-fileid'][0]
val = "%s:%s:%s:%s" % (fileId, name, size, fileType)
filename = urlsafe_b64decode(name)
tmp_files_info[fileId] = [fileId, filename, size, fileType]
# XXX: We currently don't generate any thumbnails!
# yield threads.deferToThread(self._enqueueMessage, bucket, key, name, fileType)
yield db.insert(fileId, "tmp_files", val, "fileId")
response = """
<textarea data-type="application/json">
{"ok": true, "files": %s}
</textarea>
""" % (json.dumps(tmp_files_info))
request.write(response)
def _changePassword(self, request):
(appchange, script, args, myId) = yield self._getBasicArgs(request)
currentPass = utils.getRequestArg(request, "curr_passwd", sanitize=False)
newPass = utils.getRequestArg(request, "passwd1", sanitize=False)
rptPass = utils.getRequestArg(request, "passwd2", sanitize=False)
if not currentPass:
request.write('$$.alerts.error("%s");' % _("Enter your current password"))
defer.returnValue(None)
if not newPass:
request.write('$$.alerts.error("%s");' % _("Enter new password"))
defer.returnValue(None)
if not rptPass:
request.write('$$.alerts.error("%s");' % _("Confirm new password"))
defer.returnValue(None)
if newPass != rptPass:
request.write('$$.alerts.error("%s");' % _("Passwords do not match"))
defer.returnValue(None)
if currentPass == newPass:
request.write('$$.alerts.error("%s");' % _("New password should be different from current password"))
defer.returnValue(None)
emailId = args["me"].basic["emailId"]
col = yield db.get(emailId, "userAuth", "passwordHash")
storedPass= col.column.value
if not utils.checkpass(currentPass, storedPass):
request.write('$$.alerts.error("%s");' % _("Incorrect Password"))
defer.returnValue(None)
newPasswd = utils.hashpass(newPass)
yield db.insert(emailId, "userAuth", newPasswd, "passwordHash")
request.write('$$.alerts.info("%s");' % _('Password changed'))
def updateAndPublishStatus(userId, orgId, sessionId, status, user=None):
# Check if there is a change in the online status
results = yield db.get_slice(orgId, 'presence', super_column=userId)
results = utils.columnsToDict(results)
oldPublishedStatus = getMostAvailablePresence(results.values())
# Update the online status
if status != 'offline':
yield db.insert(orgId, 'presence', status, sessionId, userId)
else:
yield db.remove(orgId, 'presence', sessionId, userId)
# If status changed broadcast the change
# XXX: Currently everyone on the network will get the presence update.
# This will not scale well with big networks
results[sessionId] = status
newPublishedStatus = getMostAvailablePresence(results.values())
if oldPublishedStatus != newPublishedStatus:
if not user:
user = base.Entity(userId)
yield user.fetchData()
data = {"userId": userId, 'status': newPublishedStatus,
'name': user.basic['name'],
'title': user.basic['jobTitle'],
'avatar': utils.userAvatar(userId, user, 's')}
yield comet.publish('/presence/' + orgId, data)
def _block(self, request, blockType):
token = utils.getRequestArg(request, "token")
emailId = utils.getRequestArg(request, "email")
sender = yield self._isValidToken(emailId, token)
if blockType == "all":
yield db.insert(emailId, "doNotSpam", "", "*")
elif blockType == "sender":
yield db.insert(emailId, "doNotSpam", "", sender)
# The invitation is not removed.
# This is to ensure that the sender can still whom he invited and that
# the invited person did not join flocked.in
args = {'view': 'block', 'blockType': blockType, 'emailId': emailId}
t.render(request, "signup.mako", **args)
def pushToFeed(userKey, timeuuid, itemKey, parentKey, responseType,
itemType, convOwner=None, commentOwner=None, tagId='',
entities=None, promote=True):
# Caveat: assume itemKey as parentKey if parentKey is None
parentKey = itemKey if not parentKey else parentKey
convOwner = userKey if not convOwner else convOwner
commentOwner = userKey if not commentOwner else commentOwner
# Get this conversation to the top of the feed only if promote is set
if promote:
yield db.insert(userKey, "feed", parentKey, timeuuid)
if plugins.has_key(itemType) and plugins[itemType].hasIndex:
yield db.insert(userKey, "feed_"+itemType, parentKey, timeuuid)
yield updateFeedResponses(userKey, parentKey, itemKey, timeuuid, itemType,
responseType, convOwner, commentOwner, tagId,
entities, promote)
def _editSchool(self, request):
(appchange, script, args, myId) = yield self._getBasicArgs(request)
remove = utils.getRequestArg(request, 'action') == 'd'
encodedSchoolId = utils.getRequestArg(request, 'id', sanitize=False)
schoolId = utils.decodeKey(encodedSchoolId) if encodedSchoolId else None
if schoolId and remove:
db.remove(myId, "entities", schoolId, "schools")
request.write('$("#%s").remove();' % encodedSchoolId)
return
curYear = datetime.date.today().year
try:
year = int(utils.getRequestArg(request, 'year'))
if not 1920 < year <= curYear:
raise ValueError
except (ValueError,TypeError):
raise errors.InvalidRequest('Invalid graduation year')
name = utils.getRequestArg(request, 'school')
degree = utils.getRequestArg(request, 'degree')
if not remove and not name:
errors.MissingParams(['Name'])
if schoolId:
db.remove(myId, "entities", schoolId, "schools")
newSchoolId = "%s:%s" % (year, name)
newSchoolVal = degree
db.insert(myId, "entities", newSchoolVal, newSchoolId, "schools")
if schoolId:
yield t.renderScriptBlock(request, "settings.mako", "schoolItem",
False, "#"+encodedSchoolId, "replace",
args=[newSchoolId, newSchoolVal])
else:
onload = """$('#school-empty-msg').remove();"""+\
"""$('#addedu-wrap').replaceWith('<div id="addedu-wrap"><button class="button ajax" id="addedu-button" data-ref="/settings/school">Add School</button></div>');"""
yield t.renderScriptBlock(request, "settings.mako", "schoolItem",
False, "#schools-wrapper", "append", True,
handlers={'onload': onload},
args=[newSchoolId, newSchoolVal])
def makeAdmin(request, group, user, me):
"""make user admin of the group.
Only an group-administrator can make an group-member and administrator.
Keyword params:
@request:
@me:
@user: user object
@group: group object
"""
if me.id not in group.admins:
raise errors.PermissionDenied(_('You are not an administrator of the group'))
cols = yield db.get_slice(group.id, "groupMembers", [user.id])
if not cols:
raise errors.InvalidRequest(_('Only group member can become administrator'))
if user.id in group.admins:
defer.returnValue(None)
yield db.insert(group.id, "entities", '', user.id, 'admins')
yield db.insert(user.id, "entities", group.basic['name'],
group.id, "adminOfGroups")
itemType = "activity"
responseType = "I"
acl = {"accept": {"groups": [group.id]}}
_acl = pickle.dumps(acl)
itemId = utils.getUniqueKey()
item = yield utils.createNewItem(request, "activity", user,
acl, "groupAdmin")
item["meta"]["target"] = group.id
d1 = db.batch_insert(itemId, 'items', item)
d2 = feed.pushToFeed(group.id, item["meta"]["uuid"], itemId,
itemId, responseType, itemType, user.id)
d3 = feed.pushToOthersFeed(user.id, user.basic['org'],
item["meta"]["uuid"], itemId, itemId,
_acl, responseType, itemType,
user.id, promoteActor=False)
yield defer.DeferredList([d1, d2, d3])
def _addMember(request, group, user):
"""Add a new member to the group.
Add user to group followers, create a group-join activity item and push
item to group, group-followers feed. Update user groups with new group.
Keyword params:
@group: entity object of the group
@user: entity object of the user
@request:
"""
deferreds = []
itemType = "activity"
relation = Relation(user.id, [])
if not getattr(user, 'basic', []):
yield user.fetchData(['basic'])
responseType = "I"
acl = {"accept": {"groups": [group.id]}}
_acl = pickle.dumps(acl)
itemId = utils.getUniqueKey()
colname = _entityGroupMapColName(group)
yield db.insert(user.id, "entityGroupsMap", "", colname)
yield db.insert(group.id, "groupMembers", itemId, user.id)
item = yield utils.createNewItem(request, "activity", user,
acl, "groupJoin")
item["meta"]["target"] = group.id
d1 = db.insert(group.id, "followers", "", user.id)
d2 = db.batch_insert(itemId, 'items', item)
d3 = feed.pushToFeed(group.id, item["meta"]["uuid"], itemId,
itemId, responseType, itemType, user.id)
d4 = feed.pushToOthersFeed(user.id, user.basic['org'],
item["meta"]["uuid"], itemId,
itemId, _acl, responseType,
itemType, user.id, promoteActor=False)
d5 = utils.updateDisplayNameIndex(user.id, [group.id],
user.basic['name'], None)
deferreds = [d1, d2, d3, d4, d5]
yield defer.DeferredList(deferreds)
def subscribe(request, group, user, org):
"""Open group: add user to the group.
Closed group: add a pending request, send a notification to group-admins.
Raise an exception if user is blocked from joining the group.
Keyword params:
@org: org object
@user: user object
@group: group object
@request:
"""
cols = yield db.get_slice(group.id, "blockedUsers", [user.id])
if cols:
raise errors.PermissionDenied(_("You are banned from joining the group."))
isNewMember = False
pendingRequests = {}
try:
cols = yield db.get(group.id, "groupMembers", user.id)
except ttypes.NotFoundException:
if group.basic['access'] == "open":
yield _addMember(request, group, user)
yield _removeFromPending(group, user)
isNewMember = True
else:
# Add to pending connections
yield db.insert(user.id, "pendingConnections",
'', "GO:%s" % (group.id))
yield db.insert(group.id, "pendingConnections",
'', "GI:%s" % (user.id))
yield _notify(group, user)
pendingRequests["GO:%s" % (group.id)] = user.id
entities = base.EntitySet(group.admins.keys())
yield entities.fetchData()
entities.update({group.id: group, org.id: org, user.id: user})
data = {"entities": entities, "groupName": group.basic['name']}
yield notifications.notify(group.admins, ":GR", user.id, **data)
defer.returnValue((isNewMember, pendingRequests))
def _addKeywords(self, request):
orgId = request.getSession(IAuthInfo).organization
original = utils.getRequestArg(request, 'keywords', sanitize=False)
if not original:
return
original = original.split(',')
decoded = set([x.decode('utf-8', 'replace').strip() for x in original])
# Check if any word is longer than 50 chars
decoded = set([x for x in decoded if len(x) < 50])
if len(decoded) != len(original):
raise errors.InvalidRequest(_('Keywords cannot be more than 50 characters long'))
# Check if any word has invalid characters
decoded = set([x for x in decoded if regex.match('^[\w-]*$', x)])
if len(decoded) != len(original):
raise errors.InvalidRequest(_('Keywords can only include numerals, alphabet and hyphens (-)'))
# Convert to lower case
decoded = set([x.lower() for x in decoded])
# Remove stopwords
keywords = set([x.encode('utf-8') for x in decoded\
if x not in stopwords.words()])
# After all this if we still have words, add them to database
if keywords:
for keyword in keywords:
yield db.insert(orgId, "keywords", '', keyword)
yield db.insert(orgId, "originalKeywords", '', keyword)
keywords = yield db.get_slice(orgId, "originalKeywords", count=100)
keywords = utils.columnsToDict(keywords, ordered=True)
args = {'keywords': keywords}
t.renderScriptBlock(request, "admin.mako", "listKeywords",
False, "#content", "set", **args)
# We may want to display an error when we removed stopwords.
if len(keywords) < len(decoded):
pass
def _cleanupMissingComments(convId, missingIds, itemResponses):
missingKeys = []
for response in itemResponses:
userKey, responseKey = response.column.value.split(':')
if responseKey in missingIds:
missingKeys.append(response.column.name)
d1 = db.batch_remove({'itemResponses': [convId]}, names=missingKeys)
d1.addCallback(lambda x: db.get_count(convId, "itemResponses"))
d1.addCallback(lambda x: db.insert(convId, 'items', \
str(x), 'responseCount', 'meta'))
return d1
def create(request, me, name, access, description, displayPic):
"""create a new group.
add creator to the group members. make create administrator of the group.
Note: No two groups in an organization should have same name.
Keyword params:
@request:
@me:
@name: name of the group.
@access: group access type (open/closed).
@description: description of the group.
@displayPic: profile pic of the group.
"""
if not name:
raise errors.MissingParams([_("Group name")])
cols = yield db.get_slice(me.basic['org'], "entityGroupsMap",
start=name.lower(), count=2)
for col in cols:
if col.column.name.split(':')[0] == name.lower():
raise errors.InvalidGroupName(name)
groupId = utils.getUniqueKey()
group = base.Entity(groupId)
meta = {"name": name, "type": "group",
"access": access, "org": me.basic['org']}
admins = {me.id: ''}
if description:
meta["desc"] = description
if displayPic:
avatar = yield saveAvatarItem(group.id, me.basic['org'], displayPic)
meta["avatar"] = avatar
group.update({'basic': meta, 'admins': admins})
yield group.save()
colname = _entityGroupMapColName(group)
yield db.insert(me.id, "entities", name, group.id, 'adminOfGroups')
yield db.insert(me.basic['org'], "entityGroupsMap", '', colname)
yield _addMember(request, group, me)
def _reportUser(self, request, myId, targetId):
entities = base.EntitySet([myId, targetId])
yield entities.fetchData()
reportedBy = entities[myId].basic["name"]
email = entities[targetId].basic["emailId"]
rootUrl = config.get('General', 'URL')
brandName = config.get('Branding', 'Name')
authinfo = request.getSession(IAuthInfo)
amIAdmin = authinfo.isAdmin
cols = yield db.get_slice(email, "userAuth", ["reactivateToken",
"isFlagged", "isAdmin"])
cols = utils.columnsToDict(cols)
if cols.has_key("isAdmin") and not amIAdmin:
raise errors.PermissionDenied("Only administrators can flag other \
administrators for verification")
if cols.has_key("isFlagged"):
token = cols.get("reactivateToken")
else:
token = utils.getRandomKey()
yield db.insert(email, "userAuth", token, 'reactivateToken')
yield db.insert(email, "userAuth", "", 'isFlagged')
body = "%(reportedBy)s has flagged your account for verification."\
"You can verify your account by clicking on the link below.\n"\
"\n\n%(reactivateUrl)s\n\n"
reactivateUrl = "%(rootUrl)s/password/verify?email=%(email)s&token=%(token)s"%(locals())
args = {"brandName": brandName, "rootUrl": rootUrl,
"reportedBy":reportedBy, "reactivateUrl": reactivateUrl}
subject = "[%(brandName)s] Your profile has been flagged for review" %(locals())
htmlBody = t.getBlock("emails.mako", "reportUser", **args)
textBody = body %(locals())
yield utils.sendmail(email, subject, textBody, htmlBody)
request.write('$$.alerts.info("%s");' % _('User has been flagged for verification'))
def follow(group, user):
"""Add @user to @group followers
Keyword params:
@group: entity object of group
@user: entity object of user
"""
try:
yield db.get(group.id, "groupMembers", user.id)
yield db.insert(group.id, "followers", "", user.id)
defer.returnValue(True)
except ttypes.NotFoundException:
return
def _updateNotifications(self, request):
authinfo = request.getSession(IAuthInfo)
myId = authinfo.username
getArg = utils.getRequestArg
def _get(typ):
val = getArg(request, typ)
try:
return val if (0 < int(val) <= 3) else '0'
except (ValueError,TypeError):
return '0'
prefVal = ''.join([_get(x) for x in _notifyNames])
yield db.insert(myId, 'entities', prefVal, 'notify', 'basic')
request.write('$$.alerts.info("%s");' % _('Preferences saved'))
def _ensureTag(tagName, myId, orgId, presetTag=False):
try:
tagName = tagName.lower()
c = yield db.get(orgId, "orgTagsByName", tagName)
tagId = c.column.value
c = yield db.get_slice(orgId, "orgTags", super_column=tagId)
tag = utils.columnsToDict(c)
if presetTag and not tag.get('isPreset', '') == 'True':
yield db.insert(orgId, "orgPresetTags", tagId, tagName)
yield db.insert(orgId, "orgTags", 'True', 'isPreset', tagId)
tag['isPreset'] = 'True'
except ttypes.NotFoundException:
tagId = utils.getUniqueKey()
tag = {"title": tagName, 'createdBy': myId}
if presetTag:
tag['isPreset'] = 'True'
tagName = tagName.lower()
yield db.batch_insert(orgId, "orgTags", {tagId: tag})
yield db.insert(orgId, "orgTagsByName", tagId, tagName)
if presetTag:
yield db.insert(orgId, "orgPresetTags", tagId, tagName)
defer.returnValue((tagId, tag))
def _blockUser(self, request, data=None):
authInfo = request.getSession(IAuthInfo)
myId = authInfo.username
orgId = authInfo.organization
user = data['id']
# Admin cannot block himself.
if user.id == myId:
raise errors.InvalidRequest(_("You cannot block yourself."))
emailId = user.basic.get("emailId", None)
yield db.insert(emailId, "userAuth", 'True', "isBlocked")
yield db.insert(orgId, "blockedUsers", '', user.id)
sessionIds = yield db.get_slice(user.id, "userSessionsMap")
sessionIds = utils.columnsToDict(sessionIds)
for sessionId in sessionIds:
yield db.remove(sessionId, "sessions")
yield utils.cleanupChat(sessionId, user.id, orgId)
yield db.remove(user.id, "userSessionsMap")
t.renderScriptBlock(request, "admin.mako", "admin_actions",
False, "#user-actions-%s" % (user.id),
"set", args=[user.id, 'blocked'])
