Exemplo n.º 1
0
        public async Task <TeamInviteConfirmResponse> TeamInviteConfirmAsync(long teamId, CancellationToken cancellationToken, long?profileId = null) =>
        await Task.Run(async() => {
            if (!CrossConnectivity.Current.IsConnected)
            {
                throw new InvalidOperationException(AppConsts.ERROR_INTERNET_CONNECTION);
            }

            TeamInviteConfirmRequest teamInviteConfirmRequest = new TeamInviteConfirmRequest {
                AccessToken = GlobalSettings.Instance.UserProfile.AccesToken,
                Url         = string.Format(GlobalSettings.Instance.Endpoints.InviteEndPoints.TeamInviteConfirmEndPoint, teamId),
                Data        = (profileId.HasValue) ? profileId.Value : GlobalSettings.Instance.UserProfile.Id
            };

            TeamInviteConfirmResponse teamInviteConfirmResponse = null;
            try {
                teamInviteConfirmResponse = await _requestProvider.PutAsync <TeamInviteConfirmRequest, TeamInviteConfirmResponse>(teamInviteConfirmRequest);
            }
            catch (ServiceAuthenticationException exc) {
                _identityUtilService.RefreshToken();

                throw exc;
            }
            catch (Exception ex) {
                Crashes.TrackError(ex);
                Debug.WriteLine($"ERROR:{ex.Message}");

                throw;
            }
            return(teamInviteConfirmResponse);
        }, cancellationToken);
        public ChildInviteToTeamItemViewModel(IInviteService inviteService)
        {
            _inviteService = inviteService;

            AcceptCommand = new Command(async() => {
                try {
                    TeamInviteConfirmResponse teamInviteConfirmResponse = await _inviteService.TeamInviteConfirmAsync(((TeamDTO)InviteTo).Id, default(CancellationToken), Child.Id);

                    if (teamInviteConfirmResponse != null)
                    {
                        MessagingCenter.Send <object, long>(this, GlobalSettings.Instance.AppMessagingEvents.TeamEvents.InviteAccepted, ((TeamDTO)InviteTo).Id);

                        await DialogService.ToastAsync("Child joined to team");
                    }
                }
                catch (OperationCanceledException) { }
                catch (ObjectDisposedException) { }
                catch (ServiceAuthenticationException) { }
                catch (Exception exc) {
                    Crashes.TrackError(exc);

                    await DialogService.ToastAsync(exc.Message);
                }
            });

            DeclineCommand = new Command(async() => {
                try {
                    TeamInviteRejectResponse teamInviteRejectResponse = await _inviteService.TeamInviteRejectAsync(((TeamDTO)InviteTo).Id, default(CancellationToken), Child.Id);

                    if (teamInviteRejectResponse != null)
                    {
                        MessagingCenter.Send <object, long>(this, GlobalSettings.Instance.AppMessagingEvents.TeamEvents.InviteDeclined, ((TeamDTO)InviteTo).Id);

                        await DialogService.ToastAsync("Child reject invite to team");
                    }
                }
                catch (OperationCanceledException) { }
                catch (ObjectDisposedException) { }
                catch (ServiceAuthenticationException) { }
                catch (Exception exc) {
                    Crashes.TrackError(exc);

                    await DialogService.ToastAsync(exc.Message);
                }
            });
        }
        private async Task OnAccept(CancellationToken cancellationToken)
        {
            try {
                TeamInviteConfirmResponse teamInviteConfirmResponse = await _inviteService.TeamInviteConfirmAsync(TeamId, cancellationToken);

                if (teamInviteConfirmResponse != null)
                {
                    MessagingCenter.Send <object, long>(this, GlobalSettings.Instance.AppMessagingEvents.TeamEvents.InviteAccepted, TeamId);

                    await DialogService.ToastAsync($"You are joined into {TeamName}!");
                }
            }
            catch (OperationCanceledException) { }
            catch (ObjectDisposedException) { }
            catch (ServiceAuthenticationException) { }
            catch (Exception exc) {
                Crashes.TrackError(exc);

                await DialogService.ToastAsync(exc.Message);
            }
        }