def get_redirect_url(self, *args, **kwargs):
"""
Redirects user to relative social auth provider for logout process.
In-case no auth provider is found or the logout_url is missing in provider's configurations
the user is redirected to edX's default logout page '/logout'
"""
backend_name = getattr(settings, 'COLARAZ_AUTH_PROVIDER_BACKEND_NAME',
None)
if third_party_auth.is_enabled(
) and backend_name and self.request.session.has_key('id_token'):
provider = [
enabled
for enabled in third_party_auth.provider.Registry.enabled()
if enabled.backend_name == backend_name
]
if provider:
logout_url = json.loads(
getattr(provider[0], 'other_settings',
'{}')).get('logout_url')
if logout_url:
redirect_to = self.request.META.get(
'HTTP_REFERER') or get_site_base_url(self.request)
params = {
'id_token_hint': self.request.session['id_token'],
'post_logout_redirect_uri': redirect_to
}
req = PreparedRequest()
req.prepare_url(logout_url, params)
return req.url
return reverse('logout')
def _call_api(self, method, path, params=None, data=None):
"""Execute an API request.
Arguments:
method (str): HTTP request type
path (str): API request path
data (dict): Data to send in dictionary format
Returns:
Response: The requests response object
"""
url = 'https://{}/api/{}'.format(self._host, path)
if params:
req = PreparedRequest()
req.prepare_url(url, params)
url = req.url
if self._session is None:
self.connect()
response = self._session.request(method=method,
url=url,
json=data,
verify=self._verify_ssl,
timeout=self._timeout)
try:
response.raise_for_status()
return response
# TODO CHECK FOR TOKEN EXPIRATION
except Exception as exception:
raise exception
def test_prepared_copy(kwargs):
p = PreparedRequest()
if kwargs:
p.prepare(**kwargs)
copy = p.copy()
for attr in ('method', 'url', 'headers', '_cookies', 'body', 'hooks'):
assert getattr(p, attr) == getattr(copy, attr)
def _call_api(self, http_func, host, path, data, headers, timeout=None):
url = "{host}{path}".format(host=host, path=path)
begin = time.time()
# add extra params in url if not empty
if self._extra_url_params:
preReq = PreparedRequest()
preReq.prepare_url(url, self._extra_url_params)
url = preReq.url
ok, message, _data = http_func(url,
data,
headers=headers,
timeout=timeout)
if logger.isEnabledFor(logging.DEBUG):
logger.debug("do http request: method=`%s`, url=`%s`, data=`%s`",
http_func.__name__, url, json.dumps(data))
logger.debug(
"http request result: ok=`%s`, message=`%s`, _data=`%s`", ok,
message, json.dumps(_data))
logger.debug("http request took %s ms",
int((time.time() - begin) * 1000))
if not ok:
return False, message or "verify from iam server fail", None
if _data.get("code") != 0:
return False, _data.get("message") or "iam api fail", None
_d = _data.get("data")
return True, "ok", _d
def getAthleteName(name):
name = name.replace(" ", "_")
request = PreparedRequest()
request.prepare_url("https://en.wikipedia.org/wiki/", name)
url_link = "https://en.wikipedia.org/wiki/" + name
return name, url_link
def _get_response(self, url, data):
req = PreparedRequest()
req.prepare_url(url, data)
result = requests.get(unquote(req.url)).content
logging.warn('-getresponse')
logging.warn(result)
return True
def send_reset_email(user, token):
# user = user_service.get_a_user(public_id)
req = PreparedRequest()
host = request.host_url
req.prepare(url=f'{host}password_reset',
params={
'user': user.public_id,
'auth': token
})
if current_app.config['TESTING']:
return req.url
file = rel_path('../util/password-reset.html', __file__)
with open(file) as f:
html_template = Template(f.read())
html = html_template.render(
link=req.url,
host=host,
header='Reset Your Password',
name=user.name_first,
body="Tap the button below to reset your password. "
"If you didn't request a new password, you can safely delete this email.",
button_text="Reset Password",
)
email_text = MIMEText(html, 'html')
send_email(user.email, email_text, "Reset your password")
if current_app.config['DEBUG']:
return req.url
def confirm_sign_up():
from chalicelib.main import app, USER_POOL_ID, COGNITO_CLIENT_ID
confirmation_code = app.current_request.query_params["code"]
username = app.current_request.query_params["username"]
user = cognito_idp_client.admin_get_user(UserPoolId=USER_POOL_ID,
Username=username)
redirect_url = "http://chinmayamission.com"
for attribute in user["UserAttributes"]:
if attribute["Name"] == "website":
redirect_url = attribute["Value"]
try:
# Exceptions: https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_ConfirmSignUp.html
cognito_idp_client.confirm_sign_up(
ClientId=COGNITO_CLIENT_ID,
Username=username,
ConfirmationCode=confirmation_code,
)
except Exception as e:
params = {
"confirmSignupErrorMessage": e.response["Error"]["Message"],
"confirmSignupErrorCode": e.response["Error"]["Code"],
}
# Use PreparedRequest so it preserves the existing query string in redirect_url
req = PreparedRequest()
req.prepare_url(redirect_url, params)
return Response(status_code=302,
body="",
headers={"Location": req.url})
return Response(status_code=302,
body="",
headers={"Location": redirect_url})
def f(
method="GET",
url="http://mockapi.com",
headers=None,
files=None,
data=None,
params=None,
auth=None,
cookies=None,
hooks=None,
json=None,
) -> PreparedRequest:
request = PreparedRequest()
request.prepare(
method=method,
url=url,
headers=headers,
files=files,
data=data,
params=params,
auth=auth,
cookies=cookies,
hooks=hooks,
json=json,
)
return request
def generate_form_link(pid, account, amount, comment):
"""
Создание автозаполненной платежной формы
Parameters
----------
pid : str
ID провайдера
account : str
Счет получателя
amount : float
Сумма платежа
comment : str
Комментарий
Returns
-------
str
Ссылка
"""
url = "https://qiwi.com/payment/form/{0}".format(pid)
params = {"currency": 643}
if type(amount) == float:
params['amountInteger'] = str(amount).split('.')[0]
params['amountFraction'] = str(amount).split('.')[1]
else:
params['amountInteger'] = amount
from urllib.parse import urlencode
if comment:
params['comment'] = urlencode(comment)
if account:
params['account'] = urlencode(account)
return PreparedRequest().prepare_url(url, params).url
def _search(query: str):
url = "https://www.googleapis.com/youtube/v3/search"
results = []
params = {'key': token, 'part': 'snippet', 'q': query, 'maxResults': 15}
req = PreparedRequest()
req.prepare_url(url, params)
json = requests.get(req.url).json()
ids = []
for item in json['items']:
videoId = item['id'].get('videoId')
playlistId = item['id'].get('playlistId')
if (not videoId and not playlistId): continue
results.append({
'id': videoId if videoId != None else playlistId,
'title': html.unescape(item['snippet']['title']),
'isPlaylist': playlistId != None
})
if (videoId):
ids.append(videoId)
durations = get_video_durations(ids)
for i in range(len(results)):
item = results[i]
if (not item['isPlaylist']):
item['duration'] = durations[item['id']]
return results
def send_verify_email(user, token):
req = PreparedRequest()
host = request.host_url
req.prepare(url=f'{host}verify',
params={
'user': user.public_id,
'auth': token
})
if current_app.config['TESTING']:
return req.url
file = rel_path('../util/password-reset.html', __file__)
with open(file) as f:
html_template = Template(f.read())
html = html_template.render(
link=req.url,
host=host,
header='Verify Your Account',
name=user.name_first,
body=
"Tap the button below to verify your account, the link expires within 30 minutes.",
button_text="Verify Account",
)
email_text = MIMEText(html, 'html')
send_email(user.email, email_text, "Verify your account")
if current_app.config['DEBUG']:
return req.url
def search():
meta = get_meta()
filters = get_filters()
# get counts
count_total = query(count_all=True)
count_filtered = query(filters=filters, count_filtered=True)
# build response
results = query(meta=meta, filters=filters)
headers = {
"Query-Count-Total": str(count_total),
"Query-Count-Filtered": str(count_filtered),
"Cache-Control": "max-age=259200",
"Access-Control-Expose-Headers": "Query-Count-Total, Query-Count-Filtered, Query-Next"
}
if count_filtered > meta["page"] * meta["limit"]:
next_url_params = {
'page': str(meta["page"] + 1),
'page_size': str(meta["limit"]),
'order_by': meta["order_by"],
'order_by_direction': meta["order_by_direction"]
}
next_url_params.update(filters)
next_request = PreparedRequest()
next_request.prepare_url(request.base_url, next_url_params)
headers['Query-Next'] = next_request.url
return Response(result_generator(results), headers=[(k, v) for k, v in headers.iteritems()],
mimetype='text/csv')
def check_url(url):
prepared_request = PreparedRequest()
try:
prepared_request.prepare_url(url, None)
return True
except requests.exceptions.MissingSchema:
return False
def is_valid_url(url):
prepared_request = PreparedRequest()
try:
prepared_request.prepare_url(url, None)
return True
except Exception as e:
return False
def test_prepared_request_no_cookies_copy():
p = PreparedRequest()
p.prepare(method='GET',
url='http://www.example.com',
data='foo=bar',
hooks=default_hooks())
assert_copy(p, p.copy())
def scrapeYahoo(season, week, position):
url = 'https://football.fantasysports.yahoo.com/f1/47241/players'
drop_cols = [
0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 13, 17, 19, 20, 24, 25, 30, 31, 32, 33,
34, 35, 36, 37
]
col_names = [
'name', 'pass_att', 'pass_comp', 'pass_yds', 'pass_td', 'pass_int',
'pass_sack', 'rush_att', 'rush_yds', 'rush_td', 'rec_tgt', 'rec_rec',
'rec_yds', 'rec_td'
]
all_players = pd.DataFrame(columns=col_names)
for count in range(0, 300, 25):
querystring = {
'sort': 'PTS',
'sdir': '1',
'status': 'A',
'pos': '{}'.format(position),
'stat1': 'S_PW_{}'.format(week),
'jsenabled': '0',
'count': '{}'.format(count)
}
req = PreparedRequest()
req.prepare_url(url, querystring)
tables = pd.read_html(req.url)
players = tables[1]
players.drop(players.columns[drop_cols], axis=1, inplace=True)
players.columns = col_names
players['name'] = players['name'].apply(name_cleanup)
if len(players) == 0:
break
all_players = all_players.append(players, ignore_index=True)
return all_players
def drop_params_from_url(url,
params,
drop_keys,
assert_param_is_present=False):
out_url = ""
try:
pre_req = PreparedRequest()
pre_req.prepare_url(url, params)
u = urlparse(pre_req.url)
current_params = parse_qs(u.query)
if assert_param_is_present:
keys_diff = set(drop_keys) - set(current_params)
assert keys_diff == set(), f"Keys not present : {keys_diff}"
final_params = {
k: v
for k, v in current_params.items() if k not in drop_keys
}
current_url = u._replace(params="")._replace(query="")._replace(
fragment="").geturl()
pre_req.prepare_url(current_url, final_params)
out_url = pre_req.url
except Exception as e:
print(f"\n Exception occured: {e}!! \n URL: {url} \n PARAMS: {params}")
return out_url
def addParamsToUrl(self, url: str, params: dict) -> str:
"""
Belirtilen parametreleri adrese ekler.
"""
req = PreparedRequest()
req.prepare_url(url, params)
return req.url
def append_params_to_url(DO_WE_ADD_PARAMS_REUPLOAD, url): ## Used for appending random strings as query parameters to URLS in the reposting module. This gives a unique variation of the URL.
if DO_WE_ADD_PARAMS_REUPLOAD:
params = {random_char(5):random_char(5)}
req = PreparedRequest()
req.prepare_url(url, params)
return req.url
else:
return url
def apipara(a):
req = PreparedRequest()
url = "http://integra-net4/BMJ_ICE_Test/assignjob"
params = {'ID': a}
req.prepare_url(url, params)
content = urllib.request.urlopen(req.url).read()
data = json.loads(content)
return data['success'], data['msg']
def get_screenshot(
self,
url: str,
element_name: str,
user: "******",
) -> Optional[bytes]:
params = {"standalone": DashboardStandaloneMode.REPORT.value}
req = PreparedRequest()
req.prepare_url(url, params)
url = req.url or ""
driver = self.auth(user)
driver.set_window_size(*self._window)
driver.get(url)
img: Optional[bytes] = None
selenium_headstart = current_app.config[
"SCREENSHOT_SELENIUM_HEADSTART"]
logger.debug("Sleeping for %i seconds", selenium_headstart)
sleep(selenium_headstart)
try:
logger.debug("Wait for the presence of %s", element_name)
element = WebDriverWait(driver,
self._screenshot_locate_wait).until(
EC.presence_of_element_located(
(By.CLASS_NAME, element_name)))
logger.debug("Wait for .loading to be done")
WebDriverWait(driver, self._screenshot_load_wait).until_not(
EC.presence_of_all_elements_located(
(By.CLASS_NAME, "loading")))
logger.debug("Wait for chart to have content")
WebDriverWait(driver, self._screenshot_locate_wait).until(
EC.visibility_of_all_elements_located(
(By.CLASS_NAME, "slice_container")))
selenium_animation_wait = current_app.config[
"SCREENSHOT_SELENIUM_ANIMATION_WAIT"]
logger.debug("Wait %i seconds for chart animation",
selenium_animation_wait)
sleep(selenium_animation_wait)
logger.info("Taking a PNG screenshot of url %s", url)
img = element.screenshot_as_png
except TimeoutException:
logger.warning("Selenium timed out requesting url %s",
url,
exc_info=True)
img = element.screenshot_as_png
except StaleElementReferenceException:
logger.error(
"Selenium got a stale element while requesting url %s",
url,
exc_info=True,
)
except WebDriverException as ex:
logger.error(ex, exc_info=True)
finally:
self.destroy(driver,
current_app.config["SCREENSHOT_SELENIUM_RETRIES"])
return img
def prepare_param_discovery_urls(self, base_url):
"""
For given URL generates bunch of parameter discovery URLs with
canaries and returns this information back.
"""
PARAM_SEP_LEN = 2
CANARY_LEN = self.CANARY_LENGTH
url_len = len(base_url)
discovery_urls = []
param_dict = {}
canary_dict = {}
try:
with open('payloads/parameters.txt', 'r') as f:
param_list = f.read().splitlines()
self.url_discovery_parameters = param_list
except IOError as e:
self.mprint("[ERROR] Unable to open payloads/parameters.txt.")
self.fprint(e)
return
for param in param_list:
if (url_len + len(param) + PARAM_SEP_LEN +
CANARY_LEN) < self.MAX_ACCEPTED_URL_LENGTH:
# URL Character limit not exceeded yet.
canary = utils.get_rnd_string(CANARY_LEN)
param_dict[param] = canary
canary_dict[param] = canary
url_len += (PARAM_SEP_LEN + len(param) + CANARY_LEN)
else:
# Add to URLs, start preparing a new one.
r = PreparedRequest()
r.prepare_url(base_url, param_dict)
discovery_urls.append(r.url)
param_dict = {}
url_len = len(base_url)
# Leftovers after depleting all parameters from paramlist.
if len(param_dict) != 0:
r = PreparedRequest()
r.prepare_url(base_url, param_dict)
discovery_urls.append(r.url)
return (discovery_urls, canary_dict)
def add_params_to_url(url, params):
out_url = ""
try:
req = PreparedRequest()
req.prepare_url(url, params)
out_url = req.url
except Exception as e:
print(f"\n Exception occured: {e}!! \n URL: {url} \n PARAMS: {params}")
return out_url
def check_url(url):
prepared_request = PreparedRequest(
) # create an instance of the PreparedRequest class of the requests library
try:
prepared_request.prepare_url(url,
None) # checking for the correct of url
return True
except:
return False
def apipara(a):
req = PreparedRequest()
url = "any url"
params = {'ID':a}
req.prepare_url(url, params)
content = urllib.request.urlopen(req.url).read()
data = json.loads(content)
print(data['success'])#I Extract json content
print(data['msg'])#I Extract json content
def validate_url(text: str):
"""
Validates a URL.
"""
prepared_request = PreparedRequest()
try:
prepared_request.prepare_url(text, None)
return True
except MissingSchema:
return False
def session_check(session_id):
if 'uuid' in session and session['uuid'] == session_id:
session['valid'] = True
return redirect(request.args.get('follow'), code=307)
else:
follow_url = request.args.get('follow')
req = PreparedRequest()
req.prepare_url(follow_url, {'cookies_disabled': 1})
session.pop('_permanent', None)
return redirect(req.url, code=307)
def test_data_argument_accepts_tuples(data):
"""Ensure that the data argument will accept tuples of strings
and properly encode them.
"""
p = PreparedRequest()
p.prepare(method='GET',
url='http://www.example.com',
data=data,
hooks=default_hooks())
assert p.body == urlencode(data)
def get_order_requirements(
did: str,
service_endpoint: str,
consumer_address: str,
service_id: Union[str, int],
service_type: str,
token_address: str,
userdata: Optional[Dict] = None,
) -> Optional[OrderRequirements]:
"""
:param did:
:param service_endpoint:
:param consumer_address: hex str the ethereum account address of the consumer
:param service_id:
:param service_type:
:param token_address:
:return: OrderRequirements instance -- named tuple (amount, data_token_address, receiver_address, nonce),
"""
req = PreparedRequest()
params = {
"documentId": did,
"serviceId": service_id,
"serviceType": service_type,
"dataToken": token_address,
"consumerAddress": consumer_address,
}
if userdata:
userdata = json.dumps(userdata)
params["userdata"] = userdata
req.prepare_url(service_endpoint, params)
initialize_url = req.url
logger.info(f"invoke the initialize endpoint with this url: {initialize_url}")
response = DataServiceProvider._http_method("get", initialize_url)
# The returned json should contain information about the required number of tokens
# to consume `service_id`. If service is not available there will be an error or
# the returned json is empty.
if response.status_code != 200:
return None
order = dict(response.json())
return OrderRequirements(
to_wei(
Decimal(order["numTokens"])
), # comes as float, needs to be converted
order["dataToken"],
order["to"],
int(order["nonce"]),
order.get("computeAddress"),
)
