예제 #1
0
        public TeamDTO BuildTeam(CreateTeamResponse data)
        {
            TeamDTO teamDTO = null;

            if (data != null)
            {
                teamDTO = new TeamDTO()
                {
                    Coach          = data.Coach,
                    CoachId        = data.CoachId,
                    CreatedBy      = data.CreatedBy,
                    Events         = data.Events,
                    Games          = data.Games,
                    Id             = data.Id,
                    Locations      = data.Locations,
                    Members        = data.Members,
                    Name           = data.Name,
                    Opponents      = data.Opponents,
                    Organization   = data.Organization,
                    OrganizationId = data.OrganizationId,
                    Owner          = data.Owner,
                    Sport          = data.Sport
                };
            }

            return(teamDTO);
        }
예제 #2
0
        public CreateTeamResponse CreateTeam(CreateTeamRequest request)//TODO: fix bug with assigned user role
        {
            var response = new CreateTeamResponse();

            var dbTeam = new TeamEntity
            {
                TeamName         = request.Team.TeamName,
                ProjectManagerId = request.UserId
            };

            try
            {
                uow.Repository <TeamEntity>().Add(dbTeam);
                uow.Save();

                var dbXrefUserTeam = new XrefUserTeamEntity
                {
                    TeamId = dbTeam.TeamId,
                    UserId = request.UserId
                };
                uow.Repository <XrefUserTeamEntity>().Add(dbXrefUserTeam);
                uow.Save();

                response.Success = true;
                response.TeamId  = dbTeam.TeamId;
                response.UserId  = request.UserId;
            }
            catch (Exception ex)
            {
                response.ErrorMessage = ex.Message;
                response.Success      = false;
            }

            return(response);
        }
예제 #3
0
        public void Handle(EditTeamRequest request)
        {
            try
            {
                if (!String.IsNullOrEmpty(request.NameTeam) || !String.IsNullOrEmpty(request.IdFirstMember) || !String.IsNullOrEmpty(request.IdSecondMember))
                {
                    var team = _teamRepo.Get(request.Id);

                    team.NameTeam     = request.NameTeam;
                    team.FirstMember  = GetPlayerById(request.IdFirstMember);
                    team.SecondMember = GetPlayerById(request.IdSecondMember);

                    _teamRepo.Replace(team);
                    var response = new EditTeamResponse(true);
                    Sender.Tell(response);

                    _logger.Info("Edit Team successfull: {0} {1}", team.NameTeam);
                }
                else
                {
                    var response = new CreateTeamResponse(false);
                    Sender.Tell(response);

                    _logger.Error("Couldn't create Team: {0}: All fields are required", request.NameTeam);
                }
            }
            catch (Exception ex)
            {
                var response = new EditTeamResponse(false);
                Sender.Tell(response);

                _logger.Error("Couldn't Team by id: {0}: {1}", request.Id, ex.Message);
            }
        }
예제 #4
0
 public TeamMemberViewModel CreateItem(CreateTeamResponse createTeamResponse)
 {
     return(new TeamMemberViewModel {
         Sport = createTeamResponse.Sport,
         Owner = createTeamResponse.Organization?.DisplayName,
         Team = createTeamResponse.Name,
         Joined = DateTime.Now,
         CanBeDeleted = createTeamResponse.CreatedBy?.Id == GlobalSettings.Instance.UserProfile.Id
     });
 }
예제 #5
0
        public async Task <ActionResult <CreateTeamResponse> > CreateTeam([FromBody] CreateTeamRequest createTeamRequest, CancellationToken cancellationToken)
        {
            var team = new Team()
            {
                Name      = createTeamRequest.Name,
                FoundedIn = createTeamRequest.FoundedIn
            };
            await _teamsRepository.AddAsync(team, cancellationToken);

            var response = new CreateTeamResponse
            {
                Team = _mapper.Map <TeamDto>(team)
            };

            return(Ok(response));
        }
예제 #6
0
        public void Handle(CreateTeamRequest request)
        {
            try
            {
                if (!String.IsNullOrEmpty(request.NameTeam) || !String.IsNullOrEmpty(request.IdFirstMember) || !String.IsNullOrEmpty(request.IdSecondMember))
                {
                    if (_teamRepo.Any(x => x.NameTeam.Contains(request.NameTeam) && !x.IsDeleted))
                    {
                        var response = new CreateTeamResponse(false);
                        Sender.Tell(response);

                        _logger.Error("Couldn't create Team: {0}: This name is exists", request.NameTeam);
                    }
                    else
                    {
                        _teamRepo.Insert(new Team
                        {
                            NameTeam     = request.NameTeam,
                            FirstMember  = GetPlayerById(request.IdFirstMember),
                            SecondMember = GetPlayerById(request.IdSecondMember),
                            IsDeleted    = false
                        });

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

                        _logger.Info("Create Team successfull: {0}", request.NameTeam);
                    }
                }
                else
                {
                    var response = new CreateTeamResponse(false);
                    Sender.Tell(response);

                    _logger.Error("Couldn't create Team: {0} {1}: All fields are required", request.NameTeam);
                }
            }
            catch (Exception ex)
            {
                var response = new CreateTeamResponse(false);
                Sender.Tell(response);

                _logger.Error("Couldn't create Team: {0} {1}: ", request.NameTeam, ex.Message);
            }
        }
예제 #7
0
        public async Task <IActionResult> CreateTeam([FromBody] CreateTeamRequest request,
                                                     CancellationToken cancellationToken)
        {
            var command = new CreateTeamCommand
                          (
                request.Name
                          );

            var @event = await _commandDispatcher.DispatchAsync(command, cancellationToken);

            var location = Url.RouteUrl("FindTeam", new { teamId = @event.TeamId }, null, Request.Host.Value);

            Response.Headers["Location"] = location;

            var response = new CreateTeamResponse(@event.TeamId.ToString());

            return(StatusCode(201, response));
        }
예제 #8
0
        public ActionResult <CreateTeamResponse> CreateTeam(CreateTeamRequest request)
        {
            var response = new CreateTeamResponse()
            {
                ResponseMessage = Models.ResponseMessage.Failure
            };

            int?stadiumId = request.Team.StadiumId == 0 ? null : request.Team.StadiumId;

            _context.Teams.Add(new Team(request.Team.Name, request.Team.Nickname, request.Team.Location, stadiumId));

            var success = _context.SaveChanges();

            if (success > 0)
            {
                response.ResponseMessage = Models.ResponseMessage.Success;
            }

            return(Ok(response));
        }
예제 #9
0
        public Task <CreateTeamResponse> CreateTeamAsync(CreateTeamDataModel createTeamDataModel, CancellationToken cancellationToken = default(CancellationToken)) =>
        Task.Run(async() => {
            if (!CrossConnectivity.Current.IsConnected)
            {
                throw new InvalidOperationException(AppConsts.ERROR_INTERNET_CONNECTION);
            }

            CreateTeamRequest createTeamRequest = new CreateTeamRequest {
                AccessToken = GlobalSettings.Instance.UserProfile.AccesToken,
                Url         = GlobalSettings.Instance.Endpoints.TeamEndPoints.CreateTeamEndPoint,
                Data        = createTeamDataModel
            };

            CreateTeamResponse createTeamResponse = null;

            try {
                createTeamResponse = await _requestProvider.PostAsync <CreateTeamRequest, CreateTeamResponse>(createTeamRequest);
            }
            catch (ServiceAuthenticationException exc) {
                _identityUtilService.RefreshToken();

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

                string output = string.Format("{0}",
                                              createTeamBadResponse.Name?.FirstOrDefault());

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

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

            return(createTeamResponse);
        }, cancellationToken);
예제 #10
0
        public async Task <ActionResult <CreateTeamResponse> > UpdateTeam([FromRoute] int teamId, [FromBody] UpdateTeamRequest createTeamRequest, CancellationToken cancellationToken)
        {
            var team = await _teamsRepository.GetByIdAsync(teamId, cancellationToken);

            if (team != null)
            {
                team.Name      = createTeamRequest.Name;
                team.FoundedIn = createTeamRequest.FoundedIn;

                await _teamsRepository.UpdateAsync(team, cancellationToken);

                var response = new CreateTeamResponse()
                {
                    Team = _mapper.Map <TeamDto>(team)
                };
                return(Ok(response));
            }
            else
            {
                return(BadRequest());
            }
        }