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'])