status-im
/
status-react
mirror of https://github.com/status-im/status-react.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

fix #573 & remove staged-commands

This commit is contained in:
Roman Volosovskyi 2016-12-22 15:18:09 +02:00
parent 6002d53c97
commit aad122a724
15 changed files with 115 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
resources/console.js
View File

@ -1710,6 +1710,12 @@ var phoneConfig = {
title: I18n.t('phone_title'),
description: I18n.t('phone_description'),
color: "#5bb2a2",
validator: function (params) {
return {
validationHandler: "phone",
parameters: [params.phone]
};
},
params: [{
name: "phone",
type: status.types.PHONE,

11
src/status_im/chat/handlers.cljs
View File

@ -168,15 +168,14 @@
(register-handler :set-chat-input-text
(u/side-effect!
(fn [{:keys [current-chat-id] :as db} [_ text]]
(let [{:keys [dapp?] :as contact} (get-in db [:contacts current-chat-id])]
(fn [{:keys [current-chat-id]} [_ text]]
(if (console? current-chat-id)
(dispatch [::check-input-for-commands text])
(dispatch [::check-suggestions current-chat-id text]))))))
(dispatch [::check-suggestions current-chat-id text])))))
(register-handler :add-to-chat-input-text
(u/side-effect!
(fn [{:keys [chats current-chat-id] :as db} [_ text-to-add]]
(fn [{:keys [chats current-chat-id]} [_ text-to-add]]
(let [input-text (get-in chats [current-chat-id :input-text])]
(dispatch [:set-chat-input-text (str input-text text-to-add)])))))
@ -194,10 +193,10 @@
(let [text' (if (= :commands type)
(str command-prefix text)
text)]
(dispatch [::stage-command-with-content command text']))
(dispatch [::set-command-with-content command text']))
(dispatch [::check-suggestions console-chat-id text])))))
(register-handler ::stage-command-with-content
(register-handler ::set-command-with-content
(u/side-effect!
(fn [_ [_ [command type] text]]
(dispatch [:set-chat-command command type])

40
src/status_im/chat/handlers/commands.cljs
View File

@ -76,8 +76,8 @@
content)])))))
(defn invoke-command-preview!
[{:keys [staged-command] :as db} [_ command-input chat-id]]
(let [{:keys [command id]} staged-command
[db command-message [_ command-input chat-id]]
(let [{:keys [command]} command-message
{:keys [name type]} command
parameters (:params (or command-input (commands/get-command-input db)))
path [(if (= :command type) :commands :responses)
@ -86,12 +86,11 @@
params {:parameters parameters
:context {:platform platform/platform}}]
(if (and (console? chat-id) (= name "js"))
(dispatch [:send-chat-message])
(dispatch [:send-chat-message command-message])
(status/call-jail chat-id
path
params
#(do (dispatch [:command-preview chat-id id %])
(dispatch [:send-chat-message]))))))
#(dispatch [:command-preview command-message %])))))
(defn command-input
([{:keys [current-chat-id] :as db}]
@ -120,36 +119,30 @@
(handler)
(dispatch [::finish-command-staging command-input chat-id]))))))))
(register-handler :stage-command
(register-handler :validate-command
(u/side-effect!
(fn [{:keys [current-chat-id current-account-id] :as db} [_ command-input command]]
(let [command-input (or command-input (commands/get-command-input db))
command (or command (commands/get-chat-command db))]
(dispatch [::start-command-validation! {:command-input command-input
:command command
:chat-id current-chat-id
:address current-account-id}])
(assoc-in db [:disable-staging current-chat-id] true))))
:address current-account-id}])))))
(register-handler ::finish-command-staging
[(after #(dispatch [:start-cancel-command]))
(after invoke-command-preview!)]
(fn [db [_ command-input chat-id]]
[(after #(dispatch [:start-cancel-command]))]
(u/side-effect!
(fn [db [_ command-input chat-id :as parameters]]
(let [db (assoc-in db [:chats chat-id :input-text] nil)
{:keys [command content to-message-id params]} (or command-input (command-input db))
{:keys [command to-message-id params]} (or command-input (command-input db))
command-info {:command command
:params params
:to-message to-message-id
:created-at (time/now-ms)
:id (random/id)}]
(-> db
(commands/stage-command command-info)
(assoc-in [:command->chat (:id command-info)] chat-id)
(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)))
:id (random/id)
:chat-id chat-id}]
(dispatch [:set-in [:command->chat (:id command-info)] chat-id])
(invoke-command-preview! db command-info parameters)))))
(defn set-chat-command
[{:keys [current-chat-id] :as db} [_ command-key type]]
@ -285,5 +278,4 @@
(let [suggestions-trigger (keyword (:suggestions-trigger command))]
(if (= :on-send suggestions-trigger)
(dispatch [:invoke-commands-suggestions!])
(dispatch [:stage-command]))))))
(dispatch [:validate-command]))))))

4
src/status_im/chat/handlers/console.cljs
View File

@ -31,8 +31,8 @@
(register-handler :invoke-console-command-handler!
(u/side-effect!
(fn [_ [_ {:keys [chat-id staged-command] :as parameters}]]
(let [{:keys [id command params]} staged-command
(fn [_ [_ {:keys [chat-id command-message] :as parameters}]]
(let [{:keys [id command params]} command-message
{:keys [name]} command]
(dispatch [:prepare-command! chat-id parameters])
((console-commands (keyword name)) params id)))))

48
src/status_im/chat/handlers/send_message.cljs
View File

@ -49,17 +49,17 @@
(register-handler :send-chat-message
(u/side-effect!
(fn [{:keys [current-chat-id current-public-key current-account-id] :as db}]
(let [staged-commands (vals (get-in db [:chats current-chat-id :staged-commands]))
text (get-in db [:chats current-chat-id :input-text])
data {:commands staged-commands
(fn [{:keys [current-chat-id current-public-key current-account-id] :as db}
[_ {:keys [chat-id] :as command-message}]]
(let [text (get-in db [:chats current-chat-id :input-text])
data {:command command-message
:message text
:chat-id current-chat-id
:chat-id (or chat-id current-chat-id)
:identity current-public-key
:address current-account-id}]
(dispatch [:clear-input current-chat-id])
(cond
(seq staged-commands)
command-message
(dispatch [::check-commands-handlers! data])
(not (s/blank? text))
(dispatch [::prepare-message data]))))))
@ -70,9 +70,9 @@
(register-handler ::check-commands-handlers!
(u/side-effect!
(fn [_ [_ {:keys [commands message chat-id] :as params}]]
(doseq [{:keys [command] :as message} commands]
(let [params' (assoc params :staged-command message)
(fn [_ [_ {:keys [command message chat-id] :as params}]]
(let [{:keys [command] :as message} command]
(let [params' (assoc params :command-message message)
command-name (:name (:command message))]
(if (:sent-to-jail? message)
;; todo there could be other reasons for "long-running"
@ -98,34 +98,27 @@
(register-handler :prepare-command!
(u/side-effect!
(fn [{:keys [current-public-key network-status] :as db}
[_ add-to-chat-id {:keys [chat-id staged-command command handler-data] :as params}]]
[_ add-to-chat-id {:keys [chat-id command-message command handler-data] :as params}]]
(let [clock-value (messages/get-last-clock-value chat-id)
request (:request (:handler-data command))
command' (->> (assoc staged-command :handler-data handler-data)
command' (->> (assoc command-message :handler-data handler-data)
(prepare-command current-public-key chat-id clock-value request)
(cu/check-author-direction db chat-id))]
(log/debug "Handler data: " request handler-data (dissoc params :commands :staged-command))
(log/debug "Handler data: " request handler-data (dissoc params :commands :command-message))
(dispatch [:update-message-overhead! chat-id network-status])
(dispatch [:clear-command chat-id (:id staged-command)])
(dispatch [::send-command! add-to-chat-id (assoc params :command command')])
(when (cu/console? chat-id)
(dispatch [:console-respond-command params]))
(when (and (= "send" (get-in staged-command [:command :name]))
(dispatch `[:console-respond-command params]))
(when (and (= "send" (get-in command-message [:command :name]))
(not= add-to-chat-id wallet-chat-id))
(let [ct (if request
c/content-type-wallet-request
c/content-type-wallet-command)
staged-command' (assoc staged-command :id (random/id)
command-message' (assoc command-message :id (random/id)
:content-type ct)
params' (assoc params :staged-command staged-command')]
params' (assoc params :command-message command-message')]
(dispatch [:prepare-command! wallet-chat-id params'])))))))
(register-handler :clear-command
(fn [db [_ chat-id id]]
(if chat-id
(update-in db [:chats chat-id :staged-commands] dissoc id)
db)))
(register-handler ::send-command!
(u/side-effect!
(fn [_ [_ add-to-chat-id params]]
@ -157,9 +150,9 @@
(register-handler ::invoke-command-handlers!
(u/side-effect!
(fn [db [_ {:keys [chat-id address staged-command]
(fn [db [_ {:keys [chat-id address command-message]
:as parameters}]]
(let [{:keys [id command params]} staged-command
(let [{:keys [id command params]} command-message
{:keys [type name]} command
path [(if (= :command type) :commands :responses)
name
@ -169,17 +162,12 @@
:context {:from address
:to to
:message-id id}}]
(dispatch [::command-in-processing chat-id id])
(status/call-jail
chat-id
path
params
#(dispatch [:command-handler! chat-id parameters %]))))))
(register-handler ::command-in-processing
(fn [db [_ chat-id id]]
(assoc-in db [:chats chat-id :staged-commands id :sent-to-jail?] true)))
(register-handler ::prepare-message
(u/side-effect!
(fn [{:keys [network-status] :as db} [_ {:keys [chat-id identity message] :as params}]]

2
src/status_im/chat/handlers/webview_bridge.cljs
View File

@ -57,7 +57,7 @@
:parameter-idx 0
:params {"amount" (:amount params)}
:to-message-id nil}]
(dispatch [:stage-command command-input command])))))
(dispatch [:validate-command command-input command])))))
(defn chat-with-command

38
src/status_im/chat/subs.cljs
View File

@ -69,36 +69,15 @@
(get-in @db)
(reaction))))
(register-sub :get-chat-staged-commands
(fn [db _]
(->> [:chats (:current-chat-id @db) :staged-commands]
(get-in @db)
vals
(reaction))))
(register-sub :get-chat-staged-commands-ids
(fn [db _]
(->> [:chats (:current-chat-id @db) :staged-commands]
(get-in @db)
vals
(keep :to-message)
(reaction))))
(register-sub :staged-response?
(fn [_ [_ id]]
(let [commands (subscribe [:get-chat-staged-commands])]
(reaction (some #(= id (:to-message %)) @commands)))))
(register-sub :get-message-input-view-height
(fn [db _]
(reaction (get-in @db [:chats (:current-chat-id @db) :message-input-height]))))
(register-sub :valid-plain-message?
(fn [_ _]
(let [input-message (subscribe [:get-chat-input-text])
staged-commands (subscribe [:get-chat-staged-commands])]
(let [input-message (subscribe [:get-chat-input-text])]
(reaction
(plain-message/message-valid? @staged-commands @input-message)))))
(plain-message/message-valid? @input-message)))))
(register-sub :valid-command?
(fn [_ [_ validator]]
@ -157,10 +136,9 @@
(fn []
(let [command? (subscribe [:command?])
type (subscribe [:command-type])
command-suggestions (subscribe [:get-content-suggestions])
staged-commands (subscribe [:get-chat-staged-commands])]
command-suggestions (subscribe [:get-content-suggestions])]
(reaction
(cond (and @command? (= @type :response) (not (seq @staged-commands)))
(cond (and @command? (= @type :response))
c/request-info-height
(and @command? (= @type :command) (seq @command-suggestions))
@ -178,12 +156,8 @@
(register-sub :get-requests
(fn [db]
(let [chat-id (subscribe [:get-current-chat-id])
staged-ids (subscribe [:get-chat-staged-commands-ids])]
(reaction
(let [ids (set @staged-ids)
requests (get-in @db [:chats @chat-id :requests])]
(remove #(ids (:message-id %)) requests))))))
(let [chat-id (subscribe [:get-current-chat-id])]
(reaction (get-in @db [:chats @chat-id :requests])))))
(register-sub :get-requests-map
(fn [db]

12
src/status_im/chat/views/command.cljs
View File

@ -7,15 +7,9 @@
touchable-highlight]]
[status-im.chat.styles.input :as st]))
(defn cancel-command-input []
(dispatch [:start-cancel-command]))
(defn set-input-message [message]
(dispatch [:set-chat-command-content message]))
(defn send-command []
(dispatch [:stage-command]))
(defn valid? [message validator]
(if validator
(validator message)
@ -30,9 +24,3 @@
(when (not= icon-width width)
(dispatch [:set :command-icon-width width]))))}
[text {:style st/command-text} (str "!" (:name command))]]])
(defn cancel-button []
[touchable-highlight {:on-press cancel-command-input}
[view st/cancel-container
[icon :close_gray st/cancel-icon]]])

7
src/status_im/chat/views/plain_message.cljs
View File

@ -18,10 +18,9 @@
(defn send []
(dispatch [:send-chat-message]))
(defn message-valid? [staged-commands message]
(or (and (pos? (count message))
(not= "!" message))
(pos? (count staged-commands))))
(defn message-valid? [ message]
(and (pos? (count message))
(not= "!" message)))
(defn button-animation-logic [{:keys [command? val]}]
(fn [_]

14
src/status_im/chat/views/request_message.cljs
View File

@ -26,34 +26,32 @@
(def min-scale 1)
(def max-scale 1.3)
(defn button-animation [val to-value loop? answered? staged?]
(defn button-animation [val to-value loop? answered?]
(anim/anim-sequence
[(anim/anim-delay
(if (and @loop? (or @staged? (not @answered?)))
(if (and @loop? (not @answered?))
request-message-icon-scale-delay
0))
(anim/spring val {:toValue to-value})]))
(defn request-button-animation-logic
[{:keys [to-value val loop? answered? staged?] :as context}]
[{:keys [to-value val loop? answered?] :as context}]
(anim/start
(button-animation val to-value loop? answered? staged?)
#(if (and @loop? (or @staged? (not @answered?)))
(button-animation val to-value loop? answered?)
#(if (and @loop? (not @answered?))
(let [new-value (if (= to-value min-scale) max-scale min-scale)
context' (assoc context :to-value new-value)]
(request-button-animation-logic context'))
(anim/start
(button-animation val min-scale loop? answered? staged?)))))
(button-animation val min-scale loop? answered?)))))
(defn request-button [message-id command status-initialized? top-offset?]
(let [scale-anim-val (anim/create-value min-scale)
answered? (subscribe [:is-request-answered? message-id])
staged? (subscribe [:staged-response? message-id])
loop? (r/atom true)
context {:to-value max-scale
:val scale-anim-val
:answered? answered?
:staged? staged?
:loop? loop?}]
(r/create-class
{:component-did-mount

20
src/status_im/commands/handlers/jail.cljs
View File

@ -18,7 +18,7 @@
(defn command-handler!
[_ [chat-id
{:keys [staged-command] :as parameters}
{:keys [command-message] :as parameters}
{:keys [result error]}]]
(let [{:keys [context returned]} result
{handler-error :error} returned]
@ -27,13 +27,13 @@
handler-error
(log/debug :error-from-handler handler-error
:chat-id chat-id
:command staged-command)
:command command-message)
result
(let [command' (assoc staged-command :handler-data returned)
(let [command' (assoc command-message :handler-data returned)
parameters' (assoc parameters :command command')]
(if (:eth_sendTransaction context)
(dispatch [:wait-for-transaction (:id staged-command) parameters'])
(dispatch [:wait-for-transaction (:id command-message) parameters'])
(dispatch [:prepare-command! chat-id parameters'])))
(not (or error handler-error))
@ -64,14 +64,14 @@
nil)))
(defn command-preview
[db [chat-id command-id {:keys [result]}]]
[_ [command-message {:keys [result]}]]
(let [result' (:returned result)]
(dispatch [:send-chat-message
(if result'
(let [path [:chats chat-id :staged-commands command-id]]
(update-in db path assoc
(assoc command-message
:preview (generate-hiccup result')
:preview-string (str result')))
db)))
:preview-string (str result'))
command-message)])))
(defn print-error-message! [message]
(fn [_ params]
@ -98,7 +98,7 @@
(reg-handler :command-preview
(after (print-error-message! "Error on command preview"))
command-preview)
(u/side-effect! command-preview))
(reg-handler :set-local-storage
(fn [{:keys [current-chat-id] :as db} [{:keys [data] :as event}]]

4
src/status_im/db.cljs
View File

@ -50,15 +50,11 @@
:edit-mode {}
:network :testnet})
(defn chat-staged-commands-path [chat-id]
[:chats chat-id :staged-commands])
(defn chat-command-path [chat-id]
[:chats chat-id :command-input :command])
(defn chat-command-to-message-id-path [chat-id]
[:chats chat-id :command-input :to-message-id])
(defn chat-command-content-path [chat-id]
[:chats chat-id :command-input :content])
(defn chat-command-requests-path [chat-id]
[:chats chat-id :command-requests])
(defn chat-command-request-path [chat-id message-id]
[:chats chat-id :command-requests message-id])

3
src/status_im/handlers.cljs
View File

@ -24,8 +24,7 @@
status-im.network.handlers
[status-im.utils.types :as t]
[status-im.constants :refer [console-chat-id]]
[status-im.utils.ethereum-network :as enet]
[status-im.protocol.core :as protocol]))
[status-im.utils.ethereum-network :as enet]))
;; -- Common --------------------------------------------------------------

17
src/status_im/models/commands.cljs
View File

@ -74,23 +74,6 @@
[{:keys [current-chat-id] :as db}]
(get-in db (db/chat-command-to-message-id-path current-chat-id)))
(defn compare-commands
[{created-at-1 :created-at} {created-at-2 :created-at}]
(compare created-at-1 created-at-2))
(defn stage-command
[{:keys [current-chat-id] :as db} {:keys [id] :as command-info}]
(let [path (db/chat-staged-commands-path current-chat-id)
staged-commands (get-in db path)
staged-coomands' (if (seq staged-commands)
staged-commands
(priority-map-by compare-commands))]
(assoc-in db path (assoc staged-coomands' id command-info))))
(defn unstage-command [db {:keys [id]}]
(update-in db (db/chat-staged-commands-path (:current-chat-id db))
dissoc id))
(defn get-chat-command-request
[{:keys [current-chat-id] :as db}]
(get-in db (db/chat-command-request-path current-chat-id

20
src/status_im/transactions/handlers.cljs
View File

@ -87,30 +87,18 @@
(update :transactions dissoc hash)
(update :transactions-queue dissoc hash))))
(defn mark-command-as-pending [db chat-id id]
(let [path [:chats chat-id :staged-commands id]]
(if (get-in db path)
(update-in db path assoc :pending true)
db)))
(register-handler :wait-for-transaction
(after (fn [_ [_ message-id]]
(dispatch [::check-completed-transaction!
{:message-id message-id}])))
(fn [db [_ message-id {:keys [chat-id command] :as params}]]
(let [id (:id command)]
(-> db
(mark-command-as-pending chat-id id)
(assoc-in [:transaction-subscribers message-id] params)))))
(fn [db [_ message-id params]]
(assoc-in db [:transaction-subscribers message-id] params)))
(defn remove-pending-message
[{:keys [command->chat] :as db} message-id]
(let [chat-id (get command->chat message-id)
path [:chats chat-id :staged-commands]]
(let [chat-id (get command->chat message-id)]
(if chat-id
(-> db
(update :transaction-subscribers dissoc message-id)
(update-in path dissoc message-id))
(update db :transaction-subscribers dissoc message-id)
db)))
(register-handler ::remove-pending-messages