def sign_in(self, email, password):
"""Called when the "Log in" button is pressed.
Sends the user's email and password in an HTTP request to the Firebase
Authentication service.
"""
if self.debug:
print("Attempting to sign user in: ", email, password)
sign_in_url = "https://www.googleapis.com/identitytoolkit/v3/relyingparty/verifyPassword?key=" + self.web_api_key
sign_in_payload = dumps({
"email": email,
"password": password,
"returnSecureToken": True
})
UrlRequest(sign_in_url,
req_body=sign_in_payload,
on_success=self.successful_login,
on_failure=self.sign_in_failure,
on_error=self.sign_in_error,
ca_file=certifi.where())
def load_players_config(self):
app = App.get_running_app()
if not os.path.exists(CACHE_DIR):
os.makedirs(CACHE_DIR)
with open("players.json", "r") as fp:
config = json.load(fp)
self._config = config
app.user_config['zp_cookie'] = config.get("cookie")
for player_id in self._config["users"]:
player = Player(player_id)
self.players[player_id] = player
UrlRequest('http://127.0.0.1:3030/watch/add',
on_error=self._log_it,
req_headers={'Content-Type': 'application/json'},
req_body=json.dumps({"id": player_id}))
def test_ca_file(kivy_clock, scheme):
"""Passing a `ca_file` should not crash on http scheme, refs #6946"""
from kivy.network.urlrequest import UrlRequest
import certifi
obj = UrlRequestQueue([])
queue = obj.queue
req = UrlRequest(f"{scheme}://httpbin.org/get",
on_success=obj._on_success,
on_progress=obj._on_progress,
on_error=obj._on_error,
on_redirect=obj._on_redirect,
ca_file=certifi.where(),
debug=True)
wait_request_is_finished(kivy_clock, req)
if req.error and req.error.errno == 11001:
pytest.skip('Cannot connect to get address')
ensure_called_from_thread(queue)
check_queue_values(queue)
def sign_up(self, email, password):
"""If you don't want to use Firebase, just overwrite this method and
do whatever you need to do to sign the user up with their email and
password.
"""
if self.debug:
print("Attempting to create a new account: ", email, password)
signup_url = "https://www.googleapis.com/identitytoolkit/v3/relyingparty/signupNewUser?key=" + self.web_api_key
signup_payload = dumps({
"email": email,
"password": password,
"returnSecureToken": True
})
UrlRequest(signup_url,
req_body=signup_payload,
on_success=self.successful_login,
on_failure=self.sign_up_failure,
on_error=self.sign_up_error,
ca_file=certifi.where())
def update_cb(self):
def _lookup_rate(response, quote_id):
return decimal.Decimal(str(response[str(quote_id)]))
def on_success(request, response):
quote_currencies = {}
try:
for r in response:
if r[:7] == "btc_to_":
quote_currencies[r[7:].upper()] =\
_lookup_rate(response, r)
self.quote_currencies = quote_currencies
except KeyError:
pass
self.parent.set_currencies(quote_currencies)
req = UrlRequest(
url='https://coinbase.com/api/v1/currencies/exchange_rates',
on_success=on_success,
timeout=5)
def start_transaction(self):
info = {
"uid": "user1",
"currency": "ZAR",
"locale": "en-za",
"country": "ZAF",
"pay_method": "CC",
"email": "*****@*****.**"
}
headers = {
'Content-type': 'application/json',
'Accept': 'application/json'
}
UrlRequest(
f"{BASE_URL}/start-transaction",
req_body=json.dumps(info),
req_headers=headers,
on_success=self.on_start_transaction_success,
on_error=self.on_start_transaction_error,
)
def send_data(self, on_success, send_data):
if on_success == None:
on_success = self.__on_success__
data = urllib.urlencode(send_data)
headers = {
'Content-type': 'application/x-www-form-urlencoded',
'Accept': 'text/json'
}
r = UrlRequest(self.url,
on_success=on_success,
req_body=data,
req_headers=headers,
method="POST",
on_failure=self.got_fail,
on_error=self.got_error,
debug=True,
on_redirect=self.got_redirect)
if wait:
r.wait()
def update_wd(self):
def on_success(request, response):
response = json.loads(response)
quote_currencies = {'USD': 0.0}
lenprices = len(response["prices"])
usdprice = response['prices'][lenprices-1]['y']
try:
quote_currencies["USD"] = decimal.Decimal(usdprice)
except KeyError:
pass
self.quote_currencies = quote_currencies
self.parent.set_currencies(quote_currencies)
req = UrlRequest(
url='https://winkdex.com/static/data/0_600_288.json',
on_success=on_success,
timeout=5)
def ws_call(self, *parms, callback=None):
"""Call the web service"""
url = str(parms[0])
try:
url += '&p=%s' % parms[1]
except:
pass
try:
url += '&v=%s' % parms[2]
except:
pass
try:
url += '&w=%s' % parms[3]
except:
pass
#print(cmd_url % url)
if ENABLE_LOGGING:
Logger.info("Calling: %s" % (cmd_url % url))
return UrlRequest(cmd_url % url, callback)
def search_term(self, term, engine, page):
engines = {
'met': ('http://www.metmuseum.org/'
'collection/the-collection-online/search'
'?ft={term}&ao=on&rpp={rpp}&pg={page}'),
'getty':
('http://search.getty.edu/'
'gateway/search'
'?q={term}&cat=highlight&f="Open+Content+Images"&rows={rpp}&srt=&dir=s&dsp=0&img=0&pg={page}'
)
}
url = engines[engine].format(term=term,
rpp=self.config.get(
'search', 'search_rpp'),
page=page)
clean_url = urllib.quote(url, safe="%/:=&?~#+!$,;'@()*[]")
UrlRequest(clean_url, on_success=self.parse_results, debug=True)
def request_download_file(self, url, path):
"""
:type url: str;
:param url: link to content;
:type path: str;
:param path: path to save content;
"""
self.request = UrlRequest(
url,
file_path=path,
chunk_size=102400,
on_progress=self.update_progress,
on_success=self.handle_success,
on_redirect=self.handle_redirect,
on_error=lambda req, error: self.handle_error(req, error),
on_failure=lambda req, res: self.handle_error(req, "Failure"),
on_cancel=lambda req: self.handle_error(req, "Cancelled"),
)
def refresh(self, *args):
def change_actions(request, result):
self.actions = result
self.displaybox.refresh()
def get_actions(request, result):
ids = result
headers = {'Content-type': 'application/json'}
body = dumps({'command': 'get_actions', 'ids': ids})
req = UrlRequest(url=self.server,
on_success=change_actions,
req_body=body,
req_headers=headers)
def change_infos(request, result):
self.infos = result
headers = {'Content-type': 'application/json'}
body = dumps({'command': 'get_list_ids', 'list': 'actions'})
req = UrlRequest(url=self.server,
on_success=get_actions,
req_body=body,
req_headers=headers)
def get_infos(request, result):
ids = result
headers = {'Content-type': 'application/json'}
body = dumps({'command': 'get_infos', 'ids': ids})
req = UrlRequest(url=self.server,
on_success=change_infos,
req_body=body,
req_headers=headers)
headers = {'Content-type': 'application/json'}
body = dumps({'command': 'get_list_ids', 'list': 'informations'})
req = UrlRequest(url=self.server,
on_success=get_infos,
req_body=body,
req_headers=headers)
def on_enter(self, *args):
user = self.manager.ids.sc1.display.text
print(user)
def bug_posted(x, result):
print('An error is detected', result['comment'])
label = self.ids['labeltext']
label.text = result['comment']
x = UrlRequest(f"https://codeforces.com/api/user.info?handles={user}",
on_failure=bug_posted,
ca_file=cfi.where(),
verify=True)
x.wait()
try:
rating = x.result['result'][0]['rating']
print(rating)
label = self.ids['labeltext']
label.text = f"User {user} rating is {rating}"
except:
print("Already given error report")
def hit_cloud_function(self, blob_name):
try:
from urllib.parse import urlencode
msg_data = urlencode({'message': blob_name})
headers = {
'Content-type': 'application/x-www-form-urlencoded',
'Accept': 'text/plain'
}
print("Sending trigger request")
trigger_url = "https://us-central1-endless-theorem-297112.cloudfunctions.net/detect_handwriting"
UrlRequest(trigger_url,
req_body=msg_data,
req_headers=headers,
ca_file=certifi.where(),
on_failure=self.error,
on_error=self.error,
on_success=self.success)
except:
pass
def showbookmarks(self):
self.cur = -1
self.ids.acc.clear_widgets()
conn = sqlite3.connect("signup.db")
c = conn.cursor()
user = (list(c.execute("Select * from register")))
conn.commit()
c.close()
if len(user):
self.userToken = user[0][0]
str_signup = 'http://20.0.0.94:4000/bookmark/getall'
headers = {
'Content-type': 'application/x-www-form-urlencoded',
'Accept': 'text/plain'
}
Json_obj1_SignUp = {'userToken': self.userToken}
params = urllib.parse.urlencode(Json_obj1_SignUp)
req = UrlRequest(str_signup,
on_success=self.showIt,
req_body=params,
req_headers=headers)
def createinvoice(self, sessionid):
print("Create invoice")
print(self.sessionid)
session_id = self.sessionid
print(session_id)
print("http-start")
params = urllib.urlencode({'sessionid': sessionid})
headers = {
'Content-type': 'application/x-www-form-urlencoded',
'Accept': 'text/plain'
}
self.request = UrlRequest('https://www.myinv.org/api/getsupplierdata',
req_body=params,
req_headers=headers,
on_success=self.sessionid_validate,
on_failure=self.fail,
on_error=self.error,
method='POST',
verify=False)
def reset_password(self, email):
"""Called when the "Reset password" button is pressed.
Sends an automated email on behalf of your Firebase project to the user
with a link to reset the password. This email can be customized to say
whatever you want. Simply change the content of the template by going to
Authentication (in your Firebase project) -> Templates -> Password reset
"""
if self.debug:
print("Attempting to send a password reset email to: ", email)
reset_pw_url = "https://www.googleapis.com/identitytoolkit/v3/relyingparty/getOobConfirmationCode?key=" + self.web_api_key
reset_pw_data = dumps({
"email": email,
"requestType": "PASSWORD_RESET"
})
UrlRequest(reset_pw_url,
req_body=reset_pw_data,
on_success=self.successful_reset,
on_failure=self.sign_in_failure,
on_error=self.sign_in_error)
def refresh_friend_list(self):
to_be_remove = self.parent.ids['FriendListScreen'].ids['ScrollView']
to_be_remove.clear_widgets()
my_id = self.parent.ids['LoginScreen'].account
target = self.parent.ids['FriendListScreen'].ids['ScrollView']
url = f'https://kivypractice.firebaseio.com/{my_id}.json'
result = requests.get(url, timeout=30)
data = json.loads(result.content.decode())
if 'friend' in data.keys():
for k in data['friend']:
url = f'https://kivypractice.firebaseio.com/' + k + '.json'
self.response = UrlRequest(url,
timeout=10,
on_success=partial(
self.get_result, k, target))
else:
pass
def get_gps(device_id, num, street, zipcode, city):
address = quote_plus(num + ", " + street + ", " + city + ", " + zipcode)
format = "json"
params = "search?q=" + address + "&format=" + format
url = "https://nominatim.openstreetmap.org/" + params
headers = {"User-Agent": device_id}
response = UrlRequest(url, req_headers=headers)
while not response.is_finished:
sleep(0.1)
Clock.tick()
# print(f"Lat: {response.result[0]['lat']}, Long: {response.result[0]['lon']}")
if response.result:
return response.result[0]['lat'], response.result[0]['lon']
else:
return None, None
def main():
command = "start"
print("Sending request")
params = urllib.parse.urlencode({
"@number": 12524,
"@type": "issue",
"@action": "show"
})
headers = {
"Content-type": "application/x-www-form-urlencoded",
"Accept": "text/plain"
}
r = UrlRequest(
url=f"http://192.168.0.23/{command}",
req_headers=headers,
on_success=partial(success, command),
on_failure=partial(failure, command),
)
print(str(r))
sleep(1)
def send(self, on_success=None, wait=True):
if on_success == None:
on_success = self.__on_success__
SEND_DATA = {'data': json.dumps(self.qson_sender)}
data = urllib.urlencode(SEND_DATA)
headers = {
'Content-type': 'application/x-www-form-urlencoded',
'Accept': 'text/json'
}
r = UrlRequest(self.url,
on_success=on_success,
req_body=data,
req_headers=headers,
method="POST",
on_failure=self.__got_fail__,
on_error=self.__got_error__,
on_redirect=self.__got_redirect__)
if wait:
r.wait()
def test_auth_auto(self):
if os.environ.get('NONETWORK'):
return
self.queue = []
req = UrlRequest(
'http://*****:*****@httpbin.org/basic-auth/user/passwd',
on_success=self._on_success,
on_progress=self._on_progress,
on_error=self._on_error,
on_redirect=self._on_redirect,
debug=True)
# don't use wait, but maximum 10s timeout
for i in range(50):
Clock.tick()
sleep(.5)
if req.is_finished:
break
self.assertTrue(req.is_finished)
# we should have 2 progress minimum and one success
self.assertTrue(len(self.queue) >= 3)
# ensure the callback is called from this thread (main).
tid = _thread.get_ident()
self.assertEqual(self.queue[0][0], tid)
self.assertEqual(self.queue[-2][0], tid)
self.assertEqual(self.queue[-1][0], tid)
self.assertEqual(self.queue[0][1], 'progress')
self.assertEqual(self.queue[-2][1], 'progress')
self.assertIn(self.queue[-1][1], ('success', 'redirect'))
self.assertEqual(self.queue[-1][2], ({
'authenticated': True,
'user': '******'
}, ))
self.assertEqual(self.queue[0][2][0], 0)
self.assertEqual(self.queue[-2][2][0], self.queue[-2][2][1])
def upload_payslips(self, fn, pb_inc, *args):
def on_success(req, result):
self.pb.value += pb_inc
print("Progressbar is on {0}%".format(self.pb.value))
try:
os.remove(fn)
except OSError:
print(traceback.format_exc())
print "POSScreen.upload_payslips() on_success: no such file or directory"
if self.pb.value >= 99.9:
self.popup.dismiss()
self.parent.parent.parent.update_icon(True)
def on_failure(req, result):
on_error(req, result)
def on_error(req, result):
self.pb.value += pb_inc
print("Progressbar is on {0}%".format(self.pb.value))
if self.pb.value >= 99.9:
self.popup.dismiss()
self.parent.parent.parent.update_icon(False)
try:
print ("POSScreen.upload_payslips()" + fn + ' ' + str(pb_inc))
config = ConfigParser.get_configparser(name='app')
print(config.get('serverconnection', 'server.url'))
saleurl = config.get('serverconnection', 'server.url') + "pos/sale/"
with open(fn) as data_file:
result = json.load(data_file)
file_param = dict([])
file_param['filename'] = fn
result['filename'] = file_param
data_json = json.dumps(result)
headers = {'Content-type': 'application/jsonrequest', 'Accept': 'application/jsonrequest'}
UrlRequest(url=saleurl, on_success=on_success, on_failure=on_failure, on_error=on_error,
req_headers=headers, req_body=data_json)
except Exception:
print(traceback.format_exc())
print "POSScreen.upload_payslips() Error: Could not upload payslip"
def sendOTP ( self , x ):
if( self.otp.text == '1729'):
print("test-value")
token.put(" ", value = "user")
screens.current = "nextScreen"
return
global phoneNumber
params = urllib.urlencode( {"phone_number" : unicode(phoneNumber) , "otp" : unicode(self.otp.text) })
print(params)
headers = {'Content-type':'application/x-www-form-urlencoded'}
req = UrlRequest('https://secure-garden-80717.herokuapp.com/authenticate' , method = "POST" , req_headers = headers , req_body = params)
#req = UrlRequest("https://inputtools.google.com/request" , on_success = success , on_error = error , on_failure = fail , req_body = data)
#print( type( req ) )
#print(params )
print (req.result,unicode("token"),type(unicode("token")))
if ( req.result["success"] ):
screens.current = "nextScreen" # flag=True
else:
self.popup = Popup(title='', content=Label(text='Incorrect OTP,\n Please Check Again'), size_hint=(None, None), size=(400, 400),auto_dismiss=True)
self.popup.open()
def register(self):
if not self.inp_email.text or not self.inp_password.text:
self.action_msg.color = "red"
self.action_msg.text = "Enter email and password"
return
if self.register_attempt:
self.register_btn.text = "Confirm Register"
self.register_btn.color = "red"
self.register_btn.background_color = (255, 255, 255)
self.register_attempt = False
self.switch_clear_button_state()
self.switch_buttons_state({'l': True, 'd': True})
return
self.register_btn.text = "Register"
self.register_btn.color = "white"
self.register_btn.background_color = (1, 1, 1)
self.switch_buttons_state({'r': True, 'c': True, 'l': True})
self.register_attempt = True
self.email = self.inp_email.text
self.password = self.inp_password.text
url = "http://localhost:8000/api/register/"
params = json.dumps({"email": self.email, "password": self.password})
headers = {"Content-Type": "application/json"}
req = UrlRequest(url,
req_headers=headers,
on_success=self.show_action_msg,
on_failure=self.show_action_msg,
on_error=self.show_action_msg,
method='Post',
req_body=params)
self.switch_clear_button_state()
return
def get_server_file_download(self, req_url, callback, file_path):
def update_progress(request, current_size, total_size):
pass
username = self.app.config.get("General", "username")
api_key = self.app.config.get("General", "api_key")
str_cookie = f"API_apiKey={api_key}; BCR_username={username}"
head = {
"Content-Type": "application/json",
"Accept": "application/json",
"Cookie": str_cookie,
}
req = UrlRequest(
req_url,
req_headers=head,
on_success=callback,
on_error=self.got_error,
on_redirect=self.got_redirect,
on_failure=self.got_error,
file_path=file_path,
)
def do_search(self):
def on_success(req, result):
print ('search success.')
for i in result['result']:
code = str(i['code'])
if code == '':
code = '200001'
btn = ImageButton(source='./products/'+code+'-small.png', id=code, text=str(i['id']),
size_hint_y=None, width=300, height=100)
btn.bind(on_press=self.do_add_item)
self.products_search_list.append(btn)
self.grid_layout_search_wid.add_widget(btn)
self.tabbed_panel_wid.switch_to(self.tab_search_wid)
self.grid_layout_search_wid.height = (len(result['result'])/4+4)*110
if len(self.products_search_list) > 0:
for n in self.products_search_list:
self.grid_layout_search_wid.remove_widget(n)
self.products_search_list = []
config = ConfigParser.get_configparser(name='app')
producturl = config.get('serverconnection', 'server.url') + "pos/product/" + self.text_input_wid.text
UrlRequest(producturl, on_success)
def get_station_metadata(self):
""" Get the metadata associated with the selected station
"""
self.ids.switch_button.text = 'Fetching Station information'
self.ids.switch_button.disabled = 1
if hasattr(self, 'pendingRequest'):
self.pendingRequest.cancel()
if hasattr(self, 'activeRequest'):
self.activeRequest.cancel()
if self.station_details:
station = self.ids.station_dropdown.text
URL = 'https://swd.weatherflow.com/swd/rest/observations/station/{}?token={}'
URL = URL.format(
self.station_details[station]['station_id'],
App.get_running_app().config['Keys']['WeatherFlow'])
self.activeRequest = UrlRequest(
URL,
on_success=self.parse_station_metadata,
on_failure=self.fail_station_metadata,
on_error=self.fail_station_metadata,
ca_file=certifi.where())
def auth(self):
print('Guardando..')
os.environ['SSL_CERT_FILE'] = certifi.where()
search_url = "https://bazarapi.herokuapp.com/Lamina"
params = urllib.parse.urlencode({
'numero': str(self.ids.num.text),
'nombre': str(self.ids.nom.text),
'numero_seccion': self.ids.num_sec.text,
'seccion': str(self.ids.sec.text),
'stock': self.ids.stock.text
})
headers = {
'Content-type': 'application/x-www-form-urlencoded',
'Accept': 'text/plain'
}
self.req = UrlRequest(search_url,
on_success=self.bug_posted,
req_body=params,
req_headers=headers,
ca_file=cfi.where(),
verify=True)
def observeNfcReader(self):
while True:
if self.nfc.complete_flag:
self.ids.nfc_inf.text = "決済情報をデータベースに送信中．．．"
url = DatabaseInfo.HTTP + "/transaction"
if self.pay_type == PayType.PAYMENT:
url += "/payment"
self.rb = json.dumps(PayInfo.get_DictPaymentInfo())
elif self.pay_type == PayType.CHARGE:
url += "/charge"
self.rb = json.dumps(PayInfo.get_DictChargeInfo())
req = UrlRequest(url,
on_success=self.successRequest,
on_failure=self.failRequest,
req_body=self.rb,
req_headers=DatabaseInfo.HEADER)
break
if self.nfc.cancel_flag:
break
