every note associated with it's pid now

src/NoteHub/api.clj

@@ -58,7 +58,8 @@
      :longURL (get-path noteID)
      :shortURL (get-path noteID :short)
      :statistics (storage/get-note-statistics noteID)
-     :status (create-response true)}
+     :status (create-response true)
+     :publisher (storage/get-publisher noteID)}
     (create-response false "noteID '%s' unknown" noteID)))
 
 (defn post-note
@@ -85,7 +86,7 @@
                                            (map #(str proposed-title "-" (+ 2 %)) (range)))))
             noteID (build-key date title)]
         (do
-          (storage/add-note noteID note password)
+          (storage/add-note noteID note pid password)
           (storage/create-short-url noteID)
           {:noteID noteID
            :longURL (get-path noteID)

src/NoteHub/storage.clj

@@ -5,8 +5,8 @@
         [noir.options :only [dev-mode?]])
   (:require [clj-redis.client :as redis]))
 
-; Initialize the data base 
-(def db 
+; Initialize the data base
+(def db
   (redis/init
     (when-not (dev-mode?)
       {:url (get-setting :db-url)})))
@@ -23,22 +23,23 @@
 (def sessions "sessions")
 (def short-url "short-url")
 (def publisher "publisher")
+(def publisher-key "publisher-key")
 
 (defn valid-publisher? [pid]
-  (redis/hexists db publisher pid))
+  (redis/hexists db publisher-key pid))
 
 (defn register-publisher [pid]
   "Returns nil if given PID exists or a PSK otherwise"
   (when (not (valid-publisher? pid))
     (let [psk (encrypt (str (rand-int Integer/MAX_VALUE) pid))
-          _ (redis/hset db publisher pid psk)]
+          _ (redis/hset db publisher-key pid psk)]
       psk)))
 
 (defn revoke-publisher [pid]
-  (redis/hdel db publisher pid))
+  (redis/hdel db publisher-key pid))
 
 (defn get-psk [pid]
-  (redis/hget db publisher pid))
+  (redis/hget db publisher-key pid))
 
 (defn create-session []
   (let [token (encrypt (str (rand-int Integer/MAX_VALUE)))]
@@ -59,11 +60,12 @@
     (redis/hset db note noteID text)))
 
 (defn add-note
-  ([noteID text] (add-note noteID text nil))
-  ([noteID text passwd]
+  ([noteID text pid] (add-note noteID text pid nil))
+  ([noteID text pid passwd]
    (do
      (redis/hset db note noteID text)
      (redis/hset db published noteID (get-current-date))
+     (redis/hset db publisher noteID pid)
      (when (not (blank? passwd))
        (redis/hset db password noteID passwd)))))
 
@@ -79,16 +81,21 @@
         (redis/hincrby db views noteID 1)
         text))))
 
-(defn get-note-views 
+(defn get-note-views
   [noteID]
   (redis/hget db views noteID))
 
+(defn get-publisher
+  [noteID]
+  (redis/hget db publisher noteID))
+
 (defn get-note-statistics
   "Return views, publishing and editing timestamp"
   [noteID]
-  { :views (redis/hget db views noteID)
+  {:views (get-note-views noteID)
    :published (redis/hget db published noteID)
-   :edited (redis/hget db edited noteID) })
+   :edited (redis/hget db edited noteID)
+   :publisher (get-publisher noteID)})
 
 (defn note-exists?
   [noteID]
@@ -96,7 +103,7 @@
 
 (defn delete-note
   [noteID]
-  (doseq [kw [password views note published edited]]
+  (doseq [kw [password views note published edited publisher]]
     ; TODO: delete short url by looking for the title
     (redis/hdel db kw noteID)))
 
@@ -112,7 +119,7 @@
   "Resolves short url by providing all metadata of the request"
   [url]
   (let [value (redis/hget db short-url url)]
-    (when value 
+    (when value
       (read-string value))))
 
 (defn delete-short-url
@@ -132,14 +139,14 @@
       (redis/hget db short-url key)
       (let [hash-stream (partition 5 (repeatedly #(rand-int 36)))
             hash-to-string (fn [hash]
-                             (apply str 
+                             (apply str
                                     ; map first 10 numbers to digits
                                     ; and the rest to chars
                                     (map #(char (+ (if (< 9 %) 87 48) %)) hash)))
-            url (first 
+            url (first
                   (remove short-url-exists?
                           (map hash-to-string hash-stream)))]
-        (do 
+        (do
           ; we create two mappings: key params -> short url and back,
           ; s.t. we can later easily check whether a short url already exists
           (redis/hset db short-url url key)

src/NoteHub/views/pages.clj

@@ -20,8 +20,8 @@
    [noir.core :only [defpage defpartial]]
    [noir.statuses]))
 
-(when-not (storage/valid-publisher? api/domain)
-  (storage/register-publisher api/domain))
+(when-not (storage/valid-publisher? "NoteHub")
+  (storage/register-publisher "NoteHub"))
 
 ; Creates the main html layout
 (defpartial generate-layout
@@ -148,6 +148,10 @@
                [:tr
                 [:td (get-message :edited)]
                 [:td (:edited stats)]])
+             (when (:publisher stats)
+               [:tr
+                [:td (get-message :publisher)]
+                [:td (:publisher stats)]])
              [:tr
               [:td (get-message :article-views)]
               [:td (:views stats)]]])))
@@ -178,7 +182,7 @@
 ; Creates New Note from Web
 (defpage [:post "/post-note"] {:keys [session note signature password version]}
   (if (= signature (api/get-signature session note))
-    (let [pid api/domain
+    (let [pid "NoteHub"
           psk (storage/get-psk pid)]
       (if (storage/valid-publisher? pid)
         (let [resp (api/post-note note pid (api/get-signature (str pid psk note)) password)]
@@ -190,7 +194,7 @@
 
 ; Updates a note
 (defpage [:post "/update-note"] {:keys [noteID note password version]}
-  (let [pid api/domain
+  (let [pid "NoteHub"
         psk (storage/get-psk pid)]
     (if (storage/valid-publisher? pid)
       (let [resp (api/update-note noteID note pid