Merge pull request #157 from status-im/feature/commands-validation

Commands validation

Former-commit-id: 5e88473c25

resources/commands.js

@@ -3,7 +3,7 @@ status.command({
     description: "Send location",
     color: "#9a5dcf",
     preview: function (params) {
-        var text =  status.components.text(
+        var text = status.components.text(
             {
                 style: {
                     marginTop: 5,
@@ -138,6 +138,12 @@ status.response({
     name: "phone",
     description: "Send phone number",
     color: "#5fc48d",
+    validator: function (params) {
+        return {
+            validationHandler: "phone",
+            parameters: [params.value]
+        };
+    },
     params: [{
         name: "phone",
         type: status.types.PHONE,
@@ -156,6 +162,16 @@ status.command({
     name: "help",
     description: "Help",
     color: "#7099e6",
+    /* Validator example
+    validator: function (params) {
+        if (params.value != "3") {
+            var error = status.components.view(
+                {backgroundColor: "red"},
+                [status.components.text({}, "ooops :(")]
+            );
+            return {errors: [error]}
+        }
+    },*/
     params: [{
         name: "query",
         type: status.types.TEXT

resources/status.js

@@ -22,6 +22,7 @@ Command.prototype.create = function (com) {
     this.name = com.name;
     this.description = com.description;
     this.handler = com.handler;
+    this.validator = com.validator;
     this.color = com.color;
     this.icon = com.icon;
     this.params = com.params || [];
@@ -83,13 +84,13 @@ function scrollView(options, elements) {
 }
 
 var status = {
-    command: function (n, d, h) {
+    command: function (h) {
         var command = new Command();
-        return command.create(n, d, h);
+        return command.create(h);
     },
-    response: function (n, d, h) {
+    response: function (h) {
         var response = new Response();
-        return response.create(n, d, h);
+        return response.create(h);
     },
     types: {
         TEXT: 'text',

src/status_im/android/core.cljs

@@ -54,11 +54,11 @@
                        "keyboardDidShow"
                        (fn [e]
                          (let [h (.. e -endCoordinates -height)]
-                           (when-not (= h keyboard-height)
+                           (when-not (= h @keyboard-height)
                              (dispatch [:set :keyboard-height h])))))
          (.addListener device-event-emitter
                        "keyboardDidHide"
-                       (when-not (= 0 keyboard-height)
+                       (when-not (= 0 @keyboard-height)
                          #(dispatch [:set :keyboard-height 0]))))
        :render
        (fn []

src/status_im/chat/handlers.cljs

@@ -21,10 +21,10 @@
             [status-im.utils.phone-number :refer [format-phone-number]]
             [status-im.utils.datetime :as time]
             [status-im.components.react :refer [geth]]
-            [status-im.utils.logging :as log]
             [status-im.components.jail :as j]
             [status-im.utils.types :refer [json->clj]]
             [status-im.commands.utils :refer [generate-hiccup]]
+            status-im.chat.handlers.commands
             status-im.chat.handlers.animation
             status-im.chat.handlers.requests
             status-im.chat.handlers.unviewed-messages))
@@ -56,81 +56,15 @@
         (assoc-in [:chats current-chat-id :command-input] {})
         (update-in [:chats current-chat-id :input-text] safe-trim))))
 
-(defn invoke-suggestions-handler!
-  [{:keys [current-chat-id canceled-command] :as db} _]
-  (when-not canceled-command
-    (let [{:keys [command content]} (get-in db [:chats current-chat-id :command-input])
-          {:keys [name type]} command
-          path [(if (= :command type) :commands :responses)
-                name
-                :params
-                0
-                :suggestions]
-          params {:value content}]
-      (j/call current-chat-id
-              path
-              params
-              #(dispatch [:suggestions-handler {:command command
-                                                :content content
-                                                :chat-id current-chat-id} %])))))
-
 (register-handler :start-cancel-command
   (u/side-effect!
     (fn [db _]
       (dispatch [:animate-cancel-command]))))
 
-(def command-prefix "c ")
-
-(defn cancel-command!
-  [{:keys [canceled-command]}]
-  (when canceled-command
-    (dispatch [:start-cancel-command])))
-
-(register-handler :set-chat-command-content
-  [(after invoke-suggestions-handler!)
-   (after cancel-command!)]
-  (fn [{:keys [current-chat-id] :as db} [_ content]]
-    (let [starts-as-command? (str/starts-with? content command-prefix)
-          path [:chats current-chat-id :command-input :command :type]
-          command? (= :command (get-in db path))]
-      (as-> db db
-            (commands/set-chat-command-content db content)
-            (assoc-in db [:chats current-chat-id :input-text] nil)
-            (assoc db :canceled-command (and command? (not starts-as-command?)))))))
-
 (defn update-input-text
   [{:keys [current-chat-id] :as db} text]
   (assoc-in db [:chats current-chat-id :input-text] text))
 
-(defn invoke-command-preview!
-  [{:keys [current-chat-id staged-command]} _]
-  (let [{:keys [command content]} staged-command
-        {:keys [name type]} command
-        path [(if (= :command type) :commands :responses)
-              name
-              :preview]
-        params {:value content}]
-    (j/call current-chat-id
-            path
-            params
-            #(dispatch [:command-preview current-chat-id %]))))
-
-(register-handler :stage-command
-  (after invoke-command-preview!)
-  (fn [{:keys [current-chat-id] :as db} _]
-    (let [db (update-input-text db nil)
-          {:keys [command content to-msg-id]}
-          (get-in db [:chats current-chat-id :command-input])
-          content' (if (= :command (:type command))
-                     (subs content 2)
-                     content)
-          command-info {:command    command
-                        :content    content'
-                        :to-message to-msg-id}]
-      (-> db
-          (commands/stage-command command-info)
-          (assoc :staged-command command-info)))))
-
 (register-handler :set-message-input []
   (fn [db [_ input]]
     (assoc db :message-input input)))
@@ -141,15 +75,6 @@
       (when-let [message-input (:message-input db)]
         (.blur message-input)))))
 
-(register-handler :set-response-chat-command
-  [(after invoke-suggestions-handler!)
-   (after #(dispatch [:command-edit-mode]))
-   (after #(dispatch [:set-chat-input-text ""]))]
-  (fn [db [_ to-msg-id command-key]]
-    (-> db
-        (commands/set-response-chat-command to-msg-id command-key)
-        (assoc :canceled-command false))))
-
 (defn update-text
   [{:keys [current-chat-id] :as db} [_ text]]
   (let [suggestions (get-in db [:command-suggestions current-chat-id])]
@@ -330,13 +255,6 @@
               params
               #(dispatch [:command-handler! com %])))))
 
-(defn handle-commands
-  [{:keys [new-commands]}]
-  (doseq [{{content :content} :content
-           handler            :handler} new-commands]
-    (when handler
-      (handler content))))
-
 (register-handler :send-chat-msg
   (-> prepare-message
       ((enrich prepare-staged-commans))
@@ -349,21 +267,7 @@
       ((after save-commands-to-realm!))
       ((after dispatch-responded-requests!))
       ;; todo maybe it is better to track if it was handled or not
-      ((after invoke-commands-handlers!))
+      ((after invoke-commands-handlers!))))
-      ((after handle-commands))))
-
-(register-handler :unstage-command
-  (fn [db [_ staged-command]]
-    (commands/unstage-command db staged-command)))
-
-(register-handler :set-chat-command
-  [(after invoke-suggestions-handler!)
-   (after #(dispatch [:command-edit-mode]))]
-  (fn [{:keys [current-chat-id] :as db} [_ command-key]]
-    (-> db
-        (commands/set-chat-command command-key)
-        (assoc-in [:chats current-chat-id :command-input :content] "c ")
-        (assoc :disable-input true))))
 
 (register-handler :init-console-chat
   (fn [db [_]]
@@ -569,6 +473,7 @@
     (assoc-in db [:edit-mode current-chat-id] mode)))
 
 (register-handler :command-edit-mode
+  (after #(dispatch [:clear-validation-errors]))
   (edit-mode-handler :command))
 
 (register-handler :text-edit-mode

src/status_im/chat/handlers/animation.cljs

@@ -3,6 +3,7 @@
             [status-im.utils.handlers :refer [register-handler]]
             [status-im.handlers.content-suggestions :refer [get-content-suggestions]]
             [status-im.chat.constants :refer [input-height request-info-height
+                                              suggestions-header-height
                                               minimum-command-suggestions-height
                                               response-height-normal minimum-suggestion-height]]
             [status-im.constants :refer [response-input-hiding-duration]]))
@@ -15,45 +16,54 @@
   ([name middleware handler]
    (register-handler name [(path :animations) middleware] handler)))
 
-(animation-handler :animate-cancel-command
+(register-handler :animate-cancel-command
   (after #(dispatch [:text-edit-mode]))
-  (fn [db _]
+  (fn [{:keys [current-chat-id] :as db} _]
-    (assoc db :to-response-height input-height)))
+    (assoc-in db [:animations :to-response-height current-chat-id] input-height)))
 
 (def response-height (+ input-height response-height-normal))
 
-(defn update-response-height [db]
+(defn update-response-height
-  (assoc-in db [:animations :to-response-height] response-height))
+  [{:keys [current-chat-id] :as db}]
+  (assoc-in db [:animations :to-response-height current-chat-id] response-height))
 
 (register-handler :animate-command-suggestions
-  (fn [{:keys [current-chat-id] :as db} _]
+  (fn [{chat-id :current-chat-id :as db} _]
-    (let [suggestions? (seq (get-in db [:command-suggestions current-chat-id]))
+    (let [suggestions? (seq (get-in db [:command-suggestions chat-id]))
-          current (get-in db [:animations :command-suggestions-height])
+          current (get-in db [:animations :command-suggestions-height chat-id])
           height (if suggestions? middle-height input-height)
           changed? (if (and suggestions?
                             (not (nil? current))
                             (not= input-height current))
                      identity inc)]
       (-> db
-          (update :animations assoc :command-suggestions-height height)
+          (assoc-in [:animations :command-suggestions-height chat-id] height)
           (update-in [:animations :commands-height-changed] changed?)))))
 
 (defn get-minimum-height
   [{:keys [current-chat-id] :as db}]
   (let [path [:chats current-chat-id :command-input :command :type]
-        type (get-in db path)]
+        type (get-in db path)
-    (if (= :response type)
+        errors (get-in db [:validation-errors current-chat-id])
-      minimum-suggestion-height
+        custom-errors (get-in db [:custom-validation-errors current-chat-id])
-      input-height)))
+        validation-height (if (or (seq errors) (seq custom-errors))
+                            request-info-height
+                            0)]
+    (+ validation-height
+       (if (= :response type)
+         minimum-suggestion-height
+         (if (zero? validation-height)
+           input-height
+           (+ input-height suggestions-header-height))))))
 
 (register-handler :animate-show-response
-  [(after #(dispatch [:command-edit-mode]))]
+  ;[(after #(dispatch [:command-edit-mode]))]
   (fn [{:keys [current-chat-id] :as db}]
     (let [suggestions? (seq (get-in db [:suggestions current-chat-id]))
           height (if suggestions?
                    middle-height
                    (get-minimum-height db))]
-      (assoc-in db [:animations :to-response-height] height))))
+      (assoc-in db [:animations :to-response-height current-chat-id] height))))
 
 (defn fix-height
   [height-key height-signal-key suggestions-key minimum]
@@ -64,7 +74,7 @@
           under-middle-position? (<= current middle-height)
           over-middle-position? (not under-middle-position?)
           suggestions (get-in db [suggestions-key current-chat-id])
-          old-fixed (get-in db [:animations height-key])
+          old-fixed (get-in db [:animations height-key current-chat-id])
 
           new-fixed (cond (not suggestions)
                           (minimum db)
@@ -89,7 +99,7 @@
                           (and under-middle-position? moving-down?)
                           (minimum db))]
       (-> db
-          (assoc-in [:animations height-key] new-fixed)
+          (assoc-in [:animations height-key current-chat-id] new-fixed)
           (update-in [:animations height-signal-key] inc)))))
 
 (defn commands-min-height

src/status_im/chat/handlers/commands.cljs

@@ -0,0 +1,188 @@
+(ns status-im.chat.handlers.commands
+  (:require [re-frame.core :refer [enrich after dispatch]]
+            [status-im.utils.handlers :refer [register-handler] :as u]
+            [status-im.components.jail :as j]
+            [status-im.models.commands :as commands]
+            [clojure.string :as str]
+            [status-im.commands.utils :as cu]
+            [status-im.utils.phone-number :as pn]
+            [status-im.i18n :as i18n]))
+
+(def command-prefix "c ")
+
+(defn invoke-suggestions-handler!
+  [{:keys [current-chat-id canceled-command] :as db} _]
+  (when-not canceled-command
+    (let [{:keys [command content]} (get-in db [:chats current-chat-id :command-input])
+          {:keys [name type]} command
+          path [(if (= :command type) :commands :responses)
+                name
+                :params
+                0
+                :suggestions]
+          params {:value content}]
+      (j/call current-chat-id
+              path
+              params
+              #(dispatch [:suggestions-handler {:command command
+                                                :content content
+                                                :chat-id current-chat-id} %])))))
+
+(defn cancel-command!
+  [{:keys [canceled-command]}]
+  (when canceled-command
+    (dispatch [:start-cancel-command])))
+
+(register-handler :set-chat-command-content
+  [(after invoke-suggestions-handler!)
+   (after cancel-command!)
+   (after #(dispatch [:clear-validation-errors]))]
+  (fn [{:keys [current-chat-id] :as db} [_ content]]
+    (let [starts-as-command? (str/starts-with? content command-prefix)
+          path [:chats current-chat-id :command-input :command :type]
+          command? (= :command (get-in db path))]
+      (as-> db db
+            (commands/set-chat-command-content db content)
+            (assoc-in db [:chats current-chat-id :input-text] nil)
+            (assoc db :canceled-command (and command? (not starts-as-command?)))))))
+
+(defn invoke-command-preview!
+  [{:keys [staged-command]} [_ chat-id]]
+  (let [{:keys [command content]} staged-command
+        {:keys [name type]} command
+        path [(if (= :command type) :commands :responses)
+              name
+              :preview]
+        params {:value content}]
+    (j/call chat-id
+            path
+            params
+            #(dispatch [:command-preview chat-id %]))))
+
+(defn content-by-command
+  [{:keys [type]} content]
+  (if (= :command type)
+    (subs content 2)
+    content))
+
+(defn command-input
+  ([{:keys [current-chat-id] :as db}]
+   (command-input db current-chat-id))
+  ([db chat-id]
+   (get-in db [:chats chat-id :command-input])))
+
+
+(register-handler ::validate!
+  (u/side-effect!
+    (fn [_ [_ {:keys [chat-id]} {:keys [error result]}]]
+      ;; todo handle error
+      (when-not error
+        (let [{:keys [errors validationHandler parameters]} result]
+          (cond errors
+                (dispatch [::add-validation-errors chat-id errors])
+
+                validationHandler
+                (dispatch [::validation-handler!
+                           chat-id
+                           validationHandler
+                           parameters])
+
+                :else (dispatch [::finish-command-staging chat-id])))))))
+
+(defn start-validate! [db]
+  (let [{:keys [content command chat-id] :as data} (::command db)
+        {:keys [name type]} command
+        path [(if (= :command type) :commands :responses)
+              name
+              :validator]
+        params {:value content}]
+    (j/call chat-id
+            path
+            params
+            #(dispatch [::validate! data %]))))
+
+(register-handler :stage-command
+  (after start-validate!)
+  (fn [{:keys [current-chat-id] :as db}]
+    (let [{:keys [command content]} (command-input db)
+          content' (content-by-command command content)]
+      (-> db
+          (assoc ::command {:content content'
+                            :command command
+                            :chat-id current-chat-id})
+          (assoc-in [:disable-staging current-chat-id] true)))))
+
+(register-handler ::finish-command-staging
+  [(after #(dispatch [:start-cancel-command]))
+   (after invoke-command-preview!)]
+  (fn [db [_ chat-id]]
+    (let [db (assoc-in db [:chats chat-id :input-text] nil)
+          {:keys [command content to-msg-id]} (command-input db)
+          content' (content-by-command command content)
+          command-info {:command    command
+                        :content    content'
+                        :to-message to-msg-id}]
+      (-> db
+          (commands/stage-command command-info)
+          (assoc :staged-command command-info)
+          (assoc-in [:disable-staging chat-id] true)))))
+
+(register-handler :unstage-command
+  (fn [db [_ staged-command]]
+    (commands/unstage-command db staged-command)))
+
+(defn set-chat-command
+  [{:keys [current-chat-id] :as db} [_ command-key]]
+  (-> db
+      (commands/set-chat-command command-key)
+      (assoc-in [:chats current-chat-id :command-input :content] command-prefix)
+      (assoc :disable-input true)))
+
+(register-handler :set-chat-command
+  [(after invoke-suggestions-handler!)
+   (after #(dispatch [:command-edit-mode]))]
+  set-chat-command)
+
+(defn set-response-command [db [_ to-msg-id command-key]]
+  (-> db
+      (commands/set-response-chat-command to-msg-id command-key)
+      (assoc :canceled-command false)))
+
+(register-handler :set-response-chat-command
+  [(after invoke-suggestions-handler!)
+   (after #(dispatch [:command-edit-mode]))
+   (after #(dispatch [:set-chat-input-text ""]))]
+  set-response-command)
+
+(register-handler ::add-validation-errors
+  (fn [db [_ chat-id errors]]
+    (assoc-in db [:custom-validation-errors chat-id]
+              (map cu/generate-hiccup errors))))
+
+(register-handler :clear-validation-errors
+  (fn [db]
+    (dissoc db :validation-errors :custom-validation-errors)))
+
+(def validation-handlers
+  {:phone (fn [chat-id [number]]
+            (if (pn/valid-mobile-number? number)
+              (dispatch [::finish-command-staging chat-id])
+              (dispatch [::set-validation-error
+                         chat-id
+                         {:title       (i18n/label :t/phone-number)
+                          :description (i18n/label :t/invalid-phone)}])))})
+
+(defn validator [name]
+  (validation-handlers (keyword name)))
+
+(register-handler ::validation-handler!
+  (u/side-effect!
+    (fn [_ [_ chat-id name params]]
+      (when-let [handler (validator name)]
+        (handler chat-id params)))))
+
+
+(register-handler ::set-validation-error
+  (after #(dispatch [:fix-response-height]))
+  (fn [db [_ chat-id error]]
+    (assoc-in db [:validation-errors chat-id] [error])))

src/status_im/chat/styles/command_validation.cljs

@@ -0,0 +1,17 @@
+(ns status-im.chat.styles.command-validation
+  (:require [status-im.components.styles :as st]
+            [status-im.chat.constants :as constants]))
+
+(def messages-container
+  {:background-color :red
+   :height           constants/request-info-height
+   :padding-left     16
+   :padding-top      14})
+
+(def title
+  {:color       :white
+   :font-size   12
+   :font-family st/font})
+
+(def description
+  (assoc title :opacity 0.69))

src/status_im/chat/subs.cljs

@@ -173,6 +173,28 @@
     (let [requests (subscribe [:get-requests])]
       (reaction (not (some #(= message-id (:message-id %)) @requests))))))
 
+(register-sub :validation-errors
+  (fn [db]
+    (let [current-chat-id (subscribe [:get-current-chat-id])]
+      (reaction (get-in @db [:validation-errors @current-chat-id])))))
+
+(register-sub :custom-validation-errors
+  (fn [db]
+    (let [current-chat-id (subscribe [:get-current-chat-id])]
+      (reaction (get-in @db [:custom-validation-errors @current-chat-id])))))
+
 (register-sub :unviewed-messages-count
   (fn [db [_ chat-id]]
     (reaction (get-in @db [:unviewed-messages chat-id :count]))))
+
+(register-sub :command-suggestions-height
+  (fn [db]
+    (let [chat-id (subscribe [:get-current-chat-id])]
+      (reaction
+        (get-in @db [:animations :command-suggestions-height @chat-id])))))
+
+(register-sub :response-height
+  (fn [db]
+    (let [chat-id (subscribe [:get-current-chat-id])]
+      (reaction
+        (get-in @db [:animations :to-response-height @chat-id])))))

src/status_im/chat/views/command.cljs

@@ -15,8 +15,7 @@
   (dispatch [:set-chat-command-content message]))
 
 (defn send-command []
-  (dispatch [:stage-command])
+  (dispatch [:stage-command]))
-  (cancel-command-input))
 
 (defn valid? [message validator]
   (if validator

src/status_im/chat/views/command_validation.cljs

@@ -0,0 +1,30 @@
+(ns status-im.chat.views.command-validation
+  (:require-macros [status-im.utils.views :refer [defview]])
+  (:require [status-im.components.react :as c]
+            [status-im.chat.styles.command-validation :as st]
+            [status-im.utils.listview :as lw]))
+
+(defn message [{:keys [title description]}]
+  (c/list-item
+    [c/view
+     [c/text st/title title]
+     [c/text st/description description]]))
+
+(defn messages-list [errors]
+  [c/list-view {:renderRow                 message
+                :keyboardShouldPersistTaps true
+                :dataSource                (lw/to-datasource errors)
+                :style                     st/messages-container}])
+
+(defview validation-messages []
+  [validation-messages [:validation-errors]
+   custom-errors [:custom-validation-errors]
+   command? [:command?]]
+  [c/view
+   (cond (seq custom-errors)
+         (vec (concat [c/view] custom-errors))
+
+         (seq validation-messages)
+         [messages-list validation-messages]
+
+         :else nil)])

src/status_im/chat/views/message_input.cljs

@@ -2,6 +2,7 @@
   (:require-macros [status-im.utils.views :refer [defview]])
   (:require [re-frame.core :refer [subscribe]]
             [status-im.components.react :refer [view
+                                                text
                                                 animated-view
                                                 icon
                                                 touchable-highlight
@@ -48,20 +49,19 @@
                 input-options)
    (if command? input-command input-message)])
 
-(defview plain-message-input-view [{:keys [input-options validator]}]
+(defview plain-message-input-view [{:keys [input-options]}]
   [command? [:command?]
    {:keys [type] :as command} [:get-chat-command]
    input-command [:get-chat-command-content]
-   valid-plain-message? [:valid-plain-message?]
+   valid-plain-message? [:valid-plain-message?]]
-   valid-command? [:valid-command? validator]]
   [view st/input-container
    [view st/input-view
     [plain-message/commands-button]
     [message-input-container
-     [message-input input-options validator]]
+     [message-input input-options]]
     ;; TODO emoticons: not implemented
     [plain-message/smile-button]
-    (when (if command? valid-command? valid-plain-message?)
+    (when (or command? valid-plain-message?)
       (let [on-press (if command?
                        command/send-command
                        plain-message/send)]

src/status_im/chat/views/new_message.cljs

@@ -18,8 +18,7 @@
 
 (defn get-options [{:keys [type placeholder]} command-type]
   (let [options (case (keyword type)
-                  :phone {:input-options {:keyboardType :phone-pad}
+                  :phone {:input-options {:keyboardType :phone-pad}}
-                          :validator     valid-mobile-number?}
                   :password {:input-options {:secureTextEntry true}}
                   :number {:input-options {:keyboardType :numeric}}
                   ;; todo maybe nil is fine for now :)

src/status_im/chat/views/response.cljs

@@ -15,7 +15,8 @@
             [status-im.chat.styles.dragdown :as ddst]
             [status-im.components.animation :as anim]
             [status-im.chat.suggestions-responder :as resp]
-            [status-im.chat.constants :as c]))
+            [status-im.chat.constants :as c]
+            [status-im.chat.views.command-validation :as cv]))
 
 (defn drag-icon []
   [view st/drag-container
@@ -58,14 +59,14 @@
          [icon :drag_down ddst/drag-down-icon]]))))
 
 (defn container-animation-logic [{:keys [to-value val]}]
-  (let [to-value @to-value]
+  (when-let [to-value @to-value]
     (when-not (= to-value (.-_value val))
       (anim/start (anim/spring val {:toValue to-value})))))
 
 (defn container [response-height & children]
   (let [;; todo to-response-height, cur-response-height must be specific
         ;; for each chat
-        to-response-height (subscribe [:animations :to-response-height])
+        to-response-height (subscribe [:response-height])
         changed (subscribe [:animations :response-height-changed])
         context {:to-value to-response-height
                  :val      response-height}
@@ -83,8 +84,7 @@
 
 (defview placeholder []
   [suggestions [:get-content-suggestions]]
-  (when (seq suggestions)
+  [view st/input-placeholder])
-    [view st/input-placeholder]))
 
 (defview response-suggestions-view []
   [suggestions [:get-content-suggestions]]
@@ -95,4 +95,5 @@
     [container response-height
      [request-info response-height]
      [response-suggestions-view]
+     [cv/validation-messages]
      [placeholder]]))

src/status_im/chat/views/suggestions.cljs

@@ -104,7 +104,7 @@
 (defn container [h & elements]
   (let [;; todo to-response-height, cur-response-height must be specific
         ;; for each chat
-        to-response-height (subscribe [:animations :command-suggestions-height])
+        to-response-height (subscribe [:command-suggestions-height])
         changed (subscribe [:animations :commands-height-changed])
         context {:to-value to-response-height
                  :val      h}

src/status_im/components/react.cljs

@@ -17,7 +17,11 @@
 
 (def app-registry (get-react-property "AppRegistry"))
 (def navigator (get-class "Navigator"))
-(def text (get-class "Text"))
+(def text-class (get-class "Text"))
+(defn text
+  ([s] [text-class s])
+  ([{:keys [style] :as opts} s]
+   [text-class (if style opts {:style opts}) s]))
 (def view (get-class "View"))
 (def image (get-class "Image"))
 (def touchable-highlight-class (get-class "TouchableHighlight"))

src/status_im/db.cljs

@@ -38,8 +38,7 @@
                                       :whisper-identity ""
                                       :phone-number     ""}
              :disable-group-creation false
-             :animations             {:to-response-height           0.1
+             :animations             {;; todo clear this
-                                      ;; todo clear this
                                       :tabs-bar-value               (anim/create-value 0)}})
 
 (def protocol-initialized-path [:protocol-initialized])

src/status_im/models/commands.cljs

@@ -1,11 +1,5 @@
 (ns status-im.models.commands
-  (:require [clojure.string :refer [join split]]
+  (:require [status-im.db :as db]))
-            [clojure.walk :refer [stringify-keys keywordize-keys]]
-            [re-frame.core :refer [subscribe dispatch]]
-            [status-im.db :as db]
-            [status-im.components.animation :as anim]
-            [status-im.components.styles :refer [color-blue color-dark-mint]]
-            [status-im.i18n :refer [label]]))
 
 (defn get-commands [{:keys [current-chat-id] :as db}]
   (or (get-in db [:chats current-chat-id :commands]) {}))

src/status_im/translations/en.cljs

@@ -136,4 +136,6 @@
    ;users
    :add-account                           "Add account"
 
+   ;validation
+   :invalid-phone                         "Invalid phone number"
    })