i have written an python flask app in visual studio, which i want to add ms-identity-python-webapp to:

the app sample works correctly on its own

so i added the app.py code to my views.py

and added the config files and the html files from the sample to my visual studio solution.

is that the wrong way to do it?

really need help, im sure its something simple, my app works and the sample works, how do i put them together?

here is the start of my views.py

"""
Routes and views for the flask application.
"""
from CDK_Auth import AccessCode
import requests
import json
from flask import request

from datetime import datetime
from flask import render_template, session, redirect, url_for
from FlaskSSASI import app
import urllib3
import os
import getpass
import msal

import uuid

from flask import Flask, render_template, session, request, redirect, url_for
from flask_session import Session # https://pythonhosted.org/Flask-Session

import app_config

app = Flask(name)
app.config.from_object(app_config)
Session(app)

from werkzeug.middleware.proxy_fix import ProxyFix
app.wsgi_app = ProxyFix(app.wsgi_app, x_proto=1, x_host=1)

@app.route('/')

def index():
if not session.get("user"):
return redirect(url_for("login"))
return render_template('index.html', user=session["user"], version=msal.version)

@app.route("/login")
def login():
session["state"] = str(uuid.uuid4())
# Technically we could use empty list [] as scopes to do just sign in,
# here we choose to also collect end user consent upfront
auth_url = _build_auth_url(scopes=app_config.SCOPE, state=session["state"])
return render_template("login.html", auth_url=auth_url, version=msal.version)

@app.route(app_config.REDIRECT_PATH) # Its absolute URL must match your app's redirect_uri set in
AAD
def authorized():
if request.args.get('state') != session.get("state"):
return redirect(url_for("index")) # No-OP. Goes back to Index page
if "error" in request.args: # Authentication/Authorization failure
return render_template("auth_error.html", result=request.args)
if request.args.get('code'):
cache = _load_cache()
result = _build_msal_app(cache=cache).acquire_token_by_authorization_code(
request.args['code'],
scopes=app_config.SCOPE, # Misspelled scope would cause an HTTP 400 error here
redirect_uri=url_for("authorized", _external=True))
if "error" in result:
return render_template("auth_error.html", result=result)
session["user"] = result.get("id_token_claims")
_save_cache(cache)
return redirect(url_for("index"))

@app.route("/logout")
def logout():
session.clear() # Wipe out user and its token cache from session
return redirect( # Also logout from your tenant's web session
app_config.AUTHORITY + "/oauth2/v2.0/logout" +
"?post_logout_redirect_uri=" + url_for("index", _external=True))

@app.route("/graphcall")
def graphcall():
token = _get_token_from_cache(app_config.SCOPE)
if not token:
return redirect(url_for("login"))
graph_data = requests.get( # Use token to call downstream service
app_config.ENDPOINT,
headers={'Authorization': 'Bearer ' + token['access_token']},
).json()
return render_template('display.html', result=graph_data)

def _load_cache():
cache = msal.SerializableTokenCache()
if session.get("token_cache"):
cache.deserialize(session["token_cache"])
return cache

def _save_cache(cache):
if cache.has_state_changed:
session["token_cache"] = cache.serialize()

def _build_msal_app(cache=None, authority=None):
return msal.ConfidentialClientApplication(
app_config.CLIENT_ID, authority=authority or app_config.AUTHORITY,
client_credential=app_config.CLIENT_SECRET, token_cache=cache)

def _build_auth_url(authority=None, scopes=None, state=None):
return _build_msal_app(authority=authority).get_authorization_request_url(
scopes or [],
state=state or str(uuid.uuid4()),
redirect_uri=url_for("authorized", _external=True))

def _get_token_from_cache(scope=None):
cache = _load_cache() # This web app maintains one cache per session
cca = _build_msal_app(cache=cache)
accounts = cca.get_accounts()
if accounts: # So all account(s) belong to the current signed-in user
result = cca.acquire_token_silent(scope, account=accounts[0])
_save_cache(cache)
return result

app.jinja_env.globals.update(_build_auth_url=_build_auth_url) # Used in template

if name == "main":
app.run()

#@app.route('/home')
#def home():

"""Renders the home page."""

return render_template(

'indexOLD.html',

title='Home Page',

year=datetime.now().year,

#user=MSAL23.result.json(),

)

@app.route('/contact')
def contact():
"""Renders the contact page."""
return render_template(
'contact.html',
title='Contact',
year=datetime.now().year,
message='Your contact page.'
)

@app.route('/service')
def service():
"""Renders the about page."""
return render_template(
'service.html',
title='Service',
year=datetime.now().year,
message='This is SSASI Service Portal'
)

@app.route('/OrderLog')
def OrderLog():
"""Renders the about page."""
return render_template(
'OrderLog.html',
title='Order Log',
year=datetime.now().year,
message='This is SSASI Sales Portal'
)