/// <summary>
/// 取得車隊資訊
/// </summary>
/// <param name="teamCommand">teamCommand</param>
/// <returns>Tuple(TeamInfoDto, string)</returns>
public async Task <Tuple <TeamInfoDto, string> > GetTeamInfo(TeamCommandDto teamCommand)
{
try
{
bool verifyTeamCommandResult = this.VerifyTeamCommand(teamCommand, false, true, false, false, false, false);
if (!verifyTeamCommandResult)
{
this.logger.LogError($"Get Team Info Fail For Verify TeamCommand >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID}");
return(Tuple.Create <TeamInfoDto, string>(null, "取得車隊資訊失敗."));
}
TeamData teamData = await this.teamRepository.GetTeamData(teamCommand.TeamID);
if (teamData == null)
{
return(Tuple.Create <TeamInfoDto, string>(null, "車隊不存在."));
}
if (teamData.TeamBlacklistIDs.Contains(teamCommand.TargetID))
{
return(Tuple.Create <TeamInfoDto, string>(null, "會員已被車隊設為黑名單."));
}
TeamInfoDto teamInfo = await this.OnTransformTeamDataNews(teamData, teamCommand.TargetID);
return(Tuple.Create(teamInfo, string.Empty));
}
catch (Exception ex)
{
this.logger.LogError($"Get Team Info Error >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID}\n{ex}");
return(Tuple.Create <TeamInfoDto, string>(null, "取得車隊資訊發生錯誤."));
}
}
public async Task <IActionResult> Post(TeamCommandDto teamCommand)
{
try
{
string result = await this.announcementService.DeleteAnnouncementListOfTeam(teamCommand);
if (string.IsNullOrEmpty(result))
{
result = await this.eventService.DeleteEventListOfTeam(teamCommand);
if (string.IsNullOrEmpty(result))
{
result = await this.teamService.DisbandTeam(teamCommand);
if (string.IsNullOrEmpty(result))
{
return(Ok("解散車隊成功."));
}
}
}
return(BadRequest(result));
}
catch (Exception ex)
{
this.logger.LogError($"Disband Team Error >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID}\n{ex}");
return(BadRequest("解散車隊發生錯誤."));
}
}
/// <summary>
/// 編輯活動
/// </summary>
/// <param name="teamCommand">teamCommand</param>
/// <returns>string</returns>
public async Task <string> EditEvent(TeamCommandDto teamCommand)
{
try
{
bool verifyTeamCommandResult = this.VerifyTeamCommand(teamCommand, false, true, false, false, false, true);
if (!verifyTeamCommandResult)
{
this.logger.LogError($"Edit Event Fail For Verify TeamCommand >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID} EventInfo:{JsonConvert.SerializeObject(teamCommand.EventInfo)}");
return("編輯活動失敗.");
}
if (string.IsNullOrEmpty(teamCommand.EventInfo.EventID))
{
return("活動編號無效.");
}
EventData eventData = await this.eventRepository.GetEventData(teamCommand.EventInfo.EventID);
if (eventData == null)
{
return("活動不存在.");
}
TeamData teamData = await this.teamRepository.GetTeamData(teamCommand.TeamID);
if (teamData == null)
{
return("車隊不存在.");
}
bool verifyEventExaminerAuthorityResult = this.VerifyEventExaminerAuthority(teamData, eventData, teamCommand.TargetID);
if (!verifyEventExaminerAuthorityResult)
{
this.logger.LogError($"Edit Event Fail For Verify Event Examiner Authority >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID} EventID:{teamCommand.EventInfo.EventID}");
return("編輯活動失敗.");
}
string updateEventDataHandlerReault = this.UpdateEventDataHandler(teamCommand.EventInfo, eventData);
if (!string.IsNullOrEmpty(updateEventDataHandlerReault))
{
return(updateEventDataHandlerReault);
}
bool updateEventDataResult = await this.eventRepository.UpdateEventData(eventData);
if (!updateEventDataResult)
{
return("活動資料更新失敗.");
}
return(string.Empty);
}
catch (Exception ex)
{
this.logger.LogError($"Edit Event Error >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID} EventInfo:{JsonConvert.SerializeObject(teamCommand.EventInfo)}\n{ex}");
return("編輯活動發生錯誤.");
}
}
/// <summary>
/// 邀請加入車隊
/// </summary>
/// <param name="teamCommand">teamCommand</param>
/// <returns>string</returns>
public async Task <string> InviteJoinTeam(TeamCommandDto teamCommand)
{
try
{
bool verifyTeamCommandResult = this.VerifyTeamCommand(teamCommand, true, true, false, false, false, false);
if (!verifyTeamCommandResult)
{
this.logger.LogError($"Invite Join Team Fail For Verify TeamCommand >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} TargetID:{teamCommand.TargetID}");
return("邀請加入車隊失敗.");
}
TeamData teamData = await this.teamRepository.GetTeamData(teamCommand.TeamID);
if (teamData == null)
{
return("車隊不存在.");
}
if (teamData.TeamApplyForJoinIDs.Contains(teamCommand.TargetID))
{
return("該會員已提出申請加入請求.");
}
bool verifyJoinTeamQualificationResult = this.VerifyJoinTeamQualification(teamData, teamCommand.TargetID);
if (!verifyJoinTeamQualificationResult)
{
return("邀請加入車隊失敗.");
}
bool verifyTeamExaminerAuthorityResult = this.VerifyTeamExaminerAuthority(teamData, teamCommand.ExaminerID, false, true, teamCommand.TargetID);
if (!verifyTeamExaminerAuthorityResult)
{
this.logger.LogError($"Invite Join Team Fail For Verify Team Examiner Authority >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} TargetID:{teamCommand.TargetID}");
return("邀請加入車隊失敗.");
}
bool updateTeamInviteJoinIDsResult = Utility.UpdateListHandler(teamData.TeamInviteJoinIDs, teamCommand.TargetID, true);
if (updateTeamInviteJoinIDsResult)
{
bool result = await this.teamRepository.UpdateTeamInviteJoinIDs(teamData.TeamID, teamData.TeamInviteJoinIDs);
if (!result)
{
return("邀請加入名單資料更新失敗.");
}
}
return(string.Empty);
}
catch (Exception ex)
{
this.logger.LogError($"Invite Join Team Error >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} TargetID:{teamCommand.TargetID}\n{ex}");
return("邀請加入車隊發生錯誤.");
}
}
/// <summary>
/// 更新車隊隊長
/// </summary>
/// <param name="teamCommand">teamCommand</param>
/// <returns>string</returns>
public async Task <string> UpdateTeamLeader(TeamCommandDto teamCommand)
{
try
{
bool verifyTeamCommandResult = this.VerifyTeamCommand(teamCommand, true, true, false, false, false, false);
if (!verifyTeamCommandResult)
{
this.logger.LogError($"Update Team Leader Fail For Verify TeamCommand >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} TargetID:{teamCommand.TargetID}");
return("更新車隊隊長失敗.");
}
TeamData teamData = await this.teamRepository.GetTeamData(teamCommand.TeamID);
if (teamData == null)
{
return("車隊不存在.");
}
bool verifyTeamExaminerAuthorityResult = this.VerifyTeamExaminerAuthority(teamData, teamCommand.ExaminerID, true, true, teamCommand.TargetID);
if (!verifyTeamExaminerAuthorityResult)
{
this.logger.LogError($"Update Team Leader Fail For Verify Team Examiner Authority >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} TargetID:{teamCommand.TargetID}");
return("更新車隊隊長失敗.");
}
if (!teamData.TeamPlayerIDs.Contains(teamCommand.TargetID))
{
return("會員未加入車隊.");
}
bool isMultipleTeam = await this.teamRepository.VerifyTeamDataByTeamLeaderID(teamCommand.TargetID);
if (isMultipleTeam)
{
return("無法指定其他車隊隊長.");
}
Utility.UpdateListHandler(teamData.TeamPlayerIDs, teamData.TeamLeaderID, true);
Utility.UpdateListHandler(teamData.TeamPlayerIDs, teamCommand.TargetID, false);
teamData.TeamLeaderID = teamCommand.TargetID;
bool updateTeamDataResult = await this.teamRepository.UpdateTeamData(teamData);
if (!updateTeamDataResult)
{
return("車隊資料更新失敗.");
}
return(string.Empty);
}
catch (Exception ex)
{
this.logger.LogError($"Update Team Leader Error >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} TargetID:{teamCommand.TargetID}\n{ex}");
return("更新車隊隊長發生錯誤.");
}
}
/// <summary>
/// 加入活動
/// </summary>
/// <param name="teamCommand">teamCommand</param>
/// <returns>string</returns>
public async Task <string> JoinEvent(TeamCommandDto teamCommand)
{
try
{
bool verifyTeamCommandResult = this.VerifyTeamCommand(teamCommand, false, true, false, false, false, true);
if (!verifyTeamCommandResult)
{
this.logger.LogError($"Join Event Fail For Verify TeamCommand >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID} EventID:{(teamCommand.EventInfo != null ? teamCommand.EventInfo.EventID : "Null")}");
return("加入活動失敗.");
}
if (string.IsNullOrEmpty(teamCommand.EventInfo.EventID))
{
return("活動編號無效.");
}
EventData eventData = await this.eventRepository.GetEventData(teamCommand.EventInfo.EventID);
if (eventData == null)
{
return("活動不存在.");
}
TeamData teamData = await this.teamRepository.GetTeamData(teamCommand.TeamID);
if (teamData == null)
{
return("車隊不存在.");
}
if (!teamData.TeamLeaderID.Equals(teamCommand.TargetID) && !teamData.TeamPlayerIDs.Contains(teamCommand.TargetID))
{
return("該會員非車隊隊員.");
}
bool updateJoinMemberListResult = Utility.UpdateListHandler(eventData.JoinMemberList, teamCommand.TargetID, true);
if (updateJoinMemberListResult)
{
bool result = await this.eventRepository.UpdateJoinMemberList(eventData.EventID, eventData.JoinMemberList);
if (!result)
{
return("活動參加名單資料更新失敗.");
}
}
return(string.Empty);
}
catch (Exception ex)
{
this.logger.LogError($"Join Event Error >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID} EventID:{(teamCommand.EventInfo != null ? teamCommand.EventInfo.EventID : "Null")}\n{ex}");
return("加入活動發生錯誤.");
}
}
/// <summary>
/// 取得活動詳細資訊
/// </summary>
/// <param name="teamCommand">teamCommand</param>
/// <returns>Tuple(EventDetailInfoDto, string)</returns>
public async Task <Tuple <EventDetailInfoDto, string> > GetEventDetailInfo(TeamCommandDto teamCommand)
{
try
{
bool verifyTeamCommandResult = this.VerifyTeamCommand(teamCommand, false, true, false, false, false, true);
if (!verifyTeamCommandResult)
{
this.logger.LogError($"Get Event Detail Info Fail For Verify TeamCommand >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID} EventID:{(teamCommand.EventInfo != null ? teamCommand.EventInfo.EventID : "Null")}");
return(Tuple.Create <EventDetailInfoDto, string>(null, "取得活動詳細資訊失敗."));
}
if (string.IsNullOrEmpty(teamCommand.EventInfo.EventID))
{
return(Tuple.Create <EventDetailInfoDto, string>(null, "活動編號無效."));
}
EventData eventData = await this.eventRepository.GetEventData(teamCommand.EventInfo.EventID);
if (eventData == null)
{
return(Tuple.Create <EventDetailInfoDto, string>(null, "活動不存在."));
}
TeamData teamData = await this.teamRepository.GetTeamData(teamCommand.TeamID);
if (teamData == null)
{
return(Tuple.Create <EventDetailInfoDto, string>(null, "車隊不存在."));
}
if (!teamData.TeamLeaderID.Equals(teamCommand.TargetID) && !teamData.TeamPlayerIDs.Contains(teamCommand.TargetID))
{
return(Tuple.Create <EventDetailInfoDto, string>(null, "該會員非車隊隊員."));
}
bool updateHaveSeenMemberIDsResult = Utility.UpdateListHandler(eventData.HaveSeenMemberIDs, teamCommand.TargetID, true);
if (updateHaveSeenMemberIDsResult)
{
//// 無須對【已閱活動名單資料】作審查，不應影響原功能
bool result = await this.eventRepository.UpdateHaveSeenMemberIDs(teamData.TeamID, eventData.HaveSeenMemberIDs);
}
EventDetailInfoDto eventDetailInfo = this.mapper.Map <EventDetailInfoDto>(eventData);
eventDetailInfo.TeamName = teamData.TeamName;
eventDetailInfo.TeamPhoto = teamData.TeamPhoto;
return(Tuple.Create(eventDetailInfo, string.Empty));
}
catch (Exception ex)
{
this.logger.LogError($"Get Event Detail Info Error >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID} EventID:{(teamCommand.EventInfo != null ? teamCommand.EventInfo.EventID : "Null")}\n{ex}");
return(Tuple.Create <EventDetailInfoDto, string>(null, "取得活動詳細資訊發生錯誤."));
}
}
/// <summary>
/// 刪除活動
/// </summary>
/// <param name="teamCommand">teamCommand</param>
/// <returns>string</returns>
public async Task <string> DeleteEvent(TeamCommandDto teamCommand)
{
try
{
bool verifyTeamCommandResult = this.VerifyTeamCommand(teamCommand, false, true, false, false, false, true);
if (!verifyTeamCommandResult)
{
this.logger.LogError($"Delete Event Fail For Verify TeamCommand >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID} EventID:{(teamCommand.EventInfo != null ? teamCommand.EventInfo.EventID : "Null")}");
return("刪除活動失敗.");
}
if (string.IsNullOrEmpty(teamCommand.EventInfo.EventID))
{
return("活動編號無效.");
}
TeamData teamData = await this.teamRepository.GetTeamData(teamCommand.TeamID);
if (teamData == null)
{
return("車隊不存在.");
}
EventData eventData = await this.eventRepository.GetEventData(teamCommand.EventInfo.EventID);
if (eventData == null)
{
return("活動不存在.");
}
bool verifyEventExaminerAuthorityResult = this.VerifyEventExaminerAuthority(teamData, eventData, teamCommand.TargetID);
if (!verifyEventExaminerAuthorityResult)
{
this.logger.LogError($"Delete Event Fail For Verify Event Examiner Authority >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID} EventID:{teamCommand.EventInfo.EventID}");
return("刪除活動失敗.");
}
bool deleteEventDataResult = await this.eventRepository.DeleteEventData(teamCommand.EventInfo.EventID);
if (!deleteEventDataResult)
{
return("刪除活動失敗.");
}
return(string.Empty);
}
catch (Exception ex)
{
this.logger.LogError($"Delete Event Error >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID} EventID:{(teamCommand.EventInfo != null ? teamCommand.EventInfo.EventID : "Null")}\n{ex}");
return("刪除活動發生錯誤.");
}
}
/// <summary>
/// 邀請多人加入車隊
/// </summary>
/// <param name="teamCommand">teamCommand</param>
/// <returns>string</returns>
public async Task <string> InviteManyJoinTeam(TeamCommandDto teamCommand)
{
try
{
bool verifyTeamCommandResult = this.VerifyTeamCommand(teamCommand, true, false, true, false, false, false);
if (!verifyTeamCommandResult)
{
this.logger.LogError($"Invite Many Join Team Fail For Verify TeamCommand >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} TargetIDs:{JsonConvert.SerializeObject(teamCommand.TargetIDs)}");
return("邀請多人加入車隊失敗.");
}
TeamData teamData = await this.teamRepository.GetTeamData(teamCommand.TeamID);
if (teamData == null)
{
return("車隊不存在.");
}
bool verifyTeamExaminerAuthorityResult = this.VerifyTeamExaminerAuthority(teamData, teamCommand.ExaminerID, false, false, string.Empty);
if (!verifyTeamExaminerAuthorityResult)
{
this.logger.LogError($"Invite Many Join Team Fail For Verify Team Examiner Authority >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID}");
return("邀請多人加入車隊失敗.");
}
IEnumerable <string> teamApplyForJoinIDs = teamData.TeamApplyForJoinIDs;
IEnumerable <string> targetIDs = teamCommand.TargetIDs;
IEnumerable <string> validTargetIDs = targetIDs.Where(targetID => this.VerifyJoinTeamQualification(teamData, targetID) && !teamApplyForJoinIDs.Contains(targetID));
if (!validTargetIDs.Any())
{
return("無會員名單可邀請加入車隊.");
}
bool updateTeamInviteJoinIDsResult = Utility.UpdateListHandler(teamData.TeamInviteJoinIDs, validTargetIDs, true);
if (updateTeamInviteJoinIDsResult)
{
bool result = await this.teamRepository.UpdateTeamInviteJoinIDs(teamData.TeamID, teamData.TeamInviteJoinIDs);
if (!result)
{
return("邀請加入名單資料更新失敗.");
}
}
return(string.Empty);
}
catch (Exception ex)
{
this.logger.LogError($"Invite Many Join Team Error >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} TargetIDs:{JsonConvert.SerializeObject(teamCommand.TargetIDs)}\n{ex}");
return("邀請多人加入車隊發生錯誤.");
}
}
/// <summary>
/// 發佈公告
/// </summary>
/// <param name="teamCommand">teamCommand</param>
/// <returns>string</returns>
public async Task <string> PublishAnnouncement(TeamCommandDto teamCommand)
{
try
{
bool verifyTeamCommandResult = this.VerifyTeamCommand(teamCommand, true, false, false, false, true, false);
if (!verifyTeamCommandResult)
{
this.logger.LogError($"Publish Announcement Fail For Verify TeamCommand >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} AnnouncementInfo:{JsonConvert.SerializeObject(teamCommand.AnnouncementInfo)}");
return("發佈公告失敗.");
}
TeamData teamData = await this.teamRepository.GetTeamData(teamCommand.TeamID);
if (teamData == null)
{
return("車隊不存在.");
}
bool verifyTeamExaminerAuthorityResult = this.VerifyTeamExaminerAuthority(teamData, teamCommand.ExaminerID, false, false, string.Empty);
if (!verifyTeamExaminerAuthorityResult)
{
this.logger.LogError($"Publish Announcement Fail For Verify Team Examiner Authority >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} TargetID:{teamCommand.TargetID}");
return("發佈公告失敗.");
}
Tuple <AnnouncementData, string> createAnnouncementDataResult = this.CreateAnnouncementData(teamCommand.TeamID, teamCommand.ExaminerID, teamCommand.AnnouncementInfo);
if (!string.IsNullOrEmpty(createAnnouncementDataResult.Item2))
{
return(createAnnouncementDataResult.Item2);
}
AnnouncementData announcementData = createAnnouncementDataResult.Item1;
bool isSuccess = await this.announcementRepository.CreateAnnouncementData(announcementData);
if (!isSuccess)
{
return("發佈公告失敗.");
}
//// 無須對【已閱公告名單資料】作審查，不應影響原功能
bool updateHaveSeenAnnouncementMemberIDsResult = await this.teamRepository.UpdateHaveSeenAnnouncementMemberIDs(teamData.TeamID, new List <string>());
return(string.Empty);
}
catch (Exception ex)
{
this.logger.LogError($"Publish Announcement Error >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} AnnouncementInfo:{JsonConvert.SerializeObject(teamCommand.AnnouncementInfo)}\n{ex}");
return("發佈公告發生錯誤.");
}
}
/// <summary>
/// 申請加入車隊
/// </summary>
/// <param name="teamCommand">teamCommand</param>
/// <returns>string</returns>
public async Task <string> ApplyForJoinTeam(TeamCommandDto teamCommand)
{
try
{
bool verifyTeamCommandResult = this.VerifyTeamCommand(teamCommand, false, true, false, false, false, false);
if (!verifyTeamCommandResult)
{
this.logger.LogError($"Apply For Join Team Fail For Verify TeamCommand >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID}");
return("申請加入車隊失敗.");
}
TeamData teamData = await this.teamRepository.GetTeamData(teamCommand.TeamID);
if (teamData == null)
{
return("車隊不存在.");
}
if (teamData.TeamExamineStatus == (int)TeamExamineStatusType.Close)
{
return(await this.JoinTeam(teamCommand, false));
}
bool verifyJoinTeamQualificationResult = this.VerifyJoinTeamQualification(teamData, teamCommand.TargetID);
if (!verifyJoinTeamQualificationResult)
{
return("申請加入車隊失敗.");
}
bool updateTeamPlayerIDsResult = Utility.UpdateListHandler(teamData.TeamApplyForJoinIDs, teamCommand.TargetID, true);
bool updateTeamInviteJoinIDsResult = Utility.UpdateListHandler(teamData.TeamInviteJoinIDs, teamCommand.TargetID, false);
if (updateTeamPlayerIDsResult || updateTeamInviteJoinIDsResult)
{
bool updateTeamDataResult = await this.teamRepository.UpdateTeamData(teamData);
if (!updateTeamDataResult)
{
return("車隊資料更新失敗.");
}
}
return(string.Empty);
}
catch (Exception ex)
{
this.logger.LogError($"Apply For Join Team Error >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID}\n{ex}");
return("申請加入車隊發生錯誤.");
}
}
/// <summary>
/// 更新車隊副隊長
/// </summary>
/// <param name="teamCommand">teamCommand</param>
/// <param name="isAdd">isAdd</param>
/// <returns>string</returns>
public async Task <string> UpdateTeamViceLeader(TeamCommandDto teamCommand, bool isAdd)
{
try
{
bool verifyTeamCommandResult = this.VerifyTeamCommand(teamCommand, true, true, false, false, false, false);
if (!verifyTeamCommandResult)
{
this.logger.LogError($"Update Team Vice Leader Fail For Verify TeamCommand >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} TargetID:{teamCommand.TargetID}");
return("更新車隊副隊長失敗.");
}
TeamData teamData = await this.teamRepository.GetTeamData(teamCommand.TeamID);
if (teamData == null)
{
return("車隊不存在.");
}
bool verifyTeamExaminerAuthorityResult = this.VerifyTeamExaminerAuthority(teamData, teamCommand.ExaminerID, true, true, teamCommand.TargetID);
if (!verifyTeamExaminerAuthorityResult)
{
this.logger.LogError($"Update Team Vice Leader Fail For Verify Team Examiner Authority >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} TargetID:{teamCommand.TargetID}");
return("更新車隊副隊長失敗.");
}
if (isAdd && !teamData.TeamPlayerIDs.Contains(teamCommand.TargetID))
{
return("會員未加入車隊.");
}
bool updateTeamViceLeaderIDsResult = Utility.UpdateListHandler(teamData.TeamViceLeaderIDs, teamCommand.TargetID, isAdd);
if (updateTeamViceLeaderIDsResult)
{
bool result = await this.teamRepository.UpdateTeamViceLeaders(teamData.TeamID, teamData.TeamViceLeaderIDs);
if (!result)
{
return("車隊副隊長名單資料更新失敗.");
}
}
return(string.Empty);
}
catch (Exception ex)
{
this.logger.LogError($"Update Team Vice Leader Error >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} TargetID:{teamCommand.TargetID}\n{ex}");
return("更新車隊副隊長發生錯誤.");
}
}
/// <summary>
/// 離開車隊
/// </summary>
/// <param name="teamCommand">teamCommand</param>
/// <returns>string</returns>
public async Task <string> LeaveTeam(TeamCommandDto teamCommand)
{
try
{
bool verifyTeamCommandResult = this.VerifyTeamCommand(teamCommand, false, true, false, false, false, false);
if (!verifyTeamCommandResult)
{
this.logger.LogError($"Leave Team Fail For Verify TeamCommand >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID}");
return("離開車隊失敗.");
}
TeamData teamData = await this.teamRepository.GetTeamData(teamCommand.TeamID);
if (teamData == null)
{
return("車隊不存在.");
}
if (teamCommand.TargetID.Equals(teamData.TeamLeaderID))
{
return("請先移交隊長職務.");
}
if (!teamData.TeamPlayerIDs.Contains(teamCommand.TargetID))
{
return("會員未加入車隊.");
}
bool updateTeamPlayerIDsResult = Utility.UpdateListHandler(teamData.TeamPlayerIDs, teamCommand.TargetID, false);
bool updateTeamViceLeaderIDsResult = Utility.UpdateListHandler(teamData.TeamViceLeaderIDs, teamCommand.TargetID, false);
if (updateTeamPlayerIDsResult || updateTeamViceLeaderIDsResult)
{
bool updateTeamDataResult = await this.teamRepository.UpdateTeamData(teamData);
if (!updateTeamDataResult)
{
return("車隊資料更新失敗.");
}
}
return(string.Empty);
}
catch (Exception ex)
{
this.logger.LogError($"Leave Team Error >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID}\n{ex}");
return("離開車隊發生錯誤.");
}
}
/// <summary>
/// 車隊編輯
/// </summary>
/// <param name="teamCommand">teamCommand</param>
/// <returns>Tuple(TeamInfoDto, string)</returns>
public async Task <Tuple <TeamInfoDto, string> > EditData(TeamCommandDto teamCommand)
{
try
{
bool verifyTeamCommandResult = this.VerifyTeamCommand(teamCommand, true, false, false, true, false, false);
if (!verifyTeamCommandResult)
{
this.logger.LogError($"Edit Data Fail For Verify TeamCommand >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} TeamInfo:{JsonConvert.SerializeObject(teamCommand.TeamInfo)}");
return(Tuple.Create <TeamInfoDto, string>(null, "車隊編輯失敗."));
}
TeamData teamData = await this.teamRepository.GetTeamData(teamCommand.TeamID);
if (teamData == null)
{
return(Tuple.Create <TeamInfoDto, string>(null, "車隊不存在."));
}
bool verifyTeamExaminerAuthorityResult = this.VerifyTeamExaminerAuthority(teamData, teamCommand.ExaminerID, false, false, string.Empty);
if (!verifyTeamExaminerAuthorityResult)
{
this.logger.LogError($"Edit Data Fail For Verify Team Examiner Authority >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID}");
return(Tuple.Create <TeamInfoDto, string>(null, "車隊編輯失敗."));
}
string updateTeamDataHandlerReault = await this.UpdateTeamDataHandler(teamCommand.TeamInfo, teamData);
if (!string.IsNullOrEmpty(updateTeamDataHandlerReault))
{
return(Tuple.Create <TeamInfoDto, string>(null, updateTeamDataHandlerReault));
}
bool updateTeamDataResult = await this.teamRepository.UpdateTeamData(teamData);
if (!updateTeamDataResult)
{
return(Tuple.Create <TeamInfoDto, string>(null, "車隊資料更新失敗."));
}
return(Tuple.Create(this.mapper.Map <TeamInfoDto>(teamData), string.Empty));
}
catch (Exception ex)
{
this.logger.LogError($"Edit Data Error >>> Data:{JsonConvert.SerializeObject(teamCommand)}\n{ex}");
return(Tuple.Create <TeamInfoDto, string>(null, "車隊編輯發生錯誤."));
}
}
/// <summary>
/// 建立活動
/// </summary>
/// <param name="teamCommand">teamCommand</param>
/// <returns>string</returns>
public async Task <string> CreateEvent(TeamCommandDto teamCommand)
{
try
{
bool verifyTeamCommandResult = this.VerifyTeamCommand(teamCommand, false, true, false, false, false, true);
if (!verifyTeamCommandResult)
{
this.logger.LogError($"Create Event Fail For Verify TeamCommand >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID} EventInfo:{JsonConvert.SerializeObject(teamCommand.EventInfo)}");
return("建立活動失敗.");
}
TeamData teamData = await this.teamRepository.GetTeamData(teamCommand.TeamID);
if (teamData == null)
{
return("車隊不存在.");
}
if (!teamData.TeamLeaderID.Equals(teamCommand.TargetID) && !teamData.TeamPlayerIDs.Contains(teamCommand.TargetID))
{
return("該會員非車隊隊員.");
}
Tuple <EventData, string> createEventDataResult = await this.CreateEventData(teamData.TeamID, teamData.TeamName, teamCommand.TargetID, teamCommand.EventInfo);
if (!string.IsNullOrEmpty(createEventDataResult.Item2))
{
return(createEventDataResult.Item2);
}
EventData eventData = createEventDataResult.Item1;
bool isSuccess = await this.eventRepository.CreateEventData(eventData);
if (!isSuccess)
{
return("建立活動失敗.");
}
return(string.Empty);
}
catch (Exception ex)
{
this.logger.LogError($"Create Event Error >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID} EventInfo:{JsonConvert.SerializeObject(teamCommand.EventInfo)}\n{ex}");
return("建立活動發生錯誤.");
}
}
/// <summary>
/// 強制離開車隊
/// </summary>
/// <param name="teamCommand">teamCommand</param>
/// <returns>string</returns>
public async Task <string> ForceLeaveTeam(TeamCommandDto teamCommand)
{
try
{
bool verifyTeamCommandResult = this.VerifyTeamCommand(teamCommand, true, true, false, false, false, false);
if (!verifyTeamCommandResult)
{
this.logger.LogError($"Force Leave Team Fail For Verify TeamCommand >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} TargetID:{teamCommand.TargetID}");
return("強制離開車隊失敗.");
}
TeamData teamData = await this.teamRepository.GetTeamData(teamCommand.TeamID);
if (teamData == null)
{
return("車隊不存在.");
}
bool verifyTeamExaminerAuthorityResult = this.VerifyTeamExaminerAuthority(teamData, teamCommand.ExaminerID, false, true, teamCommand.TargetID);
if (!verifyTeamExaminerAuthorityResult)
{
this.logger.LogError($"Force Leave Team Fail For Verify Team Examiner Authority >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} TargetID:{teamCommand.TargetID}");
return("強制離開車隊失敗.");
}
bool updateTeamPlayerIDsResult = Utility.UpdateListHandler(teamData.TeamPlayerIDs, teamCommand.TargetID, false);
bool updateTeamViceLeaderIDsResult = Utility.UpdateListHandler(teamData.TeamViceLeaderIDs, teamCommand.TargetID, false);
if (updateTeamPlayerIDsResult || updateTeamViceLeaderIDsResult)
{
bool updateTeamDataResult = await this.teamRepository.UpdateTeamData(teamData);
if (!updateTeamDataResult)
{
return("車隊資料更新失敗.");
}
}
return(string.Empty);
}
catch (Exception ex)
{
this.logger.LogError($"Force Leave Team Error >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} TargetID:{teamCommand.TargetID}\n{ex}");
return("強制離開車隊發生錯誤.");
}
}
public async Task <IActionResult> Join(TeamCommandDto teamCommand)
{
try
{
string result = await this.interactiveService.ApplyForJoinTeam(teamCommand);
if (string.IsNullOrEmpty(result))
{
return(Ok("申請加入車隊成功."));
}
return(BadRequest(result));
}
catch (Exception ex)
{
this.logger.LogError($"Apply For Join Team Error >>> TemaID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID}\n{ex}");
return(BadRequest("申請加入車隊發生錯誤."));
}
}
public async Task <IActionResult> Get(TeamCommandDto teamCommand)
{
try
{
Tuple <IEnumerable <string>, string> result = await this.interactiveService.GetApplyForRequestList(teamCommand);
if (string.IsNullOrEmpty(result.Item2))
{
return(Ok(result.Item1));
}
return(BadRequest(result.Item2));
}
catch (Exception ex)
{
this.logger.LogError($"Get Apply For Request List Error >>> TemaID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID}\n{ex}");
return(BadRequest("取得申請加入名單發生錯誤."));
}
}
public async Task <IActionResult> Remove(TeamCommandDto teamCommand)
{
try
{
string result = await this.interactiveService.UpdateTeamViceLeader(teamCommand, false);
if (string.IsNullOrEmpty(result))
{
return(Ok("移除車隊副隊長成功."));
}
return(BadRequest(result));
}
catch (Exception ex)
{
this.logger.LogError($"Remove Team Vice Leader Error >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} TargetID:{teamCommand.TargetID}\n{ex}");
return(BadRequest("移除車隊副隊長發生錯誤."));
}
}
public async Task <IActionResult> Post(TeamCommandDto teamCommand)
{
try
{
Tuple <TeamInfoDto, string> result = await this.teamService.GetTeamInfo(teamCommand);
if (string.IsNullOrEmpty(result.Item2))
{
return(Ok(result.Item1));
}
return(BadRequest(result.Item2));
}
catch (Exception ex)
{
this.logger.LogError($"Get Team Info Error >>> TeamID:{teamCommand.TeamID}\n{ex}");
return(BadRequest("搜尋車隊資訊列表發生錯誤."));
}
}
public async Task <IActionResult> Post(TeamCommandDto teamCommand)
{
try
{
string result = await this.interactiveService.ForceLeaveTeam(teamCommand);
if (string.IsNullOrEmpty(result))
{
return(Ok("強制離開車隊成功."));
}
return(BadRequest(result));
}
catch (Exception ex)
{
this.logger.LogError($"Force Leave Team Error >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} TargetID:{teamCommand.TargetID}\n{ex}");
return(BadRequest("強制離開車隊發生錯誤."));
}
}
public async Task <IActionResult> Post(TeamCommandDto teamCommand)
{
try
{
Tuple <TeamInfoDto, string> result = await this.teamService.EditData(teamCommand);
if (string.IsNullOrEmpty(result.Item2))
{
return(Ok(result.Item1));
}
return(BadRequest(result.Item2));
}
catch (Exception ex)
{
this.logger.LogError($"Edit Data Error >>> Data:{JsonConvert.SerializeObject(teamCommand)}\n{ex}");
return(BadRequest("車隊編輯發生錯誤."));
}
}
public async Task <IActionResult> Post(TeamCommandDto teamCommand)
{
try
{
Tuple <EventDetailInfoDto, string> result = await this.eventService.GetEventDetailInfo(teamCommand);
if (string.IsNullOrEmpty(result.Item2))
{
return(Ok(result.Item1));
}
return(BadRequest(result.Item2));
}
catch (Exception ex)
{
this.logger.LogError($"Get Event Detail Info Error >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID} EventID:{(teamCommand.EventInfo != null ? teamCommand.EventInfo.EventID : "Null")}\n{ex}");
return(BadRequest("取得活動詳細資訊發生錯誤."));
}
}
public async Task <IActionResult> Post(TeamCommandDto teamCommand)
{
try
{
string result = await this.eventService.DeleteEvent(teamCommand);
if (string.IsNullOrEmpty(result))
{
return(Ok("刪除活動成功."));
}
return(BadRequest(result));
}
catch (Exception ex)
{
this.logger.LogError($"Delete Event Error >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID} EventID:{(teamCommand.EventInfo != null ? teamCommand.EventInfo.EventID : "Null")}\n{ex}");
return(BadRequest("刪除活動發生錯誤."));
}
}
public async Task <IActionResult> Post(TeamCommandDto teamCommand)
{
try
{
string result = await this.eventService.CreateEvent(teamCommand);
if (string.IsNullOrEmpty(result))
{
return(Ok("建立活動成功."));
}
return(BadRequest(result));
}
catch (Exception ex)
{
this.logger.LogError($"Create Event Error >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID} EventInfo:{JsonConvert.SerializeObject(teamCommand.EventInfo)}\n{ex}");
return(BadRequest("建立活動發生錯誤."));
}
}
public async Task <IActionResult> ManyJoin(TeamCommandDto teamCommand)
{
try
{
string result = await this.interactiveService.InviteManyJoinTeam(teamCommand);
if (string.IsNullOrEmpty(result))
{
return(Ok("邀請多人加入車隊成功."));
}
return(BadRequest(result));
}
catch (Exception ex)
{
this.logger.LogError($"Invite Many Join Team Error >>> TemaID:{teamCommand.TeamID} TargetIDs:{JsonConvert.SerializeObject(teamCommand.TargetIDs)}\n{ex}");
return(BadRequest("邀請多人加入車隊發生錯誤."));
}
}
public async Task <IActionResult> Post(TeamCommandDto teamCommand)
{
try
{
Tuple <IEnumerable <EventSimpleInfoDto>, string> result = await this.eventService.GetEventListOfTeam(teamCommand);
if (string.IsNullOrEmpty(result.Item2))
{
return(Ok(result.Item1));
}
return(BadRequest(result.Item2));
}
catch (Exception ex)
{
this.logger.LogError($"Get Event List Of Team Error >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID}\n{ex}");
return(BadRequest("取得車隊活動列表發生錯誤."));
}
}
public async Task <IActionResult> Delete(TeamCommandDto teamCommand)
{
try
{
string result = await this.announcementService.DeleteAnnouncement(teamCommand);
if (string.IsNullOrEmpty(result))
{
return(Ok("刪除公告成功."));
}
return(BadRequest(result));
}
catch (Exception ex)
{
this.logger.LogError($"Delete Announcement Error >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} AnnouncementID:{(teamCommand.AnnouncementInfo != null ? teamCommand.AnnouncementInfo.AnnouncementID : "Null")}\n{ex}");
return(BadRequest("刪除公告發生錯誤."));
}
}
public async Task <IActionResult> Edit(TeamCommandDto teamCommand)
{
try
{
string result = await this.announcementService.EditAnnouncement(teamCommand);
if (string.IsNullOrEmpty(result))
{
return(Ok("編輯公告成功."));
}
return(BadRequest(result));
}
catch (Exception ex)
{
this.logger.LogError($"Edit Announcement Error >>> TeamID:{teamCommand.TeamID} ExaminerID:{teamCommand.ExaminerID} AnnouncementInfo:{JsonConvert.SerializeObject(teamCommand.AnnouncementInfo)}\n{ex}");
return(BadRequest("編輯公告發生錯誤."));
}
}
public async Task <IActionResult> Get(TeamCommandDto teamCommand)
{
try
{
Tuple <IEnumerable <AnnouncementInfoDto>, string> result = await this.announcementService.GetAnnouncementList(teamCommand);
if (string.IsNullOrEmpty(result.Item2))
{
return(Ok(result.Item1));
}
return(BadRequest(result.Item2));
}
catch (Exception ex)
{
this.logger.LogError($"Get Announcement List Error >>> TemaID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID}\n{ex}");
return(BadRequest("取得公告列表發生錯誤."));
}
}
