Ejemplo n.º 1
0
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: ")
Ejemplo n.º 2
0
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
Ejemplo n.º 3
0
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
Ejemplo n.º 4
0
    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')
Ejemplo n.º 5
0
 def post(self):
     if not auth.auth_check():
         return {"msg": "Not logged in.", "suc": False}
     auth.logout()
     return {
         "msg": "Logout successfully.",
         "suc": True,
     }
Ejemplo n.º 6
0
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': '******'})
Ejemplo n.º 7
0
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': '******'})
Ejemplo n.º 8
0
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'))
Ejemplo n.º 9
0
 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('/')
Ejemplo n.º 10
0
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
Ejemplo n.º 11
0
    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)
Ejemplo n.º 12
0
    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)
Ejemplo n.º 13
0
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']
Ejemplo n.º 14
0
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()
Ejemplo n.º 15
0
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)
Ejemplo n.º 16
0
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.',
        })
Ejemplo n.º 17
0
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)
Ejemplo n.º 18
0
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()
Ejemplo n.º 19
0
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
Ejemplo n.º 20
0
def test_logout1():
    '''
    Test a valid use case of auth.logout
    '''
    reset_auth_store()
    user1 = reg_user1()
    assert auth.logout(user1) == True
Ejemplo n.º 21
0
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
Ejemplo n.º 22
0
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()
Ejemplo n.º 23
0
 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
Ejemplo n.º 24
0
 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
Ejemplo n.º 25
0
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)
Ejemplo n.º 27
0
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
Ejemplo n.º 28
0
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
Ejemplo n.º 29
0
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
Ejemplo n.º 30
0
def logoff(request):
    logout(request)
    return HttpResponseRedirect('/')
Ejemplo n.º 31
0
 def logout(request):
     if request.user.is_authenticated:
         auth.logout(request)
         return HttpResponseRedirect('/')
     return HttpResponseRedirect('/')
Ejemplo n.º 32
0
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 GET(self):
     auth.logout()
     return web.seeother( '/' )
Ejemplo n.º 34
0
 def logout():
     """" Logs out a user """
     if auth.logout():
         return {'message': auth.SERVICE_MESSAGES['logout']}
     else:
         raise NotFound()
Ejemplo n.º 35
0
 def GET(self):
     return auth.logout('/')
Ejemplo n.º 36
0
def logout():
	auth.logout()
	return respond200()
Ejemplo n.º 37
0
def logout(env, headers):
    cookies = _get_cookies(env)
    auth.logout(headers, cookies)
    headers.append(('Location', '/'))
    return ''
Ejemplo n.º 38
0
def logout_url():
    logout()
    return redirect(request.environ.get("HTTP_REFERER") or "/")
Ejemplo n.º 39
0
def logout_hook():
    return auth.logout(session)
Ejemplo n.º 40
0
 def logout():
     """Responds to /auth/logout (GET request) and logout a user.
     """
     if auth.logout():
         return {"message": auth.MESSAGES["logout"]}
     raise NotFound()
Ejemplo n.º 41
0
def logoff(request):
    logout(request)
    return HttpResponseRedirect('/')
Ejemplo n.º 42
0
def logout():
    auth.logout()
    return redirect('/')
Ejemplo n.º 43
0
def logout():
    auth.logout()
    return redirect(url_for('home.index'))
Ejemplo n.º 44
0
 def GET(self):
     return auth.logout('/')
Ejemplo n.º 45
0
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
Ejemplo n.º 46
0
 def tearDown(self):
     self.logout_rsp = auth.logout(self.bf_client)
     self.bf_client = None
Ejemplo n.º 47
0
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'])
Ejemplo n.º 48
0
def logout():
    auth.logout()
    return '{}'
Ejemplo n.º 49
0
def logout():
	resp = flask.redirect(flask.url_for('home'))
	auth.logout(resp)
	return resp
Ejemplo n.º 50
0
                            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: