private void CreateTestTeamMember()
{
var route4Me = new Route4MeManagerV5(ActualApiKey);
int?ownerId = GetOwnerMemberId();
if (ownerId == null)
{
return;
}
var newMemberParameters = new TeamRequest()
{
NewPassword = testPassword,
MemberFirstName = "John",
MemberLastName = "Doe",
MemberCompany = "Test Member To Remove",
MemberEmail = GetTestEmail(),
OwnerMemberId = (int)ownerId
};
newMemberParameters.SetMemberType(MemberTypes.Driver);
TeamResponse member = route4Me.CreateTeamMember(newMemberParameters,
out ResultResponse resultResponse);
if (member != null && member.GetType() == typeof(TeamResponse))
{
membersToRemove.Add(member);
}
}
public Team AddNewTeam(TeamRequest request)
{
using (var db = new TimeTrackerModelContainer())
{
var team = new Team();
team.Name = request.Name;
var user = db.User.First(x => x.Email == request.UserEmail);
db.Team.Add(team);
var userTeamLink = new UserTeamLink
{
PublicPrice = request.PublicPrice,
PrivatePrice = request.PrivatePrice,
CurrencyId = request.CurrencyId,
UserID = user.Id,
TeamId = team.Id
};
db.UserTeamLink.Add(userTeamLink);
db.SaveChanges();
return(team);
}
}
public AnswerOnRequestOutput AnswerOnRequest(AnswerOnRequestInput input)
{
TeamRequest teamRequestEntity = TeamRequestRepository.Get(input.TeamRequestId);
if (teamRequestEntity == null)
{
throw new CityQuestItemNotFoundException(CityQuestConsts.CityQuestItemNotFoundExceptionMessageBody, "\"TeamRequest\"");
}
if (!TeamRequestPolicy.CanAnswerOnRequestFromTeam(teamRequestEntity))
{
throw new CityQuestPolicyException(CityQuestConsts.CQPolicyExceptionUpdateDenied, "\"TeamRequest\"");
}
DateTime currentDT = DateTime.Now;
teamRequestEntity.InvitedUserResponse = input.Answer;
teamRequestEntity.InvitedUserResponseDateTime = currentDT;
TeamRequestRepository.Update(teamRequestEntity);
#region Creating new career if joined new team
if (teamRequestEntity.InvitedUserResponse == true)
{
CreateNewPlayerCareer(teamRequestEntity.InvitedUserId, teamRequestEntity.TeamId, currentDT);
}
#endregion
return(new AnswerOnRequestOutput()
{
TeamRequest = teamRequestEntity.MapTo <TeamRequestDto>(),
});
}
public Team EditTeam(TeamRequest request)
{
var newTeam = new Team();
using (var db = new TimeTrackerModelContainer())
{
var result = db.Team.First(x => x.Id == request.Id);
newTeam.Id = result.Id;
newTeam.Name = request.Name;
var s = db.Set <Team>().Local.FirstOrDefault(x => x.Id == request.Id);
if (s != null)
{
db.Entry(s).State = EntityState.Detached;
}
if (result.Id == request.Id)
{
db.Entry(newTeam).State = EntityState.Modified;
db.SaveChanges();
}
}
return(newTeam);
}
/// <summary>
/// 获取阵容信息
/// </summary>
public int Call_TeamList(TeamRequest request)
{
TeamResponse response = new TeamResponse();
response.success = true;
response.pid = CurrentSession.UserId;
response.teams5 = new List <TeamInfo>();
response.teams10 = new List <TeamInfo>();
var player = this.CurrentSession.GetBindPlayer();
foreach (var team in player.Teams)
{
TeamInfo ti = new TeamInfo();
ti.selected = team.IsSelected;
ti.id = team.Id;
ti.bps = team.Units.Object;
response.teams5.Add(ti);
}
foreach (var f in player.Formations)
{
TeamInfo ti = new TeamInfo();
ti.selected = f.IsSelected;
ti.id = f.Id;
ti.bps = f.Units.Object;
response.teams10.Add(ti);
}
CurrentSession.SendAsync(response);
return(0);
}
public IActionResult SaveTeam(TeamRequest team)
{
using (TeamsDbEntities entities = new TeamsDbEntities())
{
List <Team> teamList = entities.Teams.Where(p => p.TeamName == team.Name).ToList();
if (teamList.Count > 0)
{
return(BadRequest(new { Result = "Team name used before" }));
}
else
{
Team createTeam = entities.Teams.Add(new Team
{
TeamName = team.Name,
AdminUser = team.UserID,
});
entities.TeamUserStatus.Add(new TeamUserStatu {
TeamID = createTeam.ID, UserID = team.UserID
});
entities.SaveChanges();
return(Ok(new TeamModel {
Name = createTeam.TeamName, ID = createTeam.ID, AdminUser = createTeam.AdminUser.Value
}));
}
}
}
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='model'>
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <object> PostAsync(this IStsApi operations, TeamRequest model = default(TeamRequest), CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.PostWithHttpMessagesAsync(model, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public void GetTeamUsers(TeamRequest request, TeamResponse response)
{
var xRefTeamUser = _uow.Repository <XRefTeamUserEntity>().GetOverview();
var user = _uow.Repository <UserEntity>().GetOverview();
var role = _uow.Repository <RoleEntity>().GetOverview();
var tasks = _uow.Repository <TaskEntity>().GetOverview();
var teamUsers = (from x in xRefTeamUser
join u in user
on x.UserId equals u.Id
join r in role
on x.RoleId equals r.RoleId
where x.TeamId == request.TeamId
select new User
{
UserId = u.Id,
UserName = u.UserName,
UserRole = r.RoleName,
Me = request.UserId == x.UserId ? true : false,
CountTasks = tasks.Where(t => t.UserId == u.Id && t.TeamId == request.TeamId).Count()
}).ToList();
if (teamUsers != null)
{
response.TeamUsers = teamUsers;
}
}
/// <summary>
/// The example refers to the process of updating a route member.
/// </summary>
public void UpdateTeamMember()
{
// Create the manager with the api key
var route4Me = new Route4MeManagerV5(ActualApiKey);
#region Create Member To Update
membersToRemove = new List <TeamResponse>();
CreateTestTeamMember();
if (membersToRemove.Count < 1)
{
Console.WriteLine("Cannot create a team member to remove");
return;
}
var member = membersToRemove[membersToRemove.Count - 1];
#endregion
var queryParams = new MemberQueryParameters()
{
UserId = member.MemberId.ToString()
};
var requestParams = new TeamRequest()
{
MemberPhone = "555-777-888",
ReadOnlyUser = true,
DrivingRate = 4
};
// Run the query
var updatedMember = route4Me.UpdateTeamMember(
queryParams,
requestParams,
out ResultResponse resultResponse);
PrintTeamMembers(updatedMember, resultResponse);
Console.WriteLine(
(updatedMember?.MemberPhone ?? null) == requestParams.MemberPhone
? "The member phone updated"
: "Cannot update the member phone"
);
Console.WriteLine(
(updatedMember?.ReadOnlyUser ?? null) == requestParams.ReadOnlyUser
? "The member parameter ReadOnlyUser updated"
: "Cannot update the member parameter ReadOnlyUser"
);
Console.WriteLine(
(updatedMember?.DrivingRate ?? null) == requestParams.DrivingRate
? "The member parameter DrivingRate updated"
: "Cannot update the member parameter DrivingRate"
);
RemoveTestTeamMembers();
}
public async Task <ActionResult <TeamResponse> > PostTeam(TeamRequest teamRequest)
{
var teamResponse = await _teamService.Create(teamRequest);
return(CreatedAtAction(nameof(GetTeam), new { id = teamResponse.Value.Id }, teamResponse.Value));
}
public async Task ShouldDeleteTeamBeOkHavingDeletedElement()
{
//Recupero una Team esistente non utilizzato
var existing = Scenario.Teams.FirstOrDefault();
if (existing == null)
{
Assert.Inconclusive("Team does not exists");
}
//Conteggio gli elementi prima della cancellazione
var countBefore = Scenario.Teams.Count;
//Composizione della request
var request = new TeamRequest {
TeamId = existing.Id
};
//Invoke del metodo
var response = await Controller.DeleteTeam(request);
//Parsing della risposta
var parsed = ParseExpectedOk <TeamContract>(response);
//Conteggio gli elementi dopo la cancellazione
var countAfter = Scenario.Teams.Count;
Assert.IsTrue(
parsed.Data.TeamId == existing.Id);
Assert.AreEqual(countBefore - 1, countAfter);
}
private string GetErrorMessage(TeamRequest team)
{
if (string.IsNullOrWhiteSpace(team.Name) && string.IsNullOrWhiteSpace(team.Owners) && string.IsNullOrWhiteSpace(team.Description) && string.IsNullOrWhiteSpace(team.Alias))
{
return("Please fill out all the fields");
}
else if (string.IsNullOrWhiteSpace(team.Name))
{
return("Please fill out Team Name");
}
else if (string.IsNullOrWhiteSpace(team.Description))
{
return("Please fill out Team Description");
}
else if (string.IsNullOrWhiteSpace(team.Alias))
{
return("Please fill out Team MailNickname");
}
else if (string.IsNullOrWhiteSpace(team.Owners))
{
return("Please select Team Owner");
}
else
{
return(string.Empty);
}
}
public async Task <IActionResult> Post([FromBody] TeamRequest model)
{
Team newRecord = null;
if (ModelState.IsValid)
{
InitUserCredentials();
newRecord = new Team
{
Guid = Guid.NewGuid(),
OwnerGuid = UserGuid,
CompanyGuid = CompanyGuid,
CreationTime = DateTime.UtcNow,
CreationUserGuid = UserGuid
};
newRecord = _mapper.Map(model, newRecord);
try
{
await _teamService.Save(newRecord);
}
catch (Exception e)
{
Log.Error(e.StackTrace);
throw;
}
}
return(CreatedAtAction(nameof(Post), _mapper.Map(newRecord, new TeamResponse())));
}
public async Task <TeamModelResponse> SaveTeam(TeamRequest request)
{
string responseString = await CallAsync(SaveTeamServiceName, JsonConvert.SerializeObject(request), MethodTypeEnum.POST, _state.userState.Token);
TeamModelResponse response = JsonConvert.DeserializeObject <TeamModelResponse>(responseString);
return(response);
}
public BaseResponse <object> Create(int playerId, int companyId, TeamRequest request)
{
var validationResult = Validate <object>(request);
if (!validationResult.Ok)
{
return(validationResult);
}
if (!_dbContext.Companies.Any(x => x.Id == companyId))
{
return(BaseResponse <object> .Fail(_errorMessageProvider.ChallangeNotFound));
}
var player = _dbContext.Players
.Include(x => x.Teams)
.ThenInclude(x => x.Team)
.FirstOrDefault(x => x.Id == playerId);
if (player == null)
{
return(BaseResponse <object> .Fail(_errorMessageProvider.PlayerNotFound));
}
if (player.Teams.Where(x => x.IsOwner).Any(x => x.Team.CompanyId == companyId))
{
return(BaseResponse <object> .Fail(_errorMessageProvider.PlayerAlreadyHasTeamInThisCompany));
}
var team = new Team
{
Name = request.Name, //TODO do I need make name unique?
CompanyId = companyId,
};
var teamJoinInfo = new TeamJoinInfo
{
Team = team,
Key = Guid.NewGuid().ToString() //TODO move it to invite generator
};
var playerTeam = new PlayerTeam
{
IsOwner = true,
PlayerId = player.Id,
Team = team,
};
team.Players.Add(playerTeam);
_dbContext.Teams.Add(team);
_dbContext.PlayerTeams.Add(playerTeam);
_dbContext.TeamJoinInfos.Add(teamJoinInfo);
_dbContext.SaveChanges();
return(BaseResponse <object> .Success());
}
public void GetTeamById(TeamRequest request, TeamResponse response)
{
var team = _uow.Repository <TeamEntity>().GetOverview(x => x.TeamId == request.TeamId).FirstOrDefault();
if (team != null)
{
response.Team = _mapper.Map <TeamVM>(team);
}
}
public override Task <TeamResponse> GetById(TeamRequest request, ServerCallContext context)
{
TeamResponse response = new()
{
Status = new BaseResponse {
Code = Code.Success, ErrorMessage = string.Empty
}
};
try
{
Team team = _teamsRepository.Get(request.Id);
if (team is null)
{
response.Status.Code = Code.DataError;
response.Status.ErrorMessage = "Requested team not found";
}
else
{
response.Data = new TeamData
{
Id = team.Id,
CreatedOn = Timestamp.FromDateTime(team.CreatedOn.ToUniversalTime()),
Name = team.Name,
Description = team.Description
};
}
LogData logData = new()
{
CallSide = nameof(TeamsService),
CallerMethodName = nameof(GetById),
CreatedOn = _dateTimeUtil.GetCurrentDateTime(),
Request = request,
Response = response
};
_logger.AddLog(logData);
}
catch (Exception ex)
{
LogData logData = new()
{
CallSide = nameof(TeamsService),
CallerMethodName = nameof(GetById),
CreatedOn = _dateTimeUtil.GetCurrentDateTime(),
Request = request,
Response = ex
};
_logger.AddErrorLog(logData);
response.Status.Code = Code.UnknownError;
response.Status.ErrorMessage = "An error occured while loading team data";
}
return(Task.FromResult(response));
}
}
}
public IActionResult GetTeamUsers(string teamid)
{
var request = new TeamRequest {
TeamId = Int32.Parse(teamid), UserId = UserId
};
var response = _service.GetTeamUsers(request);
return(response.Success ? Ok(response) : StatusCode(404, response.Errors));
}
public async Task validateInputAsync(IDialogContext context, IAwaitable <IMessageActivity> result)
{
var message = await result;
TeamRequest team = new TeamRequest();
if (message.Value != null)
{
// Got an Action Submit
dynamic formvalue = message.Value;
if (formvalue != null)
{
team.Name = formvalue["Teamname"];
team.Description = formvalue["Description"];
team.Alias = formvalue["TeamMailNickname"];
team.Owners = formvalue["TeamOwners"];
team.SiteType = formvalue["Type"];
team.Classification = formvalue["Classification"];
var error = GetErrorMessage(team); // Validation
IMessageActivity replyMessage = context.MakeMessage();
if (!string.IsNullOrEmpty(error))
{
replyMessage.Text = error;
await context.PostAsync(replyMessage);
}
else
{
//Insert data into database here.
string JSONString = string.Empty;
using (var sqLiteDatabase = new SqLiteDatabase())
{
sqLiteDatabase.OpenConnection();
var result1 = sqLiteDatabase.GetDataTable($"SELECT * FROM SiteProvision");
string query = string.Empty;
if (result1.Rows.Count > 0)
{
query = $"UPDATE SiteProvision SET ";
}
else
{
//query = $"INSERT INTO SiteProvision ('Name','Description', 'Alias', 'SiteType', 'Language','RequestedBy','Owners','Status') VALUES('{name}','{description}','{alias}','{siteType}','{language}','{requestedBy}','{owners}','Requested')";
}
sqLiteDatabase.ExecuteNonQuery(query);
sqLiteDatabase.CloseConnection();
}
// Save Information in service bus
replyMessage.Text = "We have submiited your site request";
await context.PostAsync(replyMessage);
context.Done(true);
}
}
}
}
public async Task <ActionResult <TeamResponse> > Create(TeamRequest teamRequest)
{
var team = MapRequestToModel(teamRequest);
team = await _teamRepository.Add(team);
var teamResponse = MapModelToResponse(team);
return(teamResponse);
}
public Task <IActionResult> FetchShooterTeamPaymentByTeam(TeamRequest request)
{
//Recupero l'elemento dal business layer
var entities = BasicLayer.FetchShooterTeamPaymentsFromTeamId(request.TeamId);
var shooterIds = entities.Select(x => x.ShooterId).ToList();
var shooters = BasicLayer.FetchShootersByIds(shooterIds);
//Return contract
return(Reply(entities.As(x => ContractUtils.GenerateContract(x, shooters.FirstOrDefault(t => t.Id == x.ShooterId)))));
}
public TeamResponse GetTeamById(TeamRequest request)
{
var response = new TeamResponse();
RunCode(MethodBase.GetCurrentMethod().Name, request, response, (uow) =>
{
_manager.GetTeamById(request, response);
});
return(response);
}
public async Task <IActionResult> PutTeam(long id, TeamRequest teamRequest)
{
if (id != teamRequest.Id)
{
return(BadRequest());
}
await _teamService.Update(teamRequest);
return(NoContent());
}
public IHttpActionResult Post([FromBody] TeamRequest team)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var response = _service.Create(team);
return(CreatedAtRoute("DefaultApi", new { id = response.TeamId }, response));
}
public List <TeamDto> GetTeamsToUser(TeamRequest user)
{
try
{
return(_teamLogic.GetTeamListForUser(user));
}
catch (Exception e)
{
throw new FaultException("Váratlan hiba történt a TeamDto lekérdezése során.");
}
}
public TeamDto AddNewTeam(TeamRequest team)
{
try
{
return(_teamLogic.AddNewTeam(team).Map());
}
catch (Exception e)
{
throw new FaultException("Sikertelen csapat mentés!");
}
}
public TeamDto EditTeam(TeamRequest request)
{
try
{
return(_teamLogic.EditTeam(request).Map());
}
catch (Exception e)
{
throw new FaultException("Sikertelen csapat módosítás!");
}
}
public TeamDto DeleteTeamAndUserLink(TeamRequest request)
{
try
{
return(_teamLogic.DeleteTeamAndUserLink(request).Map());
}
catch (Exception e)
{
throw new FaultException("Sikertelen csapat törlés");
}
}
public async Task <TeamResponse> CreateTeam(TeamRequest request)
{
var response = new TeamResponse();
await RunCodeAsync(MethodBase.GetCurrentMethod().Name, request, response, async (uow) =>
{
await _manager.CreateTeam(request, response);
});
return(response);
}
public ActionResult <TeamResponse> UpdateTeam([FromServices] ISaveModel <Team> saveTeam,
[FromRoute] Guid teamId,
TeamRequest request)
{
var team = Mapper.Map <Team>(request);
team.Id = teamId;
team = saveTeam.Execute(team);
var response = Mapper.Map <TeamResponse>(team);
return(new OkObjectResult(response));
}
