def post(self, request, registration_number):
user = request.user.username
venture_form = ventureModifyForm(request.POST)
#print('venture_form',venture_form)
if venture_form.is_valid():
vlist = Venture.objects.filter(
registration_number=registration_number)
venture = vlist[0]
venture.userid = user
venture.last_modified = dt.datetime.now()
venture.venture_state = \
venture_form.cleaned_data['venture_state']
venture.venture_name = \
venture_form.cleaned_data['venture_name']
venture.end_date = \
venture_form.cleaned_data['end_date']
venture.save()
logger.info('%s Venture successfully modified by %s',
venture.venture_name, user)
self.render_url = 'VENTURE_DETAIL'
self.tparams['ven'] = venture
self.tparams['elist'] = venture.participant_set.all()
return super(ventureModifyView, self).post(request)
else:
logger.warning('Venture modification form not valid %s', user)
self.tparams['mlist'] = venture_form._errors
return self.get(request, registration_number)
def handle_awaiting_otp(self, request):
status = tStatus.UNKNOWN_ERROR
token = None
if self.is_otp_valid(request):
logger.info('Recieved valid otp session id %s utype %s ',
self.ss_key, self.utype)
visitor_otp[self.ss_key]['state'] = \
AuthState.awaiting_approval
status = tStatus.SUCCESS
else:
logger.warning('Recieved Invalid otp session id %s utype %s ',
self.ss_key, self.utype)
status = tStatus.INVALID_OTP
if status == tStatus.SUCCESS:
return render(request, 'cricket/awaiting_approval.html', {
'baseurl': settings.SITE_URL,
'remove_header': True,
})
elif status == tStatus.INVALID_OTP:
return self.get(request)
else:
logger.error(
'Error in Otp handler session_id %s utype %s status %s',
self.ss_key, self.utype.name, status.name)
return render_status(request, status)
def get_dataset(ufile):
#stream = ufile.read().decode('utf-8')
stream = ufile.read().decode('ISO-8859-1')
#print('stream',stream)
lines = stream.split('\r\n')
logger.info('%d lines found in imported file %s', len(lines), ufile)
#print('lines',lines)
hdr = None
val = []
for x in range(len(lines)):
if x == 0:
hdr = lines[x].split(',')
else:
val.append(lines[x].split(','))
#print('hdr',hdr)
#val = val[:-1]
#print('val',val)
dataset = Dataset(headers=hdr)
for i in range(len(val)):
try:
dataset.append(val[i])
except:
logger.warning('Ingnoring row %d due to errors', i + 1)
logger.debug('dataset.csv : %s', dataset.csv)
return dataset
def post(self, request):
user = request.user.username
participant_form = participantForm(request.POST)
if participant_form.is_valid():
participant = participant_form.save(commit=False)
participant.update_registration_number()
participant.venture_state = bcfg.VentureState.ACTIVE.value
participant.last_modified = dt.datetime.now()
participant.userid = user
participant.save()
sa.send_registration_number(participant.mobile_number,
participant.registration_number)
logger.info('Participant %s created succeccfully by %s',
participant, user)
self.render_url = 'PART_DETAIL'
self.tparams['emp'] = participant
return super(participantEntryView, self).post(request)
self.render_url = 'PART_VIEW'
self.tparams['elist'] = Participant.objects.all()
elif 'myfile' in request.FILES.keys():
participant_resource = ParticipantImportResource(user)
new_participants = request.FILES['myfile']
dataset = get_dataset(new_participants)
result = participant_resource.import_data(dataset, dry_run=True)
if not result.has_errors():
participant_resource.import_data(dataset, dry_run=False)
logger.info(
'Participant import file uploaded succeccfully by %s',
user)
self.render_url = 'PART_VIEW'
self.tparams['elist'] = Participant.objects.all()
else:
logger.warning('Participant import file not uploaded')
self.render_url = 'PART_ENTRY'
self.tparams['ulist'] = self.get_elist_strings(result)
self.tparams['form'] = participantForm()
else:
logger.warning('invalid form submitted by %s: %s', user,
participant_form._errors)
self.render_url = 'PART_ENTRY'
self.tparams['form'] = participantForm()
self.tparams['mlist'] = participant_form._errors
return super(participantEntryView, self).post(request)
def post(self, request):
userid = request.user.username
logger.info('%s posting change password ', userid)
form = PasswordChangeForm(request.user, request.POST)
if form.is_valid():
user = form.save()
update_session_auth_hash(request, user) # Important!
logger.info('%s Password change successfully', userid)
return render(request, 'beetle/home.html',
{'baseurl': settings.SITE_URL})
else:
logger.warning('%s Invalid form submitted ', userid)
def post(self, request):
user = request.user.username
venture_form = ventureForm(request.POST)
if venture_form.is_valid():
venture = venture_form.save(commit=False)
venture.update_registration_number()
venture.userid = user
venture.last_modified = dt.datetime.now()
venture.venture_state = bcfg.VentureState.ACTIVE.value
venture.venture_name = venture.venture_name.strip()
venture.save()
logger.info('%s Venture successfully created by %s',
venture.venture_name, user)
self.render_url = 'VENTURE_VIEW'
self.tparams['vlist'] = Venture.objects.all()
elif 'myfile' in request.FILES.keys():
venture_resource = VentureResource(user)
new_ventures = request.FILES['myfile']
dataset = get_dataset(new_ventures)
result = venture_resource.import_data(dataset, dry_run=True)
if not result.has_errors():
self.render_url = 'VENTURE_VIEW'
self.tparams['vlist'] = Venture.objects.all()
logger.info('Venture info file successfully uploaded by %s',
user)
venture_resource.import_data(dataset, dry_run=False)
else:
self.render_url = 'VENTURE_ENTRY'
self.tparams['form'] = ventureForm()
self.tparams['ulist'] = self.get_elist_strings(result)
logger.warning('Error uploading venture import file by %s',
user)
else:
self.render_url = 'VENTURE_ENTRY'
self.tparams['form'] = ventureForm()
self.tparams['mlist'] = venture_form._errors
#print('form errors',venture_form._errors)
logger.warning('Invalid form updated by %s:%s', user,
venture_form._errors)
return super(ventureEntryView, self).post(request)
def session_expired(session_id, otp_dict):
if session_id in otp_dict.keys():
logger.info('Deleting otp dict entry %s for %s',
pp.pformat(otp_dict[session_id]), session_id)
otp_dict[session_id]['thandle'].cancel()
del otp_dict[session_id]['thandle']
otp_dict.pop(session_id, None)
logger.debug('In session expired : otp dict entries after pop \n%s\n',
pp.pformat(otp_dict))
else:
logger.warning('Session id %d not found in otp_dict %s', session_id,
otp_dict)
def get(self, request, registration_number):
user = request.user.username
ilist = Participant.objects.filter(
registration_number=registration_number)
if not ilist:
logger.warning('Invalid registration number %d by %s',
registration_number, user)
self.render_url = 'INVALID_REG'
else:
participant = ilist[0] # only one expected
self.render_url = 'PART_DETAIL'
self.tparams['emp'] = participant
return super(participantDetailView, self).get(request)
def get(self, request, registration_number):
user = request.user.username
vlist = Venture.objects.filter(registration_number=registration_number)
if vlist:
logger.info('Deleting venture %s by %s', vlist[0].venture_name,
user)
vlist.delete()
else:
logger.warning('Attemptting to delete venture(%d) from %s',
registration_number, user)
self.render_url = 'VENTURE_VIEW'
self.tparams['vlist'] = Venture.objects.all()
return super(ventureDeleteView, self).get(request)
def get(self, request, registration_number):
user = request.user.username
venlist = Venture.objects.filter(
registration_number=registration_number)
if not venlist:
self.render_url = 'INVALID_REG'
logger.warning('Attemptting to view invalid venture(%d) by %s',
registration_number, user)
else:
self.render_url = 'VENTURE_DETAIL'
ven = venlist[0] # only one expected
self.tparams['ven'] = ven
self.tparams['elist'] = ven.participant_set.all()
return super(ventureDetailView, self).get(request)
def get(self, request, registration_number):
user = request.user.username
plist = Participant.objects.filter(
registration_number=registration_number)
if plist:
logger.info('Deleting participant %s by %s', plist[0], user)
plist.delete()
else:
logger.warning('Invliad Participant %d by %s', registration_number,
user)
self.render_url = 'PART_VIEW'
self.tparams['elist'] = Participant.objects.all()
return super(participantDeleteView, self).get(request)
def handle_participant(self, request):
status = tStatus.UNKNOWN_ERROR
token = None
if self.is_otp_valid(request):
logger.info('Recieved valid otp session id %s utype %s ',
self.ss_key, self.utype)
status, token = issue_new_itoken(self.var)
logger.info('Calling session expired function')
session_expired(self.ss_key, user_otp)
else:
logger.warning('Recieved Invalid otp session id %s utype %s ',
self.ss_key, self.utype)
status = tStatus.INVALID_OTP
if status == tStatus.SUCCESS:
return render(
request, 'cricket/token_assigned.html', {
'uid': token.userid,
'pwd': token.password,
'baseurl': settings.SITE_URL,
'remove_header': True,
'status': 'NEW'
})
elif status == tStatus.TOKEN_REISSUED:
logger.debug('Rendering same token to %d', self.var)
return render(
request, 'cricket/token_assigned.html', {
'uid': token.userid,
'pwd': token.password,
'baseurl': settings.SITE_URL,
'remove_header': True,
'status': 'OLD'
})
elif status == tStatus.INVALID_OTP:
return self.get(request)
else:
logger.error(
'Error in Otp handler session_id %s utype %s status %s',
self.ss_key, self.utype.name, status.name)
return render_status(request, status)
def issue_new_itoken(registration_number):
status = tStatus.UNKNOWN_ERROR
participant_info = bmodel.get_participant_info(registration_number)
itoken = None
issued_token = None
if participant_info:
issued_token = get_issued_valid_token_for_participant(
registration_number)
else:
status = tStatus.INVALID_USER
logger.warning('Participant info not found for %d',
registration_number)
return status, None
status_str = None
if issued_token:
itoken = issued_token
status = tStatus.TOKEN_REISSUED
status_str = 'OLD'
else:
itoken = get_next_itoken()
if itoken:
itoken.token_state = ccfg.TokenState.ISSUED.value
itoken.issued_on = dt.date.today()
itoken.issued_to = registration_number
itoken.save()
logger.info('%s token issued to %d', itoken.userid,
registration_number)
status = tStatus.SUCCESS
status_str = 'NEW'
else:
logger.critical('Participant token exhausted %d',
registration_number)
status = tStatus.TOKEN_EXHAUSTED
if itoken:
sa.send_token(participant_info.mobile_number, status_str,
itoken.userid, itoken.password)
return status, itoken
def get_issued_valid_token_for_visitor(mobile_number):
tdate = dt.date.today()
issued_tokens = VisitorToken.objects.filter(mobile_number=mobile_number)
for entry in issued_tokens:
tdelta = tdate - entry.issued_on
if entry.token_state == ccfg.TokenState.ISSUED.value:
if tdelta.days < entry.validity:
return entry
else:
entry.token_state = ccfg.TokenState.EXPIRED.value
entry.save()
logger.warning('Moving visitor token %s to expired state %s',
entry.userid, entry.issued_to)
return None
def get(self, request, registration_number):
user = request.user.username
vlist = Venture.objects.filter(registration_number=registration_number)
if vlist:
venture = vlist[0]
form = ventureModifyForm(instance=venture)
self.render_url = 'VENTURE_MODIFY'
self.tparams['form'] = form
else:
logger.warning('Attemptting to modify venture(%d) from %s',
registration_number, user)
self.render_url = 'INVALID_REG'
return super(ventureModifyView, self).get(request)
def import_row(self, row, instance_loader,
using_transactions=True, dry_run=False, **kwargs):
row['last_modified'] = row['start_date']
vlist = Venture.objects.filter(
venture_name__iexact = row['company'].strip())
if vlist:
row['company'] = vlist[0].id
else:
logger.warning('No company id found for %s row %s',
row['company'],tuple(row))
instance = self.get_or_init_instance(instance_loader,row)
row['designation'] = instance[0].get_designation_number(
row['designation'].strip().upper())
return super(ParticipantImportResource,self).import_row(
row,instance_loader,using_transactions,dry_run,**kwargs)
def post(self, request, session_id):
visitor = None
status = tStatus.UNKNOWN_ERROR
if session_id and session_id in visitor_otp.keys():
visitor = visitor_otp[session_id]
visitor['state'] = AuthState.approved
if not visitor:
logger.warning('Invalid session id %s received for approval',
session_id)
status = tStatus.INVALID_PARAMETER
else:
vinfo = visitor['vinfo']
logger.info('Recieved approval request for session id %s name %s',
session_id, vinfo['name'])
status, token = issue_new_vtoken(vinfo['name'],
vinfo['email_address'],
vinfo['mobile_number'],
vinfo['refered_by'])
logger.info('Calling session expired function')
session_expired(session_id, visitor_otp)
if status == tStatus.SUCCESS:
logger.info('Issued new token to visitor %s : %d', vinfo['name'],
vinfo['mobile_number'])
return self.get(request)
elif status == tStatus.TOKEN_REISSUED:
logger.warning('Re-Issued valid token to visitor %s : %d',
vinfo['name'], vinfo['mobile_number'])
return self.get(request)
else:
logger.error('Error in AuthState session_id %s status %s',
session_id, status.name)
return render_status(request, status)
def get(self, request, registration_number):
user = request.user.username
ilist = Participant.objects.filter(
registration_number=registration_number)
if ilist:
participant = ilist[0]
form = participantModifyForm(instance=participant)
self.render_url = 'PART_MODIFY'
self.tparams['form'] = form
else:
logger.warning(
'Attempting to modify invalid participant(%d) by %s',
registration_number, user)
self.render_url = 'INVALID_REG'
return super(participantModifyView, self).get(request)
def post(self, request, registration_number):
user = request.user.username
participant_form = participantModifyForm(request.POST)
if participant_form.is_valid():
ilist = Participant.objects.filter(
registration_number=registration_number)
participant = ilist[0]
participant.userid = user
participant.last_modified = dt.datetime.now()
participant.first_name = \
participant_form.cleaned_data['first_name']
participant.last_name = \
participant_form.cleaned_data['last_name']
participant.designation = \
participant_form.cleaned_data['designation']
participant.email_address = \
participant_form.cleaned_data['email_address']
participant.mobile_number = \
participant_form.cleaned_data['mobile_number']
participant.start_date = \
participant_form.cleaned_data['start_date']
participant.end_date = \
participant_form.cleaned_data['end_date']
participant.participant_state = \
participant_form.cleaned_data['participant_state']
participant.save()
logger.info('Participant %s successfully modified by %s',
participant, user)
self.render_url = 'PART_DETAIL'
self.tparams['emp'] = participant
return super(participantModifyView, self).post(request)
else:
logger.warning('Invalid Form submitted by %s', user)
self.tparams['mlist'] = participant_form._errors
return self.get(request, registration_number)
def get_issued_valid_token_for_participant(registration_number):
tdate = dt.date.today()
issued_tokens = ParticipantToken.objects.filter(
issued_to=registration_number)
for entry in issued_tokens:
tdelta = tdate - entry.issued_on
if entry.token_state == ccfg.TokenState.ISSUED.value:
if tdelta.days < entry.validity:
return entry
else:
entry.token_state = ccfg.TokenState.EXPIRED.value
entry.save()
logger.warning(
'Moving participant token %s to expired state %d',
entry.userid, registration_number)
return None
def get_participant_info(reg_num):
ilist = Participant.objects.filter(registration_number=reg_num)
if ilist and ilist[0].company.venture_state == \
bcfg.VentureState.ACTIVE.value:
if ilist[0].participant_state == \
bcfg.ParticipantState.ACTIVE.value:
if ilist[0].end_date < dt.date.today():
ilist[0].participant_state = \
bcfg.ParticipantState.INACTIVE.value
ilist[0].save()
logger.warning('Moving Participant %s to Inactive state',
ilist[0])
else:
logger.debug('%s returned for %d', ilist[0], reg_num)
return ilist[0]
logger.warning('No records found for %d', reg_num)
return None
def post(self, request):
user = request.user.username
html_file = None
html_var = None
token_form = gForm(request.POST)
if token_form.is_valid():
ttype = token_form.cleaned_data['token_type']
print('ttype', ttype, UserType.PARTICIPANT.value)
if int(ttype) == UserType.PARTICIPANT.value: #participant
html_file = 'cricket/itoken_view.html'
html_var = {
'tlist': ParticipantToken.objects.all(),
'baseurl': settings.SITE_URL
}
ttoken = ParticipantToken()
logger.info('Created token %s type by %s',
UserType.PARTICIPANT.name, user)
else: #visitor
html_file = 'cricket/vtoken_view.html'
html_var = {
'tlist': VisitorToken.objects.all(),
'baseurl': settings.SITE_URL
}
ttoken = VisitorToken()
logger.info('Created token %s type by %s',
UserType.VISITOR.name, user)
ttoken.userid = token_form.cleaned_data['userid']
ttoken.password = token_form.cleaned_data['password']
ttoken.token_state = ccfg.TokenState.NEW.value
ttoken.validity = token_form.cleaned_data['validity']
ttoken.created_on = dt.date.today()
ttoken.issued_on = dt.date.today()
ttoken.save()
elif 'myfile' in request.FILES.keys():
logger.info('Uploading token for %s by %s of validity %s',
request.POST['token_for'], user,
request.POST['validity'])
if request.POST['token_for'] == "VISITOR":
html_file = 'cricket/vtoken_view.html'
html_var = {
'tlist': VisitorToken.objects.all(),
'baseurl': settings.SITE_URL
}
t_resource = VisitorTokenResource(request.POST['validity'])
else:
html_file = 'cricket/itoken_view.html'
html_var = {
'tlist': ParticipantToken.objects.all(),
'baseurl': settings.SITE_URL
}
t_resource = ParticipantTokenResource(request.POST['validity'])
new_tokens = request.FILES['myfile']
dataset = bview.get_dataset(new_tokens)
result = t_resource.import_data(dataset, dry_run=True)
if not result.has_errors():
t_resource.import_data(dataset, dry_run=False)
logger.info('token upload successful %s ', user)
else:
logger.warning('token upload unsuccessful %s ', user)
return render(request, html_file, html_var)
def post(self, request, otp_dict, u_type):
ss = request.session
if ss.session_key in otp_dict.keys():
logger.debug('Entering critical section session id %s',
ss.session_key)
if bmodel.is_thread_safe_mode():
self.lock.acquire()
otph = OtpHandler(u_type, otp_dict[ss.session_key]['var'],
ss.session_key)
response = otph.post(request)
if bmodel.is_thread_safe_mode():
self.lock.release()
logger.debug('Exiting critical section session id %s',
ss.session_key)
return response
if u_type == UserType.VISITOR:
form = visitorTokenForm(request.POST)
else:
form = participantTokenForm(request.POST)
status = tStatus.UNKNOWN_ERROR
mobile_number = 0
reg_num = 0
i_key = 0
vinfo = None
if form.is_valid():
logger.info('valid form received from user %s session id %s',
u_type.name, ss.session_key)
if u_type == UserType.VISITOR:
vinfo = {}
mobile_number = form.cleaned_data['mobile_number']
i_key = mobile_number
vinfo['name'] = form.cleaned_data['visitor_name']
vinfo['email_address'] = form.cleaned_data['email_address']
vinfo['mobile_number'] = form.cleaned_data['mobile_number']
vinfo['refered_by'] = form.cleaned_data['refered_by']
vinfo['timestamp'] = dt.datetime.now()
logger.debug('Visitor info %s session %s', vinfo,
ss.session_key)
status = tStatus.SUCCESS
else:
reg_num = form.cleaned_data['registration_number']
i_key = reg_num
participant_info = bmodel.get_participant_info(reg_num)
if participant_info:
logger.debug('Participant info %s session %s',
participant_info, ss.session_key)
status = tStatus.SUCCESS
else:
logger.warning(
'Invalid registration number %d from session %s ',
reg_num, ss.session_key)
status = tStatus.INVALID_USER
else:
logger.warning('Invalid form received from user %s session id %s',
u_type.name, ss.session_key)
status = tStatus.INVALID_PARAMETER
if status == tStatus.SUCCESS:
logger.debug('Entering critical section session id %s',
ss.session_key)
if bmodel.is_thread_safe_mode():
self.lock.acquire()
otph = OtpHandler(u_type, i_key, ss.session_key, vinfo)
response = otph.get(request)
if bmodel.is_thread_safe_mode():
self.lock.release()
logger.debug('Exiting critical section session id %s',
ss.session_key)
return response
return render_status(request, status)