      (this :load-agora-method))
    :load-agora-method
    (fn [{:keys [props state]} & [method-ref]]
-     (let [{:keys [namespace name snapshotId]} (or method-ref props)]
+     (let [{:keys [methodNamespace methodName methodVersion]} (or method-ref props)]
        (endpoints/call-ajax-orch
-        {:endpoint (endpoints/get-agora-method namespace name snapshotId)
+        {:endpoint (endpoints/get-agora-method methodNamespace methodName methodVersion)
          :headers utils/content-type=json
          :on-done (fn [{:keys [success? get-parsed-response status-text]}]
                     (if success?

               [comps/SidebarButton {:color :exception-state :margin :top
                                     :text "Cancel Editing" :icon :cancel
                                     :onClick (fn []
                                                (this :load-new-method-template (:prev-snapshot-id @state))
                                                (swap! state assoc :editing? false))}]))]))]))
   :-render-main
   (fn [{:keys [state this]}]

                    (let [response (get-parsed-response)]
                      (if success?
                        (endpoints/call-ajax-orch
                         {:endpoint endpoints/get-inputs-outputs
                          :payload (:methodRepoMethod response)
                          :headers utils/content-type=json
                          :on-done (fn [{:keys [success? get-parsed-response]}]
                                     (swap! state dissoc :blocker :wdl-parse-error)
                                     (let [template {:methodConfiguration (merge response config-namespace+name)}]
                                       (if success?
                                         (swap! state assoc
                                                :loaded-config (assoc template
                                                                 :invalidInputs {}
                                                                 :validInputs {}
                                                                 :invalidOutputs {}
                                                                 :validOutputs {})
                                                :inputs-outputs (get-parsed-response))
                                         (swap! state assoc :error (:message (get-parsed-response))))))})
                        (do
                          (swap! state assoc :blocker nil :wdl-parse-error (:message response))
                          (comps/push-error (style/create-server-error-message (:message response)))))))})))
   :cancel-editing
   (fn [{:keys [state props refs]}]
     (let [original-loaded-config (:original-config @state)
           original-inputs-outputs (:original-inputs-outputs @state)
           method-ref (-> original-loaded-config :methodConfiguration :methodRepoMethod)]
       (swap! state assoc :loaded-config original-loaded-config :inputs-outputs original-inputs-outputs)
       ((@refs "methodDetailsViewer") :load-agora-method method-ref)))})