Skip to content

user_routes

routes.user_routes

DEFAULT_PAGE_IDX module-attribute 

DEFAULT_PAGE_IDX = 1

DEFAULT_PAGE_SIZE module-attribute 

DEFAULT_PAGE_SIZE = 6

OrderBy

Bases: Enum

Order by column

Source code in yaptide/routes/user_routes.py 
25
26
27
28
29
class OrderBy(Enum):
    """Order by column"""

    START_TIME = "start_time"
    END_TIME = "end_time"

END_TIME class-attribute instance-attribute 

END_TIME = 'end_time'

START_TIME class-attribute instance-attribute 

START_TIME = 'start_time'

OrderType

Bases: Enum

Order type

Source code in yaptide/routes/user_routes.py 
18
19
20
21
22
class OrderType(Enum):
    """Order type"""

    ASCEND = "ascend"
    DESCEND = "descend"

ASCEND class-attribute instance-attribute 

ASCEND = 'ascend'

DESCEND class-attribute instance-attribute 

DESCEND = 'descend'

UserSimulations

Bases: Resource

Class responsible for returning user's simulations' basic infos

Source code in yaptide/routes/user_routes.py 
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
class UserSimulations(Resource):
    """Class responsible for returning user's simulations' basic infos"""

    class APIParametersSchema(Schema):
        """Class specifies API parameters"""

        page_size = fields.Integer(load_default=DEFAULT_PAGE_SIZE)
        page_idx = fields.Integer(load_default=DEFAULT_PAGE_IDX)
        order_by = fields.String(load_default=OrderBy.START_TIME.value)
        order_type = fields.String(load_default=OrderType.DESCEND.value)

    @staticmethod
    @requires_auth()
    def get(user: UserModel):
        """Method returning simulations from the database"""
        schema = UserSimulations.APIParametersSchema()
        params_dict: dict = schema.load(request.args)
        logging.info('User %s requested simulations with parameters: %s', user.username, params_dict)

        # Query the database for the paginated results
        sorting = desc if params_dict['order_type'] == OrderType.DESCEND.value else asc
        query = SimulationModel.query.\
            filter(SimulationModel.job_id != None).\
            filter_by(user_id=user.id).\
            order_by(sorting(params_dict['order_by']))
        pagination = query.paginate(page=params_dict['page_idx'], per_page=params_dict['page_size'], error_out=False)
        simulations = pagination.items

        result = {
            'simulations': [
                {
                    'title': simulation.title,
                    'job_id': simulation.job_id,
                    'start_time': simulation.start_time,
                    # submission time, when user send the request to the backend - jobs may start much later than that
                    'end_time': simulation.end_time,
                    # end time, when the all jobs are finished and results are merged
                    'metadata': {
                        'platform': simulation.platform,
                        'server': 'Yaptide',
                        'input_type': simulation.input_type,
                        'sim_type': simulation.sim_type
                    }
                }
                for simulation in simulations],
            'page_count': pagination.pages,
            'simulations_count': pagination.total,
        }
        return yaptide_response(message='User Simulations', code=200, content=result)

APIParametersSchema

Bases: Schema

Class specifies API parameters

Source code in yaptide/routes/user_routes.py 
35
36
37
38
39
40
41
class APIParametersSchema(Schema):
    """Class specifies API parameters"""

    page_size = fields.Integer(load_default=DEFAULT_PAGE_SIZE)
    page_idx = fields.Integer(load_default=DEFAULT_PAGE_IDX)
    order_by = fields.String(load_default=OrderBy.START_TIME.value)
    order_type = fields.String(load_default=OrderType.DESCEND.value)
order_by class-attribute instance-attribute 
order_by = String(load_default=START_TIME.value)
order_type class-attribute instance-attribute 
order_type = String(load_default=DESCEND.value)
page_idx class-attribute instance-attribute 
page_idx = Integer(load_default=DEFAULT_PAGE_IDX)
page_size class-attribute instance-attribute 
page_size = Integer(load_default=DEFAULT_PAGE_SIZE)

get staticmethod 

get(user)

Method returning simulations from the database

Source code in yaptide/routes/user_routes.py 
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
@staticmethod
@requires_auth()
def get(user: UserModel):
    """Method returning simulations from the database"""
    schema = UserSimulations.APIParametersSchema()
    params_dict: dict = schema.load(request.args)
    logging.info('User %s requested simulations with parameters: %s', user.username, params_dict)

    # Query the database for the paginated results
    sorting = desc if params_dict['order_type'] == OrderType.DESCEND.value else asc
    query = SimulationModel.query.\
        filter(SimulationModel.job_id != None).\
        filter_by(user_id=user.id).\
        order_by(sorting(params_dict['order_by']))
    pagination = query.paginate(page=params_dict['page_idx'], per_page=params_dict['page_size'], error_out=False)
    simulations = pagination.items

    result = {
        'simulations': [
            {
                'title': simulation.title,
                'job_id': simulation.job_id,
                'start_time': simulation.start_time,
                # submission time, when user send the request to the backend - jobs may start much later than that
                'end_time': simulation.end_time,
                # end time, when the all jobs are finished and results are merged
                'metadata': {
                    'platform': simulation.platform,
                    'server': 'Yaptide',
                    'input_type': simulation.input_type,
                    'sim_type': simulation.sim_type
                }
            }
            for simulation in simulations],
        'page_count': pagination.pages,
        'simulations_count': pagination.total,
    }
    return yaptide_response(message='User Simulations', code=200, content=result)

UserUpdate

Bases: Resource

Class responsible for updating the user

Source code in yaptide/routes/user_routes.py 
83
84
85
86
87
88
89
90
91
92
93
class UserUpdate(Resource):
    """Class responsible for updating the user"""

    @staticmethod
    @requires_auth()
    def post(user: UserModel):
        """Updates user with provided parameters"""
        json_data: dict = request.get_json(force=True)
        if not json_data:
            return error_validation_response()
        return yaptide_response(message=f'User {user.username} updated', code=202)

post staticmethod 

post(user)

Updates user with provided parameters

Source code in yaptide/routes/user_routes.py 
86
87
88
89
90
91
92
93
@staticmethod
@requires_auth()
def post(user: UserModel):
    """Updates user with provided parameters"""
    json_data: dict = request.get_json(force=True)
    if not json_data:
        return error_validation_response()
    return yaptide_response(message=f'User {user.username} updated', code=202)