plume-models/src/timeline/mod.rs

@@ -1,12 +1,13 @@
 use diesel::{self, ExpressionMethods, QueryDsl, RunQueryDsl};
 
+use lists::List;
 use posts::Post;
 use schema::{posts, timeline, timeline_definition};
 use {Connection, Error, Result};
 
 pub(crate) mod query;
 
-use self::query::{Kind, TimelineQuery};
+use self::query::{Kind, QueryError, TimelineQuery};
 
 #[derive(Clone, Queryable, Identifiable)]
 #[table_name = "timeline_definition"]
@@ -47,27 +48,74 @@ impl Timeline {
         conn: &Connection,
         user_id: i32,
         name: String,
-        query: String,
+        query_string: String,
     ) -> Result<Timeline> {
-        TimelineQuery::parse(&query)?; // verify the query is valid
+        {
+            let query = TimelineQuery::parse(&query_string)?; // verify the query is valid
+            if let Some(err) =
+                query
+                    .list_used_lists()
+                    .into_iter()
+                    .find_map(|(name, kind)| {
+                        let list = List::find_by_name(conn, Some(user_id), &name)
+                            .map(|l| l.kind() == kind);
+                        match list {
+                            Ok(true) => None,
+                            Ok(false) => Some(Error::TimelineQuery(QueryError::RuntimeError(
+                                format!("list '{}' has the wrong type for this usage", name),
+                            ))),
+                            Err(_) => Some(Error::TimelineQuery(QueryError::RuntimeError(
+                                format!("list '{}' was not found", name),
+                            ))),
+                        }
+                    })
+            {
+                Err(err)?;
+            }
+        }
         Self::insert(
             conn,
             NewTimeline {
                 user_id: Some(user_id),
                 name,
-                query,
+                query: query_string,
             },
         )
     }
 
-    pub fn new_for_instance(conn: &Connection, name: String, query: String) -> Result<Timeline> {
+    pub fn new_for_instance(
-        TimelineQuery::parse(&query)?; // verify the query is valid
+        conn: &Connection,
+        name: String,
+        query_string: String,
+    ) -> Result<Timeline> {
+        {
+            let query = TimelineQuery::parse(&query_string)?; // verify the query is valid
+            if let Some(err) =
+                query
+                    .list_used_lists()
+                    .into_iter()
+                    .find_map(|(name, kind)| {
+                        let list = List::find_by_name(conn, None, &name).map(|l| l.kind() == kind);
+                        match list {
+                            Ok(true) => None,
+                            Ok(false) => Some(Error::TimelineQuery(QueryError::RuntimeError(
+                                format!("list '{}' has the wrong type for this usage", name),
+                            ))),
+                            Err(_) => Some(Error::TimelineQuery(QueryError::RuntimeError(
+                                format!("list '{}' was not found", name),
+                            ))),
+                        }
+                    })
+            {
+                Err(err)?;
+            }
+        }
         Self::insert(
             conn,
             NewTimeline {
                 user_id: None,
                 name,
-                query,
+                query: query_string,
             },
         )
     }

plume-models/src/timeline/query.rs

@@ -177,8 +177,8 @@ impl<'a> TQ<'a> {
 
     fn list_used_lists(&self) -> Vec<(String, ListType)> {
         match self {
-            TQ::Or(inner) => inner.iter().flat_map(|e| e.list_used_lists()).collect(),
+            TQ::Or(inner) => inner.iter().flat_map(TQ::list_used_lists).collect(),
-            TQ::And(inner) => inner.iter().flat_map(|e| e.list_used_lists()).collect(),
+            TQ::And(inner) => inner.iter().flat_map(TQ::list_used_lists).collect(),
             TQ::Arg(Arg::In(typ, List::List(name)), _) => vec![(
                 name.to_string(),
                 match typ {
@@ -270,11 +270,17 @@ impl WithList {
                     }
                     (WithList::Lang, ListType::Prefix) => {
                         let lang = whatlang::detect(post.content.get())
-                            .and_then(|i| if i.is_reliable() { Some(i.lang()) } else {None} )
+                            .and_then(|i| {
+                                if i.is_reliable() {
+                                    Some(i.lang())
+                                } else {
+                                    None
+                                }
+                            })
                             .unwrap_or(Lang::Eng)
                             .name();
                         list.contains_prefix(conn, lang)
-                    },
+                    }
                     (_, _) => Err(QueryError::RuntimeError(format!(
                         "The list '{}' is of the wrong type for this usage",
                         name
@@ -313,11 +319,17 @@ impl WithList {
                 }
                 WithList::Lang => {
                     let lang = whatlang::detect(post.content.get())
-                        .and_then(|i| if i.is_reliable() { Some(i.lang()) } else {None} )
+                        .and_then(|i| {
+                            if i.is_reliable() {
+                                Some(i.lang())
+                            } else {
+                                None
+                            }
+                        })
                         .unwrap_or(Lang::Eng)
                         .name();
                     Ok(list.iter().any(|s| lang.starts_with(s)))
-                },
+                }
             },
         }
     }