Exemple #1
0
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))
Exemple #2
0
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))
Exemple #3
0
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")
Exemple #4
0
    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
     )
Exemple #9
0
 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')
Exemple #10
0
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
    })
Exemple #11
0
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
     )
Exemple #13
0
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)
Exemple #14
0
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)
Exemple #15
0
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)
Exemple #16
0
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)
Exemple #19
0
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)
Exemple #20
0
 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")
Exemple #21
0
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),
         )
Exemple #23
0
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
     )