protected override void OnStart()
        {
            // Handle when your app starts
            // DO NOT USE Timer CLASS for iOS.
            // Use Device.StartTimer instead.
            Device.StartTimer(new TimeSpan(0, 0, 3), () => {
                // do something in 3 seconds
                if (Device.RuntimePlatform == Device.iOS)
                {
                    Thickness padding     = new Thickness(0, 5);
                    Onboarding onboarding = new Onboarding();
                    onboarding.Padding    = padding;
                    NavigationPage.SetHasNavigationBar(onboarding, false);
                    MainPage.Navigation.PushAsync(onboarding);
                }
                else
                {
                    Onboarding onboarding = new Onboarding();
                    NavigationPage.SetHasNavigationBar(onboarding, false);
                    MainPage.Navigation.PushAsync(onboarding);
                }

                return(false); // true runs again, or false to stop
            });
        }
示例#2
0
    // Start is called before the first frame update
    void Start()
    {
        pos             = this.transform.position;
        pauseMenu       = FindObjectOfType <PauseTest>();
        onboard         = FindObjectOfType <Onboarding>();
        soundEffect     = GetComponent <AudioSource>();
        scoreboard      = FindObjectOfType <GameUIDisplay>();
        grid            = FindObjectOfType <Grid>();
        levelManager    = FindObjectOfType <LevelManager>();
        moveableManager = GameObject.Find("MoveableManager");
        // Carson Code
        // Call move every .3s
        InvokeRepeating("move", 0.0f, 0.15f); //This is in start but will run every .3s


        //Seating initialization
        numberOfTables = moveableManager.GetComponent <MoveableManager>().tables.Count; //Set the number of tables in the level
        inSeat         = false;
        seat           = null;
    }
示例#3
0
        async private Task <bool> Startup(bool skipWalkthrough = false)
        {
#if DEBUG
            bool watchedTutorial = skipWalkthrough;
#else
            bool watchedTutorial = Preferences.Get("WatchedTutorial", false);
#endif
            if (!watchedTutorial)
            {
                MainPage = new Onboarding();
            }
            else if (await UserManager.Current.IsLoggedIn())
            {
                MainPage = new AppShell();
            }
            else
            {
                MainPage = new SimpleLoginPage();
            }

            return(true);
        }
        /// <summary>
        /// Set the instruction for the onboarding
        /// </summary>
        /// <param name="instruction"></param>
        private void SetInstruction(Onboarding instruction)
        {
            if (instruction == Onboarding.PlaceBoard)
            {
                SetText("Detect a surface and tap to spawn gameboard");
                onboardingDictionary[instruction]        = false;
                onboardingDictionary[Onboarding.MoveCar] = true;
            }
            else if (instruction == Onboarding.MoveCar)
            {
                SetText("Control the car from the left area");
                onboardingDictionary[instruction]          = false;
                onboardingDictionary[Onboarding.OilSource] = true;
            }
            else if (instruction == Onboarding.OilSource)
            {
                SetText("Go to oil source and tap to collect 3 crude oils");
                onboardingDictionary[instruction]           = false;
                onboardingDictionary[Onboarding.RefineryIn] = true;
            }
            else if (instruction == Onboarding.RefineryIn)
            {
                SetText("Deliver 3 crude oil to refinery to get processed");
                onboardingDictionary[instruction]        = false;
                onboardingDictionary[Onboarding.Storage] = true;
            }
            else if (instruction == Onboarding.Storage)
            {
                SetText("To let oil source regenerates, storage oils here");
                onboardingDictionary[instruction]            = false;
                onboardingDictionary[Onboarding.ChangeCargo] = true;
            }
            else if (instruction == Onboarding.ChangeCargo)
            {
                SetText("Change the cargo to pick different oil type");
                onboardingDictionary[instruction]            = false;
                onboardingDictionary[Onboarding.RefineryOut] = true;
            }
            else if (instruction == Onboarding.RefineryOut)
            {
                SetText("Tap on the refinery to collect processed oil");
                onboardingDictionary[instruction]          = false;
                onboardingDictionary[Onboarding.Residence] = true;
            }
            else if (instruction == Onboarding.Residence)
            {
                SetText("Deliver to the residence to fulfill the order");
                onboardingDictionary[instruction]     = false;
                onboardingDictionary[Onboarding.Done] = true;
            }
            else if (instruction == Onboarding.Done)
            {
                SetText("You finished the tutorial! click play to start");
                int delay = 5;
                timer = MessageBroker.Default.Receive <TimerMessage>().Subscribe(_ =>
                {
                    if (delay < 0)
                    {
                        onboardingView.TurnOffPanel();
                        timer?.Dispose();
                    }

                    delay--;
                }).AddTo(this);
                onboardMessage?.Dispose();
            }
        }
示例#5
0
 // Start is called before the first frame update
 void Start()
 {
     test    = false;
     onboard = FindObjectOfType <Onboarding>();
 }
        private async void OnboardingService_ConnectRequestRecieved(object sender, EventArgs e)
        {
            UpdateStatusAsync("Connect Request received. Attempting to connect...", NotifyType.StatusMessage);
            AppData.OnboardingConfigurationState = (short)ConfigurationState.Validating;

            // 5 second delay to simulate connection attempt time.
            await Task.Delay(TimeSpan.FromSeconds(5));

            Onboarding returnArg = new Onboarding();

            if (string.IsNullOrWhiteSpace(AppData.OnboardingConfigureSsid))
            {
                returnArg.Value1 = (short)ConnectionResultCode.ErrorMessage;
                returnArg.Value2 = "Invalid SSID";
                AppData.OnboardingConfigurationState = (short)ConfigurationState.Error;
            }
            else
            {
                bool foundSsid         = false;
                bool supportedProtocol = false;

                foreach (OnboardingScanListItem item in AppData.SampleNetworkScanList)
                {
                    if (item.Value1.Equals(AppData.OnboardingConfigureSsid))
                    {
                        foundSsid = true;
                        if (AppData.OnboardingConfigureAuthType == (short)OnboardingAuthenticationType.Any)
                        {
                            supportedProtocol = true;
                        }
                        else if (AppData.OnboardingConfigureAuthType == (short)OnboardingAuthenticationType.WpaAuto)
                        {
                            if ((item.Value2 == (short)OnboardingAuthenticationType.WpaTkip) || (item.Value2 == (short)OnboardingAuthenticationType.WpaCcmp))
                            {
                                supportedProtocol = true;
                            }
                        }
                        else if (AppData.OnboardingConfigureAuthType == (short)OnboardingAuthenticationType.Wpa2Auto)
                        {
                            if ((item.Value2 == (short)OnboardingAuthenticationType.Wpa2Tkip) || (item.Value2 == (short)OnboardingAuthenticationType.Wpa2Ccmp))
                            {
                                supportedProtocol = true;
                            }
                        }
                        else
                        {
                            if (item.Value2 == AppData.OnboardingConfigureAuthType)
                            {
                                supportedProtocol = true;
                            }
                        }
                        break;
                    }
                }

                if (foundSsid)
                {
                    if (supportedProtocol)
                    {
                        if (AppData.OnboardingConfigureAuthType == (short)OnboardingAuthenticationType.Open)
                        {
                            returnArg.Value1 = (short)ConnectionResultCode.Validated;
                            returnArg.Value2 = "Connected successfully";
                            AppData.OnboardingConfigurationState = (short)ConfigurationState.Validated;
                        }
                        else
                        {
                            if (AppData.OnboardingConfigurePassphrase.Equals(ConvertUtf8ToHex(AppData.SampleNetworkPassword)))
                            {
                                returnArg.Value1 = (short)ConnectionResultCode.Validated;
                                returnArg.Value2 = "Connected successfully";
                                AppData.OnboardingConfigurationState = (short)ConfigurationState.Validated;
                            }
                            else
                            {
                                returnArg.Value1 = (short)ConnectionResultCode.Unauthorized;
                                returnArg.Value2 = "Invalid Password";
                                AppData.OnboardingConfigurationState = (short)ConfigurationState.Error;
                            }
                        }
                    }
                    else
                    {
                        returnArg.Value1 = (short)ConnectionResultCode.UnsupportedProtocol;
                        returnArg.Value2 = "Unsupported Authentication mechanism";
                        AppData.OnboardingConfigurationState = (short)ConfigurationState.Error;
                    }
                }
                else
                {
                    returnArg.Value1 = (short)ConnectionResultCode.Unreachable;
                    returnArg.Value2 = "Configured SSID unreachable";
                    AppData.OnboardingConfigurationState = (short)ConfigurationState.Error;
                }
            }

            m_producer.Signals.ConnectionResult(returnArg);
            AppData.LastErrorCode    = returnArg.Value1;
            AppData.LastErrorMessage = returnArg.Value2;

            if (returnArg.Value1 == (short)ConnectionResultCode.Validated)
            {
                UpdateStatusAsync("Onboarding successful. Connected to " + AppData.OnboardingConfigureSsid, NotifyType.StatusMessage);
            }
            else
            {
                UpdateStatusAsync(string.Format("Onboarding Failed. Attempt to connect failed with result code: {0} and message: {1}.", ((ConnectionResultCode)returnArg.Value1).ToString(), returnArg.Value2), NotifyType.ErrorMessage);
            }
        }
        private async void OnboardingService_ConnectRequestRecieved(object sender, EventArgs e)
        {
            UpdateStatusAsync("Connect Request received. Attempting to connect...", NotifyType.StatusMessage);
            AppData.OnboardingConfigurationState = (short)ConfigurationState.Validating;

            // 5 second delay to simulate connection attempt time.
            await Task.Delay(TimeSpan.FromSeconds(5));
            Onboarding returnArg = new Onboarding();

            if (string.IsNullOrWhiteSpace(AppData.OnboardingConfigureSsid))
            {
                returnArg.Value1 = (short)ConnectionResultCode.ErrorMessage;
                returnArg.Value2 = "Invalid SSID";
                AppData.OnboardingConfigurationState = (short)ConfigurationState.Error;
            }
            else
            {
                bool foundSsid = false;
                bool supportedProtocol = false;

                foreach (OnboardingScanListItem item in AppData.SampleNetworkScanList)
                {
                    if (item.Value1.Equals(AppData.OnboardingConfigureSsid))
                    {
                        foundSsid = true;
                        if (AppData.OnboardingConfigureAuthType == (short)OnboardingAuthenticationType.Any)
                        {
                            supportedProtocol = true;
                        }
                        else if (AppData.OnboardingConfigureAuthType == (short)OnboardingAuthenticationType.WpaAuto)
                        {
                            if ((item.Value2 == (short)OnboardingAuthenticationType.WpaTkip) || (item.Value2 == (short)OnboardingAuthenticationType.WpaCcmp))
                            {
                                supportedProtocol = true;
                            }
                        }
                        else if (AppData.OnboardingConfigureAuthType == (short)OnboardingAuthenticationType.Wpa2Auto)
                        {
                            if ((item.Value2 == (short)OnboardingAuthenticationType.Wpa2Tkip) || (item.Value2 == (short)OnboardingAuthenticationType.Wpa2Ccmp))
                            {
                                supportedProtocol = true;
                            }
                        }
                        else
                        {
                            if (item.Value2 == AppData.OnboardingConfigureAuthType)
                            {
                                supportedProtocol = true;
                            }
                        }
                        break;
                    }
                }

                if (foundSsid)
                {
                    if (supportedProtocol)
                    {
                        if (AppData.OnboardingConfigureAuthType == (short)OnboardingAuthenticationType.Open)
                        {
                            returnArg.Value1 = (short)ConnectionResultCode.Validated;
                            returnArg.Value2 = "Connected successfully";
                            AppData.OnboardingConfigurationState = (short)ConfigurationState.Validated;
                        }
                        else
                        {
                            if (AppData.OnboardingConfigurePassphrase.Equals(ConvertUtf8ToHex(AppData.SampleNetworkPassword), StringComparison.OrdinalIgnoreCase))
                            {
                                returnArg.Value1 = (short)ConnectionResultCode.Validated;
                                returnArg.Value2 = "Connected successfully";
                                AppData.OnboardingConfigurationState = (short)ConfigurationState.Validated;
                            }
                            else
                            {
                                returnArg.Value1 = (short)ConnectionResultCode.Unauthorized;
                                returnArg.Value2 = "Invalid password";
                                AppData.OnboardingConfigurationState = (short)ConfigurationState.Error;
                            }
                        }
                    }
                    else
                    {
                        returnArg.Value1 = (short)ConnectionResultCode.UnsupportedProtocol;
                        returnArg.Value2 = "Unsupported authentication mechanism";
                        AppData.OnboardingConfigurationState = (short)ConfigurationState.Error;
                    }
                }
                else
                {
                    returnArg.Value1 = (short)ConnectionResultCode.Unreachable;
                    returnArg.Value2 = "Configured SSID unreachable";
                    AppData.OnboardingConfigurationState = (short)ConfigurationState.Error;
                }
            }

            m_producer.Signals.ConnectionResult(returnArg);
            AppData.LastErrorCode = returnArg.Value1;
            AppData.LastErrorMessage = returnArg.Value2;

            if (returnArg.Value1 == (short)ConnectionResultCode.Validated)
            {
                UpdateStatusAsync("Onboarding successful. Connected to " + AppData.OnboardingConfigureSsid, NotifyType.StatusMessage);
            }
            else
            {
                UpdateStatusAsync(string.Format("Onboarding Failed. Attempt to connect failed with result code: {0} and message: {1}.", ((ConnectionResultCode)returnArg.Value1).ToString(), returnArg.Value2), NotifyType.ErrorMessage);
            }
        }
        public async Task <bool> Handle(ValidarTokenSmsCommand message, CancellationToken cancellationToken)
        {
            if (!message.IsValid())
            {
                NotifyValidationErrors(message);
                return(await Task.FromResult(false));
            }

            try
            {
                var client = _httpAppService.CreateClient(_serviceManager.UrlVileve);

                var token = await _httpAppService.OnPost <Token, object>(client, message.RequestId, "v1/auth/login", new
                {
                    usuario = _serviceManager.UserVileve,
                    senha   = _serviceManager.PasswordVileve
                });

                if (token == null || string.IsNullOrWhiteSpace(token.AccessToken))
                {
                    await _bus.RaiseEvent(new DomainNotification(message.MessageType, "Usuário de integração não encontrado.", message));

                    return(await Task.FromResult(false));
                }

                client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token.AccessToken);

                var validarToken = await _httpAppService.OnPost <ValidarToken, object>(client, message.RequestId, "v1/validacao-contato/validar-token", new
                {
                    token           = message.CodigoToken,
                    numero_telefone = message.NumeroCelular
                });

                if (validarToken.Valido.Equals(false))
                {
                    await _bus.RaiseEvent(new DomainNotification(message.MessageType, "Token inválido.", message));

                    return(await Task.FromResult(false));
                }
            }
            catch (Exception e)
            {
                _logger.Log(LogLevel.Error, e, JsonSerializer.Serialize(new
                {
                    message.RequestId,
                    e.Message
                }));

                await _bus.RaiseEvent(new DomainNotification(message.MessageType, "O sistema está momentaneamente indisponível, tente novamente mais tarde.", message));

                return(await Task.FromResult(false));
            }

            if (message.CodigoConvite.Equals("******"))
            {
                return(await Task.FromResult(true));
            }

            var onboarding = _onboardingRepository.Find(o => o.CodigoConvite.Equals(message.CodigoConvite) && o.NumeroCelular.Equals(message.NumeroCelular)).FirstOrDefault();

            if (onboarding != null)
            {
                if (onboarding.StatusOnboarding.Equals(StatusOnboarding.ValidacaoToken) || onboarding.StatusOnboarding.Equals(StatusOnboarding.ValidacaoEmail))
                {
                    return(await Task.FromResult(true));
                }

                await _bus.RaiseEvent(new DomainNotification(message.MessageType, "Este código do convite e número de celular estão vinculados a outro usuário.", message));

                return(await Task.FromResult(false));
            }

            onboarding = new Onboarding(Guid.NewGuid())
            {
                CodigoConvite    = message.CodigoConvite,
                NumeroCelular    = message.NumeroCelular,
                StatusOnboarding = StatusOnboarding.ValidacaoToken
            };

            _onboardingRepository.Add(onboarding);

            if (Commit())
            {
            }

            return(await Task.FromResult(true));
        }