def get_games(): options = dict() if "offset" in request.args: options["offset"] = request.args.get("offset", type=int) if "count" in request.args: options["count"] = request.args.get("count", type=int) if ("offset" in options and options["offset"] < 0 or options.get("count", 0) > constants.values.MAX_ELEMENT_COUNT): status = constants.statuses["request"]["badArguments"] return ( jsonify( create_error(status, "Offset cann't be negative", offset=options["offset"])), constants.responses[status], ) games, status = Storage.get_games(**options) http_status = constants.responses[status] total_count = Storage.get_games_count() count = len(games) if len(options) != 0 or count != total_count: options["count"] = count options["offset"] = options.get("offset", 0) return ( jsonify(games=games, total_count=total_count, status=status, **options), http_status, )
def __init__(self, serializer: BaseSerializer, central_authority: CentralAuthority, public_key_scheme: BasePublicKey, storage_path: str = None) -> None: self.central_authority = central_authority self.storage = Storage(serializer, storage_path) self.public_key_scheme = public_key_scheme self.authorities = dict() # type: Dict[str, AttributeAuthority]
def get_game(prod_id=None): prod_id = prod_id or request.args.get("id") game, status = Storage.get_game(prod_id) rating, rt_status = Storage.get_game_rating(prod_id) http_status = constants.responses[status] if status == constants.statuses["game"]["returned"]: body = dict(game=game, rating=rating, status=status) else: body = create_error(status, "no such game id: {{ID}}", ID=prod_id) return jsonify(body), http_status
class StorageUploader(object): def __init__(self, config_file='app.ini'): self.storage_service = Storage(config_file) def upload_files(self, input_dir, extension, now_time): """ ファイル転送 :param input_dir: input_dir :param extension: ext :param now_time: timestamp(string) :return: None """ self.storage_service.upload_files(input_dir, extension, now_time)
def patch_score(game_id=None): if game_id is None: game_id = request.json.get("game_id") if game_id is None: status = constants.statuses["rating"]["missingData"] http_status = constants.responses[status] return jsonify(create_error(status, "missing score data")), http_status current_app.logger.info( f"Updating score by {request.environ['user_email']} and game id {game_id}" ) request.json["user_id"] = request.environ["user_id"] request.json["game_id"] = game_id score, status = Storage.update_score(request.json, request.method) http_status = constants.responses[status] if status == constants.statuses["rating"]["modified"]: body = dict(score=score, status=status) elif status == constants.statuses["rating"]["notExists"]: body = create_error(status, "no such score") elif status == constants.statuses["rating"]["missingData"]: body = create_error(status, "missing score data") else: # status == constants.statuses["rating"]["replacingData"]: body = create_error(status, "replacing score IDs") return jsonify(body), http_status
def delete_all_games(): current_app.logger.info( f"Deleting all games by {request.environ['user_email']}") count, status = Storage.delete_all_games() http_status = constants.responses[status] return jsonify(dict(deleted=count, status=status)), http_status
def get_game_rating(game_id): game, status = Storage.get_game_rating(game_id) http_status = constants.responses[status] if status == constants.statuses["rating"]["returned"]: body = dict(rating=game, status=status) else: body = create_error(status, "no such game id: {{ID}}", ID=game_id) return jsonify(body), http_status
def delete_game(prod_id=None): prod_id = prod_id or request.args.get("id") current_app.logger.info( f"Deleting game by {request.environ['user_email']} and game id {prod_id}" ) game, status = Storage.delete_game(prod_id) http_status = constants.responses[status] if status == constants.statuses["game"]["deleted"]: body = dict(game=game, status=status) else: body = create_error(status, "no such game id: {{ID}}", ID=prod_id) return jsonify(body), http_status
def add_game(): current_app.logger.info(f"Creating game by {request.environ['user_email']}") new_id, status = Storage.add_game(**request.json) http_status = constants.responses[status] if status == constants.statuses["game"]["created"]: body = dict(id=new_id, status=status) elif status == constants.statuses["game"]["missingData"]: body = create_error(status, "missing game data") elif status == constants.statuses["game"]["extraFields"]: body = create_error(status, "Extra fields in data") else: # status == constants.statuses["game"]["invalidData"]: body = create_error(status, "Game data is invalid") return jsonify(body), http_status
def delete_score(game_id=None): current_app.logger.info( f"Deleting score by {request.environ['user_email']} and game id {game_id}" ) game, status = Storage.delete_score(game_id, request.environ["user_id"]) http_status = constants.responses[status] if status == constants.statuses["rating"]["deleted"]: body = dict(game=game, status=status) else: # status == constants.statuses["rating"]["notExists"]: body = create_error(status, "no your score for game id: {{ID}}", ID=game_id) return jsonify(body), http_status
def get_user_scores(user_id=None): if user_id is None: user_id = request.environ.get("user_id") if user_id is None: return ( jsonify( create_error( constants.statuses["user"]["unauthorized"], "No token detected" ) ), constants.common_responses["No auth"], ) scores, status = Storage.get_user_scores(user_id=user_id) http_status = constants.responses[status] return jsonify(scores=scores, status=status), http_status
def patch_game(prod_id=None): prod_id = prod_id or request.args.get("id") current_app.logger.info( f"Updating game by {request.environ['user_email']} and game id {prod_id}" ) game, status = Storage.update_game(prod_id, request.method, **request.json) http_status = constants.responses[status] if status == constants.statuses["game"]["modified"]: body = dict(game=game, status=status) elif status == constants.statuses["game"]["notExists"]: body = create_error(status, "no such game id: {{ID}}", ID=prod_id) elif status == constants.statuses["game"]["missingData"]: body = create_error(status, "missing game data") elif status == constants.statuses["game"]["extraFields"]: body = create_error(status, "Extra fields in data") elif status == constants.statuses["game"]["invalidData"]: body = create_error(status, "Game data is invalid") else: # status == constants.statuses["game"]["replacingData"]: body = create_error(status, "replacing game ID") return jsonify(body), http_status
def add_score(): current_app.logger.info( f"Add score to game {request.json.get('game_id')} by {request.environ['user_email']}" ) request.json["user_id"] = request.environ["user_id"] score, status = Storage.add_score(request.json) http_status = constants.responses[status] if status == constants.statuses["rating"]["created"]: body = dict(score=score, status=status) elif status == constants.statuses["rating"]["missingData"]: body = create_error(status, "missing score data") elif status == constants.statuses["rating"]["extraFields"]: body = create_error(status, "Extra fields in data") elif status == constants.statuses["rating"]["invalidData"]: body = create_error(status, "Rating data is invalid") else: # status == constants.statuses["rating"]["invalidGameId"]: body = create_error(status, "No game with such {{id}}", id=request.json.get("game_id")) return jsonify(body), http_status
class InsuranceService(object): """ The insurance service is the main portal for the clients and is responsible for validating signatures and storing the data records. """ def __init__(self, serializer: BaseSerializer, central_authority: CentralAuthority, public_key_scheme: BasePublicKey, storage_path: str = None) -> None: self.central_authority = central_authority self.storage = Storage(serializer, storage_path) self.public_key_scheme = public_key_scheme self.authorities = dict() # type: Dict[str, AttributeAuthority] @property def global_parameters(self): return self.central_authority.global_parameters def add_authority(self, attribute_authority: AttributeAuthority): """ Add an attribute authority. :param attribute_authority: The attribute authority to add. """ self.authorities[attribute_authority.name] = attribute_authority def create(self, create_record: CreateRecord) -> str: """ Create a new data record :param create_record: The data record to create. :return: The location of the record. """ # In future possibly adapt and check the record location = InsuranceService.determine_record_location(create_record) self.storage.store(location, create_record) return location def update(self, location: str, update_record: UpdateRecord): """ Update the data on the given location :param location: The location of the record to update the data of :param update_record: The UpdateRecord containing the updated data """ current_record = self.load(location) assert current_record is not None, 'Only existing records can be updated' assert self.public_key_scheme.verify( current_record.write_public_key, update_record.signature, update_record.data), 'Signature should be valid' current_record.update(update_record) self.storage.store(location, current_record) def policy_update(self, location: str, policy_update_record: PolicyUpdateRecord): """ Update the data on the given location :param location: The location of the record to update the policies of :param policy_update_record: The PolicyUpdateRecord containing the updated policies """ current_record = self.load(location) assert current_record is not None, 'Only existing records can be updated' assert self.public_key_scheme.verify( current_record.owner_public_key, policy_update_record.signature, pickle.dumps((policy_update_record.read_policy, policy_update_record.write_policy, policy_update_record.time_period ))), 'Signature should be valid' current_record.update_policy(policy_update_record) self.storage.store(location, current_record) @staticmethod def determine_record_location(record: DataRecord) -> str: """ Determine a unique location for a data record :param record: The data record :type record: records.data_record.DataRecord :return: A unique location """ return SHA.new(record.info).hexdigest() def load(self, location: str) -> DataRecord: return self.storage.load(location)
def __init__(self, config_file='app.ini'): self.storage_service = Storage(config_file)