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(self, request):
otp_dict = None
if self.utype == UserType.PARTICIPANT:
otp_dict = user_otp
else:
otp_dict = visitor_otp
logger.debug(
'In otp handler : get otp_dict entries before get_otp \n%s\n',
pp.pformat(otp_dict))
if self.get_otp(otp_dict, request):
form = OtpForm()
logger.info('user %s attemptting to access otp page session id %s',
self.utype.name, self.ss_key)
logger.debug(
'In otp handler : get otp_dict entries after get_otp \n%s\n',
pp.pformat(otp_dict))
return render(
request, 'cricket/get_otp.html', {
'form': form,
'count': otp_dict[self.ss_key]['count'],
'baseurl': settings.SITE_URL,
'remove_header': True,
})
else:
logger.info('Calling session expired function')
session_expired(self.ss_key, otp_dict)
return HttpResponse(
"You exceeded number of tries. Please try after sometime")
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, 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 get_otp(self, otp_dict, request):
if self.ss_key in otp_dict.keys():
logger.info('Session id %s count %d utype %s', self.ss_key,
otp_dict[self.ss_key]['count'], self.utype.name)
if otp_dict[self.ss_key]['count'] >= bmodel.otp_max_retries():
return False
else:
otp_dict[self.ss_key] = {
'otp':
random.randint(1000, 9999),
'var':
self.var,
'utype':
self.utype,
'count':
0,
'vinfo':
self.vinfo,
'thandle':
Timer(bmodel.session_timeout(), session_expired,
[self.ss_key, otp_dict]),
'state':
AuthState.awaiting_otp,
}
request.session.set_expiry(bmodel.session_timeout())
otp_dict[self.ss_key]['thandle'].start()
logger.info('Generated otp %d for new session %s for utype %s',
otp_dict[self.ss_key]['otp'], self.ss_key,
self.utype.name)
self.send_otp(otp_dict[self.ss_key]['otp'])
otp_dict[self.ss_key]['count'] += 1
return True
def issue_new_vtoken(name, email, mobile, refer):
status = tStatus.UNKNOWN_ERROR
vtoken = None
issued_token = get_issued_valid_token_for_visitor(mobile)
status_str = None
if issued_token:
vtoken = issued_token
logger.debug('Valid issued token found for visitor %s : %d',
vtoken.issued_to, vtoken.mobile_number)
status = tStatus.TOKEN_REISSUED
status_str = 'OLD'
else:
vtoken = get_next_vtoken()
if vtoken:
vtoken.token_state = ccfg.TokenState.ISSUED.value
vtoken.issued_on = dt.date.today()
vtoken.issued_to = name
vtoken.email_address = email
vtoken.mobile_number = mobile
vtoken.refered_by = refer
vtoken.save()
logger.info('%s token issued to %d', vtoken.userid, mobile)
status = tStatus.SUCCESS
status_str = 'NEW'
else:
status = tStatus.TOKEN_EXHAUSTED
logger.critical('Visitor token exhausted %d', mobile)
if vtoken:
sa.send_token(mobile, status_str, vtoken.userid, vtoken.password)
return status, vtoken
def get(self, request):
user = request.user.username
logger.info('%s accessing visitor token table view', user)
return render(request, 'cricket/vtoken_view.html', {
'tlist': VisitorToken.objects.all(),
'baseurl': settings.SITE_URL
})
def send_otp(mobile_number, otp):
s = OTP_TPLT % (otp)
logger.info('Sending otp %s to %d', s, mobile_number)
return sendSMS(
[mobile_number],
s,
)
def post(self, request):
user = request.user.username
self.tparams['baseurl'] = settings.SITE_URL
if not self.render_url:
self.render_url = 'INTERNAL_ERROR'
logger.info('%s posting %s', user, self.render_url)
logger.debug('template parameters %s', tuple(self.tparams))
return render(request, self.url_lookup[self.render_url], self.tparams)
def get(self, request):
user = request.user.username
form = gForm()
logger.info('%s accessing token entry view', user)
return render(request, 'cricket/token_entry.html', {
'form': form,
'baseurl': settings.SITE_URL
})
def update_registration_number(self):
vid = get_next_venture_id(self.start_date.year)
new_registration_number = str(self.start_date.year )+\
str(int(self.start_date.month/3)+1)+\
"%02d"%self.program+\
"%04d"%vid
self.registration_number = int(new_registration_number)
logger.info('%d regnum assign to %s', self.registration_number,
self.venture_name)
def update_registration_number(self):
self.company.employee_id_counter += 1
id = str(self.company.registration_number) +\
"%02d"%self.company.employee_id_counter
self.registration_number = int(id)
self.company.save()
logger.info('%d regnum assign to %s company %s employee id counter %d',
self.registration_number, self.first_name,
self.company.venture_name,
self.company.employee_id_counter)
def __init__(self, utype, var, ss_key, vinfo=None):
self.fsm = {
AuthState.awaiting_otp: self.handle_awaiting_otp,
AuthState.awaiting_approval: self.handle_awaiting_approval
}
self.utype = utype
self.var = var
self.ss_key = ss_key
self.vinfo = vinfo
logger.info('Otphandler created for %s, user %s var %d ', ss_key,
utype.name, var)
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 get(self, request, otp_dict, form, u_url):
if not request.session.session_key:
request.session.save()
logger.info('storing session key %s', request.session.session_key)
logger.info('get token page %s accessed session id %s', u_url,
request.session.session_key)
return render(request, u_url, {
'form': form,
'baseurl': settings.SITE_URL,
'remove_header': True,
})
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 send_token(mobile_number, status, userid, password):
s = TOKEN_TPLT % (status, userid, password)
if bm.send_token_via_sms():
logger.info('Sending token %s to %d', s, mobile_number)
return sendSMS(
[mobile_number],
s,
)
else:
logger.info('Not sending token %s to %d', s, mobile_number)
return True
def send_registration_number(mobile_number, registration_number):
s = REG_NUM_TPLT % (registration_number)
if bm.send_reg_num_via_sms():
logger.info('Sending reg_num %s to %d', s, mobile_number)
return sendSMS(
[mobile_number],
s,
)
else:
logger.info('Not sending reg_num %s to %d', s, mobile_number)
return True
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 sendSMS(numbers, message, apikey=API_KEY, sender='NSRCEL'):
data = urllib.parse.urlencode({
'apikey': apikey,
'numbers': numbers,
'message': message,
'sender': sender
})
data = data.encode('utf-8')
request = urllib.request.Request("https://api.textlocal.in/send/?")
f = urllib.request.urlopen(request, data)
fr = f.read()
logger.info('Output of send SMS %s for mobile_number %d message %s', fr,
numbers[0], message)
print(fr, message)
return (fr)
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 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 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 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 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):
form = PasswordChangeForm(request.user)
user = request.user.username
logger.info('%s attemptting to change password ', user)
return render(request, 'beetle/change_password.html', {'form': form})
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)
