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;
}
}
}
