def client(request, username, template_name="clients/clients_profile.html"):
client = get_object_or_404(Client, user__username__iexact=username)
healer = is_healer(client)
if healer:
return redirect(healer.healer_profile_url())
contact_info = None
if is_healer(request.user):
try:
contact_info = ContactInfo.objects.get(healer__user=request.user,
client=client)
except ContactInfo.DoesNotExist:
pass
is_profile_visible = Clients.objects.are_friends(request.user, client.user)
request.friend_type = "clients"
request.other_user = client.user
return render_to_response(
template_name,
{
"is_profile_visible": is_profile_visible,
"phone_numbers": client.phone_numbers.all(),
"is_me": client.user == request.user,
"contact_info": contact_info,
# "other_user": other_user,
},
context_instance=RequestContext(request, {}, [friend_bar_processor]))
def test_client_as_ambassador(self):
self.signup('client', True)
c = Client.objects.filter(user__email=self.email)
self.assertEqual(c.count(), 1)
self.assertEqual(c[0].ambassador_program, True)
self.assertFalse(is_healer(c[0]))
def impersonate(request, username):
"""Login as selected user."""
request_user = request.user
original_user = request.session.get('original_user', False)
if original_user:
if not get_object_or_404(User, username=original_user).is_superuser:
raise Http404
elif not request_user.is_superuser:
raise Http404
new_user = get_object_or_404(User, username=username)
login_user(request, new_user)
if not original_user:
request.session['original_user'] = request_user.username
elif original_user == new_user.username:
request.session['original_user'] = None
else:
request.session['original_user'] = original_user
#if original_user:
# if original_user != new_user.profile:
# request.session['original_user'] = original_user
#elif request_user != new_user:
# request.session['original_user'] = request_user.profile
if is_healer(new_user):
return redirect('what_next')
else:
return redirect('home')
def import_google_contacts(request):
if not is_healer(request.user):
raise Http404
try:
google_contacts = GoogleContacts(request.user)
except oauth2client.client.Error:
request.session['oauth_callback_redirect'] = 'import_google_contacts'
return redirect('oauth2_google_login')
healer = request.user.client.healer
# check running import from any api
import_status = ContactsImportStatus.objects.filter(user=healer.user,
status=STATUS_RUNNING)
if import_status.count() > 0:
return redirect('import_contacts_status')
# remove all previous statuses and run
ContactsImportStatus.objects.filter(user=healer.user).delete()
import_status = ContactsImportStatus.objects.create(user=healer.user,
api=GOOGLE_API,
status=STATUS_RUNNING)
import_google_contact_process(healer, google_contacts, import_status)
response = redirect('import_contacts_status')
if request.GET.get('fb', 0):
response['Location'] += '?fb=1'
return response
def test_join_invitation_success(self):
from_user = User.objects.get(id=1)
email = '*****@*****.**'
contact, created = Contact.objects.get_or_create(email=email,
user=from_user)
SiteJoinInvitation.objects.create(from_user=from_user,
contact=contact,
message="",
status="2",
confirmation_key="123",
is_to_healer=True)
fb_data = {
'first_name': 'test1',
'last_name': 'test2',
'email': email,
'id': '1'
}
user = facebook_callback.handle_no_user(self.request,
self.oauth_access, fb_data,
'healer')
self.assertEqual(user.email, fb_data['email'])
self.assertFalse(user.has_usable_password())
self.assertTrue(user.is_active)
self.assertTrue(is_healer(user.client))
def test_client_as_ambassador(self):
self.data['is_ambassador'] = '1'
response = self.signup()
self.assertEqual(response['email'], self.email)
c = Client.objects.filter(user__email=self.email)
self.assertEqual(c.count(), 1)
self.assertEqual(c[0].ambassador_program, True)
self.assertFalse(is_healer(c[0]))
def disable_stripe_connect(request):
UserAssociation.objects.filter(user=request.user,
service='stripe').delete()
healer = is_healer(request.user)
healer.gift_certificates_enabled = False
healer.booking_healersource_fee = Healer.BOOKING_HEALERSOURCE_FEE_PERCENTAGE
healer.save()
return healers.views.payments_settings(
request, message='Stripe Connect has been disabled.')
def client_detail(request, client_username):
try:
client = Client.objects.get(user__username__iexact=client_username)
except Client.DoesNotExist:
return HttpResponse("<h3>Oops!</h3>Sorry, couldn't find that Client")
client_info = client.contact_info(separator='<br />', email_link=True)
if request.user != client.user and not is_my_client(
request.user, client.user):
client_info = None
contact_info = client.get_contact_info(request.user.client)
contact_info_text = None
if contact_info:
contact_info_text = contact_info.text(separator='<br />',
email_link=True)
healer_link = None
healer = is_healer(client)
logged_in_healer = Healer.objects.get(user=request.user)
if healer:
healer_link = healer.healer_profile_url()
c = {
'has_intake_form':
logged_in_healer.has_intake_form(),
'client':
client,
'user':
request.user,
'client_info':
client_info,
'contact_info':
contact_info,
'contact_info_text':
contact_info_text,
'healer_link':
healer_link,
'answered_intake_form':
client.answered_intake_form(is_healer(request.user)),
}
return render_to_response('clients/client_detail.html',
c,
context_instance=RequestContext(request))
def profile_edit(request, template_name="clients/clients_profile_edit.html"):
client = get_object_or_404(Client, user__id=request.user.id)
try:
get_user_customer(request.user) # initiate customer
except:
pass
if is_healer(client):
return redirect('healer_edit')
phones = ClientPhoneNumber.objects.filter(client=client)
if request.method == 'POST':
form = ClientForm(request.POST)
if form.is_valid():
if phones:
phones[0].number = form.cleaned_data['phone']
phones[0].save()
else:
ClientPhoneNumber.objects.create(
client=client, number=form.cleaned_data['phone'])
client.user.first_name = form.cleaned_data['first_name']
client.user.last_name = form.cleaned_data['last_name']
client.user.save()
client.about = form.cleaned_data['about']
client.send_reminders = form.cleaned_data['send_reminders']
client.ghp_notification_frequency = form.cleaned_data[
'ghp_notification_frequency']
# client.beta_tester = form.cleaned_data['beta_tester']
client.save()
return redirect('clients_profile')
else:
form = ClientForm(
initial={
'first_name': client.user.first_name,
'last_name': client.user.last_name,
'about': client.about,
'phone': (phones[0].number if (len(phones) > 0) else ''),
'send_reminders': client.send_reminders,
'ghp_notification_frequency': client.ghp_notification_frequency
# 'beta_tester' : client.beta_tester
})
return render_to_response(template_name, {
'client': client,
'form': form,
'locations': client.get_locations_objects(),
'STRIPE_PUBLIC_KEY': settings.STRIPE_PUBLIC_KEY,
},
context_instance=RequestContext(request))
def get_healer_info_context(healer, request):
client = None
client_id = ""
request.friend_type = None
is_profile_visible = True
is_client = False
try:
client = clients.models.Client.objects.get(user__id=request.user.id)
request.friend_type = 'referrals' if is_healer(client) else "healers"
client_id = client.id
is_client = is_my_client(healer.user, request.user)
except ObjectDoesNotExist:
pass
is_profile_visible = healer.is_visible_to(request.user, is_client)
if not is_profile_visible and not request.user.is_superuser:
if request.user != healer.user:
return is_client, False, {}
locations = healer.get_locations(user=request.user, is_client=is_client,
skip_center_locations=True)
# referring_users = [o['friend'] for o in Referrals.objects.referrals_to(healer.user)]
# healers = Healer.objects.filter(user__in=referring_users)
# referrals_to_me = [h.user for h in healers if h.is_visible_to(request.user)]
referrals_to_me_count = Referrals.objects.referrals_to(healer.user, count=True)
phones = clients.models.ClientPhoneNumber.objects.filter(client=healer)
if request.user == healer.user:
modalities = Modality.objects_approved.get_with_unapproved(healer=healer)
else:
modalities = Modality.objects_approved
modalities = list(modalities.filter(healer=healer, visible=True))
modalities.reverse()
request.other_user = healer.user
return is_client, True, {
"healer": healer,
"client": client,
"client_id": client_id,
"is_my_client": is_client,
"locations": locations,
"referrals_to_me_count": referrals_to_me_count,
"phone": (phones[0].number if (len(phones) > 0) else ''),
"modalities": modalities,
"is_schedule_visible": healer.is_schedule_visible(request.user, is_client),
"review_exist": healer.reviews.filter(reviewer__user=request.user).count() if request.user.is_authenticated() else False,
"is_review_permission": healer.is_review_permission(request.user, is_client),
}
def test_healer2healer_as_client(self):
self.test_healer.client_screening = Healer.SCREEN_NONE
self.test_healer.save()
self.invitation.is_to_healer = True
self.invitation.save()
response = self.signup(confirm=True)
self.assertTrue('redirect_url' in response)
new_client = Client.objects.get(user__email=self.email)
self.assertFalse(is_healer(new_client))
self.check_friendship_clients_refferals_numbers(new_client, 1, 1, 0)
def __init__(self, user, data=None):
self.healer = None
now = settings.GET_NOW()
if is_healer(user):
self.healer = user.client.healer
now = self.healer.get_local_time()
users = Clients.objects.friends_for_user(user)
clients = [(u["friend"].client.id, str(u["friend"].client))
for u in users]
self.base_fields['client'].choices = clients
self.base_fields['client'].widget.choices = clients
healer_locations = ClientLocation.objects.filter(client__user=user)
locations = [(hl.location.id, str(hl.location))
for hl in healer_locations]
if len(locations) == 0:
locations.insert(0, ("-1", Location.get_name(None)))
self.base_fields['location'].choices = locations
self.base_fields['location'].widget.choices = locations
time_choices = []
dt = now.replace(hour=0, minute=0)
dt_end = dt + timedelta(days=1)
while dt < dt_end:
time_choices.append(
(dt.strftime("%H:%M"), dt.strftime("%I:%M %p").lower()))
dt += timedelta(minutes=15)
# self.base_fields['start'].choices = time_choices
# self.base_fields['end'].choices = time_choices
self.base_fields['start'].widget.choices = time_choices
self.base_fields[
'treatment_length'].queryset = TreatmentTypeLength.objects.filter(
treatment_type__healer__user=user)
# self.base_fields['start'].widget.initial = ["12:00"]
# self.base_fields['end'].widget.initial = [12]
super(forms.Form, self).__init__(initial={
'start': '12:00',
'end': '13:00',
'date': dt.date() + timedelta(days=1)
},
data=data)
def test_healer2client_as_client(self):
self.test_healer.client_screening = Healer.SCREEN_NONE
self.test_healer.save()
self.signup()
new_client = Client.objects.get(user__email=self.email)
self.assertFalse(is_healer(new_client))
clients = Clients.objects.filter(from_user=self.test_healer.user,
to_user=new_client.user).count()
self.assertEqual(clients, 1)
client = Client.objects.get(user__email=self.email)
self.assertEqual(client.approval_rating, 100)
def test_no_join_invitation_success(self):
fb_data = {
'first_name': 'test1',
'last_name': 'test2',
'email': '*****@*****.**',
'id': '1'
}
user = facebook_callback.handle_no_user(self.request,
self.oauth_access, fb_data,
'healer')
self.assertEqual(user.email, fb_data['email'])
self.assertFalse(user.has_usable_password())
self.assertTrue(user.is_active)
self.assertTrue(is_healer(user.client))
def remove_card(request):
def check_all_payments_disabled():
for plan_type in settings.PLAN_TYPES:
current_subscription = get_current_subscription(customer)
if getattr(current_subscription, '%s_status' % plan_type):
return 'You have to disable payments for "%s" to remove your card.' % plan_type
customer = get_user_customer(request.user)
error = check_all_payments_disabled()
if error is None:
customer.remove_card()
if is_healer(request.user):
return healers.views.account(request, error)
else:
return redirect('clients_profile')
def invite_or_create_client_friendship(client_user, healer_user, send_client_request_email=False):
#if the person is in my contacts list > auto add them, otherwise require a confirmation
is_client = is_my_client(healer_user=healer_user, client_user=client_user)
if is_client:
return
healer = is_healer(healer_user)
if not healer:
raise Healer.DoesNotExist
contact = ContactEmail.objects.filter(email=client_user.email, contact__healer=healer).count()
if healer.client_screening == Healer.SCREEN_ALL or \
(healer.client_screening == Healer.SCREEN_NOT_CONTACTS and not contact):
invitation_to = ClientInvitation.objects.filter(from_user=client_user, to_user=healer_user, status="2")
if not invitation_to:
invitation = ClientInvitation(from_user=client_user, to_user=healer_user, message="", status="2")
invitation.save()
if send_client_request_email:
ctx = {
"client_name": str(client_user.client),
"accept_url": get_full_url('friend_accept', args=['clients', client_user.id]),
"decline_url": get_full_url('friend_decline', args=['clients', client_user.id])
}
subject = render_to_string("friends/client_request_subject.txt", ctx)
send_hs_mail(subject, "friends/client_request_message.txt", ctx, settings.DEFAULT_FROM_EMAIL, [healer_user.email])
elif healer.client_screening == Healer.SCREEN_NONE or \
(healer.client_screening == Healer.SCREEN_NOT_CONTACTS and contact):
Clients.objects.create(from_user=healer_user, to_user=client_user)
else:
raise Exception
def is_healer_processor(request):
healer = False
beta_tester = True
func = getattr(request.user, "client", None)
if func:
healer = is_healer(request.user)
# beta_tester = request.user.client.beta_tester
return {
'is_healer':
healer,
'is_beta_tester':
beta_tester,
'is_wellness_center':
is_wellness_center(healer),
'healers_in_wcenter_with_schedule_perm':
get_healers_in_wcenter_with_schedule_editing_perm(healer),
'is_stripe_connect_beta_tester':
True, #request.user.username in settings.STRIPE_CONNECT_BETA_USERS
'is_gift_certificates_beta_tester':
True # request.user.username in settings.GIFT_CERTIFICATES_BETA_USERS
}
def __call__(self, request, access, token, account_type=None, is_ajax=False,
is_signup=False, is_ambassador=False, is_phonegap=False):
user_data = self.fetch_user_data(request, access, token)
if 'error' in user_data:
if is_ajax:
return None, "Error during facebook login."
return redirect('login_page')
redirect_to = self.redirect_url(request)
if not request.user.is_authenticated():
try:
user = self.lookup_user(request, access, user_data)
except FacebookNoEmail:
message = (
"Your Facebook account does not have an email "
"associated with it, so you must sign up "
"using the regular signup form. "
"Thanks and sorry for the inconvenience.")
if is_ajax:
return None, message
request.session['oauth_error_message'] = message
return redirect('oauth_error')
if user is None:
if is_ajax and not is_signup:
return None, "You have no account on healersouce.com"
if not account_type:
request.session["token"] = token
return redirect('select_account_type', access.service)
else:
user = self.handle_no_user(request, access, user_data, account_type, is_ambassador, is_phonegap)
else:
user = self.handle_unauthenticated_user(request, user, access, token, user_data)
else:
user = access.lookup_user(identifier=self.identifier_from_data(user_data))
if user and user != request.user:
facebook_associate_new_account = request.session.pop('facebook_associate_new_account', False)
if facebook_associate_new_account:
ua = UserAssociation.objects.filter(user=user, service="facebook")[0]
ua.user = request.user
ua.save()
else:
message = "There is another user connected to this account on facebook."
if is_ajax:
return None, message
request.session['oauth_error_message'] = message
request.session['oauth_error_is_facebook_duplicate'] = True
return redirect('oauth_error')
user = request.user
if user:
kwargs = {"identifier": self.identifier_from_data(user_data)}
# for first time, save fb data, load fb friends for healer
ua = UserAssociation.objects.filter(user=user, service="facebook")
if not ua.count():
save_facebook_data(user, user_data)
save_facebook_picture(user, user_data['id'], token)
if is_healer(user.client) or "send_healing_facebook" in request.session:
ContactsImportStatus.objects.filter(user=user).delete()
import_status = ContactsImportStatus.objects.create(user=user, api=FACEBOOK_API, status=STATUS_RUNNING)
save_facebook_friends_thread(user, import_status, token, request)
access.persist(user, token, **kwargs)
if "send_healing_facebook" in request.session:
del request.session["send_healing_facebook"]
request.session['got_friends_from_fb'] = True
redirect_to = reverse("send_healing")
if is_ajax:
set_signup_source(user, request, is_phonegap)
return user, None
return redirect(redirect_to)
def get(self, request, format=None):
return Response(is_healer(request.user) is not None)
def save_join_request_form(request,
form,
is_to_healer=False,
is_for_review=False,
is_for_ambassador=False):
# for client always create invitation
invite_provider_recommend = form.cleaned_data.get(
'invite_provider_recommend', True) if is_to_healer else True
email_template = subject_template = body_template = None
if type(form) in [
ContactsJoinInviteRequestForm, PostcardJoinInviteRequestForm
]:
if is_for_review:
subject_template = "friends/join_invite_review_subject.txt"
body_template = "friends/join_invite_review_message.txt"
email_template = "friends/invite_review_postcard_message.txt"
else:
# recommend message only for healer
if is_to_healer and invite_provider_recommend:
email_template = "friends/invite_recommend_postcard_message.txt"
else:
email_template = "friends/invite_postcard_message.txt"
emails = []
if 'emails' in form.cleaned_data:
if type(form.cleaned_data['emails']) == unicode:
emails.append(form.cleaned_data['emails'])
else:
emails.extend(form.cleaned_data['emails'])
if 'email_list' in form.cleaned_data:
emails.extend(form.cleaned_data['email_list'])
if 'contacts' in form.cleaned_data:
emails.extend(o.email for o in form.cleaned_data['contacts'])
# if healer:
# healer.invite_message = form.cleaned_data["message"]
# healer.save()
invitations = []
email_invitation_list = []
client_requests_list = []
provider_requests_list = []
existing_users = []
if 'providers' in form.cleaned_data:
existing_users.extend(o.user for o in form.cleaned_data['providers'])
for email in emails:
users = EmailAddress.objects.get_users_for(email)
if users:
existing_users.append(users[0])
else:
email_invitation_list.append(email)
for to_user in existing_users:
if is_to_healer and is_healer(to_user):
friend_type = 'referrals'
provider_requests_list.append(to_user.email)
else:
friend_type = 'clients'
client_requests_list.append(to_user.email)
friend_process(request, friend_type, to_user.id, "add")
for email in email_invitation_list:
invitations.append(
SiteJoinInvitation.objects.send_invitation(
request.user,
email,
form.cleaned_data["message"],
is_to_healer=is_to_healer,
create_friendship=invite_provider_recommend,
html_template_name=email_template,
subject_template=subject_template,
body_template=body_template,
postcard_background=form.cleaned_data.get(
'postcard_background', None),
is_for_ambassador=is_for_ambassador))
return invitations, email_invitation_list, client_requests_list, provider_requests_list
def after_signup(new_user, account_type=None, email_confirmed=True): def get_model_class(): if account_type == 'healer': return Healer elif account_type == 'wellness_center': return WellnessCenter else: return Client def process_dummy_users(new_user): """ Move dummy user objects to new user, confirms appointments, remove dummy users """ def copy_friendship(friendship_class, user, new_user): friends = friendship_class.objects.friends_for_user(user) for friend in friends: try: if friend['friendship'].from_user == user: friendship_class.objects.get_or_create(from_user=new_user, to_user=friend['friendship'].to_user) if friend['friendship'].to_user == user: friendship_class.objects.get_or_create(to_user=new_user, from_user=friend['friendship'].from_user) except IntegrityError: # friendship exists pass dummy_users = User.objects.filter(email__iexact=new_user.email).exclude(id=new_user.id) if len(dummy_users): # copy clients and referrals client = Client.objects.get(user=new_user) referred_by = [] for user in dummy_users: copy_friendship(Clients, user, new_user) copy_friendship(Referrals, user, new_user) dummy_client = user.client if client.approval_rating < dummy_client.approval_rating: client.approval_rating = dummy_client.approval_rating if dummy_client.referred_by: referred_by.append(dummy_client.referred_by) dummy_client.phone_numbers.update(client=client) dummy_client.clientlocation_set.update(client=client) ContactInfo.objects.filter(client=dummy_client).update(client=client) IntakeFormSentHistory.objects.filter(client=dummy_client).update(client=client) #clear friendship invitation for dummy_user FriendshipInvitation.objects.filter(Q(from_user=user) | Q(to_user=user)).delete() FriendshipInvitationHistory.objects.filter(Q(from_user=user) | Q(to_user=user)).delete() # SiteJoinInvitation.objects.filter(contact__email__iexact=user.email).delete() client.referred_by = ', '.join(referred_by) client.save() # confirm appointments dummy_user_ids = [u.id for u in dummy_users] client = Client.objects.get(user=new_user) appts = Appointment.objects.filter(client__user__id__in=dummy_user_ids) for appt in appts: if not appt.confirmed: if Appointment.check_for_auto_confirm(appt.healer, client): appt.confirm() appt.notify_created(client.user) else: appt.notify_requested(new_user) requested_friendships = [] if appt.healer.id not in requested_friendships: # request_friendship(client.user, appt.healer.user, ClientInvitation) invite_or_create_client_friendship(client.user, appt.healer.user) requested_friendships.append(appt.healer.id) appts.update(client=client) # remove all dummy users for this email dummy_users.delete() model_class = get_model_class() client = model_class.objects.get_or_create(user=new_user)[0] if not email_confirmed: return for join_invitation in SiteJoinInvitation.objects.filter(contact__email__iexact=new_user.email): ContactInfo.objects.filter(contact=join_invitation.contact).update(client=client) #is_from_site == unregistered booking if not join_invitation.is_from_site: if not is_healer(join_invitation.from_user): raise Healer.DoesNotExist if is_healer(new_user) and join_invitation.is_to_healer: FriendClass = Referrals else: FriendClass = Clients if join_invitation.create_friendship: friendship_exists = Friendship.objects.filter( from_user=join_invitation.from_user, to_user=new_user).exists() if not friendship_exists: FriendClass.objects.create( from_user=join_invitation.from_user, to_user=new_user) client.approval_rating = 100 client.save() # fixes occurred problem. try: join_invitation.delete() except JoinInvitation.DoesNotExist: pass process_dummy_users(new_user)
