l10n/it.php


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

<?php $TRANSLATIONS = array(
"News" => "Notizie",
"Can not add feed: Exists already" => "Impossible aggiungere la fonte: esiste già",
"Can not add feed: URL does not exist or has invalid xml" => "Impossibile aggiungere la fonte: l'URL non esiste o ha xml non valido",
"Can not add folder: Exists already" => "Impossibile aggiungere la cartella: esiste già",
"Undo deletion of %s" => "Annulla l'eliminazione di %s",
"Add Website" => "Aggiungi sito web",
"Error: address exists already!" => "Errore: l'indirizzo esiste già!",
"Error: folder exists already" => "Errore: la cartella esiste già",
"Address" => "Indirizzo",
"Add" => "Aggiungi",
"New folder" => "Nuova cartella",
"Folder" => "Cartella",
"Choose folder" => "Scegli cartella",
"Folder name" => "Nome della cartella",
"Back to folder selection" => "Torna alla selezione della cartella",
"Create folder" => "Crea cartella",
"Starred" => "Preferiti",
"Unread articles" => "Articoli non letti",
"All articles" => "Tutti gli articoli",
"Mark read" => "Marca come letto",
"from" => "da",
"by" => "da",
"Download" => "Scarica",
"Keep unread" => "Mantieni non letto",
"Delete website" => "Elimina sito web",
"Collapse" => "Contrai",
"Delete folder" => "Elimina la cartella",
"Rename folder" => "Rinomina la cartella",
"Import / Export OPML" => "Importa/Esporta OPML",
"Import" => "Importa",
"Export" => "Esporta",
"Error when importing: file does not contain valid OPML" => "Errore di importazione: il file non contiene OPML valido",
"Import Google Reader JSON" => "Importa JSON di Google Reader",
"To import starred and shared articles from Google \n\t\t\tReader please upload the .json files from the Google Takeout archive" => "Per importare gli articoli con stella e condivisi da Google\nReader carica i file .json dall'archivio Google Takeout",
"Error when importing: file does not contain valid JSON" => "Errore durante l'importazione: il file non contiene JSON valido",
"Show all" => "Mostra tutto",
"Show only unread" => "Mostra solo i non letti"
);
// SPDX-License-Identifier: GPL-3.0-or-later

#include "dyn_conf.h"

#define DYN_CONF_PATH_MAX (4096)
#define DYN_CONF_DIR VARLIB_DIR "/etc"

#define DYN_CONF_JOB_SCHEMA "job_schema"
#define DYN_CONF_SCHEMA "schema"
#define DYN_CONF_MODULE_LIST "modules"
#define DYN_CONF_JOB_LIST "jobs"
#define DYN_CONF_CFG_EXT ".cfg"

DICTIONARY *plugins_dict = NULL;

struct deferred_cfg_send {
    char *plugin_name;
    char *module_name;
    char *job_name;
    struct deferred_cfg_send *next;
};

struct deferred_cfg_send *deferred_configs = NULL;
pthread_mutex_t deferred_configs_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t deferred_configs_cond = PTHREAD_COND_INITIALIZER;

static void deferred_config_push_back(const char *plugin_name, const char *module_name, const char *job_name)
{
    struct deferred_cfg_send *deferred = callocz(1, sizeof(struct deferred_cfg_send));
    deferred->plugin_name = strdupz(plugin_name);
    if (module_name != NULL) {
        deferred->module_name = strdupz(module_name);
        if (job_name != NULL)
            deferred->job_name = strdupz(job_name);
    }
    pthread_mutex_lock(&deferred_configs_lock);
    struct deferred_cfg_send *last = deferred_configs;
    if (last == NULL)
        deferred_configs = deferred;
    else {
        while (last->next != NULL)
            last = last->next;
        last->next = deferred;
    }
    pthread_cond_signal(&deferred_configs_cond);
    pthread_mutex_unlock(&deferred_configs_lock);
}

static struct deferred_cfg_send *deferred_config_pop()
{
    pthread_mutex_lock(&deferred_configs_lock);
    while (deferred_configs == NULL)
        pthread_cond_wait(&deferred_configs_cond, &deferred_configs_lock);
    struct deferred_cfg_send *deferred = deferred_configs;
    deferred_configs = deferred_configs->next;
    pthread_mutex_unlock(&deferred_configs_lock);
    return deferred;
}

static void deferred_config_free(struct deferred_cfg_send *dcs)
{
    freez(dcs->plugin_name);
    freez(dcs->module_name);
    freez(dcs->job_name);
    freez(dcs);
}

static int _get_list_of_plugins_json_cb(const DICTIONARY_ITEM *item, void *entry, void *data)
{
    UNUSED(item);
    json_object *obj = (json_object *)data;
    struct configurable_plugin *plugin = (struct configurable_plugin *)entry;

    json_object *plugin_name = json_object_new_string(plugin->name);
    json_object_array_add(obj, plugin_name);

    return 0;
}

json_object *get_list_of_plugins_json()
{
    json_object *obj = json_object_new_array();

    dictionary_walkthrough_read(plugins_dict, _get_list_of_plugins_json_cb, obj);

    return obj;
}

static int _get_list_of_modules_json_cb(const DICTIONARY_ITEM *item, void *entry, void *data)
{
    UNUSED(item);
    json_object *obj = (json_object *)data;
    struct module *module = (struct module *)entry;

    json_object *json_module = json_object_new_object();

    json_object *json_item = json_object_new_string(module->name);
    json_object_object_add(json_module, "name", json_item);
    const char *module_type;
    switch (module->type) {
        case MOD_TYPE_SINGLE:
            module_type = "single";
            break;
        case MOD_TYPE_ARRAY:
            module_type = "job_array";
            break;
        default:
            module_type = "unknown";
            break;
    }
    json_item = json_object_new_string(module_type);
    json_object_object_add(json_module, "type", json_item);

    json_object_array_add(obj, json_module);

    return 0;
}

json_object *get_list_of_modules_json(struct configurable_plugin *plugin)
{
    json_object *obj = json_object_new_array();

    pthread_mutex_lock(&plugin->lock);

    dictionary_walkthrough_read(plugin->modules, _get_list_of_modules_json_cb, obj);

    pthread_mutex_unlock(&plugin->lock);

    return obj;
}

const char *job_status2str(enum job_status status)
{
    switch (status) {
        case JOB_STATUS_UNKNOWN:
            return "unknown";
        case JOB_STATUS_STOPPED:
            return "stopped";
        case JOB_STATUS_RUNNING