def unfollow(follower, followed, delay_commit=False):
followed = get_member(followed)
follower = get_member(follower)
if not followed:
raise action_error(_('unable to find followed'), code=404)
if not follower:
raise action_error(_('unable to find follower'), code=404)
#if followed not in follower.following:
# GregM: can unfollow to remove trusted invite
if not follower.is_following(
followed) and not follower.is_follow_trusted_inviter(followed):
raise action_error(_('not currently following'), code=400)
#follower.following.remove(followed)
follow = Session.query(Follow).filter(
Follow.member_id == followed.id).filter(
Follow.follower_id == follower.id).one()
Session.delete(follow)
if not delay_commit:
Session.commit()
#invalidate_member(follower)
#invalidate_member(followed)
followed.send_notification(
messages.follow_stop(member=follower, you=followed))
return True
def set_password(user, new_token, delay_commit=False):
"""
Set password
WARNING! We assume the user has already been authenticated
- remove old password (if found)
- create new password record
"""
# search for existing record and remove it
#
try:
for existing_login in [login for login in user.login_details if login.type == 'password']:
log.debug("removing password for %s" % user.username)
#if existing_login.token == old_token: raise Exception('old password token does not match - aborting password change')
Session.delete(existing_login)
log.debug("removed ok")
#try: Session.execute(UserLogin.__table__.delete().where(and_(UserLogin.__table__.c.member_id == user.id, UserLogin.__table__.c.token == token)))
except Exception:
pass
# Set new password
u_login = UserLogin()
u_login.user = user
u_login.type = 'password'
u_login.token = new_token
Session.add(u_login)
if not delay_commit:
Session.commit()
def rate_content(content, member, rating):
content = get_content(content)
member = get_member(member)
rating_value = int(rating)
if not content:
raise action_error(_('unable to find content'), code=404)
if not member:
raise action_error(_('unable to find member'), code=404)
if rating and rating_value < 0 or rating_value > 5:
raise action_error(_("Ratings can only be in the range 0 to 5"),
code=400)
# remove any existing ratings
# we need to commit after removal, otherwise SQLAlchemy
# will optimise remove->add as modify-existing, and the
# SQL trigger will break
try:
existing = Session.query(Rating).filter(
Rating.content == content).filter(Rating.member == member).one()
Session.delete(existing)
Session.commit()
except NoResultFound:
pass
# rating = 0 = remove vote
# add a new one
if rating_value > 0:
r = Rating()
r.content = content
r.member = member
r.rating = rating_value
Session.add(r)
Session.commit()
def del_group(group):
group = get_group(group)
from pylons import tmpl_context as c
for member in [member_role.member for member_role in group.members_roles]:
member.send_notification(
messages.group_deleted(group=group, admin=c.logged_in_user)
) # AllanC - We cant use the standard group.send_notification because the group wont exisit after this line!
Session.delete(group)
Session.commit()
def unboom_content(content, member, delay_commit=False):
boom = has_boomed(content, member)
if boom:
Session.delete(boom)
else:
raise action_error(_(
"%s has not boomed previously boomed this _content" % member),
code=400)
if not delay_commit:
Session.commit()
def delete_content(self, id, force=False):
if force: # ignore logged in user and just get rid of it
Session.delete(Session.query(Content).get(id))
Session.commit()
else:
self.assertIn('delete', self.get_actions(id))
response = self.app.post(url('content', id=id, format="json"),
params={
'_method': 'delete',
'_authentication_token':
self.auth_token,
},
status=200)
def remove_member(group, member, delay_commit=False):
group = get_group(group)
member = get_member(member)
membership = get_membership(group, member)
if not group:
raise action_error(_('unable to find group'), code=404)
if not member:
raise action_error(_('unable to find member'), code=404)
if not membership:
raise action_error(_('not a member of group'), code=400)
# AllanC - permissions moved to controller
#if member!=c.logged_in_persona and not group.is_admin(c.logged_in_persona):
# raise action_error('current user has no permissions for this group', 403)
#AllanC - integrety moved to model
#if membership.role=="admin" and num_admins<=1:
# raise action_error('cannot remove last admin', 400)
# Notifications
if membership.status == "active": # member removed
from pylons import tmpl_context as c
if member != c.logged_in_user:
membership.member.send_notification(
messages.group_remove_member_to_member(admin=c.logged_in_user,
group=group))
group.send_notification(
messages.group_remove_member_to_group(admin=c.logged_in_user,
group=group,
member=member))
elif membership.status == "invite": # invitation declined
group.send_notification(
messages.group_invitation_declined(member=member, group=group))
elif membership.status == "request": # request declined
membership.member.send_notification(
messages.group_request_declined(group=group))
Session.delete(membership)
if not delay_commit:
Session.commit()
#invalidate_member(group)
#invalidate_member(member)
return True
def test_flag_message(self):
self.send_member_message('unitfriend',
subject='You smell',
content='I hate you')
self.log_in_as('unitfriend')
message = self.get_messages()['list']['items'][0]
self.assertIn('hate you', message['content'])
num_emails = getNumEmails()
response = self.app.post(
url('message_action',
action='flag',
id=message['id'],
format='json'),
params={
'_authentication_token': self.auth_token,
'type': 'offensive',
'comment': 'They said they hated me, and I smell ... sniff',
},
)
self.assertEqual(getNumEmails(), num_emails + 1)
email_response = getLastEmail()
self.assertEquals(email_response.email_to, config['email.moderator'])
self.assertIn('They said', email_response.content_text)
# Get raised flag from DB, will error on fail, then delete/cleanup
flag = Session.query(FlaggedEntity).filter(
FlaggedEntity.raising_member_id == 'unitfriend').filter(
FlaggedEntity.offending_message_id == message['id']).one()
Session.delete(flag)
self.delete_message(message['id'])
def test_summary_emails(self):
def task_summary_notification_email():
response = self.app.get(url(controller='task', action='summary_notification_email'))
self.assertIn(response_completed_ok, response.body)
now_start = self.server_datetime()
now = now_start
# No summary emails should trigger yet because no users have setup an interval
num_emails = getNumEmails()
task_summary_notification_email()
self.assertEquals(num_emails, getNumEmails())
# Setup test data ------------------------------------------------------
self.setting('summary_email_interval', 'advanced', 'hours=1') # Setup summary date
# Execute timed task ---------------------------------------------------
num_emails = getNumEmails()
task_summary_notification_email()
# Add message that should trigger in last hour and send notification
m1 = Message()
m1.target = Session.query(User).get('unittest')
m1.subject = 'Test summary_notification_email notification'
m1.content = 'Test summary_notification_email notification'
m1.timestamp = now + datetime.timedelta(minutes=30, hours=1)
Session.add(m1)
m2 = Message()
m2.source = Session.query(User).get('kitten')
m2.target = Session.query(User).get('unittest')
m2.subject = 'Test summary_notification_email message'
m2.content = 'Test summary_notification_email message'
m2.timestamp = now + datetime.timedelta(minutes=15, hours=1)
Session.add(m2)
m3 = Message()
m3.source = Session.query(User).get('unittest')
m3.target = Session.query(User).get('kitten')
m3.subject = 'To Amy kitten'
m3.content = 'To Amy kitten'
m3.timestamp = now + datetime.timedelta(minutes=20, hours=1)
Session.add(m2)
Session.commit()
now = self.server_datetime(now + datetime.timedelta(hours=2))
num_emails = getNumEmails()
task_summary_notification_email()
# Check sent emails ----------------------------------------------------
self.assertEquals(getNumEmails(), num_emails + 1)
email = getLastEmail().content_text
self.assertIn ('summary_notification_email notification', email)
self.assertIn ('summary_notification_email message' , email)
self.assertIn ('To Amy' , email) # Check sent message appears in summary
self.assertIn ('Amy M' , email) # Check the avatar and names of targets are aquired from DB
self.assertNotIn('unitfriend' , email) # Loose check to try to catch if any other notifications bleed over into this summary email
# Check no emails sent if outside interval -----------------------------
now = self.server_datetime(now + datetime.timedelta(hours=20))
num_emails = getNumEmails()
task_summary_notification_email()
self.assertEquals(num_emails, getNumEmails())
# Cleanup --------------------------------------------------------------
# Reset db state
#self.setting('summary_email_interval', 'advanced', 'hours=0', assert_set_value=False) # hours=0 turns into None and this breaks the auto assertion at the end of set value
self.setting('summary_email_interval', 'advanced', '', assert_set_value=False) #AllanC - an empty string should default to None
# No summary emails should trigger yet because no users have setup an interval
num_emails = getNumEmails()
task_summary_notification_email()
self.assertEquals(num_emails, getNumEmails()) # AllanC - this fails .. investigation needs to be made
# Reset server datetime
self.server_datetime(now_start)
# Delete test messages
Session.delete(m1)
Session.delete(m2)
Session.delete(m3)
Session.commit()
def del_member(member):
member = get_member(member)
#invalidate_member(member) #invalidate the cache - AllanC unneeded the event triggers handle this
Session.delete(member)
Session.commit()
def del_content(content):
content = get_content(content)
# TODO - AllanC - send notification to group members?
#invalidate_content(content) # invalidate the cache - AllanC unneeded the event triggers handle this
Session.delete(content)
Session.commit()
def del_member(member):
member = get_member(member)
Session.delete(member)
Session.commit()
def del_message(message):
Session.delete(message)
Session.commit()
