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)