def deactivate_profile_view(context, request):
name = context.__name__
myself = authenticated_userid(request) == context.__name__
confirm = request.params.get('confirm')
if confirm:
try:
find_users(context).remove(name)
except KeyError:
pass
to_profile_inactive(context)
if myself:
return logout_view(context, request, reason='User removed')
query = {'status_message': 'Deactivated user account: %s' % name}
parent = context.__parent__
location = model_url(parent, request, query=query)
return HTTPFound(location=location)
page_title = 'Deactivate user account for %s %s' % (context.firstname,
context.lastname)
api = request.api
api.page_title = page_title
# Show confirmation page.
return dict(api=api, myself=myself)
def delete_community(obj, event):
# delete the groups related to the community when a community is
# deleted
context = obj
users = find_users(context)
users.delete_group(context.members_group_name)
users.delete_group(context.moderators_group_name)
def _add_existing_users(context, community, profiles, text, request, status=None):
users = find_users(community)
for profile in profiles:
group_name = community.members_group_name
user_name = profile.__name__
users.add_group(user_name, group_name)
# Generate HTML and text mail messages and send a mail for
# each user added to the community.
community_href = model_url(community, request)
_send_aeu_emails(community, community_href, profiles, text)
# We delivered invitation messages to each user. Redirect to
# Manage Members with a status message.
n = len(profiles)
if n == 1:
msg = 'One member added and email sent.'
else:
fmt = '%s members added and emails sent.'
msg = fmt % len(profiles)
if status:
msg = msg + ' ' + status
if request.POST.get('return_to') is not None:
location = request.POST['return_to']
return render_template_to_response('templates/javascript_redirect.pt',
url=location)
else:
location = model_url(context, request, 'manage.html',
query={'status_message': msg})
return HTTPFound(location=location)
def handle_content(self, context, request, validated):
# Handle the easy ones
names_fieldset = validated['names_fieldset']
context.firstname=names_fieldset['first_name']
context.lastname=names_fieldset['last_name']
context.email=names_fieldset['email']
context.position=validated['details']['position']
context.organization=validated['details']['organization']
context.biography=validated['details']['biography']
context.country=validated['details']['country']
# change password
users = find_users(context)
if validated['passwords']['password']:
users = find_users(context)
users.change_password(context.__name__,validated['passwords']['password'])
# handle websites
context.websites=[]
for url in validated['details']['websites']:
if not (
url.startswith('http://') or
url.startswith('https://')
):
url = 'http://'+url
context.websites.append(url)
# Handle the picture
handle_photo_upload(context, request, validated['profile_image']['photo'])
# Handle the social networking stuff
socials = validated['details']['social_networks']
for name in ('facebook', 'twitter'):
id = socials[name]
if id:
if name == 'twitter' and not id.startswith('@'):
id = '@' + id
item = self.social_category.get(name)
if not item:
item = SocialCategoryItem(
id=id, title=name, description=u''
)
context.categories['social'][name] = item
else:
item.id = id
def handle_submit(self, converted):
try:
context = self.context
request = self.request
key = request.params.get('key')
if not key or len(key) != 40:
e = ResetFailed()
e.page_title = 'Password Reset URL Problem'
raise e
users = find_users(context)
user = users.get_by_login(converted['login'])
if user is None:
# XXX should be part of form validation
raise Exception(login='******')
userid = user.get('id')
if userid is None:
userid = user['login']
profiles = find_profiles(context)
profile = profiles.get(userid)
if profile is None:
# XXX should be part of form validation
raise Exception(login='******')
if key != getattr(profile, 'password_reset_key', None):
e = ResetFailed()
e.page_title = 'Password Reset Confirmation Problem'
raise e
now = datetime.datetime.now()
t = getattr(profile, 'password_reset_time', None)
if t is None or now - t > max_reset_timedelta:
e = ResetFailed()
e.page_title = 'Password Reset Confirmation Key Expired'
raise e
# The key matched. Clear the key and reset the password.
profile.password_reset_key = None
profile.password_reset_time = None
password = converted['password'].encode('UTF-8')
users.change_password(userid, password)
page_title = 'Password Reset Complete'
api = request.api
api.page_title = page_title
return render_template_to_response(
'templates/reset_complete.pt',
api=api,
login=converted['login'],
password=converted['password'],
)
except ResetFailed, e:
api = request.api
api.page_title = e.page_title
return render_template_to_response('templates/reset_failed.pt',
api=api)
def handle_submit(self, validated):
email = self._get_email_by_request_id(validated['request_id'])
user = _get_user_by_email(self.context, email)
users = find_users(self.context)
users.change_password(user.__name__, validated['password'])
site = find_site(self.context)
del site['reset_password'][user.email]
return self._redirect()
def get_user_community_names(context, request):
userid = authenticated_userid(request)
if userid is None:
return []
users = find_users(context)
user = users.get_by_id(userid)
community_names = set()
for group in user["groups"]:
if group.startswith("group.community:"):
community_names.add(group.split(":")[1])
return community_names
def handle_submit(self, validated):
context = self.context
community = self.community
request = self.request
users = find_users(context)
profiles = self.profiles
password = validated['account']['password']
username = validated['account']['username']
if community:
community_href = model_url(community, request)
groups = [ community.members_group_name ]
users.add(username, username, password, groups)
else:
users.add(username, username, password, ['group.KarlStaff'])
plugin = request.environ['repoze.who.plugins']['auth_tkt']
identity = {'repoze.who.userid':username}
remember_headers = plugin.remember(request.environ, identity)
profile = create_content(
IProfile,
firstname=validated['details']['first_name'],
lastname=validated['details']['last_name'],
email=context.email,
country=validated['details']['country'],
dob=validated['details']['date_of_birth'],
gender=validated['details']['gender']
)
profiles[username] = profile
to_profile_active(profile)
del context.__parent__[context.__name__]
if community:
url = model_url(community, request,
query={'status_message':'Welcome!'})
_send_ai_email(community, community_href, username, profile)
else:
url = request.api.app_url+'?status_message=Welcome!'
_send_signup_ai_email(request, username, profile)
return HTTPFound(headers=remember_headers, location=url)
def to_profile_active(ob, extra_acl=None, override_default_acl=False):
from opencore.utils import find_users
from opencore.views.communities import get_community_groups
acl = []
if not override_default_acl:
acl.append((Allow, ob.creator,
MEMBER_PERMS + ('view_only',)))
acl.append((Allow, 'group.KarlUserAdmin',
ADMINISTRATOR_PERMS + ('view_only',)))
acl.append((Allow, 'group.KarlAdmin',
ADMINISTRATOR_PERMS + ('view_only',)))
acl.append((Allow, 'group.KarlStaff',
GUEST_PERMS + ('view_only',)))
acl.append((Allow, 'group.API',
API_PERMS))
if extra_acl:
acl = acl + extra_acl
# not auth'd users can view all content
acl.append((Allow, Everyone, ('view_only',)))
users = find_users(ob)
user = users.get_by_id(ob.creator)
if user is not None:
groups = user['groups']
for group, role in get_community_groups(groups):
c_group = 'group.community:%s:%s' % (group, role)
acl.append((Allow, c_group, GUEST_PERMS + ('view_only',)))
acl.append((Allow, 'system.Authenticated', GUEST_PERMS + ('view_only',)))
acl.append(NO_INHERIT)
added, removed = acl_diff(ob, acl)
if added or removed:
ob.__acl__ = acl
log.info('profile (%s) to-active, added: %s, removed: %s' % (model_path(ob), added, removed))
if ob.security_state == 'inactive':
ob.security_state = 'active'
log.info('profile (%s) security_state changed to %s' % (model_path(ob), ob.security_state))
def reactivate_profile_view(context, request,
reset_password=request_password_reset,
to_profile_active=to_profile_active):
name = context.__name__
confirm = request.params.get('confirm')
if confirm:
users = find_users(context)
temp_passwd = str(uuid.uuid4())
users.add(name, name, temp_passwd, [])
to_profile_active(context)
reset_password(users.get_by_id(name), context, request)
query = {'status_message': 'Reactivated user account: %s' % name}
location = model_url(context, request, query=query)
return HTTPFound(location=location)
page_title = 'Reactivate user account for %s %s' % (context.firstname,
context.lastname)
api = request.api
api.page_title = page_title
# Show confirmation page.
return dict(api=api)
def rename_user(context, old_name, new_name, merge=False, out=None):
"""
Renames a user with the given userid to a new userid. If `merge` is `True`
a user is expected to already exist with userid `new_name`. Moves all
content and group memberships from old user to new user before removing the
old user.
"""
profiles = find_profiles(context)
users = find_users(context)
old_user = users.get_by_id(old_name)
if old_name not in profiles:
raise ValueError("No such profile: %s" % old_name)
if merge:
if old_user is not None and users.get_by_id(new_name) is None:
raise ValueError("No such user: %s" % new_name)
if new_name not in profiles:
raise ValueError("No such profile: %s" % new_name)
if out is not None:
print >> out, "Merging user from %s to %s." % (old_name, new_name)
if old_user is not None:
for group in old_user["groups"]:
if not users.member_of_group(new_name, group):
users.add_user_to_group(new_name, group)
users.remove(old_name)
del profiles[old_name]
else:
if users.get_by_id(new_name) is not None:
raise ValueError("User already exists: %s" % new_name)
if new_name in profiles:
raise ValueError("Profile already exists: %s" % new_name)
if out is not None:
print >> out, "Renaming user %s to %s." % (old_name, new_name)
if old_user is not None:
users.add(new_name, new_name, old_user["password"], old_user["groups"], encrypted=True)
users.remove(old_name)
profile = profiles[old_name]
del profiles[old_name]
profiles[new_name] = profile
catalog = find_catalog(context)
search = ICatalogSearch(context)
index = catalog["creator"]
count, docids, resolver = search(creator=old_name)
for docid in docids:
doc = resolver(docid)
if out is not None:
print >> out, "Updating creator for %s." % model_path(doc)
doc.creator = new_name
index.reindex_doc(docid, doc)
index = catalog["modified_by"]
count, docids, resolver = search(modified_by=old_name)
for docid in docids:
doc = resolver(docid)
if out is not None:
print >> out, "Updating modified_by for %s." % model_path(doc)
doc.modified_by = new_name
index.reindex_doc(docid, doc)
def _get_group_names(self, group):
users = find_users(self)
names = users.users_in_group(group)
return set(names)
def __call__(self):
profile_details = getUtility(IProfileDict, name='profile-details')
profile_details.update_details(self.context, self.request, self.api,
self.photo_thumb_size)
context = self.context
request = self.request
api = self.api
# provide client data for rendering current tags in the tagbox
client_json_data = dict(
tagbox = get_tags_client_data(context, request),
)
# Get communities this user is a member of, along with moderator info
#
communities = {}
communities_folder = find_communities(context)
user_info = find_users(context).get_by_id(context.__name__)
if user_info is not None:
for group in user_info["groups"]:
if group.startswith("group.community:"):
unused, community_name, role = group.split(":")
if (communities.has_key(community_name) and
role != "moderators"):
continue
community = communities_folder.get(community_name, None)
if community is None:
continue
if has_permission('view', community, request):
communities[community_name] = {
"title": community.title,
"moderator": role == "moderators",
"url": model_url(community, request),
}
communities = communities.values()
communities.sort(key=lambda x:x["title"])
preferred_communities = []
my_communities = None
name = context.__name__
# is this the current user's profile?
if authenticated_userid(request) == name:
preferred_communities = get_preferred_communities(communities_folder,
request)
my_communities = get_my_communities(communities_folder, request)
tagger = find_tags(context)
if tagger is None:
tags = ()
else:
tags = []
names = tagger.getTags(users=[context.__name__])
for name, count in sorted(tagger.getFrequency(names,
user=context.__name__),
key=lambda x: x[1],
reverse=True,
)[:10]:
tags.append({'name': name, 'count': count})
self.profile = profile_details
self.communities = communities
self.my_communities = my_communities or []
self.preferred_communities = preferred_communities
self.tags = tags
self.actions = get_profile_actions(context,request)
self.head_data = convert_to_script(client_json_data)
return self.make_response()
def move_content(root, src, dst, wf_state):
try:
context = find_model(root, src)
except KeyError:
print >>sys.stderr, "Source content not found: %s" % src
sys.exit(-1)
try:
dest_folder = find_model(root, dst)
except KeyError:
print >>sys.stderr, "Destination folder not found: %s" % dst
sys.exit(-1)
src_community = find_community(context)
catalog = find_catalog(root)
assert catalog is not None
users = find_users(root)
assert users is not None
if src_community is not None:
move_header = ('<p><em>This was originally authored '
'in the "%s" community.</em></p>' %
src_community.title)
else:
move_header = ''
src_folder = context.__parent__
name = context.__name__
log.info("Moving %s", model_path(context))
for obj in postorder(context):
if hasattr(obj, 'docid'):
docid = obj.docid
catalog.document_map.remove_docid(docid)
catalog.unindex_doc(docid)
del src_folder[name]
if (context.creator != 'admin'
and users.get_by_id(context.creator) is None):
# give the entry to the system admin
log.warning(
"User %s not found; reassigning to admin", context.creator)
context.creator = 'admin'
if name in dest_folder:
name = make_unique_name(dest_folder, context.title)
dest_folder[name] = context
for obj in postorder(context):
if hasattr(obj, 'docid'):
docid = obj.docid
catalog.document_map.add(model_path(obj), docid)
catalog.index_doc(docid, obj)
if wf_state is not None:
wf = get_workflow(get_content_type(context), 'security', context)
wf.transition_to_state(context, None, wf_state)
if hasattr(context, 'text'):
context.text = "%s\n%s" % (move_header, context.text)
def handle_submit(self, converted):
log.debug('ManageMembersController.handle_submit converted: %s' % str(converted))
results = []
community = self.community
community_href = model_url(community, self.request)
context = self.context
request = self.request
moderators = community.moderator_names # property
members = community.member_names # property
invitation_names = [ x.__name__ for x in self._getInvitations() ]
members_group_name = community.members_group_name
moderators_group_name = community.moderators_group_name
users = find_users(context)
results = []
for record in converted:
name = record['name']
if record['remove']:
if name in members:
users.remove_group(name, members_group_name)
results.append('Removed member %s' % record['title'])
if name in moderators:
users.remove_group(name, moderators_group_name)
results.append('Removed moderator %s' %
record['title'])
if name in invitation_names:
del context[name]
results.append('Removed invitation %s' %
record['title'])
else:
if record['resend']:
invitation = context.get(name)
_send_invitation_email(request, community, community_href,
invitation)
results.append('Resent invitation to %s'%
record['title'])
else:
if (name in moderators) and (not record['moderator']):
users.remove_group(name, moderators_group_name)
results.append('%s is no longer a moderator'%
record['title'])
if (not name in moderators) and record['moderator']:
users.add_group(name, moderators_group_name)
results.append('%s is now a moderator' %
record['title'])
# Invariant: Don't allow removal of the last moderator.
if not community.moderator_names:
transaction.abort()
raise ValidationError(self,
members="Must leave at least one moderator for community.")
cur_moderators = community.moderator_names
new_moderators = cur_moderators - moderators
old_moderators = moderators - cur_moderators
if new_moderators or old_moderators:
_send_moderators_changed_email(community, community_href,
new_moderators, old_moderators,
cur_moderators, moderators)
joined_result = ', '.join(results)
status_message = 'Membership information changed: %s' % joined_result
location = model_url(context, request, "manage.html",
query={"status_message": status_message})
return HTTPFound(location=location)
