358 lines
12 KiB
C
358 lines
12 KiB
C
/*
|
|
* 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 <string.h>
|
|
#include <stdlib.h>
|
|
#include <mastodont_json_helper.h>
|
|
#include <mastodont_status.h>
|
|
#include <mastodont_account.h>
|
|
#include <mastodont_query.h>
|
|
#include <mastodont_pleroma.h>
|
|
|
|
int mstdnt_load_status_from_json(struct mstdnt_status* status, cJSON* js)
|
|
{
|
|
cJSON* v;
|
|
|
|
struct _mstdnt_generic_args att_args = {
|
|
&(status->media_attachments),
|
|
&(status->media_attachments_len),
|
|
};
|
|
|
|
struct _mstdnt_val_ref vals[] = {
|
|
{ "id", &(status->id), _mstdnt_val_string_call },
|
|
{ "uri", &(status->uri), _mstdnt_val_string_call },
|
|
{ "created_at", &(status->created_at), _mstdnt_val_string_call },
|
|
{ "content", &(status->content), _mstdnt_val_string_call },
|
|
{ "spoiler_text", &(status->spoiler_text), _mstdnt_val_string_call },
|
|
{ "in_reply_to_id", &(status->in_reply_to_id), _mstdnt_val_string_call },
|
|
{ "language", &(status->language), _mstdnt_val_string_call },
|
|
{ "url", &(status->url), _mstdnt_val_string_call },
|
|
{ "text", &(status->text), _mstdnt_val_string_call },
|
|
{ "in_reply_to_account_id", &(status->in_reply_to_account_id), _mstdnt_val_string_call },
|
|
{ "sensitive", &(status->sensitive), _mstdnt_val_bool_call },
|
|
{ "favourited", &(status->favourited), _mstdnt_val_bool_call },
|
|
{ "reblogged", &(status->reblogged), _mstdnt_val_bool_call },
|
|
{ "muted", &(status->muted), _mstdnt_val_bool_call },
|
|
{ "bookmarked", &(status->bookmarked), _mstdnt_val_bool_call },
|
|
{ "pinned", &(status->pinned), _mstdnt_val_bool_call },
|
|
{ "reblogs_count", &(status->reblogs_count), _mstdnt_val_uint_call },
|
|
{ "favourites_count", &(status->favourites_count), _mstdnt_val_uint_call },
|
|
{ "replies_count", &(status->replies_count), _mstdnt_val_uint_call },
|
|
{ "media_attachments", &att_args, _mstdnt_val_attachments_call },
|
|
{ "pleroma", &(status->pleroma), _mstdnt_val_status_pleroma_call }
|
|
};
|
|
|
|
for (v = js; v; v = v->next)
|
|
if (_mstdnt_key_val_ref(v, vals, _mstdnt_arr_len(vals)) == 1)
|
|
if (cJSON_IsObject(v))
|
|
if (strcmp("account", v->string) == 0)
|
|
mstdnt_load_account_from_json(&(status->account), v->child);
|
|
return 0;
|
|
}
|
|
|
|
int mstdnt_load_status_from_result(struct mstdnt_status* status,
|
|
struct mstdnt_storage* storage,
|
|
struct mstdnt_fetch_results* results)
|
|
{
|
|
cJSON* root;
|
|
if (_mstdnt_json_init(&root, results, storage))
|
|
return 1;
|
|
|
|
if (!cJSON_IsObject(root))
|
|
return 1;
|
|
|
|
if (!mstdnt_load_status_from_json(status, root->child))
|
|
storage->needs_cleanup = 1;
|
|
|
|
return 1;
|
|
}
|
|
|
|
int mstdnt_load_statuses_from_result(struct mstdnt_status* statuses[],
|
|
struct mstdnt_storage* storage,
|
|
struct mstdnt_fetch_results* results,
|
|
size_t* size)
|
|
{
|
|
size_t i = 0;
|
|
cJSON* root, *status_j_list;
|
|
if (_mstdnt_json_init(&root, results, storage))
|
|
return 1;
|
|
|
|
if (!cJSON_IsArray(root))
|
|
return 1;
|
|
|
|
if (size) *size = cJSON_GetArraySize(root);
|
|
|
|
/* malloc array - cJSON does a loop to count, let's do it once preferably */
|
|
*statuses = malloc((size ? *size : cJSON_GetArraySize(root))
|
|
* sizeof(struct mstdnt_status));
|
|
if (*statuses == NULL)
|
|
return 1;
|
|
|
|
cJSON_ArrayForEach(status_j_list, root)
|
|
{
|
|
mstdnt_load_status_from_json((*statuses) + i++, status_j_list->child);
|
|
}
|
|
storage->needs_cleanup = 1;
|
|
return 0;
|
|
}
|
|
|
|
int mastodont_account_statuses(mastodont_t* data,
|
|
char* id,
|
|
struct mstdnt_account_statuses_args* args,
|
|
struct mstdnt_storage* storage,
|
|
struct mstdnt_status* statuses[],
|
|
size_t* size)
|
|
{
|
|
int res;
|
|
char url[MSTDNT_URLSIZE];
|
|
struct mstdnt_fetch_results results = { 0 };
|
|
snprintf(url, MSTDNT_URLSIZE, "api/v1/accounts/%s/statuses", id);
|
|
|
|
/* Default args */
|
|
struct mstdnt_account_statuses_args _args;
|
|
if (args == NULL)
|
|
{
|
|
_args.pinned = 0;
|
|
_args.tagged = NULL;
|
|
_args.with_muted = 1;
|
|
_args.offset = 0;
|
|
_args.exclude_reblogs = 0;
|
|
_args.exclude_replies = 0;
|
|
_args.only_media = 0;
|
|
_args.max_id = NULL;
|
|
_args.since_id = NULL;
|
|
_args.min_id = NULL;
|
|
_args.limit = 20;
|
|
args = &_args;
|
|
}
|
|
storage->needs_cleanup = 0;
|
|
|
|
if (mastodont_fetch_curl(data, url, &results, CURLOPT_HTTPGET) != CURLE_OK)
|
|
return 1;
|
|
|
|
res = mstdnt_load_statuses_from_result(statuses, storage, &results, size);
|
|
|
|
mastodont_fetch_results_cleanup(&results);
|
|
|
|
return res;
|
|
}
|
|
|
|
int mastodont_create_status(mastodont_t* data,
|
|
struct mstdnt_create_status_args* args,
|
|
struct mstdnt_storage* storage)
|
|
{
|
|
int res = 0;
|
|
char* post;
|
|
struct mstdnt_fetch_results results = { 0 };
|
|
|
|
/* Default args */
|
|
struct mstdnt_create_status_args _args;
|
|
if (args == NULL)
|
|
{
|
|
_args.content_type = "html"; /* TODO */
|
|
_args.expires_in = 0;
|
|
_args.in_reply_to_conversation_id = NULL;
|
|
_args.in_reply_to_id = NULL;
|
|
_args.language = NULL;
|
|
_args.media_ids = NULL;
|
|
_args.poll = NULL;
|
|
_args.preview = 0;
|
|
_args.scheduled_at = NULL;
|
|
_args.sensitive = 0;
|
|
_args.spoiler_text = NULL;
|
|
_args.status = NULL;
|
|
_args.visibility = "public";
|
|
args = &_args;
|
|
}
|
|
storage->needs_cleanup = 0;
|
|
|
|
union param_value u_content_type, u_expires_in,
|
|
u_in_reply_to_conversation_id, u_in_reply_to_id,
|
|
u_language, u_media_ids, u_poll, u_preview, u_scheduled_at,
|
|
u_sensitive, u_spoiler_text, u_status, u_visibility;
|
|
u_content_type.s = args->content_type;
|
|
u_expires_in.i = args->expires_in;
|
|
u_in_reply_to_conversation_id.s = args->in_reply_to_conversation_id;
|
|
u_in_reply_to_id.s = args->in_reply_to_id;
|
|
u_language.s = args->language;
|
|
/*u_media_ids.s = args->media_ids;*/
|
|
/* poll */
|
|
u_preview.i = args->preview;
|
|
u_scheduled_at.s = args->scheduled_at;
|
|
u_sensitive.i = args->sensitive;
|
|
u_spoiler_text.s = args->spoiler_text;
|
|
u_status.s = args->status;
|
|
u_visibility.s = args->visibility;
|
|
|
|
struct _mstdnt_query_param params[] = {
|
|
{ _MSTDNT_QUERY_STRING, "in_reply_to_id", u_in_reply_to_id },
|
|
{ _MSTDNT_QUERY_STRING, "content_type", u_content_type },
|
|
{ _MSTDNT_QUERY_STRING, "status", u_status },
|
|
{ _MSTDNT_QUERY_STRING, "visibility", u_visibility },
|
|
};
|
|
|
|
post = _mstdnt_query_string(NULL, params, _mstdnt_arr_len(params));
|
|
|
|
curl_easy_setopt(data->curl, CURLOPT_POSTFIELDS, post);
|
|
|
|
if (mastodont_fetch_curl(data, "api/v1/statuses", &results, CURLOPT_POST) != CURLE_OK)
|
|
return 1;
|
|
|
|
mastodont_fetch_results_cleanup(&results);
|
|
return 0;
|
|
}
|
|
|
|
int mastodont_favourite_status(mastodont_t* data,
|
|
char* id,
|
|
struct mstdnt_storage* storage)
|
|
{
|
|
char url[MSTDNT_URLSIZE];
|
|
struct mstdnt_fetch_results results = { 0 };
|
|
snprintf(url, MSTDNT_URLSIZE,
|
|
"api/v1/statuses/%s/favourite", id);
|
|
|
|
storage->needs_cleanup = 0;
|
|
|
|
if (mastodont_fetch_curl(data, url, &results, CURLOPT_POST) != CURLE_OK)
|
|
return 1;
|
|
|
|
mastodont_fetch_results_cleanup(&results);
|
|
return 0;
|
|
}
|
|
|
|
|
|
int mastodont_reblog_status(mastodont_t* data,
|
|
char* id,
|
|
struct mstdnt_storage* storage)
|
|
{
|
|
char url[MSTDNT_URLSIZE];
|
|
struct mstdnt_fetch_results results = { 0 };
|
|
snprintf(url, MSTDNT_URLSIZE,
|
|
"api/v1/statuses/%s/reblog", id);
|
|
|
|
storage->needs_cleanup = 0;
|
|
|
|
if (mastodont_fetch_curl(data, url, &results, CURLOPT_POST) != CURLE_OK)
|
|
return 1;
|
|
|
|
mastodont_fetch_results_cleanup(&results);
|
|
return 0;
|
|
}
|
|
|
|
int mastodont_view_status(mastodont_t* data,
|
|
char* id,
|
|
struct mstdnt_storage* storage,
|
|
struct mstdnt_status* status)
|
|
{
|
|
int res;
|
|
char url[MSTDNT_URLSIZE];
|
|
struct mstdnt_fetch_results results = { 0 };
|
|
snprintf(url, MSTDNT_URLSIZE, "api/v1/statuses/%s", id);
|
|
storage->needs_cleanup = 0;
|
|
|
|
if (mastodont_fetch_curl(data, url, &results, CURLOPT_HTTPGET) != CURLE_OK)
|
|
return 1;
|
|
|
|
res = mstdnt_load_status_from_result(status, storage, &results);
|
|
|
|
mastodont_fetch_results_cleanup(&results);
|
|
|
|
return res;
|
|
}
|
|
|
|
int mastodont_status_context(mastodont_t* data,
|
|
char* id,
|
|
struct mstdnt_storage* storage,
|
|
struct mstdnt_status* statuses_before[],
|
|
struct mstdnt_status* statuses_after[],
|
|
size_t* size_before,
|
|
size_t* size_after)
|
|
{
|
|
int res = 0;
|
|
cJSON* root, *v, *status_item;
|
|
size_t* size_ptr;
|
|
struct mstdnt_status** stat_ptr = NULL;
|
|
char url[MSTDNT_URLSIZE];
|
|
struct mstdnt_fetch_results results = { 0 };
|
|
snprintf(url, MSTDNT_URLSIZE, "api/v1/statuses/%s/context", id);
|
|
storage->needs_cleanup = 0;
|
|
|
|
*size_before = 0;
|
|
*size_after = 0;
|
|
*statuses_before = NULL;
|
|
*statuses_after = NULL;
|
|
|
|
if (mastodont_fetch_curl(data, url, &results, CURLOPT_HTTPGET) != CURLE_OK)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
if (_mstdnt_json_init(&root, &results, storage))
|
|
{
|
|
res = 1;
|
|
goto cleanup;
|
|
}
|
|
storage->root = root;
|
|
|
|
for (v = root->child; v; v = v->next)
|
|
{
|
|
if (cJSON_IsObject(v->child))
|
|
{
|
|
/* Set pointers */
|
|
if (strcmp(v->string, "ancestors") == 0)
|
|
{
|
|
stat_ptr = statuses_before;
|
|
size_ptr = size_before;
|
|
}
|
|
if (strcmp(v->string, "descendants") == 0) {
|
|
stat_ptr = statuses_after;
|
|
size_ptr = size_after;
|
|
}
|
|
|
|
/* Skip allocating empty arrays */
|
|
if (cJSON_GetArraySize(v) <= 0)
|
|
continue;
|
|
|
|
*stat_ptr = malloc(cJSON_GetArraySize(v) * sizeof(struct mstdnt_status));
|
|
if (*stat_ptr == NULL)
|
|
return 1;
|
|
|
|
cJSON_ArrayForEach(status_item, v)
|
|
mstdnt_load_status_from_json((*stat_ptr) + (*size_ptr)++, status_item->child);
|
|
}
|
|
}
|
|
storage->needs_cleanup = 1;
|
|
cleanup:
|
|
mastodont_fetch_results_cleanup(&results);
|
|
|
|
return res;
|
|
}
|
|
|
|
void cleanup_status(struct mstdnt_status* status)
|
|
{
|
|
cleanup_attachments(status->media_attachments);
|
|
cleanup_status_pleroma(&(status->pleroma));
|
|
}
|
|
|
|
void cleanup_statuses(struct mstdnt_status* statuses, size_t s)
|
|
{
|
|
size_t i;
|
|
if (!statuses) return;
|
|
for (i = 0; i < s; ++i)
|
|
{
|
|
cleanup_status(statuses + i);
|
|
}
|
|
free(statuses);
|
|
}
|