public async Task <long> CreateTeam(CreateTeamModel model, string ownerId)
{
var existingTeam = await GetTeamByOwnerIdAndName(ownerId, model.Name);
if (existingTeam != null)
{
throw new ArgumentException($"A Team with name '{model.Name}' already exists.");
}
await using var command = _connection.CreateCommand();
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "CreateTeam";
command.Parameters.AddWithValue("@OwnerId", ownerId);
command.Parameters.AddWithValue("@Name", model.Name);
if (_connection.State != ConnectionState.Open)
{
await _connection.OpenAsync();
}
var reader = await command.ExecuteReaderAsync(CommandBehavior.CloseConnection);
await reader.ReadAsync();
return((long)reader.GetDecimal(0));
}
public async Task <Team> CreateTeam(CreateTeamModel model, int adminId)
{
var team = new Team
{
Name = model.Name,
AdminId = adminId
};
_db.Teams.Add(team);
await _db.SaveChangesAsync();
_db.UserTeams.AddRange(model.UserIds.Select(id => new UserTeam
{
UserId = id,
TeamId = team.Id
}));
_db.UserTeams.Add(new UserTeam
{
UserId = adminId,
TeamId = team.Id
});
await _db.SaveChangesAsync();
var userTeams = await _db.UserTeams
.Include(ut => ut.User)
.Where(ut => ut.TeamId == team.Id)
.ToListAsync();
team.UserTeams = userTeams;
return(team);
}
public IHttpActionResult CreateTeams(CreateTeamModel model)
{
var players = _dbContext.Players
.Where(w => model.Guids.Contains(w.Guid))
.ToList();
var teams = _creationService.CreateTeams(players, new List <Team> {
new Team {
Name = "Blanc"
}, new Team {
Name = "Orange"
}
});
var viewModel = teams.Select(s => new TeamViewModel
{
Guid = s.Guid,
Name = s.Name,
Players = s.Players.Select(p => new PlayerViewModel
{
FirstName = p.FirstName,
Guid = p.Guid,
GradeEnum = p.Grade,
LastName = p.LastName,
PositionEnum = p.Position,
PhoneNumber = p.PhoneNumber
}).ToList()
}).ToList();
return(Ok(viewModel));
}
public ActionResult Create(CreateTeamModel model)
{
var newTeam = new Team()
{
Name = model.TeamBindingModel.Name,
NickName = model.TeamBindingModel.NickName,
WebSite = model.TeamBindingModel.Website,
DateFounded = model.TeamBindingModel.DateFounded
};
this.Data.Teams.Add(newTeam);
this.Data.SaveChanges();
Player player = null;
foreach (var playerName in model.TeamBindingModel.Players)
{
player = this.Data.Players.All()
.FirstOrDefault(p => p.Name == playerName);
newTeam.Players.Add(player);
}
this.Data.SaveChanges();
return this.RedirectToAction("Index", "Home");
}
public async Task <IActionResult> Create([FromBody] CreateTeamModel model)
{
try
{
if (!ModelState.IsValid)
{
throw new ArgumentException($"Validation failed. Please check data you entered");
}
var user = await _userManager.GetUserAsync(User);
var res = await _dataAccess.CreateTeam(model, user.Id);
return(Ok(new { TeamId = res }));
}
catch (Exception e)
{
_logger.LogError(e, "CreateTeam");
if (_hostEnvironment.IsDevelopment())
{
throw;
}
return(BadRequest(new { Error = e.Message }));
}
}
public async Task <CreateTeamModel> CreateTeam(string fullName, string shortName, string inviteEmail)
{
User currentUser = new User();
try
{
CreateTeamModel model = new CreateTeamModel();
Team teamToRetruned = new Team();
TeamPlayer tmPlayer = new TeamPlayer();
currentUser = App.Current.Properties["loggedUser"] as User;
int userId = currentUser.Id;
//mainCity = currentUser.City;
var input = $"https://www.harbisaha.com/api/OpponentAdvert/CreateNewTeam?userId=" + userId + "&fullName=" + fullName + "&shortName=" + shortName + "&inviteEmail=" + inviteEmail;
//var client = await GetClient();
var client = await GetClient();
var result = await client.GetStringAsync(input);
model = JsonConvert.DeserializeObject <CreateTeamModel>((result));
if (tmPlayer.Team != null)
{
App.Current.Properties["loggedUserTeamPlayer"] = model.TeamPlayer;
}
return(model);
}
catch (Exception EX)
{
//return null;
throw;
}
}
public IActionResult CreateTeam([FromBody] CreateTeamModel model)
{
var teamId = Guid.NewGuid();
var traceId = Guid.NewGuid();
var team = _clusterClient.GetGrain <ITeamGrain>(teamId);
team.CreateAsync(new CreateTeam(model.Name, teamId, traceId, GetUserId));
return(Created(teamId.ToString(), new ResourceResponse(teamId, traceId)));
}
public async Task <IActionResult> Create([FromBody] CreateTeamModel model)
{
if (model.UserIds.Contains(_currentUser.Id))
{
throw new ApiException(400, "Invalid user id list", ErrorCode.InvalidRequestFormat);
}
var team = await _teamsService.CreateTeam(model, _currentUser.Id);
return(Created($"api/teams/{team.Id}", _mapper.Map <TeamViewModel>(team)));
}
public IActionResult CreateTeam(CreateTeamModel createTeamModel)
{
OperationStatusInfo operationStatusInfo = _hubEnvironment.ServerHubConnector.CreateTeam(createTeamModel.Team).Result;
if (operationStatusInfo.OperationStatus == OperationStatus.Done)
{
return(RedirectToAction("TeamList"));
}
else
{
return(View("CreateTeamPage", new CreateTeamModel(createTeamModel.Team)));
}
}
private async void BtnFinish_Clicked(object sender, EventArgs e)
{
if (!App.Current.Properties.ContainsKey("loggedUser"))
{
await DisplayAlert("HATA", "Lütfen giriş yapınız", "Tamam");
await Navigation.PushAsync(new LoginPageMain());
}
else if (App.Current.Properties["loggedUserTeamPlayer"] != null)
{
await DisplayAlert("HATA", "Bir hata oluştu", "OK");
App.Current.Properties.Remove("loggedUserTeamPlayer");
App.Current.Properties.Remove("loggedUser");
App.Current.MainPage = new NavigationPage(new IndexTabbedPages.IndexPageMain());
}
else
{
if (isSuccessName == false || isSuccessShortName == false)
{
await DisplayAlert("UYARI", "Lütfen takım adını ve kısaltmasını kontrol edin", "Tamam");
}
else
{
try
{
await Navigation.PushPopupAsync(new AnimationPopUpPage1_Waiting("Oluşturuluyor.."));
CreateTeamModel modelToReturn = await serviceTeam.CreateTeam(entryTeamName.Text, entryTeamShortName.Text, "abc");
await Navigation.PopPopupAsync();
if (modelToReturn.isSuccesful == true)
{
await DisplayAlert("Başarılı", modelToReturn.responseMessage, "OK");
App.Current.Properties["loggedUserTeamPlayer"] = modelToReturn.TeamPlayer;
App.Current.MainPage = new NavigationPage(new IndexPageMain());
}
else
{
await DisplayAlert("Hata", modelToReturn.responseMessage, "OK");
}
}
catch (Exception ex)
{
throw;
}
}
}
}
public ActionResult Create()
{
var players = this.Data.Players.All()
.Select(p =>
new SelectListItem()
{
Text = p.Name
});
var createTeamModel = new CreateTeamModel();
createTeamModel.TeamBindingModel = new TeamBindingModel();
createTeamModel.Players = players;
createTeamModel.TeamBindingModel.Players = new List<string>();
return this.View(createTeamModel);
}
public async void CRUDTest()
{
var api = new ApiService(this.ConnectionSettings);
// Create
var model = new CreateTeamModel {
Name = "Test " + Rand(), Description = "Description ..."
};
var createdTeam = await api.Post <CreateTeamModel, LabelIdModel <string> >("/api/1.0/teams", model);
Assert.NotNull(createdTeam);
Assert.NotEmpty(createdTeam.Id);
// Read
var team = await api.Get <TeamModel>($"/api/1.0/teams/{createdTeam.Id}");
Assert.NotNull(team);
Assert.NotEmpty(team.Name);
Assert.Equal(model.Name, team.Name);
Assert.Equal(model.Description, team.Description);
// Edit
var editModel = new EditTeamModel {
Id = team.Id, Name = "Test 2 ", Description = "Description 2..."
};
await api.Put <EditTeamModel, LabelIdModel <string> >("/api/1.0/teams", editModel);
// Read
team = await api.Get <TeamModel>($"/api/1.0/teams/{editModel.Id}");
Assert.NotNull(team);
Assert.NotEmpty(team.Name);
Assert.Equal(editModel.Name, team.Name);
Assert.Equal(editModel.Description, team.Description);
// Delete
await api.Delete($"/api/1.0/teams/delete/{team.Id}");
Thread.Sleep(2000);
team = await api.Get <TeamModel>($"/api/1.0/teams/{editModel.Id}");
Assert.NotNull(team);
}
public async Task <ActionResult> CreateTeamModal(CreateTeamModel model)
{
if (!ModelState.IsValid)
{
model.Games = await GetPendingGames();
return(View(model));
}
var result = await GameWriter.CreateTeam(model);
if (!ModelState.IsWriterResultValid(result))
{
model.Games = await GetPendingGames();
return(View(model));
}
return(CloseModalSuccess());
}
public async Task <IWriterResult> CreateTeam(CreateTeamModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var game = await context.Games.FirstOrDefaultAsync(x => x.Id == model.GameId);
if (game == null)
{
return(new WriterResult(false, $"Game not found"));
}
if (game.Status != Enums.GameStatus.NotStarted && game.Status != Enums.GameStatus.Paused)
{
return(new WriterResult(false, $"Unable to add team to game in {game.Status} status"));
}
if (await context.Team.AnyAsync(x => x.GameId == game.Id && x.Name == model.Name))
{
return(new WriterResult(false, $"Game with name already exists"));
}
if (await context.Team.AnyAsync(x => x.GameId == game.Id && x.Color == model.Color))
{
return(new WriterResult(false, $"Game with color already exists"));
}
context.Team.Add(new Entity.Team
{
GameId = game.Id,
Name = model.Name,
Description = model.Description,
Icon = model.Icon,
Color = model.Color,
Rank = model.Rank,
Timestamp = DateTime.UtcNow
});
await context.SaveChangesAsync();
return(new WriterResult(true));
}
}
public async ValueTask <Result> CreateTeam([FromBody] CreateTeamModel model)
{
string coachId = httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
Result httpResponse = new Result();
Coach coach;
if (context.Coaches.ToList()
.Where(coach => coach.Id == coachId)
.Any())
{
coach = context.Coaches
.Where(c => c.Id == coachId)
.First();
}
else
{
httpResponse.Success = false;
httpResponse.Errors.Add("No coach with that id could be found.");
return(httpResponse);
}
Race race = context.Races
.Where(r => r.RaceName == model.Race)
.First();
context.Teams.Add(new Team
{
Coach = coach,
Id = Guid.NewGuid().ToString(),
Race = race,
Players = new List <Player>(),
TeamName = model.TeamName,
Teamvalue = 0,
NumberOfReRolls = 0
});
context.SaveChanges();
httpResponse.Success = true;
return(httpResponse);
}
public ActionResult Create(CreateTeamModel createTeamModel)
{
var teamModel = createTeamModel.TeamModel;
teamModel.League = GetLeagueWithId(createTeamModel.LeagueId, createTeamModel.PossibleLeagues);
var dTeam = Mapper.Map <DTeam>(teamModel);
IDatabaseAccessor db = new SqlDatabaseAccessor(MvcApplication.GetMockDraftConnectionStringName());
if (ModelState.IsValid)
{
if (db.TeamExists(dTeam))
{
ViewBag.Feedback = createTeamModel.AlreadyExistedErrorMessage;
return(View(createTeamModel));
}
db.AddTeam(dTeam);
ViewBag.Feedback = createTeamModel.SuccessMessage;
}
var newTeamModel = new CreateTeamModel();
return(View(newTeamModel));
}
public static IActionResult Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
req.Headers.TryGetValue("sessionToken", out StringValues sessionToken);
User requester = SessionValidator.ValidateSession(sessionToken.ToString());
if (requester == null)
{
return new StatusCodeResult(403);
}
List<CreateTeamModel> ctms = new List<CreateTeamModel>();
using (DataContext dc = new DataContext())
{
var teams = dc.Team.Include(x => x.Users).Where(x => x.Users.Contains(requester) || requester.UserType.UserTypeName == "Admin");
foreach (var Team in teams)
{
CreateTeamModel ctm = new CreateTeamModel { TeamName = Team.TeamName, LeaderID = Team.LeaderID, ProjectName = Team.ProjectName, TeamID = Team.TeamID};
ctms.Add(ctm);
}
}
return new JsonResult(ctms);
}
public CreateTeamPage()
{
InitializeComponent();
BindingContext = new CreateTeamModel(Navigation);
}
public ActionResult Create()
{
var teamModel = new CreateTeamModel();
return(View(teamModel));
}
public async Task <IActionResult> Post([FromBody] CreateTeamModel model)
{
//TODO: Implement Detailed Error Checking
if (ModelState.IsValid)
{
try
{
//TenantServerConfig tenantServerConfig, DatabaseConfig databaseConfig, CatalogConfig catalogConfig
var databaseConfig = new DatabaseConfig
{
DatabasePassword = _configuration["DatabaseOptions:DatabasePassword"],
DatabaseUser = _configuration["DatabaseOptions:DatabaseUser"],
DatabaseServerPort = Int32.Parse(_configuration["DatabaseOptions:DatabaseServerPort"]),
SqlProtocol = SqlProtocol.Tcp,
ConnectionTimeOut = Int32.Parse(_configuration["DatabaseOptions:ConnectionTimeOut"]),
};
var catalogConfig = new CatalogConfig
{
ServicePlan = _configuration["DatabaseOptions:ServicePlan"],
CatalogDatabase = _configuration["DatabaseOptions:CatalogDatabase"],
CatalogServer = _configuration["DatabaseOptions:CatalogServer"], // + ".database.windows.net"
};
var tenantServerConfig = new TenantServerConfig
{
TenantServer = _configuration["DatabaseOptions:CatalogServer"],// + ".database.windows.net",
TenantDatabase = _configuration["DatabaseOptions:TenantDatabase"],
};
var team = new Team
{
Id = _utilities.GetTenantKey(model.TenantName),
Name = model.TenantName,
LogoLink = model.TenantLogoLink,
};
//Create Shard, Add Team and Register Tenant against shard
var shard = Sharding.CreateNewShard(tenantServerConfig.TenantDatabase, tenantServerConfig.TenantServer, databaseConfig.DatabaseServerPort, null);
await _tenantRepository.AddTeam(team);
var x = await Sharding.RegisterNewShard(team.Id, "", shard);
//Add first user to team. Team Owner!
var applicationUser = await _userService.GetApplicationUserAsync();
var user = new User {
ApplicationUserId = applicationUser.Id, Email = applicationUser.Email, UserRole = Role.SuperAdministrator
};
await _tenantRepository.AddUserToTeam(user, team.Id);
return(Ok(new { team_id = team.Id, team_name = team.Name }));
}
catch (Exception ex)
{
//TODO: Log Error
return(BadRequest(new { Error = ex.Message }));
}
}
return(BadRequest(ModelState));
}
