mirrors
/
mastodont-c
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
mastodont-c/src/notification.c

272 lines
8.9 KiB
C
Raw Blame History

/*
* This program is free software: you can redistribute it and/or modify it under
* the terms of the GNU Lesser General Public License as published by the Free
* Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include <stdlib.h>
#include <string.h>
#include <mastodont_hooks.h>
#include <mastodont_notification.h>
#include <mastodont_fetch.h>
#include <mastodont_json_helper.h>
#include <mastodont_query.h>
#include <mastodont_request.h>
#include <mastodont_generate.h>
static void _mstdnt_val_notif_type_call(cJSON* v, void* _type)
{
mstdnt_notification_t* type = _type;
if (strcmp(v->string, "type") != 0)
{
*type = 0;
return;
}
/* Sorted by most common notification type :^) */
if (strcmp(v->valuestring, "favourite") == 0) *type = MSTDNT_NOTIFICATION_FAVOURITE;
else if (strcmp(v->valuestring, "mention") == 0) *type = MSTDNT_NOTIFICATION_MENTION;
else if (strcmp(v->valuestring, "reblog") == 0) *type = MSTDNT_NOTIFICATION_REBLOG;
else if (strcmp(v->valuestring, "pleroma:emoji_reaction") == 0) *type = MSTDNT_NOTIFICATION_EMOJI_REACT;
else if (strcmp(v->valuestring, "follow") == 0) *type = MSTDNT_NOTIFICATION_FOLLOW;
else if (strcmp(v->valuestring, "follow_request") == 0) *type = MSTDNT_NOTIFICATION_FOLLOW;
else if (strcmp(v->valuestring, "poll") == 0) *type = MSTDNT_NOTIFICATION_POLL;
else if (strcmp(v->valuestring, "status") == 0) *type = MSTDNT_NOTIFICATION_STATUS;
else if (strcmp(v->valuestring, "pleroma:chat_mention") == 0) *type = MSTDNT_NOTIFICATION_CHAT_MENTION;
else if (strcmp(v->valuestring, "pleroma:report") == 0) *type = MSTDNT_NOTIFICATION_REPORT;
}
static void _mstdnt_val_malloc_notification_pleroma_call(cJSON* v, void* _type)
{
struct mstdnt_notification_pleroma** type = _type;
*type = mstdnt_calloc(1, sizeof(struct mstdnt_notification_pleroma));
if (*type)
mstdnt_notification_pleroma_json(*type, v->child);
}
int mstdnt_notification_json(struct mstdnt_notification* notif, cJSON* js)
{
cJSON* v;
if (!notif) return 1;
/* Zero out */
memset(notif, 0, sizeof(struct mstdnt_notification));
struct _mstdnt_val_ref vals[] = {
{ "account", &(notif->account), _mstdnt_val_malloc_account_call },
{ "created_at", &(notif->created_at), _mstdnt_val_datetime_unix_call },
{ "emoji", &(notif->emoji), _mstdnt_val_string_call },
{ "id", &(notif->id), _mstdnt_val_string_call },
{ "status", &(notif->status), _mstdnt_val_malloc_status_call },
{ "pleroma", &(notif->pleroma), _mstdnt_val_malloc_notification_pleroma_call },
{ "type", &(notif->type), _mstdnt_val_notif_type_call },
};
for (v = js; v; v = v->next)
_mstdnt_key_val_ref(v, vals, _mstdnt_arr_len(vals));
return 0;
}
int mstdnt_notification_pleroma_json(struct mstdnt_notification_pleroma* notif, cJSON* js)
{
cJSON* v;
if (!notif) return 1;
/* Zero out */
memset(notif, 0, sizeof(struct mstdnt_notification_pleroma));
struct _mstdnt_val_ref vals[] = {
{ "is_muted", &(notif->is_muted), _mstdnt_val_bool_call },
{ "is_seen", &(notif->is_seen), _mstdnt_val_bool_call },
};
for (v = js; v; v = v->next)
_mstdnt_key_val_ref(v, vals, _mstdnt_arr_len(vals));
return 0;
}
int mstdnt_notification_json_callback(cJSON* json, void* notif)
{
return mstdnt_notification_json(notif, json->child);
}
GENERATE_JSON_ARRAY_FUNC(mstdnt_notifications_json, struct mstdnt_notification, mstdnt_notification_json)
int mstdnt_notifications_json_callback(cJSON* json, void* _args)
{
struct _mstdnt_notifications_result_cb_args* args = _args;
return mstdnt_notifications_json(args->notif, args->size, json);
}
int mstdnt_get_notifications(mastodont_t* data,
struct mstdnt_args* m_args,
struct mstdnt_notifications_args* args,
struct mstdnt_storage* storage,
struct mstdnt_notification** notifs,
size_t* size)
{
struct _mstdnt_notifications_result_cb_args cb_args = { notifs, size };
union param_value u_exclude_types, u_account_id, u_exclude_visibilities,
u_include_types, u_with_muted, u_max_id, u_min_id,
u_since_id, u_offset, u_limit;
/* TODO Arrays of excludes, includes */
u_account_id.s = args->account_id;
u_with_muted.i = args->with_muted;
u_max_id.s = args->max_id;
u_since_id.s = args->since_id;
u_min_id.s = args->min_id;
u_offset.i = args->offset;
u_limit.i = args->limit;
struct _mstdnt_query_param params[] = {
{ _MSTDNT_QUERY_STRING, "account_id", u_account_id },
{ _MSTDNT_QUERY_INT, "with_muted", u_with_muted },
{ _MSTDNT_QUERY_STRING, "max_id", u_max_id },
{ _MSTDNT_QUERY_STRING, "since_id", u_since_id },
{ _MSTDNT_QUERY_STRING, "min_id", u_min_id },
{ _MSTDNT_QUERY_INT, "offset", u_offset },
{ _MSTDNT_QUERY_INT, "limit", u_limit },
};
struct mstdnt_request_args req_args = {
storage,
"api/v1/notifications",
params, _mstdnt_arr_len(params),
NULL, 0,
CURLOPT_HTTPGET,
NULL,
&cb_args,
mstdnt_notifications_json_callback,
};
return mstdnt_request(data, m_args, &req_args);
}
int mstdnt_notification_dismiss(mastodont_t* data,
struct mstdnt_args* m_args,
struct mstdnt_storage* storage,
char* id)
{
char url[MSTDNT_URLSIZE];
snprintf(url, MSTDNT_URLSIZE, "api/v1/notifications/%s/dismiss", id);
struct mstdnt_request_args req_args = {
storage,
url,
NULL, 0,
NULL, 0,
CURLOPT_POST,
NULL,
NULL,
NULL,
};
return mstdnt_request(data, m_args, &req_args);
}
int mstdnt_notifications_clear(mastodont_t* data,
struct mstdnt_args* m_args,
struct mstdnt_storage* storage)
{
struct mstdnt_request_args req_args = {
storage,
"api/v1/notifications/clear",
NULL, 0,
NULL, 0,
CURLOPT_POST,
NULL,
NULL,
NULL,
};
return mstdnt_request(data, m_args, &req_args);
}
int mstdnt_notifications_read(mastodont_t* data,
struct mstdnt_args* m_args,
struct mstdnt_notifications_args* args,
struct mstdnt_storage* storage,
struct mstdnt_notification* notification)
{
struct _mstdnt_query_param params[] = {
{ _MSTDNT_QUERY_STRING, "id", { .s = args ? args->id : NULL } },
{ _MSTDNT_QUERY_STRING, "max_id", { .s = args ? args->max_id : NULL } },
};
struct mstdnt_request_args req_args = {
storage,
"api/v1/pleroma/notifications/read",
NULL, 0,
params, _mstdnt_arr_len(params),
CURLOPT_POST,
NULL,
notification,
mstdnt_notification_json_callback,
};
return mstdnt_request(data, m_args, &req_args);
}
void mstdnt_cleanup_notifications(struct mstdnt_notification* notifs, size_t notifs_len)
{
size_t i;
if (!notifs) return;
for (i = 0; i < notifs_len; ++i)
mstdnt_cleanup_notification(notifs + i);
mstdnt_free(notifs);
}
void mstdnt_cleanup_notification(struct mstdnt_notification* notif)
{
if (notif->account)
{
mstdnt_cleanup_account(notif->account);
mstdnt_free(notif->account);
}
if (notif->status)
{
mstdnt_cleanup_status(notif->status);
mstdnt_free(notif->status);
}
mstdnt_free(notif->pleroma);
}
const char* mstdnt_notification_t_to_str(mstdnt_notification_t type)
{
switch (type)
{
case MSTDNT_NOTIFICATION_FOLLOW: return "follow";
case MSTDNT_NOTIFICATION_FOLLOW_REQUEST: return "follow request";
case MSTDNT_NOTIFICATION_MENTION: return "mention";
case MSTDNT_NOTIFICATION_REBLOG: return "reblog";
case MSTDNT_NOTIFICATION_FAVOURITE: return "favourite";
case MSTDNT_NOTIFICATION_POLL: return "poll";
case MSTDNT_NOTIFICATION_STATUS: return "status";
case MSTDNT_NOTIFICATION_EMOJI_REACT: return "emoji reaction";
case MSTDNT_NOTIFICATION_CHAT_MENTION: return "chat mention";
case MSTDNT_NOTIFICATION_REPORT: return "report";
case MSTDNT_NOTIFICATION_NOOP:
default:
return "unknown";
}
}
Reference in New Issue View Git Blame Copy Permalink