( access_t *perm, void *opaque, const char *op, htsmsg_t *args, htsmsg_t **resp )
{
dvr_entry_t *de;
- const char *config_uuid, *comment;
epg_broadcast_t *e;
- htsmsg_t *entries, *entries2 = NULL, *m, *l = NULL;
+ htsmsg_t *entries, *entries2 = NULL, *m, *l = NULL, *conf;
htsmsg_field_t *f;
- const char *s;
- int count = 0, enabled;
- char ubuf[UUID_HEX_SIZE];
+ const char *s, *config_uuid;
+ int count = 0;
if (!(entries = htsmsg_get_list(args, "entries"))) {
entries = entries2 = api_dvr_entry_create_from_single(args);
if (!(s = htsmsg_get_str(m, "event_id")))
continue;
- enabled = htsmsg_get_u32_or_default(m, "enabled", 1);
+ conf = htsmsg_create_map();
+ htsmsg_copy_field(conf, "enabled", m, NULL);
+ htsmsg_copy_field(conf, "comment", m, NULL);
+ htsmsg_add_str(conf, "owner", perm->aa_username);
+ htsmsg_add_str(conf, "creator", perm->aa_representative);
config_uuid = htsmsg_get_str(m, "config_uuid");
- comment = htsmsg_get_str(m, "comment");
+ de = NULL;
pthread_mutex_lock(&global_lock);
if ((e = epg_broadcast_find_by_id(strtoll(s, NULL, 10)))) {
dvr_config_t *cfg = dvr_config_find_by_list(perm->aa_dvrcfgs, config_uuid);
if (cfg) {
- de = dvr_entry_create_by_event(enabled,
- idnode_uuid_as_str(&cfg->dvr_id, ubuf),
- e, 0, 0,
- perm->aa_username,
- perm->aa_representative,
- NULL, DVR_PRIO_DEFAULT, DVR_RET_REM_DVRCONFIG,
- DVR_RET_REM_DVRCONFIG, comment);
- if (de) {
- if (l == NULL)
- l = htsmsg_create_list();
- htsmsg_add_uuid(l, NULL, &de->de_id.in_uuid);
+ htsmsg_add_uuid(conf, "config_name", &cfg->dvr_id.in_uuid);
+ htsmsg_copy_field(conf, "config_name", m, "config_uuid");
+ de = dvr_entry_create_from_htsmsg(conf, e);
+ if (de)
idnode_changed(&de->de_id);
- }
}
}
pthread_mutex_unlock(&global_lock);
+
+ htsmsg_destroy(conf);
+
+ if (de) {
+ if (l == NULL)
+ l = htsmsg_create_list();
+ htsmsg_add_uuid(l, NULL, &de->de_id.in_uuid);
+ }
+
count++;
}
dvr_entry_t *
dvr_entry_create ( const char *uuid, htsmsg_t *conf, int clone );
-
-dvr_entry_t *
-dvr_entry_create_by_event( int enabled,
- const char *dvr_config_uuid,
- epg_broadcast_t *e,
- time_t start_extra, time_t stop_extra,
- const char *owner, const char *creator,
- dvr_autorec_entry_t *dae,
- dvr_prio_t pri, int retention, int removal,
- const char *comment );
-
dvr_entry_t *
-dvr_entry_create_htsp( int enabled, const char *dvr_config_uuid,
- channel_t *ch, time_t start, time_t stop,
- time_t start_extra, time_t stop_extra,
- const char *title, const char *subtitle,
- const char *description,
- const char *lang, epg_genre_t *content_type,
- const char *owner, const char *creator,
- dvr_autorec_entry_t *dae,
- dvr_prio_t pri, int retention, int removal,
- const char *comment );
+dvr_entry_create_from_htsmsg( htsmsg_t *conf, epg_broadcast_t *e );
dvr_entry_t *
dvr_entry_update( dvr_entry_t *de, int enabled,
dvr_autorec_entry_t *
dvr_autorec_create(const char *uuid, htsmsg_t *conf);
-dvr_entry_t *
-dvr_entry_create_(int enabled, const char *config_uuid, epg_broadcast_t *e,
- channel_t *ch, time_t start, time_t stop,
- time_t start_extra, time_t stop_extra,
- const char *title, const char* subtitle, const char *description,
- const char *lang, epg_genre_t *content_type,
- const char *owner, const char *creator,
- dvr_autorec_entry_t *dae, dvr_timerec_entry_t *tae,
- dvr_prio_t pri, int retention, int removal, const char *comment);
-
dvr_autorec_entry_t *
dvr_autorec_create_htsp(htsmsg_t *conf);
* Create the event
*/
dvr_entry_t *
-dvr_entry_create_(int enabled, const char *config_uuid, epg_broadcast_t *e,
- channel_t *ch, time_t start, time_t stop,
- time_t start_extra, time_t stop_extra,
- const char *title, const char *subtitle, const char *description,
- const char *lang, epg_genre_t *content_type,
- const char *owner,
- const char *creator, dvr_autorec_entry_t *dae,
- dvr_timerec_entry_t *dte,
- dvr_prio_t pri, int retention, int removal,
- const char *comment)
+dvr_entry_create_from_htsmsg(htsmsg_t *conf, epg_broadcast_t *e)
{
dvr_entry_t *de;
char tbuf[64], *s;
struct tm tm;
time_t t;
- lang_str_t *l;
- htsmsg_t *conf;
char ubuf[UUID_HEX_SIZE];
+ epg_genre_t *genre;
- conf = htsmsg_create_map();
- if (enabled >= 0)
- htsmsg_add_u32(conf, "enabled", !!enabled);
- htsmsg_add_s64(conf, "start", start);
- htsmsg_add_s64(conf, "stop", stop);
- htsmsg_add_uuid(conf, "channel", &ch->ch_id.in_uuid);
- htsmsg_add_u32(conf, "pri", pri);
- htsmsg_add_u32(conf, "retention", retention);
- htsmsg_add_u32(conf, "removal", removal);
- htsmsg_add_str(conf, "config_name", config_uuid ?: "");
- htsmsg_add_s64(conf, "start_extra", start_extra);
- htsmsg_add_s64(conf, "stop_extra", stop_extra);
- htsmsg_add_str(conf, "owner", owner ?: "");
- htsmsg_add_str(conf, "creator", creator ?: "");
- htsmsg_add_str(conf, "comment", comment ?: "");
if (e) {
+ htsmsg_add_u32(conf, "broadcast", e->id);
htsmsg_add_u32(conf, "dvb_eid", e->dvb_eid);
+ htsmsg_set_uuid(conf, "channel", &e->channel->ch_id.in_uuid);
+ if (!htsmsg_field_find(conf, "start"))
+ htsmsg_add_s64(conf, "start", e->start);
+ if (!htsmsg_field_find(conf, "stop"))
+ htsmsg_add_s64(conf, "stop", e->stop);
if (e->episode && e->episode->title)
lang_str_serialize(e->episode->title, conf, "title");
if (e->episode && e->episode->subtitle)
htsmsg_add_str(conf, "uri", e->episode->uri);
if (e->episode && e->episode->image)
htsmsg_add_str(conf, "image", e->episode->image);
- } else if (title) {
- l = lang_str_create();
- lang_str_add(l, title, lang, 0);
- lang_str_serialize(l, conf, "title");
- lang_str_destroy(l);
- if (description) {
- l = lang_str_create();
- lang_str_add(l, description, lang, 0);
- lang_str_serialize(l, conf, "description");
- lang_str_destroy(l);
- }
- if (subtitle) {
- l = lang_str_create();
- lang_str_add(l, subtitle, lang, 0);
- lang_str_serialize(l, conf, "subtitle");
- lang_str_destroy(l);
- }
- }
- if (content_type)
- htsmsg_add_u32(conf, "content_type", content_type->code / 16);
- if (e)
- htsmsg_add_u32(conf, "broadcast", e->id);
- if (dae)
- {
- htsmsg_add_uuid(conf, "autorec", &dae->dae_id.in_uuid);
- htsmsg_add_str(conf, "directory", dae->dae_directory ?: "");
- if (dae->dae_cat1 && *dae->dae_cat1)
- htsmsg_add_str(conf, "cat1", dae->dae_cat1);
- if (dae->dae_cat2 && *dae->dae_cat2)
- htsmsg_add_str(conf, "cat2", dae->dae_cat2);
- if (dae->dae_cat3 && *dae->dae_cat3)
- htsmsg_add_str(conf, "cat3", dae->dae_cat3);
- }
- if (dte)
- {
- htsmsg_add_uuid(conf, "timerec", &dte->dte_id.in_uuid);
- htsmsg_add_str(conf, "directory", dte->dte_directory ?: "");
+ genre = LIST_FIRST(&e->episode->genre);
+ if (genre)
+ htsmsg_add_u32(conf, "content_type", genre->code / 16);
}
de = dvr_entry_create(NULL, conf, 0);
- htsmsg_destroy(conf);
-
if (de == NULL)
return NULL;
idnode_uuid_as_str(&de->de_id, ubuf),
lang_str_get(de->de_title, NULL), DVR_CH_NAME(de), tbuf,
de->de_uri ? de->de_uri : "<noid>",
- creator ?: "");
+ de->de_creator ?: "");
idnode_changed(&de->de_id);
return de;
}
-/**
- *
- */
-dvr_entry_t *
-dvr_entry_create_htsp(int enabled, const char *config_uuid,
- channel_t *ch, time_t start, time_t stop,
- time_t start_extra, time_t stop_extra,
- const char *title, const char* subtitle,
- const char *description, const char *lang,
- epg_genre_t *content_type,
- const char *owner,
- const char *creator, dvr_autorec_entry_t *dae,
- dvr_prio_t pri, int retention, int removal,
- const char *comment)
-{
- char ubuf[UUID_HEX_SIZE];
- dvr_config_t *cfg = dvr_config_find_by_uuid(config_uuid);
- if (!cfg)
- cfg = dvr_config_find_by_name(config_uuid);
- return dvr_entry_create_(enabled,
- cfg ? idnode_uuid_as_str(&cfg->dvr_id, ubuf) : NULL,
- NULL,
- ch, start, stop, start_extra, stop_extra,
- title, subtitle, description, lang, content_type,
- owner, creator, dae, NULL, pri, retention, removal,
- comment);
-}
-
/**
* Determine stop time for the broadcast taking in
* to account segmented programmes via EIT.
return de->de_segment_stop_extra = segment_stop_extra;
}
-
-/**
- *
- */
-dvr_entry_t *
-dvr_entry_create_by_event(int enabled, const char *config_uuid,
- epg_broadcast_t *e,
- time_t start_extra, time_t stop_extra,
- const char *owner,
- const char *creator, dvr_autorec_entry_t *dae,
- dvr_prio_t pri, int retention, int removal,
- const char *comment)
-{
- if(!e->channel || !e->episode || !e->episode->title)
- return NULL;
-
- return dvr_entry_create_(enabled, config_uuid, e,
- e->channel, e->start, e->stop,
- start_extra, stop_extra,
- NULL, NULL, NULL, NULL,
- LIST_FIRST(&e->episode->genre),
- owner, creator, dae, NULL, pri,
- retention, removal, comment);
-}
-
/**
* Clone existing DVR entry and stop the previous
*/
uint32_t rerecord;
epg_broadcast_t *e, *ev;
dvr_entry_t *de2;
- char cfg_uuid[UUID_HEX_SIZE];
char buf[512];
int64_t fsize1, fsize2;
time_t pre;
+ htsmsg_t *conf;
if (dvr_in_init || de->de_dont_rerecord)
return 0;
epg_broadcast_get_title(e, NULL),
channel_get_name(e->channel, channel_blank_name));
- idnode_uuid_as_str(&de->de_config->dvr_id, cfg_uuid);
snprintf(buf, sizeof(buf), _("Re-record%s%s"),
de->de_comment ? ": " : "", de->de_comment ?: "");
+ conf = htsmsg_create_map();
+ htsmsg_add_uuid(conf, "config_name", &de->de_config->dvr_id.in_uuid);
+ htsmsg_add_s64(conf, "start_extra", de->de_start_extra);
+ htsmsg_add_s64(conf, "stop_extra", de->de_stop_extra);
+ htsmsg_add_u32(conf, "pri", de->de_pri);
+ htsmsg_add_u32(conf, "retention", de->de_retention);
+ htsmsg_add_u32(conf, "removal", de->de_removal);
+ htsmsg_add_str2(conf, "owner", de->de_owner);
+ htsmsg_add_str2(conf, "creator", de->de_creator);
+ htsmsg_add_str(conf, "comment", buf);
+ de2 = dvr_entry_create_from_htsmsg(conf, e);
+ htsmsg_destroy(conf);
- de2 = dvr_entry_create_by_event(1, cfg_uuid, e,
- de->de_start_extra, de->de_stop_extra,
- de->de_owner, de->de_creator, NULL,
- de->de_pri, de->de_retention, de->de_removal,
- buf);
if (de2) {
dvr_entry_change_parent_child(de, de2, NULL, 1);
} else {
dvr_entry_create_by_autorec(int enabled, epg_broadcast_t *e, dvr_autorec_entry_t *dae)
{
char buf[512];
- char ubuf[UUID_HEX_SIZE];
const char *s;
dvr_entry_t *de;
uint32_t count = 0, max_count;
+ htsmsg_t *conf;
/* Identical duplicate detection
NOTE: Semantic duplicate detection is deferred to the start time of recording and then done using _dvr_duplicate_event by dvr_timer_start_recording. */
s = dae->dae_comment && *dae->dae_comment ? dae->dae_comment : dae->dae_name;
snprintf(buf, sizeof(buf), _("Auto recording%s%s"), s ? ": " : "", s ?: "");
- dvr_entry_create_by_event(enabled, idnode_uuid_as_str(&dae->dae_config->dvr_id, ubuf),
- e, dae->dae_start_extra, dae->dae_stop_extra,
- dae->dae_owner, dae->dae_creator, dae, dae->dae_pri,
- dae->dae_retention, dae->dae_removal, buf);
+ conf = htsmsg_create_map();
+ htsmsg_add_uuid(conf, "config_name", &dae->dae_config->dvr_id.in_uuid);
+ htsmsg_add_s64(conf, "start_extra", dae->dae_start_extra);
+ htsmsg_add_s64(conf, "stop_extra", dae->dae_stop_extra);
+ htsmsg_add_u32(conf, "pri", dae->dae_pri);
+ htsmsg_add_u32(conf, "retention", dae->dae_retention);
+ htsmsg_add_u32(conf, "removal", dae->dae_removal);
+ htsmsg_add_str2(conf, "owner", dae->dae_owner);
+ htsmsg_add_str2(conf, "creator", dae->dae_creator);
+ htsmsg_add_str(conf, "comment", buf);
+ htsmsg_add_uuid(conf, "autorec", &dae->dae_id.in_uuid);
+ htsmsg_add_str2(conf, "directory", dae->dae_directory);
+ htsmsg_add_str2(conf, "cat1", dae->dae_cat1);
+ htsmsg_add_str2(conf, "cat2", dae->dae_cat2);
+ htsmsg_add_str2(conf, "cat3", dae->dae_cat3);
+ dvr_entry_create_from_htsmsg(conf, e);
+ htsmsg_destroy(conf);
}
/**
struct tm tm_start, tm_stop;
const char *title;
char buf[200];
- char ubuf[UUID_HEX_SIZE];
+ htsmsg_t *conf;
if(dte->dte_enabled == 0 || dte->dte_weekdays == 0)
goto fail;
snprintf(buf, sizeof(buf), _("Time recording%s%s"),
dte->dte_comment ? ": " : "",
dte->dte_comment ?: "");
- de = dvr_entry_create_(1, idnode_uuid_as_str(&dte->dte_config->dvr_id, ubuf),
- NULL, dte->dte_channel,
- start, stop, 0, 0, title, NULL,
- NULL, NULL, NULL, dte->dte_owner, dte->dte_creator,
- NULL, dte, dte->dte_pri, dte->dte_retention,
- dte->dte_removal, buf);
+ conf = htsmsg_create_map();
+ htsmsg_add_uuid(conf, "config_name", &dte->dte_config->dvr_id.in_uuid);
+ htsmsg_add_str2(conf, "title", title);
+ htsmsg_add_s64(conf, "start", start);
+ htsmsg_add_s64(conf, "stop", stop);
+ htsmsg_add_u32(conf, "pri", dte->dte_pri);
+ htsmsg_add_u32(conf, "retention", dte->dte_retention);
+ htsmsg_add_u32(conf, "removal", dte->dte_removal);
+ htsmsg_add_str2(conf, "owner", dte->dte_owner);
+ htsmsg_add_str2(conf, "creator", dte->dte_creator);
+ htsmsg_add_str(conf, "comment", buf);
+ htsmsg_add_uuid(conf, "timerec", &dte->dte_id.in_uuid);
+ htsmsg_add_str2(conf, "directory", dte->dte_directory);
+ dvr_entry_create_from_htsmsg(conf, NULL);
+ htsmsg_destroy(conf);
return;
fail:
htsmsg_print0(msg, 0);
}
-
/**
*
*/
+static void htsmsg_copy_i(htsmsg_t *dst, const htsmsg_t *src);
+
static void
-htsmsg_copy_i(const htsmsg_t *src, htsmsg_t *dst)
+htsmsg_copy_f(htsmsg_t *dst, const htsmsg_field_t *f, const char *name)
{
- htsmsg_field_t *f;
htsmsg_t *sub;
- TAILQ_FOREACH(f, &src->hm_fields, hmf_link) {
+ switch(f->hmf_type) {
- switch(f->hmf_type) {
+ case HMF_MAP:
+ case HMF_LIST:
+ sub = f->hmf_type == HMF_LIST ?
+ htsmsg_create_list() : htsmsg_create_map();
+ htsmsg_copy_i(f->hmf_msg, sub);
+ htsmsg_add_msg(dst, name, sub);
+ break;
- case HMF_MAP:
- case HMF_LIST:
- sub = f->hmf_type == HMF_LIST ?
- htsmsg_create_list() : htsmsg_create_map();
- htsmsg_copy_i(f->hmf_msg, sub);
- htsmsg_add_msg(dst, f->hmf_name, sub);
- break;
-
- case HMF_STR:
- htsmsg_add_str(dst, f->hmf_name, f->hmf_str);
- break;
+ case HMF_STR:
+ htsmsg_add_str(dst, name, f->hmf_str);
+ break;
- case HMF_S64:
- htsmsg_add_s64(dst, f->hmf_name, f->hmf_s64);
- break;
+ case HMF_S64:
+ htsmsg_add_s64(dst, name, f->hmf_s64);
+ break;
- case HMF_BOOL:
- htsmsg_add_bool(dst, f->hmf_name, f->hmf_bool);
- break;
+ case HMF_BOOL:
+ htsmsg_add_bool(dst, name, f->hmf_bool);
+ break;
- case HMF_BIN:
- htsmsg_add_bin(dst, f->hmf_name, f->hmf_bin, f->hmf_binsize);
- break;
+ case HMF_UUID:
+ htsmsg_add_uuid(dst, name, (tvh_uuid_t *)f->hmf_uuid);
+ break;
- case HMF_DBL:
- htsmsg_add_dbl(dst, f->hmf_name, f->hmf_dbl);
- break;
- }
+ case HMF_BIN:
+ htsmsg_add_bin(dst, name, f->hmf_bin, f->hmf_binsize);
+ break;
+
+ case HMF_DBL:
+ htsmsg_add_dbl(dst, name, f->hmf_dbl);
+ break;
}
}
+static void
+htsmsg_copy_i(htsmsg_t *dst, const htsmsg_t *src)
+{
+ htsmsg_field_t *f;
+
+ TAILQ_FOREACH(f, &src->hm_fields, hmf_link)
+ htsmsg_copy_f(dst, f, f->hmf_name);
+}
+
htsmsg_t *
htsmsg_copy(const htsmsg_t *src)
{
htsmsg_t *dst;
if (src == NULL) return NULL;
dst = src->hm_islist ? htsmsg_create_list() : htsmsg_create_map();
- htsmsg_copy_i(src, dst);
+ htsmsg_copy_i(dst, src);
return dst;
}
+void
+htsmsg_copy_field(htsmsg_t *dst, const char *dstname,
+ const htsmsg_t *src, const char *srcname)
+{
+ htsmsg_field_t *f;
+ f = htsmsg_field_find(src, srcname ?: dstname);
+ if (f == NULL)
+ return;
+ htsmsg_copy_f(dst, f, dstname);
+}
+
/**
*
*/
*/
htsmsg_field_t *htsmsg_field_last(htsmsg_t *msg);
-
/**
* Clone a message.
*/
htsmsg_t *htsmsg_copy(const htsmsg_t *src);
+/**
+ * Copy only one field from one htsmsg to another (with renaming).
+ */
+void htsmsg_copy_field(htsmsg_t *dst, const char *dstname,
+ const htsmsg_t *src, const char *srcname);
+
/**
* Compare a message.
*/
static htsmsg_t *
htsp_method_addDvrEntry(htsp_connection_t *htsp, htsmsg_t *in)
{
- htsmsg_t *out;
+ htsmsg_t *conf, *out;
+ dvr_config_t *dvr_conf;
uint32_t eventid;
epg_broadcast_t *e = NULL;
dvr_entry_t *de;
dvr_entry_sched_state_t dvr_status;
- const char *dvr_config_name, *title, *desc, *subtitle, *lang, *comment;
- int64_t start, stop, start_extra, stop_extra;
- uint32_t u32, priority, retention, removal;
+ const char *s, *lang;
+ int64_t start, stop;
+ uint32_t u32;
channel_t *ch = NULL;
- int enabled;
- /* Options */
- enabled = htsmsg_get_u32_or_default(in, "enabled", 1);
- dvr_config_name = htsp_dvr_config_name(htsp, htsmsg_get_str(in, "configName"));
- if(htsmsg_get_s64(in, "startExtra", &start_extra))
- start_extra = 0;
- if(htsmsg_get_s64(in, "stopExtra", &stop_extra))
- stop_extra = 0;
if(!htsmsg_get_u32(in, "channelId", &u32))
ch = channel_find_by_id(u32);
if(!htsmsg_get_u32(in, "eventId", &eventid)) {
e = epg_broadcast_find_by_id(eventid);
ch = e ? e->channel : ch;
}
- if(htsmsg_get_u32(in, "priority", &priority))
- priority = DVR_PRIO_DEFAULT;
- if(htsmsg_get_u32(in, "retention", &retention))
- retention = DVR_RET_REM_DVRCONFIG;
- if(htsmsg_get_u32(in, "removal", &removal))
- removal = DVR_RET_REM_DVRCONFIG;
- comment = htsmsg_get_str(in, "comment");
- if (!(lang = htsmsg_get_str(in, "language")))
- lang = htsp->htsp_language;
/* Check access */
if (!htsp_user_access_channel(htsp, ch))
if (!ch)
return htsp_error(htsp, N_("Channel does not exist"));
+ /* Options */
+ conf = htsmsg_create_map();
+ htsmsg_copy_field(conf, "enabled", in, NULL);
+ s = htsmsg_get_str(in, "configName");
+ if (s) {
+ dvr_conf = dvr_config_find_by_uuid(s);
+ if (dvr_conf == NULL)
+ dvr_conf = dvr_config_find_by_name(s);
+ if (dvr_conf)
+ htsmsg_add_uuid(conf, "config_name", &dvr_conf->dvr_id.in_uuid);
+ }
+ htsmsg_add_uuid(conf, "channel", &ch->ch_id.in_uuid);
+ htsmsg_copy_field(conf, "start_extra", in, "startExtra");
+ htsmsg_copy_field(conf, "stop_extra", in, "stopExtra");
+ htsmsg_copy_field(conf, "pri", in, "priority");
+ htsmsg_copy_field(conf, "retention", in, NULL);
+ htsmsg_copy_field(conf, "removal", in, NULL);
+ htsmsg_copy_field(conf, "comment", in, NULL);
+
+ if (!(lang = htsmsg_get_str(in, "language")))
+ lang = htsp->htsp_language;
+
+ /* Auth */
+ s = htsp->htsp_granted_access->aa_username;
+ htsmsg_add_str2(conf, "owner", s);
+ s = htsp->htsp_granted_access->aa_representative;
+ htsmsg_add_str2(conf, "creator", s);
+
/* Manual timer */
if (!e) {
/* Required attributes */
if (htsmsg_get_s64(in, "start", &start) ||
htsmsg_get_s64(in, "stop", &stop) ||
- !(title = htsmsg_get_str(in, "title")))
+ !(s = htsmsg_get_str(in, "title")) ||
+ *s == '\0') {
+ htsmsg_destroy(conf);
return htsp_error(htsp, N_("Invalid arguments"));
+ }
- /* Optional attributes */
- if (!(subtitle = htsmsg_get_str(in, "subtitle")))
- subtitle = "";
+ htsmsg_add_s64(conf, "start", start);
+ htsmsg_add_s64(conf, "stop", stop);
+ lang_str_serialize_one(conf, "title", s, lang);
/* Optional attributes */
- if (!(desc = htsmsg_get_str(in, "description")))
- desc = "";
-
- /* Create the dvr entry */
- de = dvr_entry_create_htsp(enabled, dvr_config_name, ch, start, stop,
- start_extra, stop_extra,
- title, subtitle, desc, lang, 0,
- htsp->htsp_granted_access->aa_username,
- htsp->htsp_granted_access->aa_representative,
- NULL, priority, retention, removal, comment);
-
- /* Event timer */
- } else {
+ s = htsmsg_get_str(in, "subtitle");
+ if (s)
+ lang_str_serialize_one(conf, "subtitle", s, lang);
+ s = htsmsg_get_str(in, "description");
+ if (s)
+ lang_str_serialize_one(conf, "description", s, lang);
+ }
- de = dvr_entry_create_by_event(enabled, dvr_config_name, e,
- start_extra, stop_extra,
- htsp->htsp_granted_access->aa_username,
- htsp->htsp_granted_access->aa_representative,
- NULL, priority, retention, removal, comment);
+ /* Create the dvr entry */
+ de = dvr_entry_create_from_htsmsg(conf, NULL);
- }
+ htsmsg_destroy(conf);
dvr_status = de != NULL ? de->de_sched_state : DVR_NOSTATE;
htsmsg_add_msg(m, f, lang_str_serialize_map(ls));
}
+/* Serialize one string element directly */
+void lang_str_serialize_one
+ ( htsmsg_t *m, const char *f, const char *str, const char *lang )
+{
+ lang_str_t *l = lang_str_create();
+ lang_str_add(l, str, lang, 0);
+ lang_str_serialize(l, m, f);
+ lang_str_destroy(l);
+}
+
/* De-serialize map */
lang_str_t *lang_str_deserialize_map ( htsmsg_t *map )
{
/* Serialize/Deserialize */
htsmsg_t *lang_str_serialize_map
( lang_str_t *ls );
-void lang_str_serialize
+void lang_str_serialize
( lang_str_t *ls, htsmsg_t *msg, const char *f );
+void lang_str_serialize_one
+ ( htsmsg_t *msg, const char *f, const char *str, const char *lang );
lang_str_t *lang_str_deserialize_map
( htsmsg_t *map );
lang_str_t *lang_str_deserialize
dvr_entry_sched_state_t dvr_status;
const char *lang = http_arg_get(&hc->hc_args, "Accept-Language");
const char *s;
+ htsmsg_t *conf;
pthread_mutex_lock(&global_lock);
de = dvr_find_by_event(e);
if((http_arg_get(&hc->hc_req_args, "rec")) != NULL) {
- de = dvr_entry_create_by_event(1, NULL, e, 0, 0, hc->hc_username ?: NULL,
- hc->hc_representative ?: NULL, NULL,
- DVR_PRIO_NORMAL, DVR_RET_REM_DVRCONFIG,
- DVR_RET_REM_DVRCONFIG, "simpleui");
+ conf = htsmsg_create_map();
+ htsmsg_add_str2(conf, "owner", hc->hc_username);
+ htsmsg_add_str2(conf, "creator", hc->hc_representative);
+ htsmsg_add_str(conf, "comment", "simpleui");
+ de = dvr_entry_create_from_htsmsg(conf, e);
+ htsmsg_destroy(conf);
} else if(de != NULL && (http_arg_get(&hc->hc_req_args, "cancel")) != NULL) {
de = dvr_entry_cancel(de, 0);
}
projects / thirdparty / tvheadend.git / commitdiff
