def create_new_mobile_user(request):
"""
Request contains:
phoneNumber - the phone number of the new user
secretCode - secret code to make sure only actual user creations send a text
returns:
error code
"""
try:
obj = simplejson.loads(request.body)
except ValueError:
obj = simplejson.loads(request.POST["json"])
error = 0 # success code
try:
phone_number = normalize_phone_number(obj["phoneNumber"])
secret_code = obj["secretCode"]
try:
user_profile = UserProfile.objects.get(phone_number=phone_number)
user = user_profile.user
# generate new pin
user_profile.pin = generate_new_pin()
user_profile.save()
except ObjectDoesNotExist:
user = User.objects.create_user(phone_number)
user_profile = user.get_profile()
send_pin(phone_number, secret_code, user_profile)
except Exception, e:
print 'Error with creating new app user: %s' % e
error = 1 # error code
def authenticate(self, phone_number=None, device_id=None, device_type=None):
try:
phone_number = normalize_phone_number(phone_number)
profile = UserProfile.objects.get(phone_number=phone_number)
verifiedID = VerifiedDeviceID.objects.get(user=profile.user,
device_id=device_id, device_type=device_type)
except Exception:
return None
return profile.user
def sendMessageFromTwilio(request):
"""
View that Twilio visits when a Twilio phone number receives a SMS.
Broadcasts a message sent by a user to relevant members of the group.
Twilio API details: https://www.twilio.com/docs/api/twiml/sms/twilio_request
"""
try:
obj = request.POST
print obj
print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
sender_phone = normalize_phone_number(obj['From'])
twilio_phone = normalize_phone_number(obj['To'])
message_text = obj['Body']
user_profile = get_object_or_404(UserProfile, phone_number=sender_phone)
user = user_profile.user
user_group_link = get_object_or_404(GroupUserLink, user=user,
twilio_number=twilio_phone)
group = user_group_link.group
recipients = extract_recipients(user, group, message_text)
if "error" in recipients:
# send error message back to sender
send_message(recipients["error"], None, user, group)
return HttpResponse(Response(), mimetype='application/xml')
recipients = recipients["recipients"]
# Create Message model instance and send out the message
message = Message(sender=user, group=group, message_text=message_text)
create_ios_push_notification(message)
message.save()
for group_link in recipients:
recipient = group_link.user
message_link = MessageUserLink(message=message, recipient=recipient)
message_link.save()
send_message(message, user, recipient, group)
return HttpResponse(Response(), mimetype='application/xml')
except Exception, e:
print e
traceback.print_exc()
return e
def hydrate_m2m_users(self, bundle):
"""
Hydrates the group bundle with group-users.
"""
print 'hydrate_m2m_users'
new_user_data = []
try:
for user_data in bundle.data['users']:
if isinstance(user_data, Bundle):
# already turned data into Bundle
continue
# beyond this point, 'user_data' assumed to be a 'dict' object
# get/create (but not save) GroupUserLink/User instances
phone_number = normalize_phone_number(
user_data['phone_number'])
print 'hydrating user (%s)' % phone_number
try:
user_pf = UserProfile.objects.get(phone_number=phone_number)
user = user_pf.user
except ObjectDoesNotExist, e:
print 'creating new user...'
first_name = user_data.get('first_name', '')
last_name = user_data.get('last_name', '')
user = User(username=phone_number,
first_name=first_name, last_name=last_name)
try:
groupuser_link = GroupUserLink.objects.get(group=bundle.obj,
user=user)
except ObjectDoesNotExist, e:
groupuser_link = GroupUserLink(group=bundle.obj, user=user)
# Adapted from `get_detail` from tastypie/resources.py
gur = GroupUserResource()
b = gur.build_bundle(obj=groupuser_link, request=bundle.request)
b = gur.full_dehydrate(b)
b = gur.alter_detail_data_to_serialize(b.request, b)
new_user_data.append(b)
def create_user_profile(sender, instance, created, **kwargs):
if created and not kwargs.get('raw', False):
profile = UserProfile.objects.create(user=instance,
phone_number=normalize_phone_number(instance.username),
# set phone number to username
pin=generate_new_pin())
def normalize_username(sender, instance, raw, **kwargs):
instance.username = normalize_phone_number(instance.username)
if instance.first_name:
instance.first_name = instance.first_name.title()
if instance.last_name:
instance.last_name = instance.last_name.title()
def setUp(self):
self.already_created_user = User.objects.create_user(
normalize_phone_number("+15551234567"))
def verify_new_mobile_user(request):
"""
Request contains:
phoneNumber - the phone number of the user
pinNumber - the validating pin number
deviceInfo
returns:
error code
user object
groupsForUser [group object]
"""
try:
obj = simplejson.loads(request.body)
except ValueError:
obj = simplejson.loads(request.POST["json"])
phone_number = normalize_phone_number(obj["phoneNumber"])
pin = obj["pinNumber"]
device_id = obj["deviceInfo"]["deviceID"]
device_type = obj["deviceInfo"]["deviceType"]
data = {}
try:
print 'verifying pin'
# verify pin number
try:
user_profile = UserProfile.objects.get(pin=pin,
phone_number=phone_number)
except:
data['code'] = 11
raise Exception("Invalid pin number")
print 'creating new verified device id'
# create new VerifiedDeviceID model instance
verified_device_id, created = VerifiedDeviceID.objects.get_or_create(
device_id=device_id, device_type=device_type,
user=user_profile.user)
print 'login user'
# log-in user
user = authenticate(phone_number=phone_number, device_id=device_id,
device_type=device_type)
login(request, user)
if verified_device_id.device_type == "I":
user_profile.is_iOS_user = True
user_profile.save()
# setting up JSON object to return
data['code'] = 0
print 'group_resources~~~~~~~~~~~~~~~~~~'
group_resources = []
group_user_links = GroupUserLink.objects.filter(user=user)
for link in group_user_links:
gr = GroupResource()
group = link.group
gr_bundle = gr.build_bundle(obj=group, request=request)
gr_bundle = gr.full_dehydrate(gr_bundle)
group_resources.append(complete_dehydrate(gr_bundle.data))
ur = UserResource()
ur_bundle = ur.build_bundle(obj=user, request=request)
data['user'] = complete_dehydrate(ur.full_dehydrate(ur_bundle).data)
data['groupsForUser'] = group_resources
data = complete_dehydrate(data)
data['code'] = 0 # success
serializer = CamelCaseJSONSerializer()
return HttpResponse(serializer.to_json(data),
mimetype='application/json')
except Exception, e:
traceback.print_exc()
print 'Error with verifying a new app user: %s' % e
if data.get('code', 0) == 0:
data['code'] = 1
