def participants_new(request):
return render(request,
'sponsor/dashboard/participants/new.html.j2',
context={
'title': 'Participants',
'sponsor': get_sponsor(request.session['email']),
})
def get_context_data(self, **kwargs):
poc_form = POCForm()
context = super().get_context_data(**kwargs)
context['title'] = 'POCs'
context['sponsor'] = get_sponsor(self.request.session['email'])
context['poc_form'] = poc_form
return context
def contact(request):
if request.method == "POST":
print(request)
c_dict = parser.parse(request.POST.urlencode())
print(c_dict)
return render(request,
'sponsor/dashboard/account/contact.html.j2',
context={
'title': 'POC',
'sponsor': get_sponsor(request.session['email']),
})
def payments_add(request, type, package_id):
'''
add a new payment once a package has been selected
'''
if type == "healthcheck":
try:
dis_type = HealthCheckup.objects.get(uid=package_id)
except:
raise Http404("Invalid UID")
elif type == "discountcard":
try:
dis_type = DiscountCard.objects.get(uid=package_id)
except:
raise Http404("Invalid UID")
else:
raise Http404("Invalid Type")
if request.method == "POST":
if 'coupon' in request.session:
print("C : ", request.session['coupon'])
p_data = parser.parse(request.POST.urlencode())
request.session['users'] = p_data['can_id']
request.session['pack_type'] = type
request.session['pack_id'] = dis_type.id
return redirect('common:payment_init')
sponsor = get_sponsor(request.session['email'])
candidates = [_.user for _ in sponsor.users.all()]
fields = (
'pk',
'email',
'name',
'mobile',
'gender',
)
candidates = serializers.serialize("python", candidates, fields=fields)
return render(request,
'sponsor/dashboard/payments/add.html.j2',
context={
'title': 'Payments',
'sponsor': sponsor,
'candidates': candidates,
'card': dis_type,
'fields': fields
})
def account_basic(request):
''' edit basic organizational and POC details '''
s = Sponsor.objects.filter(user__email=request.session['email']).first()
class OrgForm(forms.ModelForm):
class Meta:
model = Organization
fields = (
'name',
'type',
'size',
'image',
)
class POCForm(forms.ModelForm):
class Meta:
model = User
fields = (
'mobile',
'email',
'gender',
)
if request.method == "POST":
org_form = OrgForm(request.POST,
request.FILES,
instance=s.organization)
poc_form = POCForm(request.POST, request.FILES, instance=s.user)
if org_form.is_valid(): org_form.save()
if poc_form.is_valid():
poc_form.save()
request.session['email'] = s.user.email
else:
org_form = OrgForm(instance=s.organization)
poc_form = POCForm(instance=s.user)
return render(request,
'sponsor/dashboard/account/basic.html.j2',
context={
'title': 'Account - Basic Details',
'sponsor': get_sponsor(request.session['email']),
'org_form': org_form,
'poc_form': poc_form,
})
def payments_new(request):
'''
route to display catalog of new discount cards and payments
'''
if 'coupon' in request.session: del request.session['coupon']
discounts = DiscountCard.objects.all()
checkups = HealthCheckup.objects.all()
return render(request,
'sponsor/dashboard/payments/new.html.j2',
context={
'title': 'Payments',
'sponsor': get_sponsor(request.session['email']),
'discounts': discounts,
'checkups': checkups,
})
def dashboard(request):
''' route for dashboard home '''
u = Sponsor.objects.filter(user__email=request.session['email']).first()
class SponsorForm(forms.ModelForm):
class Meta:
model = Sponsor
exclude = (
'user',
'users',
)
user_form = UserForm(instance=u.user)
sponsor_form = SponsorForm(instance=u)
errors = None
if request.method == "POST":
s = SponsorForm(request.POST, request.FILES, instance=u)
u = UserForm(request.POST, request.FILES, instance=u.user)
if s.is_valid() and u.is_valid():
user = u.save(commit=False)
ip_addr, del_val = getIP(request)
print("IP ADDR : ", ip_addr)
if ip_addr: user.last_IP = ip_addr
user.save()
sponsor = s.save(commit=False)
sponsor.user = user
sponsor.save()
user_form = u
sponsor_form = s
errors = [u.errors, s.errors]
print(errors)
return render(request,
'sponsor/dashboard/index.html.j2',
context={
"title": "Dashboard Home",
'user_form': user_form,
'sponsor_form': sponsor_form,
'errors': errors,
'sponsor': get_sponsor(request.session['email']),
})
def get_queryset(self):
sp = get_sponsor(self.request.session['email'])
return User.objects.filter(seeker__in=sp.users.all())
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['title'] = 'Participants - View'
context['sponsor'] = get_sponsor(self.request.session['email'])
return context
def get_queryset(self):
sp = get_sponsor(self.request.session['email'])
return Transaction.objects.filter(receiver=sp.user)
def get_queryset(self):
sp = get_sponsor(self.request.session['email'])
return sp.pocs.all()
def user_view(request):
'''
route for adding and viewing users
- Single user (new) addition (Seeker form)
- Multiple (existing user additon) (Sponsor form only single field)
- Excel based multiple (new) user addition (manually)
- Viewing added users and modifying (formset factory)
'''
class SeekerForm(forms.ModelForm):
class Meta:
model = Seeker
exclude = (
'user',
'family',
)
class SponsorForm(forms.ModelForm):
class Meta:
model = Sponsor
fields = ('users', )
def __init__(self, *args, **kwargs):
super(SponsorForm, self).__init__(*args, **kwargs)
self.fields['users'].widget = forms.CheckboxSelectMultiple()
self.fields['users'].queryset = Seeker.objects.all()
class SeekerMultipleForm(forms.Form):
file = forms.FileField()
def is_valid(self):
init_validity = super(SeekerMultipleForm, self).is_valid()
if not init_validity: return init_validity
f = self.cleaned_data['file']
if f.name.rsplit('.')[-1] not in ['xlsx', 'xls']:
print("hello error")
self.add_error('file', "Invalid file")
return False
return True
u = Sponsor.objects.filter(user__email=request.session['email']).first()
errors = None
class UserForm(forms.ModelForm):
class Meta:
model = User
fields = (
'email',
'name',
'mobile',
)
basic_user = UserForm()
seeker_specific = SeekerForm()
existing_multiple = SponsorForm(instance=u)
bulk_form = SeekerMultipleForm()
if request.method == "POST":
# handle all the forms here
# with error detection and particular routing
errors = []
if request.POST['type'] == "single_user":
b = UserForm(request.POST, request.FILES)
# s = SeekerForm(request.POST, request.FILES)
# if b.is_valid() and s.is_valid():
if b.is_valid():
user = b.save(commit=False)
ip_addr, del_val = getIP(request)
user.role = 'healthseeker'
user.password = make_password(user.mobile)
user.question = Question.objects.first()
user.answer = "default"
user.save()
# seeker = s.save(commit=False)
seeker = Seeker(user=user, dob=datetime.datetime.now().date())
seeker.user = user
seeker.save()
u.users.add(seeker)
else:
basic_user = b
# seeker_specific = s
errors += [b.errors]
elif request.POST['type'] == "existing_multiple":
# code for adding the multiple existing users
# to the sponsor users_store
s = SponsorForm(request.POST, request.FILES, instance=u)
if s.is_valid():
s.save()
else:
errors += [s.errors]
existing_multiple = s
elif request.POST['type'] == "new_multiple":
# code to handle the multiple additon
# from an excel sheet or something
# MANUAL PARSING
m = SeekerMultipleForm(request.POST, request.FILES)
if m.is_valid():
user_list, missed = addUsers(request, request.FILES['file'])
else:
errors += [m.errors]
# print(errors)
bulk_form = m
# print("errors : ", errors)
return render(
request,
'sponsor/dashboard/participants/new.html.j2',
context={
'title': "Participants",
'sponsor': get_sponsor(request.session['email']),
'errors': errors,
'basic_user': basic_user,
# 'seeker_specific': seeker_specific,
# 'existing_multiple' : existing_multiple,
'bulk_form': bulk_form
})
