Ejemplo n.º 1
0
        public Model()
        {
#if DEBUG
            // This is some test data to assist in the UI Designer
            Expecting.Add(new PmsAppointment()
            {
                ArrivalTime = "10:35am", PatientName = "Postlethwaite, Brian", PatientMobilePhone = "0423857505", ArrivalStatus = "Pending", AppointmentStartTime = "9:45am", PractitionerName = "Dr Nathan Pinskier"
            });
            Expecting.Add(new PmsAppointment()
            {
                ArrivalTime = "10:35am", PatientName = "Esler, Brett", PatientMobilePhone = "0423083847", ArrivalStatus = "Pending", AppointmentStartTime = "10:00am", PractitionerName = "Dr Nathan Pinskier"
            });
            Waiting.Add(new PmsAppointment()
            {
                ArrivalTime = "10:35am", PatientName = "Grieve, Grahame", PatientMobilePhone = "0423083847", ArrivalStatus = "Arrived", AppointmentStartTime = "10:00am", PractitionerName = "Dr Nathan Pinskier"
            });
            RoomMappings.Add(new DoctorRoomLabelMappings()
            {
                PractitionerFhirID  = "1",
                PractitionerName    = "Dr Nathan",
                LocationName        = "Room 1",
                LocationDescription = "Proceed through the main lobby and its the 3rd door on the right"
            });
#endif
        }
    private void NormalTurnCardSelected(Card card)
    {
        if (expecting == Expecting.Card)
        {
            card.Select();
            selectedCard = card;

            if (!playedCard && doubleDiscard)
            {
                expecting = Expecting.CardSlot;
            }

            else if (!playedCard && !playerDiscard)
            {
                expecting = Expecting.CardSlotOrDiscardPile;
            }

            else if (playedCard && !playerDiscard)
            {
                expecting = Expecting.DiscardPile;
            }

            else if (!playedCard && playerDiscard)
            {
                expecting = Expecting.CardSlotOrDiscardPile;
            }
        }
        else
        {
            selectedCard.Deselect();
            card.Select();
            selectedCard = card;
        }
    }
Ejemplo n.º 3
0
            private ISingleOperator <TCandidate> CreateOperator <TSpecification>(Expecting expecting) where TSpecification : ISpecification <TCandidate>, new()
            {
                var candidateOperator = new SingleOperator(_candidate);

                candidateOperator.AddToGroup <TSpecification>(expecting);
                return(candidateOperator);
            }
Ejemplo n.º 4
0
        private void CreateTestDataForDebug()
        {
#if DEBUG
            // This is some test data to assist in the UI Designer
            Expecting.Add(new PmsAppointment()
            {
                PatientName = "Postlethwaite, Brian", PatientMobilePhone = "0423857505", ArrivalStatus = Hl7.Fhir.Model.Appointment.AppointmentStatus.Pending, AppointmentStartTime = DateTime.Parse("9:45am"), PractitionerName = "Dr Nathan Pinskier"
            });
            Expecting.Add(new PmsAppointment()
            {
                PatientName = "Esler, Brett", PatientMobilePhone = "0423083847", ArrivalStatus = Hl7.Fhir.Model.Appointment.AppointmentStatus.Pending, AppointmentStartTime = DateTime.Parse("10:00am"), PractitionerName = "Dr Nathan Pinskier"
            });
            Waiting.Add(new PmsAppointment()
            {
                PatientName = "Grieve, Grahame", PatientMobilePhone = "0423083847", ArrivalStatus = Hl7.Fhir.Model.Appointment.AppointmentStatus.Arrived, AppointmentStartTime = DateTime.Parse("10:00am"), PractitionerName = "Dr Nathan Pinskier"
            });
            RoomMappings.Add(new DoctorRoomLabelMapping()
            {
                PractitionerFhirID  = "1",
                PractitionerName    = "Dr Nathan",
                LocationName        = "Room 1",
                LocationDescription = "Proceed through the main lobby and its the 3rd door on the right"
            });
            RoomMappings.Add(new DoctorRoomLabelMapping()
            {
                PractitionerFhirID  = "1",
                PractitionerName    = "Dr Smith",
                LocationName        = "Room 2",
                LocationDescription = "Proceed through the main lobby and its the 2nd door on the right"
            });
#endif
        }
    public void NoneSelected()
    {
        if (phase == Phase.RatingsPlayer)
        {
            if (expecting == Expecting.RatingConfirmation &&
                selectedCard != null)
            {
                DeFocusCard(selectedCard);
            }
        }

        else if (phase == Phase.NormalTurns)
        {
            if ((expecting == Expecting.CardSlot ||
                 expecting == Expecting.DiscardPile ||
                 expecting == Expecting.CardSlotOrDiscardPile) &&
                selectedCard != null)
            {
                selectedCard.Deselect();
                selectedCard = null;

                expecting = Expecting.Card;
            }
        }
    }
    private void NextRatingTurn()
    {
        if (turnPhase == TurnPhase.Wait1)
        {
            turnPhase    = TurnPhase.Player1;
            expecting    = Expecting.Card;
            ratingToGive = 10;

            UI.Instance.ClearUI();
            UI.Instance.UpdateHeader(turnPhase, "Player 1: Rate items");
            UI.Instance.UpdateInstructions("Which of these bring you the most joy?" +
                                           System.Environment.NewLine +
                                           "Which card is worth " + ratingToGive + "?");
        }
        else if (turnPhase == TurnPhase.Player1)
        {
            turnPhase = TurnPhase.Wait2;
            expecting = Expecting.Continue;

            UI.Instance.ClearUI();
            UI.Instance.UpdateHeader(turnPhase, "Pass turn to player 2");
            UI.Instance.UpdateInstructions("Pass turn to player 2.", "Continue");
        }
        else if (turnPhase == TurnPhase.Wait2)
        {
            turnPhase    = TurnPhase.Player2;
            expecting    = Expecting.Card;
            ratingToGive = 10;

            UI.Instance.ClearUI();
            UI.Instance.UpdateHeader(turnPhase, "Player 2: Rate items");
            UI.Instance.UpdateInstructions("Which of these bring you the most joy?" +
                                           System.Environment.NewLine +
                                           "Which card is worth " + ratingToGive + "?");

            deck.Shuffle();
            deck.Organize();
        }
        else if (turnPhase == TurnPhase.Player2)
        {
            discardPile.gameObject.SetActive(true);
            player1Room.gameObject.SetActive(true);
            player2Room.gameObject.SetActive(true);
            commonRoom.gameObject.SetActive(true);

            // Load instructions for Player 1 turn 1
            phase     = Phase.NormalTurns;
            turnPhase = TurnPhase.Wait1;
            expecting = Expecting.Continue;

            turnNumber = 1;

            UI.Instance.ClearUI();
            UI.Instance.UpdateHeader(turnPhase, "Pass turn to player 1");
            UI.Instance.UpdateInstructions("Hand the device to player 1.", "Continue");
        }

        cameraTransitions.TransitionCamera(turnPhase);
    }
Ejemplo n.º 7
0
        /// <summary>
        /// Convert escape sequences
        /// </summary>
        private string ConvertEscapeSequences(string s)
        {
            Expecting expecting = Expecting.ANY;

            int    hexNum = 0;
            string outs   = "";

            foreach (char c in s)
            {
                switch (expecting)
                {
                case Expecting.ANY:
                    if (c == '\\')
                    {
                        expecting = Expecting.ESCAPED_CHAR;
                    }
                    else
                    {
                        outs += c;
                    }
                    break;

                case Expecting.ESCAPED_CHAR:
                    if (c == 'x')
                    {
                        expecting = Expecting.HEX_1ST_DIGIT;
                    }
                    else
                    {
                        char c2 = c;
                        switch (c)
                        {
                        case 'n': c2 = '\n'; break;

                        case 'r': c2 = '\r'; break;

                        case 't': c2 = '\t'; break;
                        }
                        outs     += c2;
                        expecting = Expecting.ANY;
                    }
                    break;

                case Expecting.HEX_1ST_DIGIT:
                    hexNum    = GetHexDigit(c) * 16;
                    expecting = Expecting.HEX_2ND_DIGIT;
                    break;

                case Expecting.HEX_2ND_DIGIT:
                    hexNum   += GetHexDigit(c);
                    outs     += (char)hexNum;
                    expecting = Expecting.ANY;
                    break;
                }
            }
            return(outs);
        }
 private void DeFocusCard(Card card)
 {
     card.Return(true);
     card.Deselect();
     selectedCard = null;
     expecting    = Expecting.Card;
     UI.Instance.UpdateInstructions("Rate the rest of the cards from most to least favorite." +
                                    System.Environment.NewLine +
                                    "Which card is worth " + ratingToGive + "?");
 }
    public void DiscardPileSelected(Discard discard)
    {
        bool turnOK = (turnPhase == TurnPhase.Player1 ||
                       turnPhase == TurnPhase.Player2);

        bool expectingOK = (expecting == Expecting.DiscardPile ||
                            expecting == Expecting.CardSlotOrDiscardPile);

        if (phase == Phase.NormalTurns &&
            turnOK &&
            expectingOK &&
            selectedCard != null)
        {
            selectedCard.PutIn(discard);
            selectedCard.ShowAllRatings(turnPhase);
            selectedCard = null;

            if (!playedCard && !playerDiscard)
            {
                playerDiscard = true;
                expecting     = Expecting.Card;

                UI.Instance.UpdateInstructions("Play 1 card OR discard another cards to play 1 from the discard pile.");
            }

            else if (playedCard && !playerDiscard)
            {
                playerDiscard = true;
                InitNextTurn();
            }

            else if (!playedCard && playerDiscard)
            {
                if (turnPhase == TurnPhase.Player1)
                {
                    player1Hand.NotYourTurn();
                    discardPile.DealCards(player1DiscardHand);
                    UI.Instance.UpdateInstructions("Play one card from the discard pile.");
                }

                else if (turnPhase == TurnPhase.Player2)
                {
                    player2Hand.NotYourTurn();
                    discardPile.DealCards(player2DiscardHand);
                    UI.Instance.UpdateInstructions("Play one card from the discard pile.");
                }

                doubleDiscard = true;
                expecting     = Expecting.Card;
            }
        }
    }
    public void Start()
    {
        if (focalPoint == null)
        {
            focalPoint = transform.Find("Focal point").transform;
        }

        if (cameraTransitions == null)
        {
            cameraTransitions = GameObject.Find("Camera mount").GetComponent <CameraTransitions>();
        }

        if (sceneCamera == null)
        {
            sceneCamera = GameObject.Find("Camera mount/Main Camera").GetComponent <Camera>();

            if (sceneCamera == null)
            {
                sceneCamera = GameObject.Find("Main Camera").GetComponent <Camera>();
            }
        }

        deck.Initialize();
        deck.Shuffle();
        deck.Organize();

        cardArray = deck.GetWholeDeck();

        if (quickStart)
        {
            phase     = Phase.RatingsPlayer;
            turnPhase = TurnPhase.Player2;
            InitNextTurn();
        }
        else
        {
            phase      = Phase.RatingsPlayer;
            expecting  = Expecting.Card;
            turnNumber = 0;

            UI.Instance.ClearUI();
            UI.Instance.ShowTutorial();

            discardPile.gameObject.SetActive(false);
            player1Room.gameObject.SetActive(false);
            player2Room.gameObject.SetActive(false);
            commonRoom.gameObject.SetActive(false);
        }
    }
    private void FocusCard(Card card)
    {
        focalPoint.position = sceneCamera.transform.position + sceneCamera.transform.forward * 3f;

        if (turnPhase == TurnPhase.Player1)
        {
            focalPoint.rotation = Quaternion.LookRotation(sceneCamera.transform.position - focalPoint.position, Vector3.forward);
        }
        else if (turnPhase == TurnPhase.Player2)
        {
            focalPoint.rotation = Quaternion.LookRotation(sceneCamera.transform.position - focalPoint.position, Vector3.back);
        }

        card.InitMove(focalPoint.position, focalPoint.rotation, 0.4f);
        card.Select();
        selectedCard = card;
        expecting    = Expecting.RatingConfirmation;
        UI.Instance.UpdateInstructions("Is this card worth " + ratingToGive + "?" +
                                       System.Environment.NewLine +
                                       "Click again to confirm!");
    }
    IEnumerator NewGame()
    {
        UI.Instance.ClearUI();

        player1commonRoomCards = 0;
        player2commonRoomCards = 0;

        foreach (Card card in cardArray)
        {
            card.Enable();
            card.ClearRatings();
            card.PutIn(deck, true);
            yield return(new WaitForSeconds(0.1f));
        }

        yield return(new WaitForSeconds(0.2f));

        deck.Shuffle();
        deck.Organize();

        yield return(new WaitForSeconds(0.2f));

        phase     = Phase.RatingsPlayer;
        turnPhase = TurnPhase.Wait1;
        expecting = Expecting.Continue;

        UI.Instance.ClearUI();
        UI.Instance.ShowTutorial();
        turnNumber = 0;

        cameraTransitions.TransitionCamera(turnPhase);

        yield return(new WaitForSeconds(0.2f));

        discardPile.gameObject.SetActive(false);
        player1Room.gameObject.SetActive(false);
        player2Room.gameObject.SetActive(false);
        commonRoom.gameObject.SetActive(false);
    }
    private void NextRating()
    {
        if (ratingToGive > 1)
        {
            ratingToGive--;
            expecting = Expecting.Card;

            UI.Instance.UpdateInstructions("Rate the rest of the cards from most to least favorite." +
                                           System.Environment.NewLine +
                                           "Which card is worth " + ratingToGive + "?");
        }
        else if (ratingToGive == 1)
        {
            ratingToGive = -1;
            expecting    = Expecting.Card;

            UI.Instance.UpdateInstructions("Rate the rest of the cards from most to least favorite." +
                                           System.Environment.NewLine +
                                           "Which card is worth " + ratingToGive + "?");
        }
        else if (ratingToGive > -10)
        {
            ratingToGive--;
            expecting = Expecting.Card;

            UI.Instance.UpdateInstructions("Rate the rest of the cards from most to least favorite." +
                                           System.Environment.NewLine +
                                           "Which card is worth " + ratingToGive + "?");
        }
        else if (ratingToGive == -10)
        {
            InitNextTurn();
        }
        else
        {
            Debug.LogError("We shouldn't end up here!");
        }
    }
Ejemplo n.º 14
0
        public override string ToString()
        {
            int    unexpectedType = UnexpectedType;
            string unexpected     = (TokenNames != null && unexpectedType >= 0 && unexpectedType < TokenNames.Count) ? TokenNames[unexpectedType] : unexpectedType.ToString();
            string expected       = (TokenNames != null && Expecting >= 0 && Expecting < TokenNames.Count) ? TokenNames[Expecting] : Expecting.ToString();

            return("MismatchedTokenException(" + unexpected + "!=" + expected + ")");
        }
Ejemplo n.º 15
0
 private SpecificationValidatorDecorator(ISpecification <TCandidate> specification, Expecting expecting)
 {
     _specification = specification;
     _expecting     = expecting;
     FailureType    = FailureType.Error;
 }
    private void NextNormalTurn()
    {
        if (turnPhase == TurnPhase.Wait1)
        {
            turnPhase = TurnPhase.Player1;
            expecting = Expecting.Card;

            if (turnNumber == 1)
            {
                deck.Shuffle();
                deck.DealCards(6, player1Hand, turnPhase);
            }
            else if (turnNumber >= 2 &&
                     turnNumber <= 5)
            {
                deck.DealCards(1, player1Hand, turnPhase);
            }

            playedCard    = false;
            playerDiscard = false;
            doubleDiscard = false;

            player1Hand.YourTurn();
            player2Hand.NotYourTurn();

            UI.Instance.ClearUI();
            UI.Instance.UpdateHeader(turnPhase, "Player 1: turn " + turnNumber);
            UI.Instance.UpdateInstructions("Play 1 card and discard 1 card OR discard 2 cards and play 1 from the discard pile.");

            player1Hand.UpdateHandCardRatings(TurnPhase.Player1);
        }
        else if (turnPhase == TurnPhase.Player1)
        {
            turnPhase = TurnPhase.Wait2;
            expecting = Expecting.Continue;

            player1Hand.NotYourTurn();

            UI.Instance.ClearUI();
            UI.Instance.UpdateHeader(turnPhase, "Pass turn to player 2");
            UI.Instance.UpdateInstructions("Hand the device to player 2.", "Continue");
        }
        else if (turnPhase == TurnPhase.Wait2)
        {
            turnPhase = TurnPhase.Player2;
            expecting = Expecting.Card;

            if (turnNumber == 1)
            {
                deck.DealCards(6, player2Hand, turnPhase);
            }
            else if (turnNumber >= 2 &&
                     turnNumber <= 5)
            {
                deck.DealCards(1, player2Hand, turnPhase);
            }

            playedCard    = false;
            playerDiscard = false;
            doubleDiscard = false;

            player2Hand.YourTurn();
            player1Hand.NotYourTurn();

            UI.Instance.ClearUI();
            UI.Instance.UpdateHeader(turnPhase, "Player 2: turn " + turnNumber);
            UI.Instance.UpdateInstructions("Play 1 card and discard 1 card OR discard 2 cards and play 1 from the discard pile.");

            player2Hand.UpdateHandCardRatings(TurnPhase.Player2);
        }
        else if (turnPhase == TurnPhase.Player2)
        {
            if (turnNumber == 5)
            {
                phase = Phase.EndScreen;
                CountScores();
                return;
            }

            turnPhase = TurnPhase.Wait1;
            expecting = Expecting.Continue;

            player2Hand.NotYourTurn();

            turnNumber++;

            UI.Instance.ClearUI();
            UI.Instance.UpdateHeader(turnPhase, "Pass turn to player 1");
            UI.Instance.UpdateInstructions("Hand the device to player 1.", "Continue");

            player2Hand.UpdateHandCardRatings(TurnPhase.Player2);
        }

        player1Room.AlignAllCards(turnPhase);
        player2Room.AlignAllCards(turnPhase);
        commonRoom.AlignAllCards(turnPhase);

        if (turnPhase == TurnPhase.Player1 ||
            turnPhase == TurnPhase.Player2)
        {
            player1Room.ShowAllCardRatings(turnPhase);
            player2Room.ShowAllCardRatings(turnPhase);
            commonRoom.ShowAllCardRatings(turnPhase);
            discardPile.UpdateAllRatings(turnPhase);
        }

        cameraTransitions.TransitionCamera(turnPhase);
    }
 public static void AddToGroup <TSpecification, TCandidate>(this List <ValidationGroup <TCandidate> > source, Expecting expecting) where TSpecification : ISpecification <TCandidate>, new()
 => source.Last().AddToGroup <TSpecification>(expecting);
    public void CardSlotSelected(CardSlot slot)
    {
        bool turnOK = (turnPhase == TurnPhase.Player1 ||
                       turnPhase == TurnPhase.Player2);

        bool expectingOK = (expecting == Expecting.CardSlot ||
                            expecting == Expecting.CardSlotOrDiscardPile);

        bool player1 = (turnPhase == TurnPhase.Player1);
        bool player2 = (turnPhase == TurnPhase.Player2);

        bool player1Room = (player1 && slot.ParentRoom.Type == Room.RoomType.Player1);
        bool player2Room = (player2 && slot.ParentRoom.Type == Room.RoomType.Player2);

        bool commonroom = (slot.ParentRoom.Type == Room.RoomType.CommonRoom) &&
                          ((player1 && player1commonRoomCards < 3) ||
                           (player2 && player2commonRoomCards < 3));

        bool roomOK = player1Room || player2Room || commonroom;

        if (phase == Phase.NormalTurns &&
            turnOK &&
            expectingOK &&
            roomOK &&
            slot.Free &&
            selectedCard != null &&
            !playedCard)
        {
            selectedCard.PutIn(slot, turnPhase);
            selectedCard.ShowAllRatings(turnPhase);
            selectedCard = null;

            if (commonroom && player1)
            {
                player1commonRoomCards++;
            }

            else if (commonroom && player2)
            {
                player2commonRoomCards++;
            }

            if (!playedCard && !playerDiscard)
            {
                playedCard = true;
                expecting  = Expecting.Card;
                UI.Instance.UpdateInstructions("Now discard 1 card.");
            }
            else if (!playedCard && playerDiscard)
            {
                playedCard = true;
                InitNextTurn();
            }

            if (doubleDiscard && player1)
            {
                player1DiscardHand.DiscardWholeHand(discardPile);
            }
            else if (doubleDiscard && player2)
            {
                player2DiscardHand.DiscardWholeHand(discardPile);
            }
        }
    }
        /// <summary>
        /// An asynchroneous method for a WebSocket request processing
        /// </summary>
        /// <param name="listenerContext">Listener context</param>
        private async void ProcessWebSocketRequestAsync(HttpListenerContext listenerContext)
        {
            // Accepting WebSocket connection from the context
            WebSocketContext webSocketContext;

            try
            {
                webSocketContext = await listenerContext.AcceptWebSocketAsync(subProtocol : null);
            }
            catch (Exception e)
            {
                // The upgrade process failed somehow. For simplicity lets assume it was a failure on the part of the server and indicate this using 500.
                listenerContext.Response.StatusCode = 500;
                listenerContext.Response.Close();
                Logger.LogError(String.Format("Exception: {0}", e));
                return;
            }

            // This is our new WebSocket object
            WebSocket webSocket = webSocketContext.WebSocket;

            lock (socketsAndMessagesLock)
            {
                // Adding the new client to the list
                connectedSockets.Add(webSocket);

                // Sending all the previous messages to the new client
                Logger.Log("Sending " + cabinetController.Cards.Count + " old cards to the new client");
                foreach (var oldCard in cabinetController.Cards)
                {
                    // Making an add_card command for the selected card
                    var addCommand     = new Model.Commands.UpdateCardCommand(oldCard.Key, oldCard.Value);
                    var addCommandGram = new TextWebSockGram(serializer.SerializeCommand(addCommand));

                    // Sending the command to the new client
                    addCommandGram.Send(webSocket).Wait();
                }
            }

            // We are expecting a command to be sent from  the client
            Expecting expecting = Expecting.Command;

            // Here the received command will be held if we will be waiting for an appended binary data
            Model.Commands.Command receivedCommand = null;

            // The received WebSocket message collector
            WebSockGram receivedGram = null;

            // Communicating
            try
            {
                byte[] receiveBuffer = new byte[16384];

                // While the WebSocket connection remains open run a simple loop that receives data and sends it back.
                while (webSocket.State == WebSocketState.Open)
                {
                    WebSocketReceiveResult receiveResult = await webSocket.ReceiveAsync(new ArraySegment <byte>(receiveBuffer), CancellationToken.None);

                    if (receiveResult.MessageType == WebSocketMessageType.Close)
                    {
                        // We've got a Close request. Sending it back
                        await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
                    }
                    else
                    {
                        // We have received a message. Text or binary. We are going to collect it to the WebSockGram object

                        if (receivedGram == null)
                        {
                            // Start building of a new message
                            receivedGram = WebSockGram.StartReceivingFromReceiveResult(receiveBuffer, receiveResult);
                        }
                        else
                        {
                            // Continue building of the message
                            receivedGram.AppendFromReceiveResult(receiveBuffer, receiveResult);
                        }

                        // If the message has just ended, let's interpret it
                        if (receivedGram.Completed)
                        {
                            // Logging the message
                            if (receivedGram is TextWebSockGram)
                            {
                                Logger.Log("Received text: \"" + receivedGram.ToString() + "\"");
                            }
                            else if (receivedGram is BinaryWebSockGram)
                            {
                                Logger.Log("Received binary: " + receivedGram.Length + " bytes");
                            }
                            else
                            {
                                throw new Exception("Invalid case");
                            }

                            // Checking what we have received (depending on what we have been expecting)
                            if (expecting == Expecting.Command)
                            {
                                // We are expecting a command. So receivedGram has to be a text
                                if (receivedGram is TextWebSockGram)
                                {
                                    var command = serializer.DeserializeCommand(receivedGram.ToString());

                                    // Executing the received command
                                    if (command is Model.Commands.UpdateCardCommand)
                                    {
                                        var updateCardCommand = command as Model.Commands.UpdateCardCommand;

                                        lock (socketsAndMessagesLock)
                                        {
                                            // Giving the received message to the controller
                                            cabinetController.UpdateCard(updateCardCommand.Id, updateCardCommand.Value);

                                            // Broadcasting the message
                                            Logger.Log("Broadcasting the new card " + updateCardCommand.Value + " to the " + connectedSockets.Count + " connected clients");
                                            receivedGram.Broadcast(connectedSockets).Wait();
                                        }
                                    }
                                    else if (command is Model.Commands.UploadImageCardCommand)
                                    {
                                        // After this command a binary should be appended (containing the image data).
                                        // So we are saving the command itself...
                                        receivedCommand = command;

                                        // ...and setting the state machine to expect binary appended to the command.
                                        expecting = Expecting.AppendedBinary;
                                    }
                                    else if (command is Model.Commands.ListCardIDsCommand)
                                    {
                                        // Sending all the cards ids
                                        IList <string> ids = cabinetController.ListCardIDs();
                                        Model.Commands.ListCardIDsCommand response = new Model.Commands.ListCardIDsCommand(ids);
                                        var         ser     = serializer.SerializeCommand(response);
                                        WebSockGram listids = new TextWebSockGram(ser);
                                        await listids.Send(webSocket);
                                    }
                                }
                                else
                                {
                                    throw new Exception("We are expecting a command, but the received WebSocket message isn't a text");
                                }
                            }
                            else if (expecting == Expecting.AppendedBinary)
                            {
                                // We are expecting an appended binary
                                if (receivedGram is BinaryWebSockGram)
                                {
                                    // We've got an appended binary
                                    if (receivedCommand is Model.Commands.UploadImageCardCommand)
                                    {
                                        // Our current command is upload_image_card
                                        var uploadImageMessageCommand = receivedCommand as Model.Commands.UploadImageCardCommand;

                                        // Saving the received image
                                        byte[] imageData          = (receivedGram as BinaryWebSockGram).Data.ToArray();
                                        var    savedImageFileName = imagesController.Add(uploadImageMessageCommand.Value.Filename, new MemoryStream(imageData));

                                        lock (socketsAndMessagesLock)
                                        {
                                            // Setting up the link to the saved file. Adding it to the received Card data
                                            var imageFileCard = uploadImageMessageCommand.Value;
                                            imageFileCard.Link = new Uri(listenerContext.Request.Url, "data/" + savedImageFileName);

                                            // Creating a new card in the controller, containing the received image
                                            cabinetController.UpdateCard(uploadImageMessageCommand.Id, imageFileCard);

                                            // Broadcasting the add_card command to all the connected clients
                                            Logger.Log("Broadcasting the new image card " + imageFileCard.Link + " to the " + connectedSockets.Count + " connected clients");
                                            var             addCommand  = new Model.Commands.UpdateCardCommand(uploadImageMessageCommand.Id, imageFileCard);
                                            TextWebSockGram addCardGram = new TextWebSockGram(serializer.SerializeCommand(addCommand));
                                            addCardGram.Broadcast(connectedSockets).Wait();
                                        }
                                    }
                                    else
                                    {
                                        throw new Exception("Strange case");
                                    }
                                }
                                else
                                {
                                    // Resetting the received command (we have a client error here)
                                    throw new Exception("We are expecting a binary appended to a command, but the received WebSocket message isn't a binary");
                                }

                                // After we received the appended binary, resetting the state machine to expect a command again
                                expecting       = Expecting.Command;
                                receivedCommand = null;
                            }
                            receivedGram = null;
                        }
                    }
                }
            }
            catch (Exception e)
            {
                // Just log any exceptions to the console.
                // Pretty much any exception that occurs when calling `SendAsync`/`ReceiveAsync`/`CloseAsync`
                // is unrecoverable in that it will abort the connection and leave the `WebSocket` instance in an unusable state.
                Logger.Log(String.Format("Exception: {0}", e));
            }
            finally
            {
                // Disposing the WebSocket and removing it from the list
                try
                {
                    // Clean up by disposing the WebSocket once it is closed/aborted.
                    if (webSocket != null)
                    {
                        lock (socketsAndMessagesLock)
                        {
                            connectedSockets.Remove(webSocket);
                        }
                        webSocket.Dispose();
                    }
                }
                catch (Exception e)
                {
                    Logger.Log(String.Format("Exception during WebSocket disposure: {0}", e));
                }
            }
        }
 internal void AddToGroup <TSpecification>(Expecting expecting) where TSpecification : ISpecification <TCandidate>, new()
 => _validationGroups.AddToGroup <TSpecification, TCandidate>(expecting);
                internal static EnumerableOperator Create <TSpecification>(IEnumerable <TCandidate> candidates, Expecting expecting) where TSpecification : ISpecification <TCandidate>, new()
                {
                    var enumerableOperator = new EnumerableOperator(candidates);

                    enumerableOperator.AddToGroup <TSpecification>(expecting);
                    return(enumerableOperator);
                }
Ejemplo n.º 22
0
        public override string ToString()
        {
            //int unexpectedType = getUnexpectedType();
            //string unexpected = ( tokenNames != null && unexpectedType >= 0 && unexpectedType < tokenNames.Length ) ? tokenNames[unexpectedType] : unexpectedType.ToString();
            string expected = (TokenNames != null && Expecting >= 0 && Expecting < TokenNames.Count) ? TokenNames[Expecting] : Expecting.ToString();

            string exp = ", expected " + expected;

            if (Expecting == TokenTypes.Invalid)
            {
                exp = "";
            }
            if (Token == null)
            {
                return("UnwantedTokenException(found=" + null + exp + ")");
            }
            return("UnwantedTokenException(found=" + Token.Text + exp + ")");
        }
Ejemplo n.º 23
0
 public static SpecificationValidatorDecorator <TCandidate> CreateWithSpecification <TSpecification>(Expecting expecting) where TSpecification : ISpecification <TCandidate>, new()
 => new SpecificationValidatorDecorator <TCandidate>(new TSpecification(), expecting);
 public ExpectingTypeError(SourceLocation location, Expecting expecting) : base(location)
 {
     _expecting = expecting;
 }
Ejemplo n.º 25
0
        public async Task Initialize(Dispatcher dispatcher)
        {
            // read the settings from storage
            Settings.CopyFrom(await Storage.LoadSettings());
            if (Settings.SystemIdentifier == Guid.Empty)
            {
                // this only occurs when the system hasn't had one allocated
                // so we can create a new one, then save the settings.
                // (this will force an empty setting file with the System Identifier if needed)
                Settings.AllocateNewSystemIdentifier();
                await Storage.SaveSettings(Settings);
            }

            // read the room mappings from storage
            RoomMappings.Clear();
            foreach (var map in await Storage.LoadRoomMappings())
            {
                RoomMappings.Add(map);
            }

            Templates.Clear();
            foreach (var template in await Storage.LoadTemplates())
            {
                Templates.Add(template);
            }
            AddMissingTemplates();

            // reload any unmatched messages
            var messages = await Storage.LoadUnprocessableMessages(DisplayingDate);

            foreach (var item in messages)
            {
                UnprocessableMessages.Add(item);
            }

            PmsSimulator.Initialize(Storage);
            if (!IsSimulation)
            {
                FhirApptReader = new FhirAppointmentReader(FhirAppointmentReader.GetServerConnection);
                SmsProcessor.Initialize(Settings);
            }
            logger.Log(1, "Start up");
            if (!String.IsNullOrEmpty(Settings.AdministratorPhone))
            {
                logger.Log(1, "Send SMS to " + Settings.AdministratorPhone);
                try
                {
                    SmsProcessor.SendMessage(new SmsMessage(Settings.AdministratorPhone, "System is starting"));
                    if (!IsSimulation)
                    {
                        App.AdministratorPhone = Settings.AdministratorPhone;
                        App.SmsSender          = SmsProcessor;
                    }
                }
                catch (Exception ex)
                {
                    System.Windows.MessageBox.Show("Error sending message: " + ex.Message);
                }
            }

            // setup the background worker routines
            ReadSmsMessage = new BackgroundProcess(Settings, serverStatuses.IncomingSmsReader, dispatcher, async() =>
            {
                // Logic to run on this process
                // (called every settings.interval)
                StatusBarMessage            = $"Last read SMS messages at {DateTime.Now.ToLongTimeString()}";
                var engine                  = PrepareMessagingEngine();
                List <PmsAppointment> appts = new List <PmsAppointment>();
                appts.AddRange(Appointments);
                var messagesReceived = await engine.SmsSender.ReceiveMessages();
                serverStatuses.IncomingSmsReader.Use(messagesReceived.Count());
                engine.ProcessIncomingMessages(appts, messagesReceived);
            });

            ScanAppointments = new BackgroundProcess(Settings, serverStatuses.AppointmentScanner, dispatcher, async() =>
            {
                // Logic to run on this process
                // (called every settings.interval)
                var engine = PrepareMessagingEngine();
                List <PmsAppointment> appts = await FhirApptReader.SearchAppointments(this.DisplayingDate, RoomMappings, Storage);
                serverStatuses.Oridashi.Use(1);
                serverStatuses.AppointmentScanner.Use(engine.ProcessTodaysAppointments(appts));

                // Now update the UI once we've processed it all
                Expecting.Clear();
                Waiting.Clear();
                Appointments.Clear();
                foreach (var appt in appts)
                {
                    Appointments.Add(appt);
                    if (appt.ArrivalStatus == Hl7.Fhir.Model.Appointment.AppointmentStatus.Booked)
                    {
                        Expecting.Add(appt);
                    }
                    else if (appt.ArrivalStatus == Hl7.Fhir.Model.Appointment.AppointmentStatus.Arrived)
                    {
                        Waiting.Add(appt);
                    }
                }
            });

            ProcessUpcomingAppointments = new BackgroundProcess(Settings, serverStatuses.UpcomingAppointmentProcessor, dispatcher, async() =>
            {
                // Logic to run on this process
                // (called every settings.intervalUpcoming)
                var engine = PrepareMessagingEngine();
                List <PmsAppointment> appts = new List <PmsAppointment>();
                appts.AddRange(await FhirApptReader.SearchAppointments(this.DisplayingDate.AddDays(1), RoomMappings, Storage));
                appts.AddRange(await FhirApptReader.SearchAppointments(this.DisplayingDate.AddDays(2), RoomMappings, Storage));
                serverStatuses.Oridashi.Use(1);
                serverStatuses.UpcomingAppointmentProcessor.Use(engine.ProcessUpcomingAppointments(appts));
            }, true);
        }