action.h

Go to the documentation of this file.

 
 
#ifndef ACTION_H
#define ACTION_H
 
#include <json-c.h>
#include <stdbool.h>
#include <stdio.h>
 
#include "const.h"
#include "cfg.h"
#include "db.h"
#include "server.h"
#include "types.h"
 
typedef enum {
    status_bad_request = 400,           
    status_unauthorized = 401,          
    status_forbidden = 403,             
    status_not_found = 404,             
    status_payload_too_large = 413,     
    status_unprocessable_content = 422, 
    status_too_many_requests = 429,     
    status_internal_server_error = 500  
} status_t;
 
typedef enum {
    action_error_type_type,        
    action_error_type_missing_key, 
    action_error_type_invalid,     
    action_error_type_rate_limit,  
    action_error_type_invariant,   
    action_error_type_other,       
} action_error_type_t;
 
typedef struct {
    action_error_type_t type;
    union {
        struct {
            char const *location;
            json_object *obj_actual;
            json_type expected;
        } type;
        struct {
            char const *location;
        } missing_key;
        struct {
            char const *location;
            char const *reason;
            json_object *obj_bad;
        } invalid;
        struct {
            time_t next_request_at;
        } rate_limit;
        struct {
            char const *name;
        } invariant;
        struct {
            status_t status;
        } other;
    } info;
} action_error_t;
 
typedef enum {
    action_type_error,
 
#define X(name) action_type_##name,
    X_ACTIONS(X)
#undef X
} action_type_t;
 
#define ACTION_TYPE(name) CAT(action_type_, name)
 
typedef struct {
    action_type_t type;
    union {
        action_error_t error;
        struct {
            api_key_t api_key;
            slice_t password;
        } login;
        struct {
            token_t token;
        } logout, motd;
        struct {
            api_key_t api_key;
            serial_t user_id;
        } whois;
        struct {
            token_t token;
            serial_t dest_user_id;
            slice_t content;
        } send;
        struct {
            token_t token;
            page_number_t page;
        } inbox, outbox;
        struct {
            token_t token;
            serial_t msg_id;
            slice_t new_content;
        } edit;
        struct {
            token_t token;
            serial_t msg_id;
        } rm;
        struct {
            token_t token;
            serial_t user_id;
        } block, unblock, ban, unban;
    } with;
} action_t;
 
typedef struct {
    action_type_t type;
    bool has_next_page;
    union {
        action_error_t error;
        struct {
            token_t token;
        } login;
        struct {
            user_t user;
        } whois;
        struct {
            serial_t msg_id;
        } send;
        msg_list_t motd, inbox, outbox;
        /*struct {
 
        } edit;
        struct {
 
        } rm;
        struct {
 
        } block;
        struct {
 
        } unblock;
        struct {
 
        } ban;
        struct {
 
        } unban;*/
    } body;
} response_t;
 
void response_destroy(response_t *response);
 
response_t response_for_rate_limit(time_t next_request_at);
 
void put_role(role_flags_t role, FILE *stream);
 
action_t action_parse(cfg_t *cfg, db_t *db, json_object *obj);
 
response_t action_evaluate(action_t const *action, cfg_t *cfg, db_t *db, server_t *server);
 
json_object *response_to_json(response_t *response);
 
#ifndef NDEBUG
void action_explain(action_t const *action, FILE *output);
#endif // NDEBUG
 
#endif // ACTION_H