Pass token

.paket/Paket.Restore.targets

@@ -20,75 +20,82 @@
     <PaketBootstrapperStyle Condition="Exists('$(PaketToolsPath)paket.bootstrapper.proj')">proj</PaketBootstrapperStyle>
     <PaketExeImage>assembly</PaketExeImage>
     <PaketExeImage Condition=" '$(PaketBootstrapperStyle)' == 'proj' ">native</PaketExeImage>
-    <MonoPath Condition="'$(MonoPath)' == '' And Exists('/Library/Frameworks/Mono.framework/Commands/mono')">/Library/Frameworks/Mono.framework/Commands/mono</MonoPath>
+    <MonoPath Condition="'$(MonoPath)' == '' AND Exists('/Library/Frameworks/Mono.framework/Commands/mono')">/Library/Frameworks/Mono.framework/Commands/mono</MonoPath>
     <MonoPath Condition="'$(MonoPath)' == ''">mono</MonoPath>
 
     <!-- PaketBootStrapper  -->
     <PaketBootStrapperExePath Condition=" '$(PaketBootStrapperExePath)' == '' AND Exists('$(PaketRootPath)paket.bootstrapper.exe')">$(PaketRootPath)paket.bootstrapper.exe</PaketBootStrapperExePath>
     <PaketBootStrapperExePath Condition=" '$(PaketBootStrapperExePath)' == '' ">$(PaketToolsPath)paket.bootstrapper.exe</PaketBootStrapperExePath>
     <PaketBootStrapperExeDir Condition=" Exists('$(PaketBootStrapperExePath)') " >$([System.IO.Path]::GetDirectoryName("$(PaketBootStrapperExePath)"))\</PaketBootStrapperExeDir>
 
-    <PaketBootStrapperCommand Condition=" '$(OS)' == 'Windows_NT'">"$(PaketBootStrapperExePath)"</PaketBootStrapperCommand>
+    <PaketBootStrapperCommand Condition=" '$(OS)' == 'Windows_NT' ">"$(PaketBootStrapperExePath)"</PaketBootStrapperCommand>
     <PaketBootStrapperCommand Condition=" '$(OS)' != 'Windows_NT' ">$(MonoPath) --runtime=v4.0.30319 "$(PaketBootStrapperExePath)"</PaketBootStrapperCommand>
 
-    <!-- Disable automagic references for F# dotnet sdk -->
-    <!-- This will not do anything for other project types -->
-    <!-- see https://github.com/fsharp/fslang-design/blob/master/tooling/FST-1002-fsharp-in-dotnet-sdk.md -->
-    <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
-    <DisableImplicitSystemValueTupleReference>true</DisableImplicitSystemValueTupleReference>
-
     <!-- Disable Paket restore under NCrunch build -->
     <PaketRestoreDisabled Condition="'$(NCrunch)' == '1'">True</PaketRestoreDisabled>
 
+    <!-- Disable test for CLI tool completely - overrideable via properties in projects or via environment variables -->
+    <PaketDisableCliTest Condition=" '$(PaketDisableCliTest)' == '' ">False</PaketDisableCliTest>
+
     <PaketIntermediateOutputPath Condition=" '$(PaketIntermediateOutputPath)' == '' ">$(BaseIntermediateOutputPath.TrimEnd('\').TrimEnd('\/'))</PaketIntermediateOutputPath>
   </PropertyGroup>
 
-  <!-- Check if paket is available as local dotnet cli tool -->
+  <!-- Resolve how paket should be called -->
+  <!-- Current priority is: local (1: repo root, 2: .paket folder) => 3: as CLI tool => as bootstrapper (4: proj Bootstrapper style, 5: BootstrapperExeDir) => 6: global path variable -->
   <Target Name="SetPaketCommand" >
-
-    <!-- Call 'dotnet paket' and see if it returns without an error. Mute all the output. -->
-    <Exec Command="dotnet paket --version" IgnoreExitCode="true" StandardOutputImportance="low" StandardErrorImportance="low" >
-      <Output TaskParameter="ExitCode" PropertyName="LocalPaketToolExitCode" />
-    </Exec>
+    <!-- Test if paket is available in the standard locations. If so, that takes priority. Case 1/2 - non-windows specific -->
+    <PropertyGroup Condition=" '$(OS)' != 'Windows_NT' ">
+      <!-- no windows, try native paket as default, root => tool -->
+      <PaketExePath Condition=" '$(PaketExePath)' == '' AND Exists('$(PaketRootPath)paket') ">$(PaketRootPath)paket</PaketExePath>
+      <PaketExePath Condition=" '$(PaketExePath)' == '' AND Exists('$(PaketToolsPath)paket') ">$(PaketToolsPath)paket</PaketExePath>
+    </PropertyGroup>
 
-    <!-- If local paket tool is found, use that -->
-    <PropertyGroup Condition=" '$(LocalPaketToolExitCode)' == '0' ">
-      <InternalPaketCommand>dotnet paket</InternalPaketCommand>
+    <!-- Test if paket is available in the standard locations. If so, that takes priority. Case 2/2 - same across platforms -->
+    <PropertyGroup>
+      <!-- root => tool -->
+      <PaketExePath Condition=" '$(PaketExePath)' == '' AND Exists('$(PaketRootPath)paket.exe') ">$(PaketRootPath)paket.exe</PaketExePath>
+      <PaketExePath Condition=" '$(PaketExePath)' == '' AND Exists('$(PaketToolsPath)paket.exe') ">$(PaketToolsPath)paket.exe</PaketExePath>
     </PropertyGroup>
 
-    <!-- If not, then we go through our normal steps of setting the Paket command.  -->
-    <PropertyGroup Condition=" '$(LocalPaketToolExitCode)' != '0' ">
-      <!-- windows, root => tool => proj style => bootstrapper => global -->
-      <PaketExePath Condition=" '$(PaketExePath)' == '' AND '$(OS)' == 'Windows_NT' AND Exists('$(PaketRootPath)paket.exe') ">$(PaketRootPath)paket.exe</PaketExePath>
-      <PaketExePath Condition=" '$(PaketExePath)' == '' AND '$(OS)' == 'Windows_NT' AND Exists('$(PaketToolsPath)paket.exe') ">$(PaketToolsPath)paket.exe</PaketExePath>
-      <PaketExePath Condition=" '$(PaketExePath)' == '' AND '$(OS)' == 'Windows_NT' AND '$(PaketBootstrapperStyle)' == 'proj' ">$(PaketToolsPath)paket.exe</PaketExePath>
-      <PaketExePath Condition=" '$(PaketExePath)' == '' AND '$(OS)' == 'Windows_NT' AND Exists('$(PaketBootStrapperExeDir)') ">$(_PaketBootStrapperExeDir)paket.exe</PaketExePath>
-      <PaketExePath Condition=" '$(PaketExePath)' == '' AND '$(OS)' == 'Windows_NT' ">paket.exe</PaketExePath>
+    <!-- If paket hasn't be found in standard locations, test for CLI tool usage. -->
+    <!-- First test: Is CLI configured to be used in "dotnet-tools.json"? - can result in a false negative; only a positive outcome is reliable. -->
+    <PropertyGroup Condition=" '$(PaketExePath)' == '' ">
+      <_DotnetToolsJson Condition="Exists('$(PaketRootPath)/.config/dotnet-tools.json')">$([System.IO.File]::ReadAllText("$(PaketRootPath)/.config/dotnet-tools.json"))</_DotnetToolsJson>
+      <_ConfigContainsPaket Condition=" '$(_DotnetToolsJson)' != ''">$(_DotnetToolsJson.Contains('"paket"'))</_ConfigContainsPaket>
+      <_ConfigContainsPaket Condition=" '$(_ConfigContainsPaket)' == ''">false</_ConfigContainsPaket>
+    </PropertyGroup>
 
-      <!-- no windows, try native paket as default,  root => tool => proj style => mono paket => bootstrpper => global -->
-      <PaketExePath Condition=" '$(PaketExePath)' == '' AND '$(OS)' != 'Windows_NT' AND Exists('$(PaketRootPath)paket') ">$(PaketRootPath)paket</PaketExePath>
-      <PaketExePath Condition=" '$(PaketExePath)' == '' AND '$(OS)' != 'Windows_NT' AND Exists('$(PaketToolsPath)paket') ">$(PaketToolsPath)paket</PaketExePath>
-      <PaketExePath Condition=" '$(PaketExePath)' == '' AND '$(OS)' != 'Windows_NT' AND '$(PaketBootstrapperStyle)' == 'proj' ">$(PaketToolsPath)paket</PaketExePath>
+    <!-- Second test: Call 'dotnet paket' and see if it returns without an error. Mute all the output. Only run if previous test failed and the test has not been disabled. -->
+    <!-- WARNING: This method can lead to processes hanging forever, and should be used as little as possible. See https://github.com/fsprojects/Paket/issues/3705 for details. -->
+    <Exec Condition=" '$(PaketExePath)' == '' AND !$(PaketDisableCliTest) AND !$(_ConfigContainsPaket)" Command="dotnet paket --version" IgnoreExitCode="true" StandardOutputImportance="low" StandardErrorImportance="low" >
+      <Output TaskParameter="ExitCode" PropertyName="LocalPaketToolExitCode" />
+    </Exec>
 
-      <!-- no windows, try mono paket -->
-      <PaketExePath Condition=" '$(PaketExePath)' == '' AND '$(OS)' != 'Windows_NT' AND Exists('$(PaketRootPath)paket.exe') ">$(PaketRootPath)paket.exe</PaketExePath>
-      <PaketExePath Condition=" '$(PaketExePath)' == '' AND '$(OS)' != 'Windows_NT' AND Exists('$(PaketToolsPath)paket.exe') ">$(PaketToolsPath)paket.exe</PaketExePath>
+    <!-- If paket is installed as CLI use that. Again, only if paket haven't already been found in standard locations. -->
+    <PropertyGroup Condition=" '$(PaketExePath)' == '' AND ($(_ConfigContainsPaket) OR '$(LocalPaketToolExitCode)' == '0') ">
+      <_PaketCommand>dotnet paket</_PaketCommand>
+    </PropertyGroup>
 
-      <!-- no windows, try bootstrapper -->
-      <PaketExePath Condition=" '$(PaketExePath)' == '' AND '$(OS)' != 'Windows_NT' AND Exists('$(PaketBootStrapperExeDir)') ">$(PaketBootStrapperExeDir)paket.exe</PaketExePath>
+    <!-- If neither local files nor CLI tool can be found, final attempt is searching for boostrapper config before falling back to global path variable. -->
+    <PropertyGroup Condition=" '$(PaketExePath)' == '' AND '$(_PaketCommand)' == '' ">
+      <!-- Test for bootstrapper setup -->
+      <PaketExePath Condition=" '$(PaketExePath)' == '' AND '$(PaketBootstrapperStyle)' == 'proj' ">$(PaketToolsPath)paket</PaketExePath>
+      <PaketExePath Condition=" '$(PaketExePath)' == '' AND Exists('$(PaketBootStrapperExeDir)') ">$(PaketBootStrapperExeDir)paket</PaketExePath>
 
-      <!-- no windows, try global native paket -->
-      <PaketExePath Condition=" '$(PaketExePath)' == '' AND '$(OS)' != 'Windows_NT' ">paket</PaketExePath>
+      <!-- If all else fails, use global path approach. -->
+      <PaketExePath Condition=" '$(PaketExePath)' == ''">paket</PaketExePath>
+    </PropertyGroup>
 
+    <!-- If not using CLI, setup correct execution command. -->
+    <PropertyGroup Condition=" '$(_PaketCommand)' == '' ">
       <_PaketExeExtension>$([System.IO.Path]::GetExtension("$(PaketExePath)"))</_PaketExeExtension>
-      <InternalPaketCommand Condition=" '$(InternalPaketCommand)' == '' AND '$(_PaketExeExtension)' == '.dll' ">dotnet "$(PaketExePath)"</InternalPaketCommand>
-      <InternalPaketCommand Condition=" '$(InternalPaketCommand)' == '' AND '$(OS)' != 'Windows_NT' AND '$(_PaketExeExtension)' == '.exe' ">$(MonoPath) --runtime=v4.0.30319 "$(PaketExePath)"</InternalPaketCommand>
-      <InternalPaketCommand Condition=" '$(InternalPaketCommand)' == '' ">"$(PaketExePath)"</InternalPaketCommand>
-
+      <_PaketCommand Condition=" '$(_PaketCommand)' == '' AND '$(_PaketExeExtension)' == '.dll' ">dotnet "$(PaketExePath)"</_PaketCommand>
+      <_PaketCommand Condition=" '$(_PaketCommand)' == '' AND '$(OS)' != 'Windows_NT' AND '$(_PaketExeExtension)' == '.exe' ">$(MonoPath) --runtime=v4.0.30319 "$(PaketExePath)"</_PaketCommand>
+      <_PaketCommand Condition=" '$(_PaketCommand)' == '' ">"$(PaketExePath)"</_PaketCommand>
     </PropertyGroup>
 
     <!-- The way to get a property to be available outside the target is to use this task. -->
-    <CreateProperty Value="$(InternalPaketCommand)">
+    <CreateProperty Value="$(_PaketCommand)">
       <Output TaskParameter="Value" PropertyName="PaketCommand"/>
     </CreateProperty>
 

FBlazorShop.Web.BlazorClient/Checkout.fs

@@ -94,9 +94,9 @@ let update remote message (model : Model, commonState : Common.State) =
     | OrderPlaced order, (_, { Authentication = None}) ->  
         let c = Cmd.ofMsg(OrderPlaced order)
         model, c, Common.authenticationRequested
-    | OrderPlaced order, _ -> 
+    | OrderPlaced order,(_,{Authentication = Some auth}) -> 
         let order  = {order with DeliveryAddress = model.CurrentAddress}
-        let cmd = Cmd.ofAsync remote.placeOrder order OrderAccepted raise
+        let cmd = Cmd.ofAsync remote.placeOrder (auth.Token, order) OrderAccepted raise
         model, cmd, Cmd.none
 
     | OrderAccepted _ , _ -> invalidOp "should not happen"

FBlazorShop.Web.BlazorClient/Home/Home.fs

@@ -83,7 +83,7 @@ type Cards() =
 
 let view model dispatch =
     cond model.specials <| function
-    | [] -> empty
+    | [] -> h2  [] [text "Loading data, please wait..."]
     | _ ->
          let cards = ecomp<Cards, _, _> model dispatch
          let pizzaconfig = PizzaConfig.view model.PizzaConfig (PizzaConfigMsg >> dispatch)

FBlazorShop.Web.BlazorClient/Main.fs

@@ -38,10 +38,10 @@ and Message=
     | SignInMessage of SignIn.Message
     | RemoveBuffer
 
-let defaultPageModel remote = function
+let defaultPageModel remote  = function
 | MyOrders m -> Router.definePageModel m (MyOrders.init remote|> fst)
 | Home m ->Router.definePageModel m (Home.init remote |> fst)
-| OrderDetail (key, m) -> Router.definePageModel m (OrderDetail.init remote key |> fst)
+| OrderDetail (key, m) -> Router.definePageModel m (OrderDetail.init  (key , None)|> fst)
 | Checkout m -> Router.definePageModel m (Checkout.init remote None|> fst)
 | Start -> ()
 let router remote = Router.inferWithModel SetPage (fun m -> m.Page) (defaultPageModel remote)
@@ -52,7 +52,8 @@ let initPage  init (model : Model) msg page =
     { model with Page  = page; }, Cmd.map msg cmd
 
 let initOrderDetail  remote key model = 
-    initPage  (OrderDetail.init remote key) model OrderDetailMsg (fun pageModel -> OrderDetail(key, pageModel))
+    initPage  (OrderDetail.init  (key ,None)) model OrderDetailMsg 
+        (fun pageModel -> OrderDetail(key, pageModel))
 
 let initMyOrders remote  model = 
     initPage  (MyOrders.init remote) model MyOrdersMsg MyOrders
@@ -145,7 +146,7 @@ let update remote jsRuntime message model =
     | SignedOut, _ -> init
     | TokenNotFound , _ -> model, Cmd.none
     | MyOrdersMsg msg, MyOrders myOrdersModel ->
-        genericUpdate MyOrders.update (myOrdersModel.Model) msg MyOrdersMsg MyOrders
+        genericUpdateWithCommon (MyOrders.update remote) (myOrdersModel.Model) msg MyOrdersMsg MyOrders
 
     | HomeMsg (Home.Message.OrderMsg (CheckoutRequested o)),_  -> 
         let orderModel = Checkout.init remote (Some o) |> fst
@@ -156,7 +157,7 @@ let update remote jsRuntime message model =
         genericUpdate (Home.update remote)(homeModel.Model) msg HomeMsg Home
 
     | CheckoutMsg (Checkout.Message.OrderAccepted o), _  ->
-        let orderModel = OrderDetail.init remote o |> fst
+        let orderModel = OrderDetail.init  (o,None) |> fst
         let init = { Model = orderModel } 
         model, (o,init) |> OrderDetail |> SetPage |> Cmd.ofMsg
 
@@ -169,7 +170,7 @@ let update remote jsRuntime message model =
         model, Cmd.none
 
     | OrderDetailMsg msg, OrderDetail(key, orderModel) ->
-        genericUpdate 
+        genericUpdateWithCommon 
             (OrderDetail.update remote)
             (orderModel.Model)
             msg 

FBlazorShop.Web.BlazorClient/MyOrders.fs

@@ -9,13 +9,16 @@ type Model = { MyOrders : OrderWithStatus list option}
 
 type Message =
     | OrdersLoaded  of OrderWithStatus list
+    | Initialized
 
 let init (remote : PizzaService)  =
-    { MyOrders = None } , Cmd.ofAsync remote.getOrderWithStatuses () OrdersLoaded raise
+    { MyOrders = None } , Cmd.ofMsg Initialized
 
-let update message model = 
-    match message with
-    | OrdersLoaded orders -> { MyOrders = Some orders }, Cmd.none
+let update (remote :PizzaService) message (model , commonState: Common.State) = 
+    match message, commonState.Authentication with
+    | Initialized , Some auth-> model, Cmd.ofAsync remote.getOrderWithStatuses auth.Token OrdersLoaded raise, Cmd.none
+    | OrdersLoaded orders , _ -> { MyOrders = Some orders }, Cmd.none, Cmd.none
+    | _ -> failwith ""
 
 
 open Bolero.Html

FBlazorShop.Web.BlazorClient/OrderDetail.fs

@@ -10,22 +10,23 @@ type Model = { Order : OrderWithStatus option}
 
 type Message =
     | OrderLoaded of id :int * OrderWithStatus option
+   // | Initialized of id : int
 
-let loadPeriodically remote id =
+let loadPeriodically remote token id =
     let doWork i = 
         async{ 
             do! Async.Sleep 4000; 
-            return! remote.getOrderWithStatus i 
+            return! remote.getOrderWithStatus (token,i) 
     }
-    Cmd.ofAsync doWork id (fun m -> OrderLoaded(id,m)) (fun m -> OrderLoaded(id,None))
+    Cmd.ofAsync doWork id (fun m -> OrderLoaded(id,m)) (fun _ -> OrderLoaded(0,None))
 
-let init (remote : PizzaService) id  =
-    { Order = None } , Cmd.ofAsync remote.getOrderWithStatus id (fun m -> OrderLoaded(id,m)) raise
+let init  id  = { Order = None}, Cmd.ofMsg (OrderLoaded id)
 
-let update remote message (model : Model) = 
-    match message with
-    | OrderLoaded (id , None) -> model,Cmd.none
-    | OrderLoaded (id, order) -> { Order =  order }, loadPeriodically remote id
+let update remote message (model : Model, commonModel: Common.State) = 
+    match message, commonModel.Authentication with
+    | _ , None-> model, Cmd.none, Cmd.none
+    | OrderLoaded (0 , None), _ -> model,Cmd.none, Cmd.none
+    | OrderLoaded (id, order), Some auth -> { Order =  order }, loadPeriodically remote auth.Token id, Cmd.none
 
 open Bolero.Html
 open FBlazorShop.ComponentsLibrary

FBlazorShop.Web.BlazorClient/Services.fs

@@ -8,10 +8,10 @@ type public PizzaService =
     {
         getSpecials : unit -> Async<PizzaSpecial list>
         getToppings : unit -> Async<Topping list>
-        getOrders : unit -> Async<Order list>
-        getOrderWithStatuses : unit -> Async<OrderWithStatus list>
-        getOrderWithStatus : int -> Async<OrderWithStatus option>
-        placeOrder : Order -> Async<int>
+        getOrders : string -> Async<Order list>
+        getOrderWithStatuses : string -> Async<OrderWithStatus list>
+        getOrderWithStatus : string * int -> Async<OrderWithStatus option>
+        placeOrder : string * Order -> Async<int>
         signIn : string * string -> Async<Result<Authentication,string>>
     }
     interface IRemoteService with

FBlazorShop.Web/.config/dotnet-tools.json

@@ -0,0 +1,5 @@
+{
+  "version": 1,
+  "isRoot": true,
+  "tools": {}
+}

FBlazorShop.Web/FBlazorShop.Web.fsproj

@@ -12,7 +12,8 @@
     <DefineConstants></DefineConstants>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
-    <DefineConstants></DefineConstants>
+    <DefineConstants>WASM</DefineConstants>
+    <PlatformTarget>x86</PlatformTarget>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="Services.fs" />

FBlazorShop.Web/Program.fs

@@ -21,6 +21,7 @@ module Program =
         Host.CreateDefaultBuilder(args)
             .ConfigureWebHostDefaults(fun webBuilder ->
                 webBuilder.UseStartup<Startup>() |> ignore
+                webBuilder.UseSetting(WebHostDefaults.DetailedErrorsKey, "true") |> ignore
             )
 
     [<EntryPoint>]

FBlazorShop.Web/Services.fs

@@ -25,17 +25,22 @@ type public PizzaService(ctx: IRemoteContext) =
 
             getSpecials = this.GetItems<PizzaSpecial>()
             getToppings = this.GetItems<Topping>()
-            getOrders = this.GetItems<Order>()
+            getOrders  = fun token -> 
+                             async{
+                                 let! orders = this.GetItems<Order>()() 
+                                 let statuses = orders
+                                 return statuses
+                             }
 
             getOrderWithStatuses = 
-                fun () -> 
+                fun token -> 
                     async{
                         let! orders = this.GetItems<Order>()() 
                         let statuses = orders |> List.map OrderWithStatus.FromOrder
                         return statuses
                     }
             getOrderWithStatus = 
-                           fun i -> 
+                           fun (token,i) -> 
                                async{
                                     let! orders = this.GetItems<Order>()() 
                                     let status = 
@@ -45,7 +50,7 @@ type public PizzaService(ctx: IRemoteContext) =
                                     return status
                                }
             placeOrder = 
-                fun order -> 
+                fun (token,order) -> 
                     async {
                         let orderService = this.GetService<IOrderService>()
                         let! i = order |> orderService.PlaceOrder  |> Async.AwaitTask