def tx_request(tx, cursor):
payload = json.loads(tx.payload)
payload['payment'] = int(payload['payment'])
payload['dealer_fee'] = int(payload.get('dealer_fee', '0'))
buyer = models.Account(tx.chain_id, tx.sender, cursor)
parcel = models.Parcel(tx.chain_id, payload['target'], None, cursor)
request = models.Request(tx.chain_id, parcel.parcel_id, buyer.address,
cursor)
request.payment = payload['payment']
request.dealer = payload.get('dealer', None)
request.dealer_fee = payload['dealer_fee']
request.extra = json.dumps(payload.get('extra', {}))
request.save(cursor)
if tx.sender not in yappers:
rel = models.RelParcelTx(tx.chain_id, parcel.parcel_id, tx.height,
tx.index)
rel.save(cursor)
if request.dealer is not None:
buyer.balance -= request.dealer_fee
buyer.balance -= request.payment
buyer.save(cursor)
rel = models.RelAccountTx(tx.chain_id, buyer.address, tx.height, tx.index,
cursor)
rel.amount -= request.payment
rel.save(cursor)
def tx_grant(tx, cursor):
payload = json.loads(tx.payload)
parcel = models.Parcel(tx.chain_id, payload['target'], None, cursor)
storage = models.Storage(tx.chain_id, parcel.storage_id, None, cursor)
host = models.Account(tx.chain_id, storage.owner, cursor)
owner = models.Account(tx.chain_id, parcel.owner, cursor)
request = models.Request(tx.chain_id, payload['target'],
payload['grantee'], cursor)
usage = models.Usage(tx.chain_id, payload['target'], payload['grantee'],
cursor)
usage.custody = payload['custody']
usage.extra = payload.get('extra', '{}')
usage.save(cursor)
owner.balance += request.payment
if request.dealer is not None:
dealer = models.Account(tx.chain_id, request.dealer, cursor)
dealer.balance += request.dealer_fee
dealer.save(cursor)
owner.balance -= storage.hosting_fee
owner.save(cursor)
host.balance += storage.hosting_fee
host.save(cursor)
request.delete(cursor)
def tx_cancel(tx, cursor):
payload = json.loads(tx.payload)
buyer = models.Account(tx.chain_id, tx.sender, cursor)
request = models.Request(tx.chain_id, payload['target'], tx.sender, cursor)
buyer.balance += request.payment
buyer.balance += request.dealer_fee
buyer.save(cursor)
request.delete(cursor)
def tx_grant(tx, cursor):
payload = json.loads(tx.payload)
grantee = ''
if 'grantee' in payload:
grantee = payload['grantee']
elif 'recipient' in payload:
grantee = payload['recipient']
parcel = models.Parcel(tx.chain_id, payload['target'], None, cursor)
storage = models.Storage(tx.chain_id, parcel.storage_id, None, cursor)
host = models.Account(tx.chain_id, storage.owner, cursor)
owner = models.Account(tx.chain_id, parcel.owner, cursor)
# NOTE: This is line is for creating buyer account in s_accounts table. It
# is necessary to satisfy the foreign key constraint. Even if we create a
# row for each tx sender, it is not the case for the recipient for
# `request` or `grant` tx. So, we need to explicitly create a grantee or
# recipient account in s_accounts table.
buyer = models.Account(tx.chain_id, grantee, cursor)
buyer.save(cursor)
request = models.Request(tx.chain_id, payload['target'], grantee, cursor)
usage = models.Usage(tx.chain_id, payload['target'], grantee, cursor)
usage.custody = payload['custody']
usage.extra = json.dumps(payload.get('extra', {}))
usage.save(cursor)
if tx.sender not in yappers:
rel = models.RelParcelTx(tx.chain_id, parcel.parcel_id, tx.height,
tx.index)
rel.save(cursor)
owner.balance += request.payment
if request.dealer is not None:
dealer = models.Account(tx.chain_id, request.dealer, cursor)
dealer.balance += request.dealer_fee
dealer.save(cursor)
owner.balance -= storage.hosting_fee
owner.save(cursor)
if storage.hosting_fee > 0:
rel = models.RelAccountTx(tx.chain_id, owner.address, tx.height,
tx.index, cursor)
rel.amount -= storage.hosting_fee
rel.save(cursor)
host.balance += storage.hosting_fee
host.save(cursor)
rel = models.RelAccountTx(tx.chain_id, host.address, tx.height,
tx.index, cursor)
rel.amount += storage.hosting_fee
rel.save(cursor)
request.delete(cursor)
def tx_cancel(tx, cursor):
payload = json.loads(tx.payload)
buyer = models.Account(tx.chain_id, tx.sender, cursor)
request = models.Request(tx.chain_id, payload['target'], tx.sender, cursor)
buyer.balance += request.payment
buyer.balance += request.dealer_fee
buyer.save(cursor)
rel = models.RelAccountTx(tx.chain_id, buyer.address, tx.height, tx.index,
cursor)
rel.amount += request.payment + request.dealer_fee
rel.save(cursor)
request.delete(cursor)
def handle_request(connection: socket.socket, address, logger, root_dir):
logger.debug("Connected at %r", address)
try:
req = models.Request(connection.recv(1024))
except IndexError:
connection.send(b'Non HTTP protocol used')
connection.close()
logger.debug("Connection closed")
return
is_dir = False
path = root_dir + urllib.parse.unquote(urllib.parse.urlparse(req.URL).path)
if path[-1] == '/':
is_dir = True
path += 'index.html'
resp_code = 200
if not os.path.exists(path):
if is_dir:
resp_code = 403
else:
resp_code = 404
if path.find('../') != -1:
resp_code = 403
resp: models.Response
if resp_code == 200 and req.Method in methods:
size = os.path.getsize(path)
resp = models.Response(req.Protocol, req.Method, resp_code,
mimetypes.guess_type(path)[0], size)
else:
resp = models.Response(req.Protocol, req.Method, resp_code)
logger.debug(resp_code)
connection.sendall(resp.get_raw_headers())
if req.Method == 'GET' and resp_code == 200:
file = open(path, 'rb')
connection.sendfile(file, 0)
file.close()
connection.shutdown(socket.SHUT_RDWR)
connection.shutdown(socket.SHUT_RDWR)
logger.debug("Connection closed")
def data_put(request):
if request.method != 'POST':
return render(request, 'api.html', {})
r = models.Request()
r.put()
data_id = r.key().id()
# save data to file into gcs, because it size can exceed taskqueue payload capacity (~ 100 Kb)
store.put("%s" % data_id, zlib.compress(request.POST.get('data', '')))
taskqueue.add(url=reverse('api_do', None, [], {}),
method="POST",
params={'key': data_id})
return redirect(reverse('api_get', None, [], {
'questid': data_id,
}))
def tx_request(tx, cursor):
payload = json.loads(tx.payload)
payload['payment'] = int(payload['payment'])
payload['dealer_fee'] = int(payload.get('dealer_fee', '0'))
buyer = models.Account(tx.chain_id, tx.sender, cursor)
parcel = models.Parcel(tx.chain_id, payload['target'], None, cursor)
request = models.Request(tx.chain_id, parcel.parcel_id, buyer.address,
cursor)
request.payment = payload['payment']
request.dealer = payload.get('dealer', None)
request.dealer_fee = payload['dealer_fee']
request.extra = payload.get('extra', '{}')
request.save(cursor)
if request.dealer is not None:
buyer.balance -= request.dealer_fee
buyer.balance -= request.payment
buyer.save(cursor)
def postservice():
title = request.form['title']
description = request.form['description']
target = request.form['target']
client = request.form['client']
category = request.form['category']
rank = request.form['rank']
# Database
# req is creating a new constructor object based off the Request Class.
req = models.Request(title=title,
description=description,
target=target,
client=client,
category=category,
rank=rank)
# Adds req to the database session.
db.session.add(req)
# Runs the SQL INSERT statement which adds the data to the database.
db.session.commit()
return 'post successful'
def tx_grant(tx, cursor):
payload = json.loads(tx.payload)
parcel = models.Parcel(tx.chain_id, payload['target'], None, cursor)
storage = models.Storage(tx.chain_id, parcel.storage_id, None, cursor)
host = models.Account(tx.chain_id, storage.owner, cursor)
owner = models.Account(tx.chain_id, parcel.owner, cursor)
request = models.Request(tx.chain_id, payload['target'],
payload['grantee'], cursor)
usage = models.Usage(tx.chain_id, payload['target'], payload['grantee'],
cursor)
usage.custody = payload['custody']
usage.extra = json.dumps(payload.get('extra', {}))
usage.save(cursor)
# rel = models.RelParcelTx(tx.chain_id, parcel.parcel_id, tx.height,
# tx.index, cursor)
# rel.save(cursor)
owner.balance += request.payment
if request.dealer is not None:
dealer = models.Account(tx.chain_id, request.dealer, cursor)
dealer.balance += request.dealer_fee
dealer.save(cursor)
owner.balance -= storage.hosting_fee
owner.save(cursor)
if storage.hosting_fee > 0:
rel = models.RelAccountTx(tx.chain_id, owner.address, tx.height,
tx.index, cursor)
rel.amount -= storage.hosting_fee
rel.save(cursor)
host.balance += storage.hosting_fee
host.save(cursor)
rel = models.RelAccountTx(tx.chain_id, host.address, tx.height,
tx.index, cursor)
rel.amount += storage.hosting_fee
rel.save(cursor)
request.delete(cursor)
def notify():
"""
Notifies a new positive or symptomatic case of COVID-19 and returns a `201 Created` response.
Returns a `403 Forbidden` response when trying to notify an already reported case.
Returns a `429 Too many requests` response when getting more than 5 requests per 5 minutes from
the same remote host.
"""
form = NotifyForm(request.form)
if form.validate():
# Does not allow to override an already reported case.
already_exists = models.DailyKey.query \
.filter(models.DailyKey.key.in_(key['value'] for key in form.keys.data)) \
.count()
if already_exists > 0:
return 'Forbidden', 403
# Does not allow more than 5 requests per IP per hour.
#
# We allow a reasonable amount of devices from the same address to notify cases in a short
# period of time as multiple cases can legitimately originate from the same household or
# organisation.
if not request.headers.getlist("X-Forwarded-For"):
remote_addr = request.remote_addr
else:
remote_addr = request.headers.getlist("X-Forwarded-For")[0]
user_agent = request.headers.get('User-Agent')
one_hour_ago = datetime.datetime.utcnow() - datetime.timedelta(hours=1)
prev_reporting_count = models.Request.query \
.filter_by(remote_addr=remote_addr) \
.filter(models.Request.created_at >= one_hour_ago) \
.count()
if prev_reporting_count >= 5:
return 'Too many requests', 429
# --
for key in form.keys.data:
db_key = models.DailyKey(
key=key['value'],
date=key['date'],
is_tested=form.is_tested.data,
)
models.db.session.add(db_key)
req = models.Request(
remote_addr=remote_addr,
user_agent=user_agent,
comment=form.comment.data,
)
models.db.session.add(req)
models.db.session.commit()
return 'Created', 201
else:
return 'Bad request', 400
engine = create_engine('sqlite:///:memory:', echo=True)
Session = sessionmaker(engine)
session = Session()
models.Base.metadata.create_all(engine)
manager = models.Employee(name_last='Supervisor', name_first='Mark')
me = models.Employee(name_last='Rubin',
name_first='Benjamin',
email='*****@*****.**',
manager=manager)
jas = models.Employee(name_last='Doe',
name_first='Jane',
email='*****@*****.**',
manager=manager)
session.add(manager)
session.commit()
session.add_all((me, jas))
session.commit()
req = models.Request(start_date=datetime.now(),
end_date=datetime.now(),
employee_id=me.id)
session.add(req)
session.commit()
print(me.requests_pending)
