From: Jaroslav Kysela <perex@perex.cz>
Date: Thu, 11 Jan 2018 20:28:16 +0000 (+0100)
Subject: DVR: recode dvr_entry_create_(), use htsmsg_t dynamic config instead
X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=15a4fbbacdfb9bd48f811dcd5d9eae258bdd151d;p=thirdparty%2Ftvheadend.git

DVR: recode dvr_entry_create_(), use htsmsg_t dynamic config instead
---

diff --git a/src/api/api_dvr.c b/src/api/api_dvr.c
index e6920c6c8..336f315ad 100644
--- a/src/api/api_dvr.c
+++ b/src/api/api_dvr.c
@@ -206,13 +206,11 @@ api_dvr_entry_create_by_event
   ( 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);
@@ -226,30 +224,35 @@ api_dvr_entry_create_by_event
     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++;
   }
 
diff --git a/src/dvr/dvr.h b/src/dvr/dvr.h
index bc1fd523f..33a54b4d7 100644
--- a/src/dvr/dvr.h
+++ b/src/dvr/dvr.h
@@ -548,28 +548,8 @@ dvr_entry_clone ( dvr_entry_t *de );
 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,
@@ -667,16 +647,6 @@ int dvr_get_disk_space(int64_t *bfree, int64_t *bused, int64_t *btotal);
 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);
 
diff --git a/src/dvr/dvr_db.c b/src/dvr/dvr_db.c
index 870a46c01..203f1b0de 100644
--- a/src/dvr/dvr_db.c
+++ b/src/dvr/dvr_db.c
@@ -955,42 +955,23 @@ dvr_entry_create(const char *uuid, htsmsg_t *conf, int clone)
  * 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)
@@ -1011,49 +992,13 @@ dvr_entry_create_(int enabled, const char *config_uuid, epg_broadcast_t *e,
       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;
 
@@ -1068,40 +1013,12 @@ dvr_entry_create_(int enabled, const char *config_uuid, epg_broadcast_t *e,
          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.
@@ -1182,31 +1099,6 @@ static time_t dvr_entry_get_segment_stop_extra( dvr_entry_t *de )
   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
  */
@@ -1246,10 +1138,10 @@ dvr_entry_rerecord(dvr_entry_t *de)
   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;
@@ -1320,15 +1212,21 @@ not_so_good:
                         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 {
@@ -1749,10 +1647,10 @@ void
 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. */
@@ -1780,10 +1678,23 @@ dvr_entry_create_by_autorec(int enabled, epg_broadcast_t *e, dvr_autorec_entry_t
   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);
 }
 
 /**
diff --git a/src/dvr/dvr_timerec.c b/src/dvr/dvr_timerec.c
index be5ecd74d..b91d9067d 100644
--- a/src/dvr/dvr_timerec.c
+++ b/src/dvr/dvr_timerec.c
@@ -108,7 +108,7 @@ dvr_timerec_check(dvr_timerec_entry_t *dte)
   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;
@@ -152,13 +152,22 @@ dvr_timerec_check(dvr_timerec_entry_t *dte)
   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:
diff --git a/src/htsmsg.c b/src/htsmsg.c
index 7924bd68f..475eba89b 100644
--- a/src/htsmsg.c
+++ b/src/htsmsg.c
@@ -1211,61 +1211,82 @@ htsmsg_print(htsmsg_t *msg)
   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);
+}
+
 /**
  *
  */
diff --git a/src/htsmsg.h b/src/htsmsg.h
index 6ff6dc299..02d11eb0a 100644
--- a/src/htsmsg.h
+++ b/src/htsmsg.h
@@ -453,12 +453,17 @@ htsmsg_field_t *htsmsg_field_find(const htsmsg_t *msg, const char *name);
  */
 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.
  */
diff --git a/src/htsp_server.c b/src/htsp_server.c
index 0af1bf744..991b74cad 100644
--- a/src/htsp_server.c
+++ b/src/htsp_server.c
@@ -1883,39 +1883,23 @@ htsp_method_getDvrConfigs(htsp_connection_t *htsp, htsmsg_t *in)
 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))
@@ -1923,41 +1907,63 @@ htsp_method_addDvrEntry(htsp_connection_t *htsp, htsmsg_t *in)
   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;
   
diff --git a/src/lang_str.c b/src/lang_str.c
index 0a2b2f249..1c76c7415 100644
--- a/src/lang_str.c
+++ b/src/lang_str.c
@@ -243,6 +243,16 @@ void lang_str_serialize ( lang_str_t *ls, htsmsg_t *m, const char *f )
   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 )
 {
diff --git a/src/lang_str.h b/src/lang_str.h
index 648d6007a..d3edcc36d 100644
--- a/src/lang_str.h
+++ b/src/lang_str.h
@@ -56,8 +56,10 @@ int             lang_str_set2
 /* 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
diff --git a/src/webui/simpleui.c b/src/webui/simpleui.c
index 4722ac337..8f9107147 100644
--- a/src/webui/simpleui.c
+++ b/src/webui/simpleui.c
@@ -324,6 +324,7 @@ page_einfo(http_connection_t *hc, const char *remain, void *opaque)
   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);
 
@@ -335,10 +336,12 @@ page_einfo(http_connection_t *hc, const char *remain, void *opaque)
   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);
   }