def post(self):
"""
---
summary: Request a new user account
description: Creates a new pending user account.
tags:
- auth
requestBody:
description: User basic information
content:
application/json:
schema: AuthRegisterRequestSchema
responses:
200:
description: User login on successful registration.
content:
application/json:
schema: UserSuccessResponseSchema
400:
description: When request body is invalid.
403:
description: When registration feature is disabled or reCAPTCHA token wasn't valid.
409:
description: When user login or group name already exists.
500:
description: When ReCAPTCHA verification service is unavailable.
"""
if not app_config.mwdb.enable_registration:
raise Forbidden("User registration is not enabled.")
schema = AuthRegisterRequestSchema()
obj = loads_schema(request.get_data(as_text=True), schema)
login = obj["login"]
if db.session.query(exists().where(User.login == login)).scalar():
raise Conflict("Name already exists")
if db.session.query(exists().where(Group.name == login)).scalar():
raise Conflict("Name already exists")
verify_recaptcha(obj.get("recaptcha"))
user = User.create(login,
obj["email"],
obj["additional_info"],
pending=True)
try:
send_email_notification("pending",
"Pending registration in MWDB",
user.email,
base_url=app_config.mwdb.base_url,
login=user.login)
except MailError:
logger.exception("Can't send e-mail notification")
logger.info('User registered', extra={'user': user.login})
schema = UserSuccessResponseSchema()
return schema.dump({"login": user.login})
def join_lobby(db_session, user_session, lobby_code):
user = db_session.query(User).get(user_session["user_id"])
if user.lobby is not None:
raise Conflict("User is already in a lobby.")
lobby = (
db_session.query(Lobby)
.filter(Lobby.code == lobby_code)
.filter(Lobby.state == LOBBY_CONSTANTS["state"]["ready"])
).one_or_none()
if lobby is None:
raise NotFound(
f"No lobby with code {lobby_code} was found."
)
if lobby.is_at_capacity():
raise Conflict(
f"Max number of {lobby.capacity} players exceeded."
)
user.lobby = lobby
user_session["lobby_id"] = lobby.id
return {
"state": lobby.get_state(),
"players": [player.name for player in lobby.players],
}
def batch_tallies(election: Election) -> BatchTallies:
# We only support one contest for batch audits
assert len(list(election.contests)) == 1
contest = list(election.contests)[0]
# Validate the batch tallies files. We can't do this validation when they
# are uploaded because we need all of the jurisdictions' files.
total_votes_by_choice: Dict[str, int] = defaultdict(int)
for jurisdiction in contest.jurisdictions:
batch_tallies = typing_cast(BatchTallies, jurisdiction.batch_tallies)
if batch_tallies is None:
raise Conflict(
"Some jurisdictions haven't uploaded their batch tallies files yet."
)
for tally in batch_tallies.values():
for choice_id, votes in tally[contest.id].items():
total_votes_by_choice[choice_id] += votes
for choice in contest.choices:
if total_votes_by_choice[choice.id] > choice.num_votes:
raise Conflict(
f"Total votes in batch tallies files for contest choice {choice.name}"
f" ({total_votes_by_choice[choice.id]}) is greater than the"
f" reported number of votes for that choice ({choice.num_votes})."
)
# Key each batch by jurisdiction name and batch name since batch names
# are only guaranteed unique within a jurisdiction
return {
(jurisdiction.name, batch_name): tally
for jurisdiction in contest.jurisdictions
for batch_name, tally in jurisdiction.batch_tallies.items() # type: ignore
}
def validate_new_election(election: JSONDict):
validate(election, ELECTION_SCHEMA)
if Election.query.filter_by(
audit_name=election["auditName"],
organization_id=election["organizationId"]).first():
raise Conflict(
f"An audit with name '{election['auditName']}' already exists within your organization"
)
valid_math_types_for_audit_type = {
AuditType.BALLOT_POLLING: [AuditMathType.BRAVO, AuditMathType.MINERVA],
AuditType.BALLOT_COMPARISON: [AuditMathType.SUPERSIMPLE],
AuditType.BATCH_COMPARISON: [AuditMathType.MACRO],
}
if (election["auditMathType"]
not in valid_math_types_for_audit_type[election["auditType"]]):
raise Conflict(
f"Audit math type '{election['auditMathType']}' cannot be used with audit type '{election['auditType']}'"
)
# For now, disable Minerva audit math in production
if FLASK_ENV == "production" and election[
"auditMathType"] == AuditMathType.MINERVA:
raise BadRequest("Invalid audit math type")
def create(self, user: auth.User, **kwargs) -> int:
if self._form is not None:
# This is indeed an internal server error.
raise Exception("instantiated form can't create other")
self._validate_kwargs(**kwargs)
creation_kwargs = self._convert_kwarg_values(**kwargs)
with base.db.atomic() as transaction:
try:
try:
self._form = self._db_model.create(
user=user, type=self._structure_and_function_type)
except peewee.IntegrityError:
raise Conflict("form already exists")
_measures = list()
for measure in creation_kwargs["measures"]:
try:
_measure = forms.StructureAndFunctionMeasure.create(
structure_and_function=self._form, **measure)
except peewee.IntegrityError:
raise Conflict("form measure already exists")
_measures.append(_measure)
self._measures = _measures
except Exception:
transaction.rollback()
raise
return self._form.id
def validate_numbers(self, data, **kwargs):
if data.get("password") is not None and \
data.get("confirm_password") is None:
raise Conflict(
description='You need to enter password confirmation')
if data.get("password") is None and \
data.get("confirm_password") is not None:
raise Conflict(description='You need to enter password first')
def validate_numbers(self, data, **kwargs):
if data.get("end_date") < data.get("start_date"):
raise Conflict(description='End date is before ' \
'start date')
if data.get('free_places') < 0:
raise Conflict(description='Free places must be positive number')
if data.get('price') < 0:
raise Conflict(description='Price must be positive value')
def _set_parent_folder(cls, folder, parent_id):
parent = cls.get(parent_id)
if parent is folder:
raise Conflict("Cannot move folder to itself")
for grand_parent in parent.iter_parents():
if grand_parent is folder:
raise Conflict("Cannot move folder to a subfolder of itself")
folder.parent = parent
def validate_offline_results(
election: Election, jurisdiction: Jurisdiction, round: Round, results: JSONDict
):
if election.online:
raise Conflict("Cannot record offline results for online audit.")
current_round = get_current_round(election)
if not current_round or round.id != current_round.id:
raise Conflict(f"Round {round.round_num} is not the current round")
num_audit_boards = AuditBoard.query.filter_by(
jurisdiction_id=jurisdiction.id, round_id=round.id
).count()
if num_audit_boards == 0:
raise Conflict("Must set up audit boards before recording results")
validate(results, OFFLINE_RESULTS_SCHEMA)
contest_ids = {c.id for c in jurisdiction.contests}
if set(results.keys()) != contest_ids:
raise BadRequest("Invalid contest ids")
choices_by_contest = dict(
ContestChoice.query.filter(ContestChoice.contest_id.in_(contest_ids))
.group_by(ContestChoice.contest_id)
.values(ContestChoice.contest_id, func.array_agg(ContestChoice.id))
)
for contest_id, results_by_choice in results.items():
if set(results_by_choice.keys()) != set(choices_by_contest[contest_id]):
raise BadRequest(f"Invalid choice ids for contest {contest_id}")
ballot_draws_by_contest = dict(
SampledBallot.query.join(Batch)
.filter_by(jurisdiction_id=jurisdiction.id)
.join(SampledBallotDraw)
.filter_by(round_id=current_round.id)
.group_by(SampledBallotDraw.contest_id)
.values(SampledBallotDraw.contest_id, func.count())
)
ballots_sampled = (
SampledBallot.query.join(Batch)
.filter_by(jurisdiction_id=jurisdiction.id)
.count()
)
for contest in jurisdiction.contests:
num_ballots = (
ballot_draws_by_contest.get(contest.id, 0)
if contest.is_targeted
else ballots_sampled
)
total_results = sum(results[contest.id].values())
allowed_results = num_ballots * contest.votes_allowed
if total_results > allowed_results:
raise BadRequest(
f"Total results for contest {contest.name} should not exceed"
f" {allowed_results} - the number of sampled ballots ({num_ballots})"
f" times the number of votes allowed ({contest.votes_allowed}).",
)
def _check_if_date_is_invalid(first_date, second_date, flag):
if first_date > second_date and flag:
raise Conflict(
description='Start date is in the past'
)
elif first_date > second_date:
raise Conflict(
description='Start date is after end date'
)
def _check_if_number_is_positive(number, flag):
if number < 0 and flag:
raise Conflict(
description='Free places must be positive value'
)
elif number < 0:
raise Conflict(
description='Price must be positive value'
)
def route_add_division_machine_player(division_id,division_machine_id,player_id):
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
division_machine = fetch_entity(tables.DivisionMachine,division_machine_id)
player = fetch_entity(tables.Player,player_id)
if division_machine.division.active is False:
raise Conflict("Division is not active.")
if division_machine.removed is True:
raise Conflict("Machine is not active. You have been very naughty.")
if player.active is False:
raise Conflict('Player is not active. Please see the front desk.')
if division_machine.player_id or division_machine.team_id:
raise Conflict('Machine is already being played')
if check_player_team_can_start_game(current_app,division_machine,player) is False:
raise BadRequest('Player can not start game - either no tickets or already on another machine')
if len(player.teams) > 0:
if tables.DivisionMachine.query.filter_by(team_id=player.teams[0].team_id).first():
raise BadRequest('Player can not start game - his team is playing on another machine')
set_token_start_time(current_app,player,division_machine,commit=False)
create_audit_log_ex(current_app, "Game Started",
user_id=current_user.user_id,
player_id=player.player_id,
division_machine_id=division_machine.division_machine_id,
commit=False)
division_machine.player_id=player.player_id
##db.session.commit()
queue = tables.Queue.query.filter_by(player_id=player.player_id).first()
players_to_alert = []
players_in_other_queue = []
if queue:
players_to_alert = get_player_list_to_notify(player.player_id,queue.division_machine)
players_in_other_queue = get_players_in_queue_after_player(player.player_id)
removed_queue = remove_player_from_queue(current_app,player,commit=True)
if removed_queue and removed_queue is not False:
create_audit_log_ex(current_app, "Player removed from queue",
user_id=current_user.user_id,
player_id=player.player_id,
division_machine_id=removed_queue.division_machine_id,
description="Player removed from queue %s by getting started on %s" % (removed_queue.division_machine.machine.machine_name,division_machine.machine.machine_name),
commit=False)
for player_in_other_que in players_in_other_queue:
create_audit_log_ex(current_app, "Other player removed from queue",
user_id=current_user.user_id,
player_id=player_in_other_que['player_id'],
division_machine_id=player_in_other_que['division_machine_id'],
description="Player moved up on queue %s due to removal of player %s" % (player_in_other_que['division_machine']['division_machine_name'],player.first_name+" "+player.last_name),
commit=False)
if removed_queue is not None and removed_queue is not False and len(players_to_alert) > 0:
push_notification_message = "The queue for %s has changed! Please check the queue to see your new position." % queue.division_machine.machine.machine_name
send_push_notification(push_notification_message, players=players_to_alert)
db.session.commit()
return jsonify({'data':division_machine.to_dict_simple()})
def delete(self):
""" Deletes the envelope if it does not have any associated transactions """
if len(self.transactions) > 0:
raise Conflict("Envelope is referenced by transactions")
if len(self.periodic_expenses) > 0:
raise Conflict(
"Envelope is referenced by budgeted periodic expenses")
if len(self.annual_expenses) > 0:
raise Conflict(
"Envelope is referenced by budgeted annual expenses")
super().delete()
def post(self, login):
schema = UserProfileManageInfoSchema()
obj = schema.loads(request.get_data(as_text=True))
if obj.errors:
return {"errors": obj.errors}, 400
user_login_obj = UserLoginSchemaBase().load({"login": login})
if user_login_obj.errors:
return {"errors": user_login_obj.errors}, 400
if db.session.query(exists().where(User.login == login)).scalar():
raise Conflict("User exists yet")
if db.session.query(exists().where(Group.name == login)).scalar():
raise Conflict("Group exists yet")
user = User()
user.login = login
user.email = obj.data.get("email")
user.additional_info = obj.data.get("additional_info")
user.feed_quality = obj.data.get("feed_quality")
user.disabled = False
user.pending = False
user.registered_by = g.auth_user.id
user.registered_on = datetime.datetime.now()
user.groups.append(Group.public_group())
user.reset_sessions()
db.session.add(user)
group = Group()
group.name = login
group.private = True
group.users.append(user)
db.session.add(group)
if obj.data.get("send_email", False):
try:
send_email_notification("register",
"New account registered in Malwarecage",
user.email,
base_url=app_config.malwarecage.base_url,
login=user.login,
set_password_token=user.generate_set_password_token().decode("utf-8"))
except MailError:
logger.exception("Can't send e-mail notification")
raise InternalServerError("SMTP server needed to fulfill this request is"
" not configured or unavailable.")
db.session.commit()
logger.info('User created', extra={'user': user.login})
schema = UserSuccessSchema()
return schema.dump({"login": user.login})
def validate_cvr_upload(request: Request, election: Election,
jurisdiction: Jurisdiction):
if election.audit_type != AuditType.BALLOT_COMPARISON:
raise Conflict(
"Can only upload CVR file for ballot comparison audits.")
if not jurisdiction.manifest_file_id:
raise Conflict(
"Must upload ballot manifest before uploading CVR file.")
if "cvrs" not in request.files:
raise BadRequest("Missing required file parameter 'cvrs'")
def invitations_accept():
invitation = _invitation_query() \
.filter(Invitation.hash == current_request.get_json()["hash"]) \
.one()
if invitation.status != "open":
raise Conflict(f"The invitation has status {invitation.status}")
if invitation.expiry_date and invitation.expiry_date < datetime.datetime.now():
if invitation.external_identifier:
invitation.status = "expired"
db.session.merge(invitation)
db.session.commit()
else:
delete(Invitation, invitation.id)
raise Conflict(f"The invitation has expired at {invitation.expiry_date}")
collaboration = invitation.collaboration
user_id = current_user_id()
if collaboration.is_member(user_id):
delete(Invitation, invitation.id)
raise Conflict(f"User {user_id} is already a member of {collaboration.name}")
role = invitation.intended_role if invitation.intended_role else "member"
collaboration_membership = CollaborationMembership(user_id=user_id,
collaboration_id=collaboration.id,
role=role,
expiry_date=invitation.membership_expiry_date,
created_by=invitation.user.uid,
updated_by=invitation.user.uid)
if invitation.external_identifier:
collaboration_membership.invitation_id = invitation.id
collaboration_membership = db.session.merge(collaboration_membership)
# We need the persistent identifier of the collaboration_membership which will be generated after the delete-commit
if invitation.external_identifier:
invitation.status = "accepted"
db.session.merge(invitation)
db.session.commit()
else:
delete(Invitation, invitation.id)
# ensure all authorisation group membership are added
groups = invitation.groups + list(filter(lambda ag: ag.auto_provision_members, collaboration.groups))
for group in set(list({ag.id: ag for ag in groups}.values())):
group.collaboration_memberships.append(collaboration_membership)
db.session.merge(group)
add_user_aups(collaboration, user_id)
res = {'collaboration_id': collaboration.id, 'user_id': user_id}
return res, 201
def player_bet(player, current_round, amount):
if current_round.current_bet > 0:
raise Conflict("There is already a bet. Try raising or calling.")
try:
player.place_bet(amount, current_round.pot)
except OutOfMoney:
raise Conflict("User does not have sufficient money to bet.")
player.player_status.last_action = PLAYER_STATUS_CONSTANTS["action"]["bet"]
current_round.go_to_next_player()
return {"message": "User has successfully bet."}
def route_undo_division_machine_player_team(division_id,division_machine_id):
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
division_machine = fetch_entity(tables.DivisionMachine,division_machine_id)
if division_machine.division.team_tournament is False and division_machine.player_id is None:
raise Conflict('Machine is not being played')
if division_machine.division.team_tournament and division_machine.team_id is None:
raise Conflict('Machine is not being played')
token = tables.Token.query.filter_by(player_id=division_machine.player_id,division_machine_id=division_machine_id,used=False).first()
token.division_machine_id=None
division_machine.player_id=None
db.session.commit()
return jsonify({'data':division_machine.to_dict_simple()})
def _post_supply_delivery(self, resource):
try:
fhir = SimpleFhirR4Reader(resource)
patient = fhir.patient
pid = patient.identifier
p_id = from_client_participant_id(pid.value)
bo_id = fhir.basedOn[0].identifier.value
_id = self.dao.get_id(
ObjDict({
'participantId': p_id,
'order_id': int(bo_id)
}))
tracking_status = fhir.extension.get(
url=DV_FHIR_URL + 'tracking-status').valueString.lower()
except AttributeError as e:
raise BadRequest(e.message)
except Exception as e:
raise BadRequest(e.message)
if not _id:
raise Conflict(
'Existing SupplyRequest for order required for SupplyDelivery')
dvo = self.dao.get(_id)
if not dvo:
raise Conflict(
'Existing SupplyRequest for order required for SupplyDelivery')
merged_resource = None
# Note: POST tracking status should be either 'enroute/in_transit'. PUT should only be 'delivered'.
if tracking_status in [
'in_transit', 'enroute', 'delivered'
] and self._to_mayo(fhir) and not dvo.biobankOrderId:
# Send to mayolink and create internal biobank order
response = self.dao.send_order(resource, p_id)
merged_resource = merge_dicts(response, resource)
merged_resource['id'] = _id
logging.info(
'Sending salivary order to biobank for participant: %s', p_id)
self.dao.insert_biobank_order(p_id, merged_resource)
response = super(DvOrderApi, self).put(bo_id,
participant_id=p_id,
skip_etag=True,
resource=merged_resource)
response[2]['Location'] = '/rdr/v1/SupplyDelivery/{}'.format(bo_id)
response[2]['auth_user'] = resource['auth_user']
if response[1] == 200:
created_response = list(response)
created_response[1] = 201
return tuple(created_response)
return response
def post(self):
"""This endpoint allows an unregistered user to sign up."""
req_data = request.data.decode().replace("'", '"')
if not req_data:
raise BadRequest("Provide data in the request")
body = json.loads(req_data)
try:
username = body['username']
first_name = body['first_name'].strip()
last_name = body['last_name'].strip()
ek_number = body['ek_number'].strip()
email = body['email'].strip()
phone_number = body['phone_number'].strip()
password = body['password'].strip()
user_level = body['user_level']
if not user_level:
user_level = 1
except (KeyError, IndexError) as e:
raise BadRequest
user_data = {
"username": username,
"first_name": first_name,
"last_name": last_name,
"ek_number": ek_number,
"email": email,
"phone_number": phone_number,
"password": password,
"user_level": user_level
}
_validate_user(user_data)
user = UserModel(**user_data)
if user.check_exists(table="users", field="username",
data=username) == True:
raise Conflict("There is a user with such a username")
elif user.check_exists(table="users", field="email",
data=email) == True:
raise Conflict("There is a user with such an email")
elif user.check_exists(table="users",
field="ek_number",
data=ek_number) == True:
raise Conflict("There is a user with the same EK number")
else:
resp = user.save()
e = Email([email])
e.welcome_text(first_name + ' ' + last_name, password, username)
respn = {"message": "Successfully added", "username": username}
return respn, 201
def insert_user(self, user_data):
"""Inserts a user into database and it returns his e-mail."""
# just remove `password` field to log the parameter
password = user_data.pop('password')
logging.info(f"insert_user - user_data: {user_data}")
user_data['password'] = password
# check if user exists by his e-mail
user = self.db_ps_register.select_from_user(email=user_data['email'])
if user:
logging.info(
f"insert_user - E-mail has already been registered! E-mail: `{user_data['email']}`"
)
raise Conflict(
f"E-mail has already been registered! E-mail: `{user_data['email']}`"
)
# check if user exists by his username
user = self.db_ps_register.select_from_user(
username=user_data['username'])
if user:
logging.info(
f"insert_user - Username has already been registered! Username: `{user_data['username']}`"
)
raise Conflict(
f"Username has already been registered! Username: `{user_data['username']}`"
)
# default value to `address_id`, if there is not an `address_id`, then insert NULL
user_data['address_id'] = None
# if there is 'address' field, then try to insert address
# information in the database
if 'address' in user_data:
# if there are properties inside 'address' field,
# then insert the address in the database
if user_data['address']:
logging.info(f"insert_user - address: {user_data['address']}")
address_id = self.db_ps_register.insert_into_address(user_data)
user_data['address_id'] = address_id
# remove 'address' field from dict
del user_data['address']
return self.db_ps_register.insert_into_user(user_data)
def validate_standardized_contests_upload(request: Request,
election: Election):
if election.audit_type != AuditType.BALLOT_COMPARISON:
raise Conflict(
"Can only upload standardized contests file for ballot comparison audits."
)
if len(list(election.jurisdictions)) == 0:
raise Conflict(
"Must upload jurisdictions file before uploading standardized contests file."
)
if "standardized-contests" not in request.files:
raise BadRequest(
"Missing required file parameter 'standardized-contests'")
def validate_batch_tallies_upload(request: Request, election: Election,
jurisdiction: Jurisdiction):
if election.audit_type != AuditType.BATCH_COMPARISON:
raise Conflict(
"Can only upload batch tallies file for batch comparison audits.")
if len(list(jurisdiction.contests)) == 0:
raise Conflict("Jurisdiction does not have any contests assigned")
if not jurisdiction.manifest_file_id:
raise Conflict(
"Must upload ballot manifest before uploading batch tallies.")
if "batchTallies" not in request.files:
raise BadRequest("Missing required file parameter 'batchTallies'")
def put(self, username):
if UserModel().check_exists("users", "username", username) == False:
raise NotFound("No such user in our record")
if username == g.user or UserModel().get_user_username(g.user)[4] == 0:
req_data = request.data.decode().replace("'", '"')
if not req_data:
raise BadRequest("Provide data in the request")
body = json.loads(req_data)
_validate_user(body)
for field, value in body.items():
if field == "username" or field == "user_level":
raise Unauthorized(
"You are not permitted to preform this operation")
elif field == "email":
if UserModel().check_exists(table="users",
field="email",
data=value) == True:
raise Conflict("There is a user with such an email")
else:
UserModel().update_item(table="users",
field=field,
data=value,
item_field="username",
item_id=username)
elif field == "ek_number":
if UserModel().check_exists(table="users",
field="ek_number",
data=value) == True:
raise Conflict(
"There is a user with the same EK number")
else:
UserModel().update_item(table="users",
field=field,
data=value,
item_field="username",
item_id=username)
else:
UserModel().update_item(table="users",
field=field,
data=value,
item_field="username",
item_id=username)
new_user = {"message": "Successfully Updated"}
return new_user, 200
else:
raise Unauthorized(
"You are not permitted to preform this operation")
def validate_post(args):
"""
Validates the POST request parameters.
:param dict args: request parameters
"""
# all args except Description must have a value
for arg, value in args.items():
if arg != JobFields.DESCRIPTION and not value:
raise BadRequest(f"'{arg}' is required in request.")
name = args[JobFields.NAME]
# Make sure name has no arbitrary (unallowed) characters for the filesystem
match = re.match('^[^*&%\/\s]+$', name)
if not match:
raise BadRequest(f"'name' cannot have characters *, &, /, %.")
# make sure no other combo of name & router & provider exists
existing_combo: Job = Job.query.filter(
Job.name == args[JobFields.NAME],
Job.provider == args[JobFields.PROVIDER],
Job.router == args[JobFields.ROUTER]).first()
if existing_combo:
raise Conflict(
f"Combination of 'name' & 'router' & 'provider' already exists with ID {existing_combo.id}"
)
_validate_common(args)
def post(self):
"""
Creates a new customer.
"""
if not (0 <= request.json["pin"] <= 99999):
raise UnprocessableEntity("The PIN must be of 5 digits")
new_customer = Customer(
customer_mail_address=request.json['mail_address'],
customer_first_name=request.json['first_name'],
customer_last_name=request.json['last_name'],
customer_pin_hash=str(request.json['pin']))
print(new_customer.customer_pin_hash)
db.session.add(new_customer)
try:
db.session.commit()
except OperationalError:
db.session.remove()
raise InternalServerError(
description='Customer table does not exists.')
except IntegrityError:
db.session.remove()
raise Conflict(description=new_customer.__repr__() +
' already exists')
current_app.logger.info(new_customer.__repr__() +
' added to database.')
return {'message': 'Resource created'}, 201
def on_restore(self, req):
"""Entry point for restore rule"""
account = req.args.get('acct')
container = req.args.get('ref')
if not account:
raise BadRequest('Missing Account name')
if not container:
raise BadRequest('Missing Container name')
if req.method not in ('PUT', 'HEAD'):
return Response("Not supported", 405)
try:
self.proxy.container_get_properties(account, container)
if not req.headers.get('range') and req.method == 'PUT':
raise Conflict('Container already exists')
except exc.NoSuchContainer:
pass
except Conflict:
raise
except Exception:
raise BadRequest('Fail to verify container')
if req.method == 'HEAD':
return self._do_put_head(req, account, container)
return self._do_put(req, account, container)
def response(cls, data, request):
if isinstance(request, XMLRequest):
if isinstance(data, TrytonException):
data = client.Fault(data.code, str(data))
elif isinstance(data, Exception):
data = client.Fault(255, str(data))
else:
data = (data,)
return Response(client.dumps(
data, methodresponse=True, allow_none=True),
content_type='text/xml')
else:
if isinstance(data, UserWarning):
return Conflict(data)
elif isinstance(data, LoginException):
return Forbidden(data)
elif isinstance(data, ConcurrencyException):
return Locked(data)
elif isinstance(data, RateLimitException):
return TooManyRequests(data)
elif isinstance(data, MissingDependenciesException):
return InternalServerError(data)
elif isinstance(data, TrytonException):
return BadRequest(data)
elif isinstance(data, Exception):
return InternalServerError(data)
return Response(data)
def post(memo_id: int) -> str:
# 指定されたidがあるかどうか確認する
is_exist: bool = exist(memo_id)
if is_exist:
raise Conflict(f'memo_id [{memo_id}] is already registered.')
# リクエストから値を取得する
memo: str = request.form["memo"]
# DBクライアントを作成する
conn = connector.connect(**config)
cursor = conn.cursor()
# memoを保存する
query = "INSERT INTO test_table (memo_id, memo) VALUES (%s, %s)"
cursor.execute(query, (memo_id, memo))
# DBクライアントをcloseする
cursor.close()
conn.close()
return jsonify(
{
"message": "saved."
}
)
def response(cls, data, request):
try:
parsed_data = request.parsed_data
except BadRequest:
parsed_data = {}
if (isinstance(request, JSONRequest)
and set(parsed_data.keys()) == {'id', 'method', 'params'}):
response = {'id': parsed_data.get('id', 0)}
if isinstance(data, TrytonException):
response['error'] = data.args
elif isinstance(data, Exception):
# report exception back to server
response['error'] = (str(data), data.__format_traceback__)
else:
response['result'] = data
else:
if isinstance(data, UserWarning):
return Conflict(data)
elif isinstance(data, LoginException):
return Forbidden(data)
elif isinstance(data, ConcurrencyException):
return Locked(data)
elif isinstance(data, RateLimitException):
return TooManyRequests(data)
elif isinstance(data, MissingDependenciesException):
return InternalServerError(data)
elif isinstance(data, TrytonException):
return BadRequest(data)
elif isinstance(data, Exception):
return InternalServerError(data)
response = data
return Response(json.dumps(response,
cls=JSONEncoder,
separators=(',', ':')),
content_type='application/json')
