def invite(site_id): user = users.get_current_user() site = Site.get_admin_or_404(site_id) form = InviteForm(request.form) if form.validate(): invite_hash = sha1() invite_hash.update(str(site.key())) invite_hash.update(os.urandom(8)) invite_hash.update(form.email.data) invite_hash = b32encode(invite_hash.digest()).lower() invite = Invitation(hash=invite_hash, email=form.email.data, site=site, admin=form.admin.data, inviter=user) invite.put() mail.send_mail( sender=settings.invite_sender_email, to=invite.email, subject='%s invited you to join them on %s' % (user.email(), settings.appname), body=render_template('invite_email.txt', invite=invite), html=render_template('invite_email.html', invite=invite), ) if request.is_xhr: return 'OK' flash('Invitation Sent!', 'success') else: errors = sum(form.errors.values(), []) if request.is_xhr: return ', '.join(errors) for error in errors: flash(error, 'error') flash(form.email.data, 'error') return redirect(url_for('edit_siteusers', site_id=site_id))
def invite(request, code): profile = check_profile(code) if not profile: messages.error(request, 'Your personal URL is incorrect, please reset your account or provide proper url') return redirect('index') from forms import InvitationForm if request.method == 'POST': form = InvitationForm(request.POST) if form.is_valid(): emails=form.cleaned_data['emails'] emails=emails.split(',') for e in emails: e=e.strip() i=Invitation(email=e, key=generate_key()) i.save() u, created=User.objects.get_or_create(username=e[:30], email=e) notification.send([u], 'invite', {'key': i.key, 'profile':profile }) if len(emails): messages.info(request, '%d invitation(s) has been sent ' % len(emails)) return redirect('homepage', code=code) else: form=InvitationForm(initial={'key':code}) return render_to_response('researchers/invite.html', {'profile':profile, 'form':form, 'key':code}, context_instance=RequestContext(request))
def json_add_member(request, band_id): if isInBand(request.user, band_id): #current user is in this band if isManager(request.user, band_id): #current user is a manager if request.method == 'POST': #load data data = json.loads(request.body) #add an invitation to the email provided band = Band.objects.get(id=band_id) if "email" in data: email = data["email"] else: email = None newInv = Invitation(band=band, email=email, active=True) newInv.save() #add the member to the band regardless name = data["name"] role = data["role"] if "phone" in data: phone = data["phone"] else: phone = None status = data["status"] newMem = Member(band=band, name=name, role=role, phone=phone, status=status, email=email) newMem.save() return HttpResponse("success") return HttpResponse("failure")
def post(self): """ Ajax call to send an invitation on behalf of a user. path: /account/quick-send-initation """ current_user_obj = self.get_current_user_object() if current_user_obj.invitation_count < 0: #free day return self.write({'error': 'No invitations left'}) email_address = self.get_argument('email_address', None) if not email_address: return self.write({'error': 'You need to specify an email.'}) if not email_re.match(email_address): return self.write({'error': 'That email doesn\'t look right.'}) Invitation.create_for_email(email_address, current_user_obj.id) current_user_obj.invitation_count = current_user_obj.invitation_count - 1 current_user_obj.save() message = "<p>You've sent invitations to:</p> <ul>" for invitation in Invitation.by_user(current_user_obj): message += "<li>%s</li>" % invitation.email_address message += "</ul>" return self.write({ 'response': 'ok', 'count': current_user_obj.invitation_count, 'message': message })
def create_invitation(invitor, invitee, assign): invitation = Invitation( invitor = invitor.key, invitee = invitee.key, assignment_number = assign, active = True ) invitation.put() return invitation
def get_all_invites_for_pair(confirming, being_confirmed, active=True): # this method returns all invitations that involve BOTH members of a student pair return Invitation.query( ndb.OR(Invitation.invitee == confirming.key, Invitation.invitee == being_confirmed.key), ndb.OR(Invitation.invitor == being_confirmed.key, Invitation.invitor == confirming.key), Invitation.active == active, ).fetch()
def get(self): try: i = Invitation.get(self.request.get('invitation', '')) if i is None: self.redirect("/") return # only allow privilege increase, when the project and the code matches the stored Invitation instance if int(self.request.get('code', 0))==i.code and str(self.request.get('project', ''))==str(i.project.key()): # check for existing access to project rights = ProjectRights.gql("WHERE user=:user and project=:project", user=users.get_current_user(), project=i.project).get() # edit rights if not rights: rights = ProjectRights(project=i.project, user=users.GetCurrentUser(), right=i.right) # possibly upgrade rights if rights.right<i.right: rights.right = i.right rights.put() # delete invitation i.delete() else: # invalid invitation raise Exception("Invalid invitation %(p1)s!=%(p2)s" % {'p1': self.request.get('project', ''), 'p2':i.project.key() } ) # redirect to project summary, even if we can not increase privilege self.redirect("/summary?project=%(project)s" % { 'project': i.project.key() } ) except BadKeyError: # self.redirect("/summary?project=%(project)s" % { 'project': self.request.get('project', 'invalid')} ) return
def get_open_invitations_for_pair_for_assign(confirming, being_confirmed, assign_num): return Invitation.query( ndb.OR(Invitation.invitee == confirming.key, Invitation.invitee == being_confirmed.key), ndb.OR(Invitation.invitor == being_confirmed.key, Invitation.invitor == confirming.key), Invitation.assignment_number == assign_num, Invitation.active == True )
def post(self): if self.get_argument('waitlist_id', None): waitlist_id = self.get_argument('waitlist_id') waiter = Waitlist.get('id = %s', waitlist_id) invitation = Invitation.create_for_email(waiter.email, self.admin_user.id) waiter.invited = 1 waiter.save() return self.redirect('/admin/waitlist')
def add_group_user(request, groupName=None): if request.method == 'POST': users = request.POST.getlist('user') groupName = request.POST['groupName'] sgroup = get_object_or_404(SocialGroup, name=groupName) if request.user != sgroup.creator: msg = 'You dont have the permission' else: msg = "" ul = User.objects.filter(username__in=users) for u in ul: #to make sure user isnot already in and not already sent if not Membership.objects.filter( sgroup=sgroup, member=u ).count( ): # = Invitation.objects.get(sgroup, u).response='accept' if not Invitation.objects.filter( socialgroup=sgroup, invite=u, response='').count(): invite = Invitation(invite=u, socialgroup=sgroup) invite.save() msg = msg + 'Invitation sent to users' else: msg = msg + '%s already in the group or is invited <br />' % u else: sgroup = get_object_or_404(SocialGroup, name=groupName) invitations = Invitation.objects.filter(socialgroup=sgroup).exclude( response="reject") invitedList = [] for invitation in invitations: invitedList.append(invitation.invite) users = User.objects.exclude(id=request.user.id).exclude( id__in=sgroup.members.all()).exclude(username__in=invitedList) # to exclude members already in or already invited return render(request, 'add_group_user.html', { 'groupName': groupName, 'users': users }) return render(request, 'add_group_user.html', { 'groupName': groupName, 'msg': msg })
def invite(request, code): profile = check_profile(code) if not profile: messages.error( request, 'Your personal URL is incorrect, please reset your account or provide proper url' ) return redirect('index') from forms import InvitationForm if request.method == 'POST': form = InvitationForm(request.POST) if form.is_valid(): emails = form.cleaned_data['emails'] emails = emails.split(',') for e in emails: e = e.strip() i = Invitation(email=e, key=generate_key()) i.save() u, created = User.objects.get_or_create(username=e[:30], email=e) notification.send([u], 'invite', { 'key': i.key, 'profile': profile }) if len(emails): messages.info(request, '%d invitation(s) has been sent ' % len(emails)) return redirect('homepage', code=code) else: form = InvitationForm(initial={'key': code}) return render_to_response('researchers/invite.html', { 'profile': profile, 'form': form, 'key': code }, context_instance=RequestContext(request))
def get_all_invitations_involving_students_in_pair(confirming, being_confirmed, assign_num, active=True): # this method returns all invitations that involve AT LEAST ONE member of a student pair return Invitation.query( ndb.OR( ndb.OR( Invitation.invitor == confirming.key, Invitation.invitor == being_confirmed.key), ndb.OR( Invitation.invitee == confirming.key, Invitation.invitee == being_confirmed.key)), Invitation.assignment_number == assign_num, Invitation.active == active )
def invitation(hash): user = users.get_current_user() invite = Invitation.gql('WHERE hash=:1', hash).get() if not invite: return render_template('invitation_expired.html') # We want the user to be logged out once before coming here so they can choose which account the invite applies to. if not invite.has_been_logged_out: invite.has_been_logged_out = True invite.put() if user: return redirect(users.create_logout_url(request.path)) if not user: return redirect(users.create_login_url(request.path)) site = invite.site if user not in site.users: site.users.append(user) if invite.admin and user not in site.admins: site.admins.append(user) site.put() for invite in Invitation.gql('WHERE email=:1 AND site=:2', invite.email, invite.site): invite.delete() return render_template('invitation.html', site=site)
def add_friend(request,username): user = User.objects.get(username=username) invitation = Invitation(name = user.username, email= user.email, code= User.objects.make_random_password(20),sender=request.user) invitation.save() invitation.send() connection = Connections.objects.filter(connector_id= user.id) variables = RequestContext(request, {'username':username, 'connections': connection, 'users': User.objects.all()}) return render_to_response('user_connections.html',variables)
def invite(site_id): user = users.get_current_user() site = Site.get_admin_or_404(site_id) form = InviteForm(request.form) if form.validate(): invite_hash = sha1() invite_hash.update(str(site.key())) invite_hash.update(os.urandom(8)) invite_hash.update(form.email.data) invite_hash = b32encode(invite_hash.digest()).lower() invite = Invitation( hash=invite_hash, email=form.email.data, site=site, admin=form.admin.data, inviter=user ) invite.put() mail.send_mail( sender = settings.invite_sender_email, to = invite.email, subject = '%s invited you to join them on %s' % (user.email(), settings.appname), body = render_template('invite_email.txt', invite=invite), html = render_template('invite_email.html', invite=invite), ) if request.is_xhr: return 'OK' flash('Invitation Sent!', 'success') else: errors = sum(form.errors.values(), []) if request.is_xhr: return ', '.join(errors) for error in errors: flash(error, 'error') flash(form.email.data, 'error') return redirect(url_for('edit_siteusers', site_id=site_id))
def invite(request, next=None): """Handles invite form submission""" invite_form = InviteForm(instance=Invitation(user=request.user), data=request.POST) if invite_form.is_valid(): invites = invite_form.save() emails = ", ".join([invite.email for invite in invites]) messages.success(request, 'Invitation sent to %s' % emails) else: messages.error( request, 'Form values where invalid, please try fill out the form again.') if request.is_ajax() and request.method == 'POST': message_html = loader.render_to_string('_messages.html', {}, RequestContext(request)) return HttpResponse(message_html) next = request.POST.get("next", next) if next: return redirect(next) return redirect("index")
def post(self, request): form = InvitationForm(request.POST) if form.is_valid(): email = form.cleaned_data['email'] subject = 'Invitation to join MyTweet App' sender_name = request.user.username sender_email = request.user.email invite_code = Invite.generate_invite_code(email) link = 'http://%s/users/invite/accept/%s/' % (settings.SITE_HOST, invite_code) context = Context({"sender_name": sender_name, "sender_email": sender_email, "email": email, "link": link}) invite_email_template = render_to_string('partials/_invite_email_template.html', context) msg = EmailMultiAlternatives(subject, invite_email_template, settings.EMAIL_HOST_USER, [email], cc=[settings.EMAIL_HOST_USER]) user = User.objects.get(username=request.user.username) invitation = Invitation() invitation.email = email invitation.code = invite_code invitation.sender = user invitation.save() success = msg.send() return HttpResponseRedirect('/users/invite?success='+str(success) +'&email='+email)
def invite(request): emails = request.POST.getlist('emailList[]', '') custom_message = request.POST.get('custom_message', '') if emails: user = User.objects.get(username=request.user.username) user_account = Account.objects.get(user=user) did_not_invite = [] # TODO: Move this to string templates if custom_message: email_body = "{host_name} has invited you to be part of CiviWiki Beta with the following message: {custom_message}".format( host_name=user_account.full_name, custom_message=custom_message ) else: email_body = "{host_name} has invited you to be part of CiviWiki Beta. Follow the link below to get registered.".format( host_name=user_account.full_name ) email_messages = [] valid_emails = [] for email in emails: if Invitation.objects.filter(invitee_email=email).exists(): did_not_invite.append(email) else: valid_emails.append(email) verification_hash = uuid.uuid4().hex[:31] data = { 'host_user': user, 'invitee_email': email, 'verification_code': verification_hash, } domain = get_current_site(request).domain base_url = "http://{domain}/beta_register/{email}/{token}" url_with_code = base_url.format( domain=domain, email=email, token=verification_hash ) email_context = { 'title' : "You're Invited to Join CiviWiki Beta", 'greeting' : "You're Invited to Join CiviWiki Beta", 'body' : email_body, 'link': url_with_code, 'recipient': [email] } email_messages.append(email_context) new_invitation = Invitation(**data) # new_invitation.host_user = user # new_invitation.invitee_email = email # new_invitation.verification_code = "" new_invitation.save() if email_messages: email_subject = "Invitation to CiviWiki" send_mass_email.delay( subject=email_subject, contexts=email_messages ) if len(did_not_invite) == len(emails): response_data = { "message": "Invitations exist for submitted email(s). No new invitations sent", "error":"INVALID_EMAIL_DATA" } return JsonResponse(response_data, status=400) invitations = Invitation.objects.filter_by_host(host_user=user).order_by("-date_created").all() invitees = [invitation.summarize() for invitation in invitations] response_data = { 'did_not_invite': did_not_invite, 'invitees': invitees } return JsonResponse(response_data) else: # Return an 'invalid login' error message. response = { "message": 'Invalid Email Data', "error":"INVALID_EMAIL_DATA" } return JsonResponse(response, status=400)
def post(self): emails = self.get_argument("emails") for email in emails.split('\r\n'): email = email.strip() Invitation.create_for_email(email, self.admin_user.id) return self.redirect("/admin")
def do_start_user(client, message, *args, **kwargs): session = kwargs.get('session') user = session.query(User).filter(User.chat_id == message.chat.id).first() if user: # Utente era già fibberato fibberations = session.query(Invitation).filter(Invitation.signer == user).all() reply = "👋 **Bentornato {}**\n" \ "☣ Hai fibberato **{}** Persone!\n" \ "💰 Possiedi 💸**{} FiberCoin**\n\n" \ "🔗 Fibbera la gente con questo link:\n{}" \ .format(user.name, len(fibberations), user.coins, BASE_LINK.format(user.code)) message.reply(reply) elif len(message.command) > 1: # fibbera un nuovo utente con invito invite_code = try_parse_int(message.command[1], None) if invite_code: inviter = session.query(User).filter(User.code == invite_code).first() if inviter: # Insert a User in the user table name = message.from_user.username if not name: name = "{} {}".format(message.from_user.first_name, message.from_user.last_name) new_user = User( chat_id=message.chat.id, name=name, code=(random.randint(10000,9999999)^message.chat.id), coins=math.floor(FC_PER_FIBBERATION/2) ) session.add(new_user) #session.commit() # Insert fiberation in the fibberations table new_fibberation = Invitation(signer=inviter, signed=new_user) session.add(new_fibberation) #session.commit() inviter.coins += FC_PER_FIBBERATION session.commit() # Prepare reply app.send_message(chat_id=inviter.chat_id, text="Hai ricevuto 💸**{} FiberCoin** per aver fibberato {}\n" "💰 Borsellino: 💸**{} FiberCoin**"\ .format(FC_PER_FIBBERATION, MENTION.format(new_user.name, new_user.chat_id), inviter.coins) ) message.reply("**SEI STATO FIBBERATO!**⬆\n\n" "🔗 Puoi fibberare la gente con questo link:\n" "{}\n\n"\ "Scopri di più utilizzando il comando /about\n"\ .format(BASE_LINK.format(new_user.code))) else: message.reply("FibberCode non valido!") elif not len(session.query(User).all()): # Fibbera un nuovo utente senza invito (SOLO SE NESSUN ALTRO è STATO FIBBERATO) name = message.from_user.username if not name: name = "{} {}".format(message.from_user.first_name, message.from_user.last_name) new_user = User( chat_id=message.chat.id, name=name, code=(random.randint(10000,9999999)^message.chat.id), coins=math.floor(FC_PER_FIBBERATION / 2), privilege=1 ) session.add(new_user) session.commit() reply = "SEI STATO FIBBERATO!\n\n\n Sei il primo fibberatore della catena.\nPuoi fibberare laggente con questo link:\n{}" \ .format(BASE_LINK.format(new_user.code)) message.reply(reply)
def get_all_invitations_involving_student(confirming): return Invitation.query( ndb.OR( Invitation.invitor == confirming.key, Invitation.invitee == confirming.key), )
def submitcircle(request): new_member = get_current_member(request) new_circle = get_current_circle(request) count = 2 posted_members = {} custom_errors = "" while count <= settings.CIRCLE_MAX_SIZE: member_contact = {} current_name = request.POST.get("name_" + str(count), None) current_contact = request.POST.get("contact_" + str(count), None) if (current_name): if (current_contact): # Check to see if current contact info is valid phone or email if is_phone(current_contact): member_contact["contact_type"] = "phone" if is_email(current_contact): member_contact["contact_type"] = "email" if not is_phone(current_contact) and not is_email(current_contact): # Bad data error custom_errors += "<li>contact_" + str(count) + " must be either a valid phone number OR email</li>" member_contact["contact_info"] = current_contact posted_members[current_name] = member_contact else: # Missing contact data error custom_errors += "<li>name_" + str(count) + " is present but contact_" + str(count) + " is missing</li>" else: if len(posted_members) < (settings.CIRCLE_MIN_SIZE - 1): # Missing name data error custom_errors += "<li>name_" + str(count) + " is missing</li>" count += 1 # Check to see if we have minimum more members added if len(posted_members) < (settings.CIRCLE_MIN_SIZE - 1): custom_errors += "<li>You need at least " + str(settings.CIRCLE_MIN_SIZE) + " members (including yourself) in your circle</li>" if custom_errors != "": custom_errors = format_html("<p><ul>{}</ul></p>", mark_safe(custom_errors)) # If there are any errors, kick out and display them context = {"member":new_member, "num_range_str":settings.CONTACT_RANGE_STR, "custom_errors":custom_errors, } return render(request, "circly/network.html", context) for each_member in posted_members.keys(): # Create new members and add to the circle if (posted_members[each_member]["contact_type"] == "email"): next_member = Member(circle=new_circle, circle_owner=False, member_name=each_member, member_email=posted_members[each_member]["contact_info"], member_created_date=timezone.now(), ) elif (posted_members[each_member]["contact_type"] == "phone"): new_phone = phonenumbers.parse(posted_members[each_member]["contact_info"], "US") new_phone = phonenumbers.format_number(new_phone, phonenumbers.PhoneNumberFormat.E164) next_member = Member(circle=new_circle, circle_owner=False, member_name=each_member, member_phone=new_phone, member_created_date=timezone.now(), ) next_member.save() # Create invite code with short link for profile sign up invite_code = hash_code(posted_members[each_member]["contact_info"]) invite_url = "http://www.circly.org/invite/" + invite_code new_short_url = random_bitly(invite_url) invite = Invitation(member=next_member, invite_code=invite_code, invite_short_url=new_short_url, invite_created_date=timezone.now(), invite_send_date=timezone.now()) invite.save() # Create reminders for all new members to join the circle remind = Reminder(member=next_member, reminder_subject=new_circle.circle_owner_name() + " would like you to join their circle of support", reminder_message="Hey " + each_member + ", visit " + new_short_url + " to fill in your profile and join a circle of preventive care.", reminder_created_date=timezone.now(), reminder_send_date=timezone.now(), ) remind.save() if new_member.member_email: owner_hash = hash_code(new_member.member_email) if new_member.member_phone: owner_hash = hash_code(new_member.member_phone) dashboard_url = "http://www.circly.org/dashboard/" + owner_hash new_short_dashboard_url = random_bitly(dashboard_url) new_circle.circle_short_url = new_short_dashboard_url new_circle.save() set_member_and_circle(request, new_circle, new_member) return HttpResponseRedirect(reverse("connect:dashboard", kwargs={"owner_hash":owner_hash}))
def get_recvd_invites_by_student_and_assign(student, assign_num, active=True): return Invitation.query( Invitation.invitee == student.key, Invitation.assignment_number == assign_num, Invitation.active == active )