def menu(): print("-------- WAITER MENU ----------") print('(1) - Enter block dates') print('(2) - See shifts') print( '(3) - See Personal information' ) # in this fuction need to another button to update the personal information print('(4) - Enter a memo') print('(5) - Enter worker request') print('(6) - Logout') # print('to send general application to manager or responsible shift 7') choice = int(input("Option: ")) if (choice == 1): EnterBlockes() elif (choice == 2): printShifts() elif (choice == 3): ShowPersonalDetails() elif (choice == 4): EnterMemo() elif (choice == 5): General_Request() elif (choice == 6): auth.logout() return x = input("Press any key to return the menu: ")
def fetch_all_url_filering_rules(isFull: bool = False) -> Dict[str, str]: """Get Zscaler's url filtering rules.""" api_endpoint: str = f"{base.base_url}/urlFilteringRules" api_token: str = login() headers: dict[str, str] = { "content-type": "application/json", "cache-control": "no-cache", "cookie": api_token, } response: Response = requests.get(api_endpoint, headers=headers) logout(api_token) url_filtering_rules: list = response.json() if not isFull: try: for url_filtering_rule in url_filtering_rules: del ( url_filtering_rule['rank'], url_filtering_rule['requestMethods'], url_filtering_rule['blockOverride'], url_filtering_rule['enforceTimeValidity'], url_filtering_rule['cbiProfileId'], ) except: pass url_filtering_rules = sorted(url_filtering_rules, key=lambda x: x['order']) return url_filtering_rules
def create_custom_url_category( configured_name: str, urls: List[str], db_categorized_urls: List[str], description: str, ) -> str: api_token = login() api_endpoint = "{}/urlCategories".format(base.base_url) headers = { "content-type": "application/json", "cache-control": "no-cache", "cookie": api_token, } payload = { "configuredName": configured_name, "urls": urls, "dbCategorizedUrls": db_categorized_urls, "customCategory": True, "editable": True, "description": description, "superCategory": "USER_DEFINED", "urlsRetainingParentCategoryCount": 0, "type": "URL_CATEGORY", } response = requests.post(api_endpoint, json.dumps(payload), headers=headers) logout(api_token) message: str = ( f"[INFO] {str(response.status_code)} {response.json()['configuredName']}" if response.status_code == 200 else f"[INFO] {str(response.status_code)} {response.json()['message'] }") return message
def geturl(self, content_id, cookie=None, encrypted=False): device_id = get_device_id() platform = 'PCTV' if not encrypted else vod_platform # 'PCTV_DASH' url = 'https://apac.ti-platform.com/AGL/1.0/R/%s/%s/TNTGO_LATAM_BR/CONTENT/CDN/?id=%s&type=VOD&asJson=Y&accountDeviceId=%s' % (LANGUAGE, platform, content_id, device_id) retry = True if not cookie else False cookie = cookie or get_token() headers = { 'Accept': 'application/json', 'cookie': 'avs_cookie=' + cookie, 'User-Agent': 'Tnt/2.2.13.1908061505 CFNetwork/1107.1 Darwin/19.0.0' } control.log('TNT GET ' + url) control.log(headers) result = requests.get(url, headers=headers, proxies=proxy).json() or {} control.log(result) if 'message' in result and result['message'] == u'Token not valid' and retry: cookie = get_token(True) return self.geturl(content_id, cookie, encrypted) if result.get('resultCode', u'KO') == u'KO': logout() raise Exception('%s: %s' % (result.get('message', u'STREAM URL ERROR'), result.get('errorDescription', u'UNKNOWN'))) return result.get('resultObj', {}).get('src')
def post(self): if not auth.auth_check(): return {"msg": "Not logged in.", "suc": False} auth.logout() return { "msg": "Logout successfully.", "suc": True, }
def test_invalid_email_login(): ''' Test login if provided an invalid login ''' reset_auth_store() user1 = reg_user1() auth.logout({'token': user1['token']}) with pytest.raises(InputError): auth.login({'email': 'Kennan@com', 'password': '******'})
def test_wrong_pass(): ''' Test login if provided with an incorrect pass ''' reset_auth_store() user1 = reg_user1() auth.logout({'token': user1['token']}) with pytest.raises(InputError): auth.login({'email': '*****@*****.**', 'password': '******'})
def logout(): # checks to make sure the user is logged in if logged_in(): # if they are, then runs the logout function from auth.py and alerts the user to the success of the function auth.logout() flash('You have been logged out.') return redirect(url_for('index')) # if they are not logged in, alerts the user and brings them to the login page flash('You are not logged in!') return redirect(url_for('login'))
def get(self): with locks.global_lock: session_id = self.get_cookie('session_id') if auth.load_session(session_id) is None: self.write( render_template('auth_error.html', error=lc.get('logout_no_session'))) return auth.logout(session_id) self.clear_cookie('session_id') self.redirect('/')
def test_bad_token(): ''' Test logout on a bad token ''' reset_auth_store() reg_user1() user2 = reg_user2() auth.logout(user2) assert auth.logout(user2) == False
def test_already_logged_out(self): """ If the user is already logged out, after calling logout the session should still get flushed. """ session = self.client.session session[SESSION_KEY] = 'some id' user = VerbaAnonymousUser() request = mock.MagicMock(session=session, user=user) logout(request) self.assertTrue(isinstance(request.user, VerbaAnonymousUser)) self.assertFalse(SESSION_KEY in request.session)
def test_logged_in(self): """ If the user is logged in, after calling logout, the session should get flushed. """ session = self.client.session session[SESSION_KEY] = 'some id' user = VerbaUser(pk=1, token='user token', user_data={'username': '******'}) request = mock.MagicMock(session=session, user=user) logout(request) self.assertTrue(isinstance(request.user, VerbaAnonymousUser)) self.assertFalse(SESSION_KEY in request.session)
def test_login1(): ''' Test basic functionality of login ''' reset_auth_store() user1 = reg_user1() auth.logout({'token': user1['token']}) assert auth.login({ 'email': '*****@*****.**', 'password': '******' })['token'] == user1['token']
def fetch_url_categories(isCustomOnly: bool = False) -> str: """Get Zscaler's url catergories.""" api_token = login() api_endpoint = ("{}/urlCategories?customOnly=true".format(base.base_url) if isCustomOnly else "{}/urlCategories".format(base.base_url)) headers = { "content-type": "application/json", "cache-control": "no-cache", "cookie": api_token, } response = requests.get(api_endpoint, headers=headers) logout(api_token) return response.json()
def logout(request, next_page=None, template_name='registration/logged_out.html', redirect_field_name=REDIRECT_FIELD_NAME): "Logs out the user and displays 'You are logged out' message." from auth import logout logout(request) if next_page is None: redirect_to = request.REQUEST.get(redirect_field_name, '') if redirect_to: return HttpResponseRedirect(redirect_to) else: return render_to_response(template_name, { 'title': _('Logged out') }, context_instance=RequestContext(request)) else: # Redirect to this page until the session has been cleared. return HttpResponseRedirect(next_page or request.path)
def on_logout(event): """Handles logging out the user.""" user_name = event['user']['name'] try: auth.logout(user_name) except Exception as e: logging.exception(e) return flask.jsonify({ 'text': 'Failed to log out user %s: ```%s```' % (user_name, e), }) else: return flask.jsonify({ 'text': 'Logged out.', })
def logout_then_login(request, login_url=None): "Logs out the user if he is logged in. Then redirects to the log-in page." if not login_url: login_url = settings.LOGIN_URL return logout(request, login_url)
def lookup_url_classification(target_urls: List[str]) -> Dict[str, str]: """Lookup url category classifications to given url.""" api_token = login() api_endpoint = "{}/urlLookup".format(base.base_url) headers = { "content-type": "application/json", "cache-control": "no-cache", "cookie": api_token, } domains = [extract_url_domain(url) for url in target_urls] response = requests.post(api_endpoint, json.dumps(domains), headers=headers) logout(api_token) return response.json()
def fetch_adminusers(search_query: str = None) -> str: """Get Zscaler's url catergories.""" api_endpoint: str = f"{base.base_url}/adminUsers" if search_query is not None: api_endpoint = f"{api_endpoint}?search={search_query}" api_token: str = login() headers: dict[str, str] = { "content-type": "application/json", "cache-control": "no-cache", "cookie": api_token, } response: Response = requests.get(api_endpoint, headers=headers) logout(api_token) return response.text
def test_logout1(): ''' Test a valid use case of auth.logout ''' reset_auth_store() user1 = reg_user1() assert auth.logout(user1) == True
def create_adminuser( loginName: str, userName: str, email: str, password: str, rolename: str, ) -> str: api_token: str = login() role_api_endpoint: str = f"{base.base_url}/adminRoles/lite" user_api_endpoint: str = f"{base.base_url}/adminUsers" headers: Dict[str, str] = { "content-type": "application/json", "cache-control": "no-cache", "cookie": api_token, } role_response: Response = requests.get(role_api_endpoint, headers=headers) roles: List[Dict[str, Union[int, str]]] = role_response.json() role_id: int = None for role in roles: if rolename in role.values(): role_id: int = role["id"] admin_user_information = { "loginName": loginName, "userName": userName, "email": email, "password": password, "role": { "id": role_id }, "adminScopescopeGroupMemberEntities": [], "adminScopeType": "ORGANIZATION", "adminScopeScopeEntities": [], "isPasswordLoginAllowed": True, "name": "Yuta Kawamura", } user_response = requests.post(user_api_endpoint, json.dumps(admin_user_information), headers=headers) logout(api_token) message: str = "Success" if user_response.status_code == 200 else f"Failed" message += f": {user_response.status_code} {user_response.text}" if message == "Failed" else None return message
def update_custom_url_category( category_id: str, urls: List[str], ) -> str: """Update an existing Zscaler's url catergory.""" api_endpoint = f"{base.base_url}/urlCategories/{category_id}" api_token = login() headers = { "content-type": "application/json", "cache-control": "no-cache", "cookie": api_token, } payload = {urls} response = requests.put(api_endpoint, data=json.dumps(payload), headers=headers) logout(api_token) return response.json()
def process_response(self, request, response): # If the "_logout" flag is set on the response, generate a response # that will log the user out. if getattr(response, '_logout', False): return auth.logout(redirect=request.GET.get('redirect', None)) # If our security token is old, issue a new one. if hasattr(request, 'user'): cred = getattr(request.user, '_credentials', None) if cred and cred.security_token_is_stale: auth.attach_credentials(response, request.user) return response
def logout(request, next_page=None, template_name='registration/logged_out.html', redirect_field_name=REDIRECT_FIELD_NAME): "Logs out the user and displays 'You are logged out' message." #from django.contrib.auth import logout from auth import logout logout(request) return HttpResponseRedirect("/") if next_page is None: redirect_to = request.REQUEST.get(redirect_field_name, '') if redirect_to: return HttpResponseRedirect(redirect_to) else: return render_to_response(template_name, {'title': _('Logged out')}, context_instance=RequestContext(request)) else: # Redirect to this page until the session has been cleared. return HttpResponseRedirect(next_page or request.path)
def services(user): print("Welcome %s %s " % (user[0], user[1])) selected_option = int( input( "What would you like to do? (1) deposit (2) withdrawal (3) Logout (4) Exit \n" )) if selected_option == 1: deposit() elif selected_option == 2: withdraw() elif selected_option == 3: auth.logout() elif selected_option == 4: exit() else: print("Invalid option selected") services(user)
async def user_post(request): """ Handle login, logout, and account creation """ session = await get_session(request) data = await request.post() action = data.get("action") if action == "create" or action == "login": username = data.get("username") password = data.get("password") if (username is None or password is None): raise web.HTTPBadRequest if action == "create": auth.create_account(session, username, password) elif action == "login": auth.login(session, username, password) elif action == "logout": auth.logout(session) raise web.HTTPOk
def create_url_filering_rules(name: str, order: int, protocols: List[str], locations: List[str], groups: List[str], departments: List[str], users: List[str], url_categories: List[str], state: str, rank: int, action: str) -> str: api_endpoint: str = f"{base.base_url}/urlFilteringRules" api_token: str = login() headers: dict[str, str] = { "content-type": "application/json", "cache-control": "no-cache", "cookie": api_token, } payload: Dict[str, Union[str, int, List[str]]] = { "name": name, "order": order, "protocols": protocols, "locations": locations, "groups": groups, "departments": departments, "users": users, "urlCategories": url_categories, "state": state, "rank": rank, "action": action, } response: Response = requests.post(api_endpoint, json.dumps(payload), headers=headers) logout(api_token) message = ( f"Success: '{response.json()['name']}' is created" if response.status_code == 200 else f"Failed: { response.status_code } { response.json()['message'] }") return message
def handle_long_ttl(cardGenTime, race_list, market_info): """Wrapper method to handle the situation where TTL is greater than 5 mins. Sleep and refresh the card if there are no races in the next 3 hrs. """ logger.debug('TTL is greater than 4 mins') sleepTill = market_info.marketLite.marketTime - datetime.timedelta(0,240) sleepFor = sleepTill - market_info.header.timestamp if sleepFor.seconds > 10800: logger.info("No races for the next 3 hours, \ regenerating race card to check for new races. \ Logging out till races start again.") logout_rsp = auth.logout(betfairClient) time.sleep(sleepFor.seconds - 1000) login_rsp = auth.login(betfairClient) cardGenTime = cardGenTime - datetime.timedelta(0,21600) #force card to regenerate (race_list, cardGenTime) = gen_race_list(cardGenTime, race_list, betfairClient) else: logger.debug('Sleeping for %s mins', sleepFor.seconds / 60) time.sleep(sleepFor.seconds) return True
def logoff(request): logout(request) return HttpResponseRedirect('/')
def logout(request): if request.user.is_authenticated: auth.logout(request) return HttpResponseRedirect('/') return HttpResponseRedirect('/')
def GET(self): auth.logout() return web.seeother( '/' )
def logout(): """" Logs out a user """ if auth.logout(): return {'message': auth.SERVICE_MESSAGES['logout']} else: raise NotFound()
def GET(self): return auth.logout('/')
def logout(): auth.logout() return respond200()
def logout(env, headers): cookies = _get_cookies(env) auth.logout(headers, cookies) headers.append(('Location', '/')) return ''
def logout_url(): logout() return redirect(request.environ.get("HTTP_REFERER") or "/")
def logout_hook(): return auth.logout(session)
def logout(): """Responds to /auth/logout (GET request) and logout a user. """ if auth.logout(): return {"message": auth.MESSAGES["logout"]} raise NotFound()
def logout(): auth.logout() return redirect('/')
def logout(): auth.logout() return redirect(url_for('home.index'))
def main(**args): # Command method method = sys.argv[1] if method == "version": message = "Duplicati client version " message += config.APPLICATION_VERSION return common.log_output(message, True) # Default values data = { "last_login": None, "parameters_file": None, "server": { "port": "", "protocol": "http", "url": "localhost", "verify": True }, 'token': None, 'token_expires': None, 'verbose': False, 'precise': False, 'authorization': '' } # Detect home dir for config file config.CONFIG_FILE = compatibility.get_config_location() # Load configuration overwrite = args.get("overwrite", False) data = load_config(data, overwrite) param_file = args.get("param-file", None) # Set parameters file if method == "params": data = set_parameters_file(data, args, param_file) # Load parameters file args = common.load_parameters(data, args) # Show parameters if method == "params": if args.get("show", False) or param_file is None: display_parameters(data) return # Toggle verbosity if method == "verbose": mode = args.get("mode", None) data = toggle_verbose(data, mode) return # Toggle precise time if method == "precise": mode = args.get("mode", None) data = toggle_precise(data, mode) return # Write verbosity setting to config variable config.VERBOSE = data.get("verbose", False) # Display the config if requested if method == "config": display_config(data) return # Display the status if requested if method == "status": display_status(data) return # Login if method == "login": url = args.get("url", None) password = args.get("password", None) basic_user = args.get("basic_user", None) basic_pass = args.get("basic_pass", None) certfile = args.get("certfile", None) insecure = args.get("insecure", False) verify = auth.determine_ssl_validation(data, certfile, insecure) interactive = args.get("script", False) data = auth.login(data, url, password, verify, interactive, basic_user, basic_pass) return # Logout if method == "logout": data = auth.logout(data) return # List resources if method == "list": resource_type = args.get("type", None) output_type = args.get("output", None) list_resources(data, resource_type, output_type) return # Get resources if method == "get": resource_type = args.get("type", None) resource_ids = args.get("id", None) output_type = args.get("output", None) get_resources(data, resource_type, resource_ids, output_type) return # Describe resources if method == "describe": resource_type = args.get("type", None) resource_ids = args.get("id", None) output_type = args.get("output", None) describe_resources(data, resource_type, resource_ids, output_type) return # Set resource values if method == "set": resource = sys.argv[2] if resource == "password": password = args.get("password", None) disable_login = args.get("disable", False) interactive = args.get("script", False) auth.set_password(data, password, disable_login, interactive) return # Repair a database if method == "repair": backup_id = args.get("id", None) repair_database(data, backup_id) return # Vacuum a database if method == "vacuum": backup_id = args.get("id", None) vacuum_database(data, backup_id) return # Verify remote data files if method == "verify": backup_id = args.get("id", None) verify_remote_files(data, backup_id) return # Compact remote data if method == "compact": backup_id = args.get("id", None) compact_remote_files(data, backup_id) return # Dismiss notifications if method == "dismiss": resource_id = args.get("id", "all") if not resource_id.isdigit() and resource_id != "all": common.log_output("Invalid id: " + resource_id, True) return dismiss_notifications(data, resource_id) return # Show logs if method == "logs": log_type = args.get("type", None) backup_id = args.get("id", None) remote = args.get("remote", False) follow = args.get("follow", False) lines = args.get("lines", 10) show_all = args.get("all", False) output_type = args.get("output", None) get_logs(data, log_type, backup_id, remote, follow, lines, show_all, output_type) return # Run backup if method == "run": backup_id = args.get("id", None) run_backup(data, backup_id) return # Abort backup if method == "abort": backup_id = args.get("id", None) abort_task(data, backup_id) return # Create method if method == "create": import_type = args.get("type", None) import_file = args.get("import-file", None) import_meta = args.get("import_metadata", None) import_resource(data, import_type, import_file, None, import_meta) return # Update method if method == "update": import_type = args.get("type", None) import_id = args.get("id", None) import_file = args.get("import-file", None) # import-metadata is the inverse of strip-metadata import_meta = not args.get("strip_metadata", False) import_resource(data, import_type, import_file, import_id, import_meta) return # Delete a resource if method == "delete": resource_id = args.get("id", None) resource_type = args.get("type", None) delete_db = args.get("delete_db", False) confirm = args.get("confirm", False) recreate = args.get("recreate", False) delete_resource(data, resource_type, resource_id, confirm, delete_db, recreate) return # Export method if method == "export": resource_id = args.get("id", None) output_type = args.get("output", None) path = args.get("output_path", None) export_passwords = args.get("no_passwords", True) all_ids = args.get("all", False) timestamp = args.get("timestamp", False) print(export_passwords) confirm = args.get("confirm", False) export_backup(data, resource_id, output_type, path, export_passwords, all_ids, timestamp, confirm) return # Pause if method == "pause": time = args.get("duration", "xxx") pause(data, time) return # Resume if method == "resume": resume(data) return
def tearDown(self): self.logout_rsp = auth.logout(self.bf_client) self.bf_client = None
def logout_view(): user_data = logout() if user_data is None: return 'No user to log out.' return 'Logged out user {0}.'.format(user_data['username'])
def logout(): auth.logout() return '{}'
def logout(): resp = flask.redirect(flask.url_for('home')) auth.logout(resp) return resp
strategy.RunStrategy(betfairClient, marketId, selectionId, timeId) logger.debug('strategy calculation success.') except IndexError: if handle_IndexError(betfairClient, exchangeId, marketId): continue else: break except Exception, e: logger.exception("Running strategy") raise e time.sleep(1.5) else: time.sleep(9) pass logout_rsp = auth.logout(betfairClient) def find_a_race_to_bet(): """Wrapper function that contains all the functions that are required to find a race to bet on. """ def gen_race_list(cardGenTime, race_list, betfairClient): """gen_race_list refreshes the list of races every 6 hours, unless there are less than 3 races in the queue (which there should never be) It calls find_races() """ try: now = datetime.datetime.now() if not race_list: