           (let [[v c] (alts! (keys chan-to-path-map))
                 path (get chan-to-path-map c)]
             (condp some (-> path)
-              #{:score} (handle-score-update report-match path v)
-              #{:player1 :player2} (handle-player-update report-match path v)
-              #{:matchdate} (handle-matchdate-update report-match path v)
+              #{:score} (handle-score-update match-report path v)
+              #{:player1 :player2} (handle-player-update match-report path v)
+              #{:matchdate} (handle-matchdate-update match-report path v)
               nil)
             (recur)))))
 
     om/IRenderState
     (render-state [_ {:keys [team1 team2 matchdate]}]
-      (let [_   (debug "players" (map (fn [p] (str "'" (:name p) "'"))
-                                     (selected-players (:team1 report-match)
-                                                       (:team2 report-match))))
-            __  (debug "scores" (map (fn [kw] (get-in report-match [kw :score])) [:team1 :team2]))
-            ___ (debug "matchdate" (-> report-match :matchdate d/->str))
-            ____ (debug "submits" submits)
+      (let [submitting (:submitting match-report)
+            _    (debug "players" (map (fn [p] (str "'" (:name p) "'"))
+                                     (selected-players (:team1 match-report)
+                                                       (:team2 match-report))))
+            __   (debug "scores" (map (fn [kw] (get-in match-report [kw :score])) [:team1 :team2]))
+            ___  (debug "matchdate" (-> match-report :matchdate d/->str))
+            ____ (debug "submitting" submitting)
             render-team (partial render-team-controls app)
-            enabled? (valid-report? report-match)]
+            enabled? (and (not submitting)
+                          (valid-report? match-report))]
         (html
          [:div
           [:h1 "Report Match Result"]

        (when-not (@app :players)
          (data/go-update-data! "/api/players" app :players))
        (let [empty-team {:player1 nil :player2 nil :score nil :valid-score? true}]
          (om/transact! app [:report-match] (fn [rm] (merge rm
                                                           {:team1 empty-team
                                                            :team2 empty-team
                                                            :matchdate (tc/now)}))))

    (when (= 1 (count difference))
      (first difference))))

(defn- render-team-controls [{:keys [match-report active-players] :as app}
                             team-num
                             {:keys [score player1 player2] :as chans}]
  (let [team-sel       (team-selector team-num)
        other-team-sel (other-team team-sel)
        team           (team-sel match-report)
        other-team     (other-team-sel match-report)
        render-player  (fn [num change-ch]
                         (let [selected-player ((player-selector num) team)]
                           (om/build team-player-component team
