Пример #1
0
        /// <summary>
        ///     Handles the specified request.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <param name="response">The response.</param>
        protected override void Handle(RemoveTeamRequest request, DtoResponse <TeamSummaryDto> response)
        {
            var team = _teamRepository.GetByKey(request.TeamKey);

            team.RemoveTeam(team.Key);
            response.DataTransferObject = Mapper.Map <Team, TeamSummaryDto> (team);
        }
Пример #2
0
        public void Handle(RemoveTeamRequest request)
        {
            try
            {
                //_teamRepo.Delete(request.Id);

                var team = _teamRepo.Get(request.Id);

                team.IsDeleted = true;

                _teamRepo.Replace(team);

                var response = new RemoveTeamResponse(true);
                Sender.Tell(response);

                _logger.Info("Remove Team successfull: {0} {1}", team.NameTeam);
            }
            catch (Exception ex)
            {
                var response = new RemoveTeamResponse(false);
                Sender.Tell(response);

                _logger.Error("Couldn't remove Team by id: {0}: {1}", request.Id, ex.Message);
            }
        }
Пример #3
0
        public Task <bool> RemoveTeamByIdAsync(long teamId, CancellationTokenSource cancellationTokenSource) =>
        Task <bool> .Run(async() => {
            if (!CrossConnectivity.Current.IsConnected)
            {
                throw new InvalidOperationException(AppConsts.ERROR_INTERNET_CONNECTION);
            }

            bool deleteCompletion = false;

            RemoveTeamRequest removeTeamRequest = new RemoveTeamRequest()
            {
                AccessToken = GlobalSettings.Instance.UserProfile.AccesToken,
                Url         = string.Format(GlobalSettings.Instance.Endpoints.TeamEndPoints.RemoveTeamByIdEndPoint, teamId)
            };

            RemoveTeamResponse removeTeamResponse = null;

            try {
                removeTeamResponse = await _requestProvider.PostAsync <RemoveTeamRequest, RemoveTeamResponse>(removeTeamRequest);

                if (removeTeamResponse != null)
                {
                    deleteCompletion = true;
                }
                else
                {
                    throw new InvalidOperationException(TeamService.REMOVE_TEAM_BY_ID_COMMON_ERROR_MESSAGE);
                }
            }
            catch (ServiceAuthenticationException exc) {
                _identityUtilService.RefreshToken();

                throw exc;
            }
            catch (HttpRequestExceptionEx exc) {
                removeTeamResponse = JsonConvert.DeserializeObject <RemoveTeamResponse>(exc.Message);

                string output = string.Format("{0}",
                                              removeTeamResponse.Errors?.FirstOrDefault());

                output = (string.IsNullOrWhiteSpace(output) || string.IsNullOrEmpty(output)) ? TeamService.REMOVE_TEAM_BY_ID_COMMON_ERROR_MESSAGE : output;

                throw new InvalidOperationException(output.Trim());
            }
            catch (Exception exc) {
                Crashes.TrackError(exc);
                throw;
            }

            return(deleteCompletion);
        }, cancellationTokenSource.Token);
Пример #4
0
 public async Task <IHttpActionResult> Remove([FromUri] RemoveTeamRequest request)
 {
     request.TenantId = (await _userManager.GetUserAsync(User)).TenantId;
     return(Ok(await _mediator.Send(request)));
 }
Пример #5
0
        public async Task <RemoveTeamResponse> RemoveTeam(string id)
        {
            var request = new RemoveTeamRequest(id);

            return(await _teamActor.Ask <RemoveTeamResponse>(request));
        }