public Team Add(CreateTeamDto teamToCreate) { var players = teamToCreate.Roster.Select(x => x.Id); var roster = _unitOfWork.Context.Players .Where(p => players.Contains(p.Id)).ToList(); var newTeam = new TeamEntity { Name = teamToCreate.Name, Coach = teamToCreate.Coach, CaptainId = teamToCreate.Captain.Id, Achievements = teamToCreate.Achievements, Players = roster }; if (!_dbStorageSpecification.IsSatisfiedBy(newTeam)) { throw new InvalidEntityException(); } _dalTeams.Add(newTeam); _unitOfWork.Commit(); return(new Team( newTeam.Id, newTeam.Name, newTeam.Coach, newTeam.Achievements, new PlayerId(newTeam.CaptainId), teamToCreate.Roster.ToList() )); }
public async Task <IActionResult> Create(TeamViewModel teamViewModel) { if (ModelState.IsValid) { string path = string.Empty; if (teamViewModel.LogoFile != null) { path = await _imageHelper.UploadImageAsync(teamViewModel.LogoFile, "Teams"); } TeamEntity teamEntity = _converterHelper.ToTeamEntity(teamViewModel, path, true); _context.Add(teamEntity); try { await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } catch (Exception ex) { if (ex.InnerException.Message.Contains("duplicate")) { ModelState.AddModelError(string.Empty, $"Club con il nome {teamEntity.Name} già esistente"); } else { ModelState.AddModelError(string.Empty, ex.InnerException.Message); } } } return(View(teamViewModel)); }
/// <summary> /// 批量添加成员 /// </summary> /// <param name="listModel"></param> /// <returns></returns> public int Save(List <TeamEntity> listModel) { int ret = 0; try { if (listModel != null && listModel.Count > 0) { TeamEntity model = listModel.FirstOrDefault(); var ps = model.GetType().GetProperties(); List <string> @colms = new List <string>(); List <string> @params = new List <string>(); foreach (var p in ps) { @colms.Add(string.Format("[{0}]", p.Name)); @params.Add(string.Format("@{0}", p.Name)); } var sql = string.Format("INSERT INTO [{0}] ({1}) VALUES({2})", "tbTeam", string.Join(", ", @colms), string.Join(", ", @params)); using (var _conn = GetConnection()) { _conn.Execute("delete from tbTeam where ProjectId = @ProjectId and TaskId='0'", new { ProjectId = listModel[0].ProjectId }); ret = _conn.Execute(sql, listModel); } } } catch (Exception ex) { throw ex; } return(ret); }
public async Task <IActionResult> PutTeamEntity(int id, TeamEntity teamEntity) { if (id != teamEntity.Id) { return(BadRequest()); } _context.Entry(teamEntity).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!TeamEntityExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
private IEnumerable <Activity> CreateActivities( TeamEntity teamEntity, IEnumerable <Notification> notifications) { var activities = new List <Activity>(); foreach (var notification in notifications) { var message = this.CreateMessage(notification); var attachment = this.eventCardBuilder.BuildAttachment(notification); var mention = this.CreateMention(notification); var activity = this.botActivityBuilder.CreateActivity( teamEntity.ServiceUrl, string.IsNullOrWhiteSpace(teamEntity.ActiveChannelId) ? teamEntity.TeamId : teamEntity.ActiveChannelId); activity.ChannelData = new TeamsChannelData { Team = new TeamInfo { Id = teamEntity.TeamId }, }; activity.Conversation.ConversationType = BotMetadataConstants.ChannelConversationType; activity.Text = message; activity.AttachmentLayout = "carousel"; activity.Attachments.Add(attachment); activity.Entities = new List <Entity> { mention }; activities.Add(activity); } return(activities); }
public async Task MatchTime_Within_Fixture_TimeLimit(TimeSpan startTime, bool startTimeMustBeSet, bool expected) { // Note: all times are set and compared to local time var team = new TeamEntity(); _tenantContext.TournamentContext.TeamRuleSet = new TeamRules { HomeMatchTime = new HomeMatchTime { IsEditable = true, MustBeSet = startTimeMustBeSet } }; _tenantContext.TournamentContext.FixtureRuleSet = new FixtureRuleSet { RegularMatchStartTime = new RegularMatchStartTime { MinDayTime = new TimeSpan(19, 0, 0), MaxDayTime = new TimeSpan(21, 0, 0) } }; var tv = new TeamValidator(team, _tenantContext); team.MatchTime = startTime; var factResult = await tv.CheckAsync(TeamValidator.FactId.MatchTimeWithinRange, CancellationToken.None); Assert.Multiple(() => { Assert.AreEqual(expected, factResult.IsChecked == startTimeMustBeSet && factResult.Success && factResult.Message.Contains(_tenantContext.TournamentContext.FixtureRuleSet .RegularMatchStartTime.MinDayTime.ToShortTimeString())); Assert.IsNull(factResult.Exception); }); }
public async Task DayOfWeek_Must_Be_In_Range(DayOfWeek?dayOfWeek, bool errorIfNotInRange, bool expected) { var team = new TeamEntity { MatchDayOfWeek = dayOfWeek.HasValue ? (int)dayOfWeek : default(int?) }; _tenantContext.TournamentContext.TeamRuleSet = new TeamRules { HomeMatchTime = new HomeMatchTime { IsEditable = true, MustBeSet = true, ErrorIfNotInDaysOfWeekRange = errorIfNotInRange, DaysOfWeekRange = new List <DayOfWeek> { DayOfWeek.Monday, DayOfWeek.Tuesday } } }; var tv = new TeamValidator(team, _tenantContext); var factResult = await tv.CheckAsync(TeamValidator.FactId.DayOfWeekWithinRange, CancellationToken.None); Assert.Multiple(() => { Assert.AreEqual(factResult.Enabled, _tenantContext.TournamentContext.TeamRuleSet.HomeMatchTime.IsEditable && _tenantContext.TournamentContext.TeamRuleSet.HomeMatchTime.MustBeSet); if (factResult.Enabled) { Assert.IsTrue(errorIfNotInRange ? factResult.Type == FactType.Error : factResult.Type == FactType.Warning); Assert.AreEqual(expected, factResult.Success); } Assert.IsNull(factResult.Exception); }); }
public async Task <IActionResult> Edit(TeamViewModel model) { if (ModelState.IsValid) { var path = model.LogoPath; if (model.LogoFile != null) { path = await _imageHelper.UploadingImageAsync(model.LogoFile, "Teams"); } TeamEntity team = _converterHelper.ToTeamEntity(model, path, false); _context.Update(team); try { await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } catch (Exception ex) { if (ex.InnerException.Message.Contains("duplicate")) { ModelState.AddModelError(string.Empty, "Already there is a record with the same name."); } else { ModelState.AddModelError(string.Empty, ex.InnerException.Message); } } } return(View(model)); }
public async Task <IActionResult> Edit(int id, TeamEntity teamEntity) { if (id != teamEntity.Id) { return(NotFound()); } if (ModelState.IsValid) { _context.Update(teamEntity); try { await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } catch (Exception ex) { if (ex.InnerException.Message.Contains("duplicate")) { ModelState.AddModelError(string.Empty, $"there is Already a team with the same name:{teamEntity.Name}."); } else { ModelState.AddModelError(string.Empty, ex.InnerException.Message); } } } return(View(teamEntity)); }
private TeamEntity CreateTeam(TeamEntryType frenoyTeam) { var team = new TeamEntity(); team.Competition = _settings.Competition.ToString(); team.ReeksType = _settings.DivisionType; team.Year = _settings.Year; team.LinkId = $"{frenoyTeam.DivisionId}_{frenoyTeam.Team}"; if (_isVttl) { var teamRegexMatch = VttlDivisionRegex.Match(frenoyTeam.DivisionName); team.ReeksNummer = teamRegexMatch.Groups[1].Value; team.ReeksCode = teamRegexMatch.Groups[2].Value; } else { var teamRegexMatch = SportaDivisionRegex.Match(frenoyTeam.DivisionName.Trim()); team.ReeksNummer = teamRegexMatch.Groups[1].Value; team.ReeksCode = teamRegexMatch.Groups[2].Value; } team.FrenoyDivisionId = int.Parse(frenoyTeam.DivisionId); team.FrenoyTeamId = frenoyTeam.TeamId; team.TeamCode = frenoyTeam.Team; return(team); }
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,LogoPath")] TeamEntity teamEntity) { if (id != teamEntity.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(teamEntity); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!TeamEntityExists(teamEntity.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(teamEntity)); }
private async Task SyncTeamsAndMatches(GetClubTeamsResponse frenoyTeams) { foreach (var frenoyTeam in frenoyTeams.TeamEntries) { // Create new division for each team in the club // Check if it already exists: Two teams could play in the same division TeamEntity teamEntity = _db.Teams.SingleOrDefault(x => x.FrenoyDivisionId.ToString() == frenoyTeam.DivisionId && x.TeamCode == frenoyTeam.Team); if (teamEntity == null) { teamEntity = CreateTeam(frenoyTeam); _db.Teams.Add(teamEntity); await CommitChanges(); // Create the teams in the new division=reeks var frenoyDivision = await _frenoy.GetDivisionRankingAsync(new GetDivisionRankingRequest { DivisionId = frenoyTeam.DivisionId }); foreach (var frenoyTeamsInDivision in frenoyDivision.GetDivisionRankingResponse.RankingEntries.Where(x => ExtractTeamCodeFromFrenoyName(x.Team) != frenoyTeam.Team || !IsOwnClub(x.TeamClub))) { var teamOpponent = await CreateTeamOpponent(teamEntity, frenoyTeamsInDivision); _db.TeamOpponents.Add(teamOpponent); } await CommitChanges(); } await SyncTeamMatches(teamEntity); } }
public async Task <ViewModels.View> CreateAsync(ViewModels.ViewForm view, CancellationToken ct) { if (!(await _authorizationService.AuthorizeAsync(_user, null, new ViewCreationRequirement())).Succeeded) { throw new ForbiddenException(); } var viewEntity = _mapper.Map <ViewEntity>(view); var viewAdminPermission = await _context.Permissions .Where(p => p.Key == PlayerClaimTypes.ViewAdmin.ToString()) .FirstOrDefaultAsync(ct); if (viewAdminPermission == null) { throw new EntityNotFoundException <Permission>($"{PlayerClaimTypes.ViewAdmin.ToString()} Permission not found."); } var userId = _user.GetId(); TeamEntity teamEntity = null; ViewMembershipEntity viewMembershipEntity = null; // Create an Admin team with the caller as a member if (view.CreateAdminTeam) { teamEntity = new TeamEntity() { Name = "Admin" }; teamEntity.Permissions.Add(new TeamPermissionEntity() { Permission = viewAdminPermission }); viewMembershipEntity = new ViewMembershipEntity { View = viewEntity, UserId = userId }; viewEntity.Teams.Add(teamEntity); viewEntity.Memberships.Add(viewMembershipEntity); } _context.Views.Add(viewEntity); await _context.SaveChangesAsync(ct); if (view.CreateAdminTeam) { var teamMembershipEntity = new TeamMembershipEntity { Team = teamEntity, UserId = userId, ViewMembership = viewMembershipEntity }; viewMembershipEntity.PrimaryTeamMembership = teamMembershipEntity; _context.TeamMemberships.Add(teamMembershipEntity); _context.ViewMemberships.Update(viewMembershipEntity); await _context.SaveChangesAsync(ct); } await _context.SaveChangesAsync(ct); return(await GetAsync(viewEntity.Id, ct)); }
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); }
/// <summary> /// Gets a bot turn context, and run call back function in the turn context. /// </summary> /// <param name="teamEntity">The team entity used in here to continue a conversation with a MS Teams team.</param> /// <param name="callback">The callback function.</param> /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> public async Task ContinueConversationAsync( TeamEntity teamEntity, Func <ITurnContext, Task> callback) { var serviceUrl = teamEntity.ServiceUrl; var tenantId = teamEntity.TenantId; var teamId = teamEntity.TeamId; var conversationReference = this.PrepareConversationReferenceAsync( serviceUrl, tenantId, teamId); await this.celebrationBotAdapter.ContinueConversationAsync( this.botId, conversationReference, async (turnContext, cancellationToken) => { turnContext.Activity.ChannelData = new TeamsChannelData { Team = new TeamInfo { Id = teamId, }, }; await callback.Invoke(turnContext); }, CancellationToken.None); }
//private void Init() //{ // List<AndonAlertEntity> andon = AndonFactory.GetByTime(); // for (int i = 0; i < andon.Count; i++) // { // if (GridAndon.Rows.Count < andon.Count) // GridAndon.Rows.Add(); // StationEntity Stationen = StationFactory.GetByPrimaryKey(andon[i].LOCATION_CODE); // LocationEntity location = LocationFactory.GetByMasterKey(Stationen.RMES_ID); // GridAndon.Rows[i].Cells[0].Value = andon[i].ANDON_ALERT_TIME.ToString("MM/dd/HH:mm"); // GridAndon.Rows[i].Cells[1].Value = Stationen.STATION_NAME; // // GridAndon.Rows[i].Cells[2].Value = location.LOCATION_NAME; // GridAndon.Rows[i].Cells[3].Value = andon[i].ANDON_ALERT_CONTENT.Substring(3, 4); // } //} private void Init() { //textBox.Text = "123"; List <AndonAlertEntity> andon = AndonFactory.GetByTime(); string string1 = "";//, string2, string3; string string2 = ""; string string3 = ""; string string4 = ""; string str1 = ""; string[] str = new string[] { "", "", "" }; for (int i = 0; i < andon.Count; i++) { StationEntity Stationen = StationFactory.GetByPrimaryKey(andon[i].LOCATION_CODE); LocationEntity location = LocationFactory.GetByMasterKey(Stationen.RMES_ID); TeamEntity team = TeamFactory.GetByTeamCode(andon[i].TEAM_CODE); string1 = andon[i].ANDON_ALERT_TIME.ToString("MM/dd/HH:mm"); string2 = Stationen.STATION_NAME; string3 = team.TEAM_NAME; string4 = andon[i].ANDON_ALERT_CONTENT.ToString(); str[i] = string1 + " ," + string2 + string3 + string4; str1 = str1 + str[i] + "\r\n"; textBox.Text = str1; } }
public async Task MatchTime_Must_Be_Set(TimeSpan?matchTime, bool isEditable, bool mustBeSet, bool expected) { var team = new TeamEntity { MatchTime = matchTime, MatchDayOfWeek = 1 }; _tenantContext.TournamentContext.TeamRuleSet = new TeamRules { HomeMatchTime = new HomeMatchTime { IsEditable = isEditable, MustBeSet = mustBeSet } }; var tv = new TeamValidator(team, _tenantContext); var factResult = await tv.CheckAsync(TeamValidator.FactId.MatchDayOfWeekAndTimeIsSet, CancellationToken.None); Assert.Multiple(() => { Assert.AreEqual(factResult.Enabled, isEditable && mustBeSet); if (factResult.Enabled) { Assert.AreEqual(matchTime.HasValue, factResult.Success); } Assert.IsNull(factResult.Exception); }); }
public TeamEntity MapToTeamEntity(TeamDataDTO source, TeamEntity target = null) { if (source == null) { return(null); } if (target == null) { target = DefaultGet <TeamEntity>(source.Keys); } if (MapToRevision(source, target) == false) { return(target); } target.Name = source.Name; target.Profile = source.Profile; target.TeamColor = source.TeamColor; target.TeamHomepage = source.TeamHomepage; if (target.Members == null) { target.Members = new List <LeagueMemberEntity>(); } MapCollection(source.MemberIds .Select(x => new LeagueMemberInfoDTO() { MemberId = x }), target.Members, GetMemberEntity, x => x.Keys, removeFromCollection: true); return(target); }
public async Task DayOfWeek_Must_Be_Set(DayOfWeek?dayOfWeek, bool isEditable, bool mustBeSet, bool expected) { var team = new TeamEntity { MatchDayOfWeek = dayOfWeek.HasValue ? (int)dayOfWeek : default(int?), MatchTime = new TimeSpan(18, 0, 0) }; _tenantContext.TournamentContext.TeamRuleSet = new TeamRules { HomeMatchTime = new HomeMatchTime { IsEditable = isEditable, MustBeSet = mustBeSet, } }; var tv = new TeamValidator(team, _tenantContext); var factResult = await tv.CheckAsync(TeamValidator.FactId.DayOfWeekWithinRange, CancellationToken.None); Assert.Multiple(() => { Assert.AreEqual(factResult.Enabled, isEditable && mustBeSet); if (factResult.Enabled) { Assert.AreEqual(expected, factResult.Success); } Assert.IsNull(factResult.Exception); }); }
public async Task Add_Remove_To_Implicit_Roles() { const string email = "*****@*****.**"; var team = new TeamEntity { Name = "Fancy Team" }; var userEntity = new UserEntity { Email = email, UserName = "******" }; userEntity.PlayerInTeams.Add(new PlayerInTeamEntity { User = userEntity, Team = team }); userEntity.ManagerOfTeams.Add(new ManagerOfTeamEntity { User = userEntity, Team = team }); await _appDb.GenericRepository.SaveEntityAsync(userEntity, true, true, CancellationToken.None); var user = await _userStore.FindByEmailAsync(email, CancellationToken.None); Assert.IsTrue(await _userStore.IsInRoleAsync(user, Constants.RoleName.Player, CancellationToken.None)); Assert.IsTrue(await _userStore.IsInRoleAsync(user, Constants.RoleName.TeamManager, CancellationToken.None)); Assert.IsTrue((await _userStore.GetUsersInRoleAsync(Constants.RoleName.Player, CancellationToken.None)).Count == 1); Assert.IsTrue((await _userStore.GetUsersInRoleAsync(Constants.RoleName.TeamManager, CancellationToken.None)).Count == 1); await _appDb.GenericRepository.DeleteEntitiesUsingConstraintAsync <PlayerInTeamEntity>(null, CancellationToken.None); await _appDb.GenericRepository.DeleteEntitiesUsingConstraintAsync <ManagerOfTeamEntity>(null, CancellationToken.None); Assert.IsFalse(await _userStore.IsInRoleAsync(user, Constants.RoleName.Player, CancellationToken.None)); Assert.IsFalse(await _userStore.IsInRoleAsync(user, Constants.RoleName.TeamManager, CancellationToken.None)); }
public async Task Unique(string teamName, long teamId, bool expected) { var team = new TeamEntity { Name = teamName, Id = teamId }; _tenantContext.TournamentContext.TeamRuleSet = new TeamRules { HomeMatchTime = new HomeMatchTime { } }; var tv = new TeamValidator(team, _tenantContext); var factResult = await tv.CheckAsync(TeamValidator.FactId.TeamNameIsUnique, CancellationToken.None); Assert.Multiple(() => { Assert.AreEqual(factResult.Enabled, teamName != null); Assert.AreEqual(expected, factResult.Success); if (factResult.Enabled && !factResult.Success) { Assert.IsTrue(factResult.Message.Contains(teamName ?? string.Empty)); } Assert.IsNull(factResult.Exception); }); }
public async Task <IEnumerable <Permission> > GetByTeamIdForUserAsync(Guid teamId, Guid userId) { var userQuery = _context.Users .Include(u => u.Role.Permissions) .Where(u => u.Id == userId) .Future(); var teamQuery = _context.Teams .Where(t => t.Id == teamId) .Future(); UserEntity user = (await userQuery.ToListAsync()).FirstOrDefault(); TeamEntity team = (await teamQuery.ToListAsync()).FirstOrDefault(); if (user == null) { throw new EntityNotFoundException <User>(); } if (team == null) { throw new EntityNotFoundException <Team>(); } if (!(await _authorizationService.AuthorizeAsync(_user, null, new SameUserOrExerciseAdminRequirement(team.ExerciseId, userId))).Succeeded) { throw new ForbiddenException(); } return(await GetPermissions(team.ExerciseId, user)); }
public async Task <ActionResult <TeamEntity> > PostTeamEntity(TeamEntity teamEntity) { _context.Teams.Add(teamEntity); await _context.SaveChangesAsync(); return(CreatedAtAction("GetTeamEntity", new { id = teamEntity.Id }, teamEntity)); }
/// <summary> /// Overriding to send welcome card once Bot/ME is installed in team. /// </summary> /// <param name="membersAdded">A list of all the members added to the conversation, as described by the conversation update activity.</param> /// <param name="turnContext">Provides context for a turn of a bot.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param> /// <returns>Welcome card when bot is added first time by user.</returns> protected override async Task OnMembersAddedAsync(IList <ChannelAccount> membersAdded, ITurnContext <IConversationUpdateActivity> turnContext, CancellationToken cancellationToken) { turnContext = turnContext ?? throw new ArgumentNullException(nameof(turnContext)); var activity = turnContext.Activity; this.logger.LogInformation($"conversationType: {activity.Conversation?.ConversationType}, membersAdded: {membersAdded?.Count}"); if (membersAdded.Where(member => member.Id == activity.Recipient.Id).FirstOrDefault() != null) { this.logger.LogInformation($"Bot added {activity.Conversation.Id}"); await turnContext.SendActivityAsync(MessageFactory.Attachment(WelcomeCard.GetCard(this.appBaseUrl, this.localizer)), cancellationToken); } var teamsDetails = turnContext.Activity.TeamsGetTeamInfo(); TeamEntity teamEntity = new TeamEntity { TeamId = teamsDetails.Id, BotInstalledOn = DateTime.UtcNow, ServiceUrl = turnContext.Activity.ServiceUrl, }; bool operationStatus = await this.teamStorageProvider.StoreOrUpdateTeamDetailAsync(teamEntity); if (!operationStatus) { this.logger.LogInformation($"Unable to store bot installed detail in table storage."); } }
public async Task<IActionResult> PutTeamEntity([FromRoute] int id, [FromBody] TeamEntity teamEntity) { if (!ModelState.IsValid) { return BadRequest(ModelState); } if (id != teamEntity.Id) { return BadRequest(); } _context.Entry(teamEntity).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!TeamEntityExists(id)) { return NotFound(); } else { throw; } } return NoContent(); }
/// <summary> /// Method to send welcome card once Bot is installed in personal/team scope. /// </summary> /// <param name="membersAdded">A list of all the members added to the conversation, as described by the conversation update activity.</param> /// <param name="turnContext">Provides context for a turn of a bot.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param> /// <returns>Returns a task.</returns> public async Task SendWelcomeNotificationAsync( IList <ChannelAccount> membersAdded, ITurnContext <IConversationUpdateActivity> turnContext, CancellationToken cancellationToken) { var activity = turnContext?.Activity; if (membersAdded.Any(member => member.Id == activity.Recipient.Id) && activity.Conversation.ConversationType == CardConstants.PersonalConversationType) { await this.SendPersonalNotificationAsync(turnContext, cancellationToken); } // Check it is not the member that is adding to the conversation. else if (membersAdded.Any(member => member.AadObjectId == null) && activity.Conversation.ConversationType == CardConstants.ChannelConversationType) { // Storing team information to storage var teamsDetails = activity.TeamsGetTeamInfo(); TeamEntity teamEntity = new TeamEntity { TeamId = teamsDetails.Id, ServiceUrl = turnContext.Activity.ServiceUrl, Name = teamsDetails.Name, InstalledByAadObjectId = turnContext.Activity.From.AadObjectId, AadGroupId = teamsDetails.AadGroupId, }; // Check whether the team id is human resource manager team. var teamWelcomeCardAttachment = this.botOptions.Value.HumanResourceTeamId == teamsDetails.Id ? this.welcomeCardFactory.GetHumanResourceWelcomeCard() : this.welcomeCardFactory.GetTeamWelcomeCard(); await this.teamStorageProvider.StoreOrUpdateTeamDetailAsync(teamEntity); await turnContext.SendActivityAsync(MessageFactory.Attachment(teamWelcomeCardAttachment)); } }
/// <summary> /// Send a welcome card if bot is installed in Team scope. /// </summary> /// <param name="turnContext">Provides context for a turn in a bot.</param> /// <returns>A task that represents a response.</returns> private async Task HandleMemberAddedInTeamAsync(ITurnContext <IConversationUpdateActivity> turnContext) { turnContext = turnContext ?? throw new ArgumentNullException(nameof(turnContext)); var userWelcomeCardAttachment = WelcomeCard.GetWelcomeCardAttachmentForTeam(this.botOptions.Value.AppBaseUri, localizer: this.localizer); await turnContext.SendActivityAsync(MessageFactory.Attachment(userWelcomeCardAttachment)); var activity = turnContext.Activity; this.logger.LogInformation($"Bot added in team {turnContext.Activity.Conversation.Id}"); // Storing team information to storage var teamsDetails = activity.TeamsGetTeamInfo(); TeamEntity teamEntity = new TeamEntity { TeamId = teamsDetails.Id, BotInstalledOn = DateTime.UtcNow, ServiceUrl = activity.ServiceUrl, }; bool operationStatus = await this.teamStorageProvider.UpsertTeamDetailAsync(teamEntity); if (!operationStatus) { this.logger.LogInformation($"Unable to store bot installation state in storage."); } }
public Team ToTeam(TeamEntity teamEntity) { Sport teamSport = sportConverter.ToSport(teamEntity.Sport); Team convertedTeam = new Team(teamEntity.TeamNumber, teamEntity.Name, teamEntity.Photo, teamSport); return(convertedTeam); }
protected WeeklyProgrammeMatchEntity(SerializationInfo info, StreamingContext context) : base(info, context) { if (SerializationHelper.Optimization != SerializationOptimization.Fast) { _team_ = (TeamEntity)info.GetValue("_team_", typeof(TeamEntity)); if (_team_ != null) { _team_.AfterSave += new EventHandler(OnEntityAfterSave); } _team = (TeamEntity)info.GetValue("_team", typeof(TeamEntity)); if (_team != null) { _team.AfterSave += new EventHandler(OnEntityAfterSave); } _weeklyProgrammeDay = (WeeklyProgrammeDayEntity)info.GetValue("_weeklyProgrammeDay", typeof(WeeklyProgrammeDayEntity)); if (_weeklyProgrammeDay != null) { _weeklyProgrammeDay.AfterSave += new EventHandler(OnEntityAfterSave); } base.FixupDeserialization(FieldInfoProviderSingleton.GetInstance()); } // __LLBLGENPRO_USER_CODE_REGION_START DeserializationConstructor // __LLBLGENPRO_USER_CODE_REGION_END }
private void AddAndRemovePlayersInTeam(Team teamToUpdated, TeamEntity entityToUpdate) { var playersInTeamToUpdate = teamToUpdated.Roster.Select(p => p.Id); var playersInEntityToUpdate = entityToUpdate.Players.Select(p => p.Id); var playersToAdd = playersInTeamToUpdate.Except(playersInEntityToUpdate); var playersToRemove = playersInEntityToUpdate.Except(playersInTeamToUpdate); var playersIds = playersToAdd.Union(playersToRemove).ToList(); var playerEntities = _unitOfWork.Context.Players .Where(p => playersIds.Contains(p.Id)); foreach (var player in playerEntities) { if (playersToAdd.Contains(player.Id)) { player.TeamId = entityToUpdate.Id; } if (playersToRemove.Contains(player.Id)) { player.TeamId = null; } } }