Exemplo n.º 1
0
        async void handleApplicationTapped(object sender, ItemTappedEventArgs e)
        {
            try
            {
                if (!isBusy)
                {
                    isBusy = true;
                    if (e.Item == null)
                    {
                        return;
                    }

                    var selectedApplication = e.Item as Workbench.Client.Models.Application;

                    //Reset the IsInitiator property
                    App.ViewModel.IsUserInitiator = false;


                    await App.ViewModel.SetCurrentApplication(selectedApplication.Id.ToString());

                    await App.ViewModel.RefreshWorkflowsForSelectedApplication(selectedApplication.Id.ToString());
                }
            }
            catch (Exception ex)
            {
                AppCenterHelper.Report(ex);
            }
            finally
            {
                isBusy = false;
            }
        }
        public async Task <bool> LoginAsync()
        {
            if (IsBusy)
            {
                return(false);
            }

            IsBusy             = true;
            IsAnimationVisible = true;

            try
            {
                var response = await executeLoginAsync();

                IsAnimationVisible = false;

                return(response);
            }
            catch (Exception e)
            {
                AppCenterHelper.Report(e);
                await App.Current.MainPage.DisplayAlert("Error", $"executeLoginAsync: {e.Message}", "OK");
            }
            finally
            {
                IsBusy             = false;
                IsAnimationVisible = false;
            }

            return(false);
        }
        public async Task <LoginResponse> LoginAsync(string authority, string resource, string clientId, string returnUri, bool isRefresh = false)
        {
            var authContext = new AuthenticationContext(authority);

            if (authContext.TokenCache.ReadItems().Any())
            {
                authContext = new AuthenticationContext(authContext.TokenCache.ReadItems().First().Authority);
            }

            try
            {
                AuthenticationResult authResult;
                if (isRefresh)
                {
                    authResult = await authContext.AcquireTokenSilentAsync(resource, clientId);
                }
                else
                {
                    var controller     = ViewControllerHelpers.GetVisibleViewController();
                    var uri            = new Uri(returnUri);
                    var platformParams = new PlatformParameters(controller);

                    authResult = await authContext.AcquireTokenAsync(resource, clientId, uri, platformParams);
                }

                var result = new LoginResponse
                {
                    AuthHeader            = authResult.CreateAuthorizationHeader(),
                    AccessToken           = authResult.AccessToken,
                    AccessTokenType       = authResult.AccessTokenType,
                    ExpiresOn             = authResult.ExpiresOn,
                    ExtendedLifetimeToken = authResult.ExtendedLifeTimeToken,
                    IdToken  = authResult.IdToken,
                    TenantId = authResult.TenantId
                };

                result.Profile.DisplayableId = authResult.UserInfo.DisplayableId;
                result.Profile.FamilyName    = authResult.UserInfo.FamilyName;
                result.Profile.GivenName     = authResult.UserInfo.GivenName;
                result.Profile.UniqueId      = authResult.UserInfo.UniqueId;

                return(result);
            }
            catch (Exception e)
            {
                var _controller = ViewControllerHelpers.GetVisibleViewController();
                var alert       = UIAlertController.Create("Error", e.Message, UIAlertControllerStyle.Alert);
                alert.AddAction(UIAlertAction.Create("Cancel", UIAlertActionStyle.Cancel, null));

                _controller.BeginInvokeOnMainThread(() =>
                {
                    _controller.PresentViewController(alert, true, null);
                });

                AppCenterHelper.Report(e);
                clearTokenFromCache(authority);
                return(null);
            }
        }
Exemplo n.º 4
0
        public async Task <LoginResponse> LoginAsync(string authority, string resource, string clientId, string returnUri, bool isRefresh = false)
        {
            var authContext = new AuthenticationContext(authority);

            if (authContext.TokenCache.ReadItems().Any())
            {
                authContext = new AuthenticationContext(authContext.TokenCache.ReadItems().First().Authority);
            }

            var uri            = new Uri(returnUri);
            var platformParams = new PlatformParameters((Android.App.Activity)Xamarin.Forms.Forms.Context);

            try
            {
                AuthenticationResult authResult;

                if (isRefresh)
                {
                    authResult = await authContext.AcquireTokenSilentAsync(resource, clientId);
                }
                else
                {
                    authResult = await authContext.AcquireTokenAsync(resource, clientId, uri, platformParams).ConfigureAwait(false);
                }

                var result = new LoginResponse
                {
                    AuthHeader            = authResult.CreateAuthorizationHeader(),
                    AccessToken           = authResult.AccessToken,
                    AccessTokenType       = authResult.AccessTokenType,
                    ExpiresOn             = authResult.ExpiresOn,
                    ExtendedLifetimeToken = authResult.ExtendedLifeTimeToken,
                    IdToken  = authResult.IdToken,
                    TenantId = authResult.TenantId
                };

                result.Profile.DisplayableId = authResult.UserInfo.DisplayableId;
                result.Profile.FamilyName    = authResult.UserInfo.FamilyName;
                result.Profile.GivenName     = authResult.UserInfo.GivenName;
                result.Profile.UniqueId      = authResult.UserInfo.UniqueId;

                return(result);
            }
            catch (Exception e)
            {
                AppCenterHelper.Report(e);
                clearTokenFromCache(authority);
                return(null);
            }
        }
        public async Task LoadContractInstanceAsync()
        {
            IsBusy = true;

            try
            {
                Blocks         = new List <BlockModel>();
                DisplayActions = false;

                var res = await GatewayApi.Instance.GetContractByIdAsync(ContractInstance.Id.ToString());

                if (res != default(Contract) || res != null)
                {
                    ContractInstance = res;
                    assembleBlocks();
                }

                assembleUsers();

                var actions = await GatewayApi.Instance.GetWorkflowActionsAsync(ContractInstance.Id.ToString());

                if (actions != null)
                {
                    Actions = new List <WorkflowFunction>(actions);

                    if (Actions?.Count > 0)
                    {
                        DisplayActions = true;
                    }
                    else
                    {
                        DisplayActions = false;
                    }
                }
                else
                {
                    DisplayActions = false;
                }
            }
            catch (Exception e)
            {
                AppCenterHelper.Report(e);
            }
            finally
            {
                IsBusy = false;
            }
        }
        async Task configureFirstEnvironment()
        {
            try
            {
                addingNewEnvironment = true;

                var prompt = new PromptConfig
                {
                    IsCancellable = true,
                    Message       = $"Please enter the URL that contains your environment configuration JSON",
                    OkText        = "Ok",
                    Title         = "Add Environment"
                };

                var URLResults = await UserDialogs.Instance.PromptAsync(prompt);

                if (!string.IsNullOrEmpty(URLResults?.Value))
                {
                    using (var httpclient = new HttpClient())
                    {
                        var results = await httpclient.GetStringAsync(URLResults?.Value);

                        if (!string.IsNullOrEmpty(results))
                        {
                            var environment = JsonConvert.DeserializeObject <BlockchainEnvironment>(results);

                            await LocalDbHelper.Instance.SaveEnvironmentAsync(environment);

                            Device.BeginInvokeOnMainThread(async() =>
                            {
                                await LoginAsync();
                            });
                        }
                        else
                        {
                            await UserDialogs.Instance.AlertAsync("Unable to get environment data, please ensure you entered a valid URL", "Error", "OK");
                        }
                    }
                }
            }
            catch (Exception e)
            {
                AppCenterHelper.Report(e);
                await UserDialogs.Instance.AlertAsync("Unable to get environment data, please ensure you entered a valid URL", "Error", "OK");
            }
        }
Exemplo n.º 7
0
        public void clearTokenFromCache(string authority)
        {
            try
            {
                Android.Webkit.CookieManager.Instance.RemoveAllCookies(null);

                var authContext = new AuthenticationContext(authority);
                authContext.TokenCache.Clear();

                var editor = SharedPreferences.Edit();
                editor.Remove(SharedPreferencesKey);
            }
            catch (Exception ex)
            {
                // log the error
                AppCenterHelper.Report(ex);
                System.Diagnostics.Debug.WriteLine(ex.Message);
            }
        }
Exemplo n.º 8
0
        public App()
        {
            FlowListView.Init();

            GatewayApi.Instance.ExpiredAccessToken += async(object sender, EventArgs e) =>
            {
                var localEnvironments = await LocalDbHelper.Instance.GetAllSavedEnvironmentsAsync();

                BlockchainEnvironment environment = localEnvironments[0];

                var authService   = ServiceContainer.Resolve <IAuthentication>();
                var loginResponse = await authService.LoginAsync(
                    $"https://login.windows.net/{environment.TenantId}",
                    environment.ResourceId,
                    environment.ClientId,
                    environment.ReturnUrl,
                    isRefresh : true);

                if (loginResponse != null)
                {
                    AppCenterHelper.TrackEvent("Refreshed Token", new Dictionary <string, string>()
                    {
                        { "username", loginResponse.Profile.DisplayableId }
                    });

                    Settings.AccessToken = loginResponse.AccessToken;
                    GatewayApi.Instance.SetAuthToken(loginResponse.AccessToken);
#if DEBUG
                    Settings.AccessTokenExpiration            = new DateTimeOffset(DateTime.Now.AddMinutes(2));
                    GatewayApi.Instance.AccessTokenExpiration = new DateTimeOffset(DateTime.Now.AddMinutes(2));
#else
                    Settings.AccessTokenExpiration            = loginResponse.ExpiresOn;
                    GatewayApi.Instance.AccessTokenExpiration = loginResponse.ExpiresOn;
#endif
                }
                else
                {
                    App.Logout(false);
                }
            };

            GatewayApi.Instance.ExceptionThrown += async(object sender, Exception e) =>
            {
                AppCenterHelper.Report(e, new Dictionary <string, string>()
                {
                    { "baseurl", GatewayApi.SiteUrl }
                });
            };

            ViewModel = new AppViewModel();

            backgroundPage = new BackgroundPage();

            var navPage       = new Xamarin.Forms.NavigationPage(backgroundPage);
            var detailNavPage = new Xamarin.Forms.NavigationPage(new ApplicationsPage());

            ContractsPage = new WorklfowInstanceListPage();

            navPage.BarBackgroundColor       = Constants.NavBarBackgroundColor;
            navPage.BarTextColor             = Constants.NavBarTextColor;
            detailNavPage.BarBackgroundColor = Constants.NavBarBackgroundColor;
            detailNavPage.BarTextColor       = Constants.NavBarTextColor;

            Master = new MasterDetailPage {
                BindingContext = ViewModel
            };
            Master.IsPresentedChanged += (object sender, EventArgs e) =>
            {
                var mdp = sender as MasterDetailPage;
                if (mdp.IsPresented)
                {
                    ((Xamarin.Forms.NavigationPage)mdp.Detail)
                    .On <iOS>()
                    .SetStatusBarTextColorMode(StatusBarTextColorMode.DoNotAdjust);
                }
                else
                {
                    ((Xamarin.Forms.NavigationPage)mdp.Detail)
                    .On <iOS>()
                    .SetStatusBarTextColorMode(StatusBarTextColorMode.MatchNavigationBarTextLuminosity);
                }
            };

            Master.Master = new MasterPage {
                BindingContext = ViewModel
            };
            Master.Detail = detailNavPage;
            Master.SetBinding(MasterDetailPage.IsPresentedProperty, nameof(AppViewModel.MenuPresented), BindingMode.TwoWay);

            Xamarin.Forms.NavigationPage.SetHasNavigationBar(detailNavPage, false);

            try
            {
                MainPage = navPage;
            }
            catch (Exception e)
            {
                AppCenterHelper.Report(e);
            }
        }
Exemplo n.º 9
0
        void setupActionView()
        {
            foreach (var actionParam in contractAction?.Parameters)
            {
                var action = actionParam.Type.Name.ToLower();

                //Add Labels
                var label = new Label
                {
                    HorizontalOptions = LayoutOptions.FillAndExpand,
                    Text = $"{actionParam.DisplayName}:"
                };
                parameterViewStack.Children.Add(label);

                //Check if action parameter is within the application roles
                var currentAppRole = App.ViewModel.CurrentApplication.ApplicationRoles.FirstOrDefault(x => x.Name.ToLower().Equals(action));
                if (currentAppRole != null)
                {
                    var picker = new Picker
                    {
                        HorizontalOptions = LayoutOptions.FillAndExpand,
                        Title             = actionParam.DisplayName
                    };

                    var listOfRoles = App.ViewModel.ApplicationRoleMappingsList.Where(X => X.ApplicationRoleId.Equals(currentAppRole.Id));

                    picker.ItemsSource = listOfRoles.Select(x => x.User).ToList().Select(Y => Y.DisplayName).ToList();
                    parameterViewStack.Children.Add(picker);
                }
                else
                {
                    switch (action)
                    {
                    case ContractParameterType.String:
                    case ContractParameterType.Address:
                    case ContractParameterType.Contract:
                        var stringEntry = new Entry
                        {
                            HorizontalOptions = LayoutOptions.FillAndExpand
                        };
                        parameterViewStack.Children.Add(stringEntry);
                        break;

                    case ContractParameterType.Money:
                    case ContractParameterType.Uint:
                    case ContractParameterType.Int:
                    case ContractParameterType.Time:
                        var moneyEntry = new Entry
                        {
                            HorizontalOptions = LayoutOptions.FillAndExpand,
                            Keyboard          = Keyboard.Numeric
                        };
                        parameterViewStack.Children.Add(moneyEntry);
                        break;

                    case ContractParameterType.Device:
                    case ContractParameterType.User:
                        var picker = new Picker
                        {
                            HorizontalOptions = LayoutOptions.FillAndExpand,
                            Title             = actionParam.DisplayName
                        };

                        var listOfRoles = App.ViewModel.ApplicationRoleMappingsList.Where(X => X.ApplicationRoleId.Equals(currentAppRole.Id));

                        picker.ItemsSource = listOfRoles.Select(x => x.User).ToList().Select(Y => Y.DisplayName).ToList();
                        parameterViewStack.Children.Add(picker);
                        break;

                    case ContractParameterType.Enum:
                        var enumPicker = new Picker
                        {
                            HorizontalOptions = LayoutOptions.FillAndExpand,
                            Title             = actionParam.DisplayName
                        };

                        enumPicker.ItemsSource = actionParam.Type.EnumValues;
                        parameterViewStack.Children.Add(enumPicker);
                        break;

                    case ContractParameterType.Array:
                        var arrayEntry = new Entry
                        {
                            HorizontalOptions = LayoutOptions.FillAndExpand
                        };
                        if (actionParam.Type.ElementType.Name.Equals("bool"))
                        {
                            arrayEntry.Keyboard    = Keyboard.Default;
                            arrayEntry.Placeholder = "Input a comma separated array of booleans";
                        }
                        else
                        {
                            arrayEntry.Placeholder = "Input a comma separated array of integers";
                            arrayEntry.Keyboard    = Keyboard.Numeric;
                        }
                        parameterViewStack.Children.Add(arrayEntry);
                        break;

                    case ContractParameterType.Bool:
                        var boolPicker = new Picker
                        {
                            HorizontalOptions = LayoutOptions.FillAndExpand,
                            Title             = actionParam.DisplayName
                        };

                        boolPicker.ItemsSource = new List <string>()
                        {
                            "True", "False"
                        };
                        parameterViewStack.Children.Add(boolPicker);
                        break;

                    default:
                        AppCenterHelper.Report(new Exception($"unsupported data type encountered: {action}"));
                        break;
                    }
                }
            }
        }