def _start(self):
self.cache = FileCache(path=self.cache_path)
self.esi_app = EsiApp(cache=self.cache, cache_prefix=self.prefix)
self.app = self.esi_app.get_latest_swagger
self.security = EsiSecurity(
app=self.app,
redirect_uri='http://localhost/oauth-callback', # This doesnt matter
headers={
'User-Agent':
'Discord bot by Prozn: https://github.com/prozn/dankcord'
},
client_id=self.client_id,
secret_key=self.secret_key,
)
self.esi = EsiClient(
retry_requests=
False, # set to retry on http 5xx error (default False)
headers={
'User-Agent':
'Discord bot by Prozn: https://github.com/prozn/dankcord'
},
security=self.security)
self.security.update_token({
'access_token': '', # leave this empty
'expires_in':
-1, # seconds until expiry, so we force refresh anyway
'refresh_token': self.refresh_token
})
self.security.refresh()
def test_esisecurity_other_init(self):
""" test security init without app and with urls """
with self.assertRaises(AttributeError):
EsiSecurity(
redirect_uri=TestEsiSecurity.CALLBACK_URI,
client_id=TestEsiSecurity.CLIENT_ID,
secret_key=TestEsiSecurity.SECRET_KEY,
sso_url=""
)
security = EsiSecurity(
redirect_uri=TestEsiSecurity.CALLBACK_URI,
client_id=TestEsiSecurity.CLIENT_ID,
secret_key=TestEsiSecurity.SECRET_KEY,
sso_url='foo.com',
esi_url='bar.baz'
)
self.assertEqual(
security.oauth_verify,
"bar.baz/verify/"
)
self.assertEqual(
security.oauth_token,
"foo.com/oauth/token"
)
self.assertEqual(
security.oauth_authorize,
"foo.com/oauth/authorize"
)
def __init__(self, token_file):
#Retrieve the tokens from the file
with open(token_file, "rb") as fp:
tokens_file = pickle.load(fp)
fp.close()
esi_app = EsiApp(cache=cache, cache_time=0, headers=headers)
self.app = esi_app.get_latest_swagger
self.security = EsiSecurity(redirect_uri=redirect_uri,
client_id=client_id,
secret_key=secret_key,
headers=headers)
self.client = EsiClient(retry_requests=True,
headers=headers,
security=self.security)
self.security.update_token({
'access_token':
'',
'expires_in':
-1,
'refresh_token':
tokens_file['refresh_token']
})
tokens = self.security.refresh()
api_info = self.security.verify()
print("security: Authenticated for " + str(api_info['Scopes']))
def __init__(self, token, refresh=False):
self.client_id = os.environ.get('EVE_SKILLS_CID')
self.secret_id = os.environ.get('EVE_SKILLS_SECRET')
self.redir_url = os.environ.get('EVE_SKILLS_REDIR')
self.app = App.create(
url=
"https://esi.evetech.net/latest/swagger.json?datasource=tranquility"
)
self.security = EsiSecurity(
app=self.app,
redirect_uri=self.redir_url,
client_id=self.client_id,
secret_key=self.secret_id,
)
self.client = EsiClient(
header={'User-Agent': 'EVE-SKILLS'},
raw_body_only=
False, # parse json automatically, slow, bad performance
security=self.security)
self.token = None
if not refresh:
self.token = self.security.auth(
token) # use code from login redirect
if refresh:
print('[I] refreshing token')
self.security.update_token({
'access_token': '',
'expires_in': -1, # force refresh anyway
'refresh_token': token
})
self.token = self.security.refresh()
print(self.token)
def test_esisecurity_init(self):
with httmock.HTTMock(*_all_auth_mock_):
with self.assertRaises(AttributeError):
EsiSecurity(redirect_uri=TestEsiSecurity.CALLBACK_URI,
client_id=TestEsiSecurity.CLIENT_ID,
secret_key=TestEsiSecurity.SECRET_KEY,
sso_endpoints_url="")
with self.assertRaises(AttributeError):
EsiSecurity(redirect_uri=TestEsiSecurity.CALLBACK_URI,
client_id=TestEsiSecurity.CLIENT_ID)
with open(TestEsiSecurity.RSC_JWKS, 'r') as jwks:
jwks = json.load(jwks)
EsiSecurity(redirect_uri=TestEsiSecurity.CALLBACK_URI,
client_id=TestEsiSecurity.CLIENT_ID,
secret_key=TestEsiSecurity.SECRET_KEY,
jwks_key=jwks['keys'][0])
self.assertEqual(self.security.security_name,
TestEsiSecurity.SECURITY_NAME)
self.assertEqual(self.security.redirect_uri,
TestEsiSecurity.CALLBACK_URI)
self.assertEqual(self.security.client_id, TestEsiSecurity.CLIENT_ID)
self.assertEqual(self.security.secret_key, TestEsiSecurity.SECRET_KEY)
self.assertEqual(self.security.token_identifier,
TestEsiSecurity.TOKEN_IDENTIFIER)
self.assertEqual(self.security.oauth_issuer,
self.sso_endpoints['issuer'])
self.assertEqual(self.security.oauth_authorize,
self.sso_endpoints['authorization_endpoint'])
self.assertEqual(self.security.oauth_token,
self.sso_endpoints['token_endpoint'])
self.assertEqual(self.security.oauth_revoke,
self.sso_endpoints['revocation_endpoint'])
def test_esisecurity_init_with_app(self):
""" test security init with app and URL"""
with self.assertRaises(NameError):
EsiSecurity(app=self.app,
redirect_uri=TestEsiSecurity.CALLBACK_URI,
client_id=TestEsiSecurity.CLIENT_ID,
secret_key=TestEsiSecurity.SECRET_KEY,
security_name="security_name_that_does_not_exist")
with self.assertRaises(AttributeError):
EsiSecurity(app=self.app,
redirect_uri=TestEsiSecurity.CALLBACK_URI,
client_id=TestEsiSecurity.CLIENT_ID,
secret_key=TestEsiSecurity.SECRET_KEY,
esi_url="")
self.assertEqual(self.security.security_name,
TestEsiSecurity.SECURITY_NAME)
self.assertEqual(self.security.redirect_uri,
TestEsiSecurity.CALLBACK_URI)
self.assertEqual(self.security.client_id, TestEsiSecurity.CLIENT_ID)
self.assertEqual(self.security.secret_key, TestEsiSecurity.SECRET_KEY)
self.assertEqual(self.security.oauth_verify,
TestEsiSecurity.OAUTH_VERIFY)
self.assertEqual(self.security.oauth_token,
TestEsiSecurity.OAUTH_TOKEN)
self.assertEqual(self.security.oauth_authorize,
TestEsiSecurity.OAUTH_AUTHORIZE)
def initialize_esi_client(refresh_token=None):
"""
Retrieves a public or authorized ESI client.
Args:
auth_id (optional): refresh_token of the user whose client we want to
retrieve. By default, a public ESI client is returned.
Returns:
esi_client (EsiClient): Client object from esipy.
"""
auth = EsiSecurity(
headers={'User-Agent': client_name},
redirect_uri='https://localhost/callback',
client_id=client_id,
secret_key=secret_key,
)
if refresh_token is not None:
auth.refresh_token = refresh_token
esi_client = EsiClient(
auth,
retry_requests=True,
cache=DictCache(),
headers={'User-Agent': client_name},
)
return esi_client
def setUp(self, urlopen_mock):
# I hate those mock... thx urlopen instead of requests...
urlopen_mock.return_value = open('test/resources/swagger.json')
self.app = App.create('https://esi.tech.ccp.is/latest/swagger.json')
self.security = EsiSecurity(
app=self.app,
redirect_uri=TestEsiSecurity.CALLBACK_URI,
client_id=TestEsiSecurity.CLIENT_ID,
secret_key=TestEsiSecurity.SECRET_KEY,
)
def get_esi_security(token=None):
"""
EsiSecurity is used to refresh and manage EVE Token objects
"""
client = EveClient.get_instance()
esi_security = EsiSecurity(redirect_uri=client.esi_callback_url,
client_id=client.esi_client_id,
secret_key=client.esi_secret_key,
headers={'User-Agent': "Krypted Platform"})
if token:
esi_security.update_token(token.populate())
return esi_security
def get_api(fn, scopes):
esi_app = App.create(
'https://esi.tech.ccp.is/latest/swagger.json?datasource=tranquility')
esi_security = EsiSecurity(
app=esi_app,
redirect_uri='http://localhost:8080/callback',
client_id='0b9ac4978a9a4feba20a7eba4f666a46',
secret_key='odtDKZWZbwbFnBHNXnOhRX50YrU49owBw1qE3v7p',
)
esi_client = EsiClient(retry_requests=True, security=esi_security)
def write_refresh_token(refresh_token, **kwargs):
with open(fn, "w") as f:
f.write(refresh_token)
AFTER_TOKEN_REFRESH.add_receiver(write_refresh_token)
if os.path.isfile(fn):
with open(fn) as f:
token = open(fn).read()
esi_security.update_token({
'access_token': '',
'expires_in': -1,
'refresh_token': token
})
tokens = esi_security.refresh()
else:
print(esi_security.get_auth_uri(scopes=scopes))
tokens = esi_security.auth(input())
write_refresh_token(**tokens)
api_info = esi_security.verify()
return api_info, esi_app, esi_client
def ESIMail(self, KilledCharID):
security = EsiSecurity(
app=self.app,
redirect_uri='http://localhost/callback/',
client_id=GlobalConsts.CLIENTID,
secret_key=GlobalConsts.SECRETKEY,
)
print(security.get_auth_uri(scopes=GlobalConsts.REQUESTSCOPES))
try:
tokens = security.auth(GlobalConsts.CHARAUTHTOKEN)
except:
security.refresh_token = GlobalConsts.CHARREFRESHTOKEN
tokens = security.refresh()
accessToken = tokens[GlobalConsts.TOKENAUTHKEY]
RefreshToken = tokens[GlobalConsts.TOKENREFRESHKEY]
expire_date = datetime.fromtimestamp(
time.time() + tokens[GlobalConsts.TOKENEXPIRESKEY], )
api_info = security.verify()
strCharacterID = api_info['CharacterID']
Response = SendMail(strCharacterID, KilledCharID,
GlobalConsts.DEFAULTMESSAGE, accessToken)
if Response.status_code == GlobalConsts.SUCCESSRESPONSECODE:
print("Sent message to characterid {0}".format(KilledCharID))
else:
print("Failed to send message to characterid {0}".format(
KilledCharID))
def setUp(self):
warnings.simplefilter('ignore')
self.custom_refresh_token_signal = Signal()
with httmock.HTTMock(*_all_auth_mock_):
self.security = EsiSecurity(
redirect_uri=TestEsiSecurity.CALLBACK_URI,
client_id=TestEsiSecurity.CLIENT_ID,
secret_key=TestEsiSecurity.SECRET_KEY,
signal_token_updated=self.custom_refresh_token_signal,
token_identifier=TestEsiSecurity.TOKEN_IDENTIFIER)
self.security_pkce = EsiSecurity(
redirect_uri=TestEsiSecurity.CALLBACK_URI,
client_id=TestEsiSecurity.CLIENT_ID,
code_verifier=TestEsiSecurity.CODE_VERIFIER,
)
with open(TestEsiSecurity.RSC_SSO_ENDPOINTS, 'r') as sso_endpoints:
self.sso_endpoints = json.load(sso_endpoints)
def setUp(self, urlopen_mock):
# I hate those mock... thx urlopen instead of requests...
urlopen_mock.return_value = open('test/resources/swagger.json')
warnings.simplefilter('ignore')
self.app = App.create(
'https://esi.evetech.net/latest/swagger.json'
)
self.security = EsiSecurity(
app=self.app,
redirect_uri=TestEsiPy.CALLBACK_URI,
client_id=TestEsiPy.CLIENT_ID,
secret_key=TestEsiPy.SECRET_KEY,
)
self.cache = DictCache()
self.client = EsiClient(self.security, cache=self.cache)
self.client_no_auth = EsiClient(cache=self.cache, retry_requests=True)
def repeated_verify(security: EsiSecurity,
count: int = 0,
max_count: int = 5) -> Dict:
"""
Calls verify up to max times or untill there is no error
"""
try:
return security.verify()
except APIException as e:
if 'SSO JSON failure' in e.response.decode('utf-8'):
logger.error('SSO JSON Failure, trying workaround...')
resp = security.refresh()
security.signal_token_updated.send(
token_identifier=security.token_identifier, **resp)
if count >= max_count:
logger.exception('Failed to verify because of repeated errors',
exc_info=True)
raise e
else:
return repeated_verify(security, count + 1, max_count)
def setUp(self, urlopen_mock):
# I hate those mock... thx urlopen instead of requests...
urlopen_mock.return_value = open('test/resources/swagger.json')
warnings.simplefilter('ignore')
self.app = App.create('https://esi.evetech.net/latest/swagger.json')
with open(TestEsiPy.RSC_SSO_ENDPOINTS, 'r') as sso_endpoints:
with open(TestEsiPy.RSC_JWKS, "r") as jwks:
self.security = EsiSecurity(
app=self.app,
redirect_uri=TestEsiPy.CALLBACK_URI,
client_id=TestEsiPy.CLIENT_ID,
secret_key=TestEsiPy.SECRET_KEY,
sso_endpoints=json.load(sso_endpoints),
jwks_key=json.load(jwks))
self.cache = DictCache()
self.client = EsiClient(self.security, cache=self.cache)
self.client_no_auth = EsiClient(cache=self.cache, retry_requests=True)
def do_security(tokens_file, scopes):
esi_app = EsiApp(cache=cache, cache_time=0)
app = esi_app.get_latest_swagger
security = EsiSecurity(redirect_uri=redirect_uri,
client_id=client_id,
secret_key=secret_key,
headers=headers)
client = EsiClient(retry_requests=True, headers=headers, security=security)
print("Open link in browser and authorize")
print(security.get_auth_uri(scopes=scopes))
code = input("Enter in code:\n")
tokens = security.auth(code)
print(tokens)
print("\n Writing tokens to " + str(tokens_file))
with open(tokens_file, 'wb') as fp:
pickle.dump(tokens, fp)
fp.close()
def authenticate():
app = App.create(
url="https://esi.tech.ccp.is/latest/swagger.json?datasource=tranquility"
)
security = EsiSecurity(
app=app,
redirect_uri='http://localhost:51350',
client_id=secret['client_id'],
secret_key=secret['secret_key'],
)
client = EsiClient(retry_requests=True,
header={'User-Agent': 'shipLocation'},
security=security)
eve_sso_auth_url = security.get_auth_uri(
scopes=['esi-location.read_ship_type.v1'])
webbrowser.open(eve_sso_auth_url, new=2) # open in a new browser tab
auth_code = fetch_auth_code(
) # fetch authentication code using a temporary web server
tokens = security.auth(auth_code)
return (app, client, security, tokens)
def test_esisecurity_verify(self):
# this is just for coverage purpose. This doesn't work without valid
# jwt token
with self.assertRaises(AttributeError):
self.security.verify()
self.security.update_token({
'access_token': 'access_token',
'refresh_token': 'refresh_token',
'expires_in': 60
})
with self.assertRaises(JWTError):
self.security.verify()
with httmock.HTTMock(*_all_auth_mock_):
with open(TestEsiSecurity.RSC_JWKS, 'r') as jwks:
jwks = json.load(jwks)
security_nojwks = EsiSecurity(
redirect_uri=TestEsiSecurity.CALLBACK_URI,
client_id=TestEsiSecurity.CLIENT_ID,
secret_key=TestEsiSecurity.SECRET_KEY,
jwks_key=jwks['keys'][0])
security_nojwks.update_token({
'access_token': 'access_token',
'refresh_token': 'refresh_token',
'expires_in': 60
})
with self.assertRaises(JWTError):
security_nojwks.verify()
def __init__(self):
self.db = Database()
self.config = Config()
self.scopes = self.config.getConfig()["settings"]["esiScopes"]
self.esi_app = App.create(
url=self.config.getConfig()["settings"]["esiURL"], )
self.security = EsiSecurity(
app=self.esi_app,
redirect_uri=self.config.getConfig()["settings"]["esiCallback"],
client_id=self.config.getConfig()["settings"]["esiClientID"],
secret_key=self.config.getConfig()["settings"]["esiSecretKey"],
headers={
'User-Agent':
self.config.getConfig()["settings"]["esiCustomHeader"]
})
self.client = EsiClient(
security=self.security,
retry_requests=True,
headers={
'User-Agent':
self.config.getConfig()["settings"]["esiCustomHeader"]
})
def setup_esi(app_id, app_secret, refresh_token, cache=DictCache()):
"""Set up the ESI client
Args:
app_id (string): SSO Application ID from CCP
app_secret (string): SSO Application Secret from CCP
refresh_token (string): SSO refresh token
cache (False, optional): esipy.cache instance
Returns:
tuple: esi app definition, esi client
>>> setup_esi(CONFIG['SSO_APP_ID'], CONFIG['SSO_APP_KEY'],
... CONFIG['SSO_REFRESH_TOKEN'], cache) # doctest: +ELLIPSIS
(<pyswagger.core.App object ...>, <esipy.client.EsiClient object ...>)
"""
esi_meta = EsiApp(cache=cache)
esi = esi_meta.get_latest_swagger
esi_security = EsiSecurity(
redirect_uri='http://localhost',
client_id=app_id,
secret_key=app_secret,
headers={'User-Agent': 'https://github.com/eve-n0rman/structurebot'})
esi_security.update_token({
'access_token': '',
'expires_in': -1,
'refresh_token': refresh_token
})
esi_client = EsiClient(
retry_requests=True,
headers={'User-Agent': 'https://github.com/eve-n0rman/structurebot'},
raw_body_only=False,
security=esi_security,
cache=cache)
return (esi, esi_client, esi_security)
def init_esi():
esi_app = App.create(
'https://esi.tech.ccp.is/latest/swagger.json?datasource=tranquility')
esi_security = EsiSecurity(
app=esi_app,
redirect_uri='https://www.msully.net/stuff/get-token',
client_id='fca36d677f9a4b8e8581d8cd2c738c2c',
# 'The "Secret Key" should never be human-readable in your application.'
secret_key=codecs.decode('AIUr5ntWiEIXiavPjKtUCiNFwlvTBlJqmElgAk4x',
'rot_13'),
)
esi_client = EsiClient(esi_security)
return ESI(esi_app, esi_security, esi_client)
def who_am_i(token: SSOToken) -> Dict:
signal = Signal()
signal.add_receiver(token_argument_update_cb)
security: EsiSecurity = EsiSecurity(
'',
config.crest_client_id,
config.crest_client_secret,
headers={'User-Agent': config.user_agent},
signal_token_updated=signal,
token_identifier=token.tokenID)
security.update_token(token.info_for_esi_security())
return repeated_verify(security)
def save(self, *args, **kwargs):
if EveClient.objects.all():
EveClient.objects.all()[0].delete()
self.esi_sso_url = EsiSecurity(
client_id=self.esi_client_id,
redirect_uri=self.esi_callback_url,
secret_key=self.esi_secret_key,
headers={
'User-Agent': "Krypted Platform"
}).get_auth_uri(scopes=EveScope.get_formatted_scopes(),
state=self.esi_client_id)
super(EveClient, self).save(*args, **kwargs)
def authorize(code: str) -> Dict:
"""
Get SSO tokens using an SSO auth code.
:param code: SSO auth code for getting the tokens
:returns a Dict containing 'access_token', 'refresh_token', 'expires_in'
"""
security: EsiSecurity = EsiSecurity(
'',
config.crest_client_id,
config.crest_client_secret,
headers={'User-Agent': config.user_agent})
return security.auth(code)
import logging
from flask import Flask, render_template, request, flash, redirect, url_for
from esipy import App, EsiClient, EsiSecurity
from lib import CharacterExplorer, all_esi_read_scopes
app = Flask(__name__)
app.config.from_json('config.json')
esi_headers = {'User-Agent': 'EVE Character Explorer | [email protected]'}
esi_app = App.create(
'https://esi.tech.ccp.is/latest/swagger.json?datasource=tranquility')
esi_security = EsiSecurity(app=esi_app,
client_id=app.config['CLIENT_ID'],
secret_key=app.config['SECRET_KEY'],
redirect_uri=app.config['REDIRECT_URI'],
headers=esi_headers)
esi_client = EsiClient(security=esi_security, headers=esi_headers)
@app.route('/')
def index():
return render_template(
'index.html',
sso_go=esi_security.get_auth_uri(scopes=all_esi_read_scopes))
@app.route('/view', methods=['POST'])
def view():
token = request.form.get('refresh_token')
import json
from esipy import App
from esipy import EsiClient
from esipy import EsiSecurity
app = App.create(url="https://esi.tech.ccp.is/latest/swagger.json?datasource=tranquility")
# replace the redirect_uri, client_id and secret_key values
# with the values you get from the STEP 1 !
security = EsiSecurity(
app=app,
redirect_uri='your uri',
client_id='your id',
secret_key='your key',
)
# and the client object, replace the header user agent value with something reliable !
client = EsiClient(
retry_requests=True,
headers={'User-Agent': 'your app name'},
security=security
)
# import scope
# with open ('scopes', 'rb') as fp:
# scopeslist = pickle.load(fp)
sscp = app.root._Swagger__securityDefinitions['evesso']._SecurityScheme__scopes
def invalidate(self, key):
cache.delete(_hash(key))
lbcache = LbCache()
transport_adapter = HTTPAdapter(
pool_connections=20,
pool_maxsize=300,
)
# ESI objects to be imported
esiapp = EsiApp(cache=lbcache, cache_time=0, datasource=config.ESI_DATASOURCE)
esisecurity = EsiSecurity(
app=esiapp.get_latest_swagger,
redirect_uri="%s%s" % (
config.ESI_REDIRECT_DOMAIN,
'/sso/callback',
),
client_id=config.ESI_CLIENT_ID,
secret_key=config.ESI_SECRET_KEY,
)
esiclient = EsiClient(security=esisecurity,
transport_adapter=transport_adapter,
cache=lbcache,
headers={'User-Agent': config.ESI_USER_AGENT})
# register observers
AFTER_TOKEN_REFRESH.add_receiver(token_update_observer)
app = Flask(__name__)
if __name__ == '__main__':
config = {}
execfile("config.conf",config)
serverIP = config['serverIP']
serverPort = config['serverPort']
debug = config['debug']
app.secret_key = config['appKey']
esi_app = App.create('https://esi.tech.ccp.is/latest/swagger.json?datasource=tranquility')
security = EsiSecurity(
app=esi_app,
redirect_uri=config['callbackURL'],
client_id=config['clientID'],
secret_key=config['secretKey']
)
client = EsiClient(security=security)
scopes = ['esi-location.read_location.v1']
#Example route to show how to grab data from ESI
@app.route('/getLocation')
def location():
if 'char' in session:
security.update_token(session['token'])
security.refresh()
verif = security.verify()
charID = verif.get('CharacterID')
charLocation = esi_app.op['get_characters_character_id_location'](character_id=charID)
@login_manager.user_loader
def load_user(character_id):
""" Required user loader for Flask-Login """
return User.query.get(character_id)
# -----------------------------------------------------------------------
# ESIPY Init
# -----------------------------------------------------------------------
# create the app
esiapp = App.create(config.ESI_SWAGGER_JSON)
# init the security object
esisecurity = EsiSecurity(
app=esiapp,
redirect_uri=config.ESI_CALLBACK,
client_id=config.ESI_CLIENT_ID,
secret_key=config.ESI_SECRET_KEY,
)
# init the client
esiclient = EsiClient(security=esisecurity,
cache=None,
headers={'User-Agent': config.ESI_USER_AGENT})
# -----------------------------------------------------------------------
# Login / Logout Routes
# -----------------------------------------------------------------------
def generate_token():
"""Generates a non-guessable OAuth token"""
chars = ('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789')
from esipy import App, EsiClient, EsiSecurity
from esipy.exceptions import APIException
from .settings import ESI_URL, ESI_CONNECT_IMG_BAR, ESI_CLIENT_ID, ESI_SECRET_KEY, ESI_CALLBACK_URL, ESI_SCOPES
esi_app = App.create(ESI_URL)
esi_security = EsiSecurity(app=esi_app,
redirect_uri=ESI_CALLBACK_URL,
client_id=ESI_CLIENT_ID,
secret_key=ESI_SECRET_KEY)
esi_client = EsiClient(security=esi_security)
esi_scopes = ESI_SCOPES
esi_secure = esi_security.get_auth_uri(scopes=esi_scopes)
esi_secure_url = "<a href='" + esi_secure + "'><img src='" + ESI_CONNECT_IMG_BAR + "'></a>"
def esi_update_token(request):
esi_security.update_token(request.session['token'])
def esi_refresh_verify(request):
esi_security.update_token(request.session['token'])
esi_security.refresh()
return esi_security.verify()
def esi_verify():
return esi_security.verify()
from esipy import App
from esipy import EsiClient
from esipy import EsiSecurity
from flask import Flask, request
CLIENT_ID = ''
SECRET_KEY = ''
SCOPES = ['esi-universe.read_structures.v1', 'esi-markets.structure_markets.v1']
app = Flask(__name__)
esi_app = App.create(url="https://esi.tech.ccp.is/latest/swagger.json?datasource=tranquility")
security = EsiSecurity(
app=esi_app,
redirect_uri='http://127.0.0.1:5000/ESICallback',
client_id=CLIENT_ID,
secret_key=SECRET_KEY
)
client = EsiClient(
retry_requests=True,
header={'User-Agent': 'ESI Token Fetcher'},
security=security
)
webbrowser.open_new(security.get_auth_uri(scopes=SCOPES))
@app.route('/ESICallback')
def esi_callback():
code = request.args.get('code', '')
