Exemplo n.º 1
0
        public static async Task Update()
        {
            if (!currentlyUpdating)
            {
                currentlyUpdating = true;
                //1
                ServiceChat.ServerStatus serverInfo = null;
                if (isConnected)
                {
                    if (client != null)
                    {
                        {
                            try
                            {
                                serverInfo = await client.GetServerStatusAsync(ClientReadiness);
                            }
                            catch (Exception e)
                            {
                                Log.Instance.W(client ?? new object {}, "An error occurred while the client was trying to update its data");
                                Log.Instance.W(client ?? new object { }, e.Message);

                                return;
                            }
                        }
                    }
                }

                if (serverInfo != null && serverInfo.ServerDeliverer != null)
                {
                    //CurrentDeliverer.ID != serverInfo.ServerDeliverer.ID
                    CurrentDeliverer = serverInfo.ServerDeliverer;
                    //if (isSelfServer)
                    //{
                    //    //LeaderServer.CurrentServer.ServerState == ServerStates.DelivererSet
                    //    ClientStateChanged?.Invoke(ClientState.DelivererSet);
                    //}
                    //else
                    //{
                    //    ClientStateChanged?.Invoke(ClientState.DelivererWait);
                    //}
                }

                //2
                if (serverInfo != null)
                {
                    if (LeaderServer.CurrentServer == null)
                    {
                        LeaderServer.CurrentServer = new LeaderServer();
                    }
                    LeaderServer.CurrentServer.ServerState = (ServerStates)serverInfo.ServerState;



                    ClientUsersChanged?.Invoke(serverInfo.Users);
                }
                else
                {
                    //LeaderServer.CurrentServer = null;
                }


                //3
                //client.SendUser(ServerUser.Current);
                if (serverInfo != null)
                {
                    ServerUser.Current.ID = ID;

                    var CurrentUser = serverInfo.Users.FirstOrDefault(x => x.ID == ID);
                    if (CurrentUser == null || CurrentUser.MissionForClient == 1)
                    {
                        bw.CancelAsync();
                        Disconnect();

                        currentlyUpdating = false;
                        return;
                    }

                    CurrentDiscount = serverInfo.Discount;

                    if (ClientReadiness)
                    {
                        FinalUsersStatus = serverInfo.Users;
                    }

                    switch (serverInfo.ServerState)
                    {
                    case ServiceChat.ServerStates.DelivererSet:
                        if (isSelfServer)
                        {
                            //LeaderServer.CurrentServer.ServerState == ServerStates.DelivererSet
                            ClientStateChanged?.Invoke(ClientState.DelivererSet);
                        }
                        else
                        {
                            ClientStateChanged?.Invoke(ClientState.DelivererWait);
                        }
                        break;

                    case ServiceChat.ServerStates.OrdersSet:
                        ClientStateChanged?.Invoke(ClientState.OrderSet);
                        break;

                    case ServiceChat.ServerStates.ReadyToCalculate:

                        //if (FinalUsersStatus.Count <= serverInfo.Users.Count)
                        //    FinalUsersStatus = serverInfo.Users;
                        ClientReadiness = true;
                        //ClientStateChanged?.Invoke(ClientState.WaitingForCalculation);
                        //if (isSelfServer && ServerStatus.Current.Users.Count(x => !x.Ready) == 0
                        //                 && ServerStatus.Current.Users.Count(x => x.MissionForClient!=2) == 0)
                        //{
                        //    ServerStatus.Current.ServerState = ServerStates.Verifying;
                        //}
                        if (CurrentUser.MissionForClient == 2)
                        {
                            FinalUsersStatus             = serverInfo.Users;
                            CurrentUser.MissionForClient = 3;
                        }

                        if (isSelfServer &&
                            (ServerStatus.Current.Users.Count(x => x.MissionForClient == 4))
                            == ServerStatus.Current.Users.Count())
                        {
                            ServerStatus.Current.ServerState = ServerStates.Verifying;
                        }

                        break;

                    case ServiceChat.ServerStates.Verifying:
                        //if(FinalUsersStatus.Count<= serverInfo.Users.Count)
                        //FinalUsersStatus = serverInfo.Users;
                        //isConnected = false;
                        //FinalUsersStatus = serverInfo.Users;
                        ClientStateChanged?.Invoke(ClientState.Calculated);
                        if (CurrentUser.MissionForClient == 4)
                        {
                            CurrentUser.MissionForClient = 5;
                        }

                        //if (isSelfServer
                        //    && (ServerStatus.Current.Users.Count(x => x.MissionForClient == 6))
                        //        == ServerStatus.Current.Users.Count()
                        //)
                        //{
                        //    foreach (var user in ServerStatus.users)
                        //    {
                        //        user.MissionForClient = 7;
                        //        CurrentUser.MissionForClient = 7;
                        //        //ServerStatus.Current.ServerState = ServerStates.Verifying;
                        //    }
                        //}

                        if (CurrentUser.MissionForClient == 6)
                        {
                            await Task.Run(() => { Thread.Sleep(25000); });

                            await ClientMaintaining.Disconnect(true);

                            //FinalUsersStatus = serverInfo.Users;
                            //CurrentUser.MissionForClient = 3;
                        }

                        if (isSelfServer && CurrentUser.MissionForClient == 6)
                        {
                            await Task.Run(() => { Thread.Sleep(15000); });

                            await ServerFunction.ServerMaintaining.ServerStop();
                        }

                        //await Task.Run(() => { Thread.Sleep(10000); });
                        //await ClientMaintaining.Disconnect(true);
                        //if (isSelfServer
                        //&& (ServerStatus.Current.Users.Count(x => x.MissionForClient == 8)
                        //    == ServerStatus.Current.Users.Count())
                        //)
                        //{
                        //    await Task.Run(() => { Thread.Sleep(3000); });
                        //    await ServerFunction.ServerMaintaining.ServerStop();
                        //}
                        //return;
                        break;
                    }

                    ServerUser.Current.Name     = CurrentUser.Name;
                    ServerUser.Current.isLeader = isSelfServer;
                    ServerUser.Current.Ready    = ClientReadiness;

                    if (ServerUser.Current.Order == null || ServerUser.Current.Order.Items == null)
                    {
                        ServerUser.Current.Order = new UserOrder()
                        {
                            Items = new List <Item>()
                        }
                    }
                    ;

                    var s = ServerUser.Current;
                    var o = new List <ServiceChat.Item>();
                    if (s.Order.Items != null)
                    {
                        foreach (var i in s.Order.Items)
                        {
                            o.Add(new ServiceChat.Item()
                            {
                                ID          = i.ID,
                                Quantity    = i.Quantity,
                                Price       = i.Price,
                                Name        = i.Name,
                                Description = i.Description
                            });
                        }
                    }

                    try
                    {
                        var c = new ServiceChat.ServerUser()
                        {
                            ID               = s.ID,
                            isLeader         = s.isLeader,
                            Name             = s.Name,
                            Ready            = s.Ready,
                            MissionForClient = CurrentUser.MissionForClient,
                            Order            = new ServiceChat.UserOrder()
                            {
                                Items = o
                            }
                        };
                        await client.SendUserAsync(c);
                    }
                    catch (Exception e)
                    {
                        Log.Instance.W(client, ClientUIPresenter.GetString("ErrorappearedwhenyouvetriedtosenduserdataTryagain")
                                       + e.Message);
                        currentlyUpdating = false;
                    }
                }

                currentlyUpdating = false;
            }
        }