public async Task <bool> Delete(ScheduleMaster ScheduleMaster)
{
if (await ValidateId(ScheduleMaster))
{
}
return(ScheduleMaster.IsValidated);
}
public async Task <ScheduleMaster> Delete(ScheduleMaster ScheduleMaster)
{
if (!await ScheduleMasterValidator.Delete(ScheduleMaster))
{
return(ScheduleMaster);
}
try
{
await UOW.Begin();
await UOW.ScheduleMasterRepository.Delete(ScheduleMaster);
await UOW.Commit();
await Logging.CreateAuditLog(new { }, ScheduleMaster, nameof(ScheduleMasterService));
return(ScheduleMaster);
}
catch (Exception ex)
{
await UOW.Rollback();
await Logging.CreateSystemLog(ex.InnerException, nameof(ScheduleMasterService));
if (ex.InnerException == null)
{
throw new MessageException(ex);
}
else
{
throw new MessageException(ex.InnerException);
}
}
}
public async Task <bool> Create(ScheduleMaster ScheduleMaster)
{
ScheduleMasterDAO ScheduleMasterDAO = new ScheduleMasterDAO();
ScheduleMasterDAO.Id = ScheduleMaster.Id;
ScheduleMasterDAO.ManagerId = ScheduleMaster.ManagerId;
ScheduleMasterDAO.SalerId = ScheduleMaster.SalerId;
ScheduleMasterDAO.Name = ScheduleMaster.Name;
ScheduleMasterDAO.Code = ScheduleMaster.Code;
ScheduleMasterDAO.StatusId = ScheduleMaster.StatusId;
ScheduleMasterDAO.RecurDays = ScheduleMaster.RecurDays;
ScheduleMasterDAO.StartDate = ScheduleMaster.StartDate;
ScheduleMasterDAO.EndDate = ScheduleMaster.EndDate;
ScheduleMasterDAO.NoEndDate = ScheduleMaster.NoEndDate;
ScheduleMasterDAO.StartDayOfWeek = ScheduleMaster.StartDayOfWeek;
ScheduleMasterDAO.DisplayOrder = ScheduleMaster.DisplayOrder;
ScheduleMasterDAO.Description = ScheduleMaster.Description;
ScheduleMasterDAO.CreatedAt = StaticParams.DateTimeNow;
ScheduleMasterDAO.UpdatedAt = StaticParams.DateTimeNow;
DataContext.ScheduleMaster.Add(ScheduleMasterDAO);
await DataContext.SaveChangesAsync();
ScheduleMaster.Id = ScheduleMasterDAO.Id;
await SaveReference(ScheduleMaster);
return(true);
}
public async Task <IActionResult> Edit(long id, [Bind("ScheduleMasterId,ScheduleDesciption,ScheduleCronExpression,ActiveYn")] ScheduleMaster scheduleMaster)
{
if (id != scheduleMaster.ScheduleMasterId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(scheduleMaster);
if (!await CanPerformCurrentActionOnRecord(scheduleMaster))
{
return(new ForbidResult());
}
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ScheduleMasterExists(scheduleMaster.ScheduleMasterId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(IndexDataTable)));
}
return(View(scheduleMaster));
}
public async Task <bool> Update(ScheduleMaster ScheduleMaster)
{
ScheduleMasterDAO ScheduleMasterDAO = DataContext.ScheduleMaster.Where(x => x.Id == ScheduleMaster.Id).FirstOrDefault();
if (ScheduleMasterDAO == null)
{
return(false);
}
ScheduleMasterDAO.Id = ScheduleMaster.Id;
ScheduleMasterDAO.ManagerId = ScheduleMaster.ManagerId;
ScheduleMasterDAO.SalerId = ScheduleMaster.SalerId;
ScheduleMasterDAO.Name = ScheduleMaster.Name;
ScheduleMasterDAO.Code = ScheduleMaster.Code;
ScheduleMasterDAO.StatusId = ScheduleMaster.StatusId;
ScheduleMasterDAO.RecurDays = ScheduleMaster.RecurDays;
ScheduleMasterDAO.StartDate = ScheduleMaster.StartDate;
ScheduleMasterDAO.EndDate = ScheduleMaster.EndDate;
ScheduleMasterDAO.NoEndDate = ScheduleMaster.NoEndDate;
ScheduleMasterDAO.StartDayOfWeek = ScheduleMaster.StartDayOfWeek;
ScheduleMasterDAO.DisplayOrder = ScheduleMaster.DisplayOrder;
ScheduleMasterDAO.Description = ScheduleMaster.Description;
ScheduleMasterDAO.UpdatedAt = StaticParams.DateTimeNow;
await DataContext.SaveChangesAsync();
await SaveReference(ScheduleMaster);
return(true);
}
public async Task <ActionResult <ScheduleMaster_ScheduleMasterDTO> > Create([FromBody] ScheduleMaster_ScheduleMasterDTO ScheduleMaster_ScheduleMasterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
if (!await HasPermission(ScheduleMaster_ScheduleMasterDTO.Id))
{
return(Forbid());
}
ScheduleMaster ScheduleMaster = ConvertDTOToEntity(ScheduleMaster_ScheduleMasterDTO);
ScheduleMaster = await ScheduleMasterService.Create(ScheduleMaster);
ScheduleMaster_ScheduleMasterDTO = new ScheduleMaster_ScheduleMasterDTO(ScheduleMaster);
if (ScheduleMaster.IsValidated)
{
return(ScheduleMaster_ScheduleMasterDTO);
}
else
{
return(BadRequest(ScheduleMaster_ScheduleMasterDTO));
}
}
// GET: ScheduleMaster/Create
public IActionResult Create()
{
ScheduleMaster scheduleMaster = new ScheduleMaster();
scheduleMaster.ActiveYn = true;
return(View(scheduleMaster));
}
private ScheduleMaster ConvertDTOToEntity(ScheduleMaster_ScheduleMasterDTO ScheduleMaster_ScheduleMasterDTO)
{
ScheduleMaster ScheduleMaster = new ScheduleMaster();
ScheduleMaster.Id = ScheduleMaster_ScheduleMasterDTO.Id;
ScheduleMaster.ManagerId = ScheduleMaster_ScheduleMasterDTO.ManagerId;
ScheduleMaster.SalerId = ScheduleMaster_ScheduleMasterDTO.SalerId;
ScheduleMaster.Name = ScheduleMaster_ScheduleMasterDTO.Name;
ScheduleMaster.Code = ScheduleMaster_ScheduleMasterDTO.Code;
ScheduleMaster.StatusId = ScheduleMaster_ScheduleMasterDTO.StatusId;
ScheduleMaster.RecurDays = ScheduleMaster_ScheduleMasterDTO.RecurDays;
ScheduleMaster.StartDate = ScheduleMaster_ScheduleMasterDTO.StartDate;
ScheduleMaster.EndDate = ScheduleMaster_ScheduleMasterDTO.EndDate;
ScheduleMaster.NoEndDate = ScheduleMaster_ScheduleMasterDTO.NoEndDate;
ScheduleMaster.StartDayOfWeek = ScheduleMaster_ScheduleMasterDTO.StartDayOfWeek;
ScheduleMaster.DisplayOrder = ScheduleMaster_ScheduleMasterDTO.DisplayOrder;
ScheduleMaster.Description = ScheduleMaster_ScheduleMasterDTO.Description;
ScheduleMaster.Manager = ScheduleMaster_ScheduleMasterDTO.Manager == null ? null : new AppUser
{
Id = ScheduleMaster_ScheduleMasterDTO.Manager.Id,
Username = ScheduleMaster_ScheduleMasterDTO.Manager.Username,
DisplayName = ScheduleMaster_ScheduleMasterDTO.Manager.DisplayName,
Address = ScheduleMaster_ScheduleMasterDTO.Manager.Address,
Email = ScheduleMaster_ScheduleMasterDTO.Manager.Email,
Phone = ScheduleMaster_ScheduleMasterDTO.Manager.Phone,
PositionId = ScheduleMaster_ScheduleMasterDTO.Manager.PositionId,
Department = ScheduleMaster_ScheduleMasterDTO.Manager.Department,
OrganizationId = ScheduleMaster_ScheduleMasterDTO.Manager.OrganizationId,
StatusId = ScheduleMaster_ScheduleMasterDTO.Manager.StatusId,
Avatar = ScheduleMaster_ScheduleMasterDTO.Manager.Avatar,
ProvinceId = ScheduleMaster_ScheduleMasterDTO.Manager.ProvinceId,
SexId = ScheduleMaster_ScheduleMasterDTO.Manager.SexId,
Birthday = ScheduleMaster_ScheduleMasterDTO.Manager.Birthday,
};
ScheduleMaster.Saler = ScheduleMaster_ScheduleMasterDTO.Saler == null ? null : new AppUser
{
Id = ScheduleMaster_ScheduleMasterDTO.Saler.Id,
Username = ScheduleMaster_ScheduleMasterDTO.Saler.Username,
DisplayName = ScheduleMaster_ScheduleMasterDTO.Saler.DisplayName,
Address = ScheduleMaster_ScheduleMasterDTO.Saler.Address,
Email = ScheduleMaster_ScheduleMasterDTO.Saler.Email,
Phone = ScheduleMaster_ScheduleMasterDTO.Saler.Phone,
PositionId = ScheduleMaster_ScheduleMasterDTO.Saler.PositionId,
Department = ScheduleMaster_ScheduleMasterDTO.Saler.Department,
OrganizationId = ScheduleMaster_ScheduleMasterDTO.Saler.OrganizationId,
StatusId = ScheduleMaster_ScheduleMasterDTO.Saler.StatusId,
Avatar = ScheduleMaster_ScheduleMasterDTO.Saler.Avatar,
ProvinceId = ScheduleMaster_ScheduleMasterDTO.Saler.ProvinceId,
SexId = ScheduleMaster_ScheduleMasterDTO.Saler.SexId,
Birthday = ScheduleMaster_ScheduleMasterDTO.Saler.Birthday,
};
ScheduleMaster.Status = ScheduleMaster_ScheduleMasterDTO.Status == null ? null : new Status
{
Id = ScheduleMaster_ScheduleMasterDTO.Status.Id,
Code = ScheduleMaster_ScheduleMasterDTO.Status.Code,
Name = ScheduleMaster_ScheduleMasterDTO.Status.Name,
};
ScheduleMaster.BaseLanguage = CurrentContext.Language;
return(ScheduleMaster);
}
public ResponseModel Schedule([FromBody] ScheduleMaster scheduleMaster)
{
ResponseModel objResponseModel = new ResponseModel();
int StatusCode = 0;
string statusMessage = "";
try
{
string token = Convert.ToString(Request.Headers["X-Authorized-Token"]);
Authenticate authenticate = new Authenticate();
authenticate = SecurityService.GetAuthenticateDataFromToken(_radisCacheServerAddress, SecurityService.DecryptStringAES(token));
StoreReportCaller reportCaller = new StoreReportCaller();
int result = reportCaller.ScheduleStoreReport(new StoreReportService(_connectioSting), scheduleMaster, authenticate.TenantId, authenticate.UserMasterID);
StatusCode =
result > 0 ?
(int)EnumMaster.StatusCode.Success : (int)EnumMaster.StatusCode.InternalServerError;
statusMessage = CommonFunction.GetEnumDescription((EnumMaster.StatusCode)StatusCode);
objResponseModel.Status = true;
objResponseModel.StatusCode = StatusCode;
objResponseModel.Message = statusMessage;
objResponseModel.ResponseData = result;
}
catch (Exception)
{
throw;
}
return(objResponseModel);
}
public async Task <bool> Delete(ScheduleMaster ScheduleMaster)
{
await DataContext.ScheduleMaster.Where(x => x.Id == ScheduleMaster.Id).UpdateFromQueryAsync(x => new ScheduleMasterDAO {
DeletedAt = StaticParams.DateTimeNow
});
return(true);
}
public async Task <ScheduleMaster> Get(long Id)
{
ScheduleMaster ScheduleMaster = await UOW.ScheduleMasterRepository.Get(Id);
if (ScheduleMaster == null)
{
return(null);
}
return(ScheduleMaster);
}
public async Task <IActionResult> Create([Bind("ScheduleMasterId,ScheduleDesciption,ScheduleCronExpression,ActiveYn")] ScheduleMaster scheduleMaster)
{
if (ModelState.IsValid)
{
_context.Add(scheduleMaster);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(IndexDataTable)));
}
return(View(scheduleMaster));
}
public void ScheduleMaster_KnowsOutsideTheSeason()
{
var cut = new ScheduleMaster();
var leagueCode = "NFL";
var season = 2021;
Assert.False(
cut.IsSeason(
leagueCode,
season,
new DateTime(2021, 8, 29)));
}
public void ScheduleMaster_KnowsStartOfTheSeason()
{
var cut = new ScheduleMaster();
var leagueCode = "NFL";
var season = 2021;
Assert.Equal(
new DateTime(2021, 09, 10).Date,
cut.SeasonStart(
leagueCode,
season).Date);
}
public void ScheduleMaster_CanDescribeRoundToMarkdown_Ok()
{
var cut = new ScheduleMaster();
var leagueCode = "EPL";
var season = 2021;
Assert.True(cut.HasSeason(leagueCode, season));
var result = cut.GetRound(1, leagueCode, season);
_output.WriteLine(
result);
}
public void ScheduleMaster_KnowsTheSeason()
{
var cut = new ScheduleMaster();
var leagueCode = "NFL";
var season = 2021;
Assert.True(
cut.IsSeason(
leagueCode,
season,
new DateTime(2021, 11, 01)));
}
public void ScheduleMaster_KnowsWhatNflWeekItIs()
{
var cut = new ScheduleMaster();
var leagueCode = "NFL";
var season = 2021;
Assert.Equal(
9,
cut.RoundFor(
leagueCode,
season,
new DateTime(2021, 11, 05)));
}
public void ScheduleMaster_CanReturnWhichLeaguesItHas()
{
var cut = new ScheduleMaster();
var result = cut.GetLeagues();
Assert.NotNull(
result);
foreach (var l in result)
{
_output.WriteLine(
l.ToString());
}
}
// Start is called before the first frame update
void Start()
{
if (Instance != null && Instance != this)
{
Destroy(this.gameObject);
}
else
{
Instance = this;
}
//Store everyone's skills in this skill master
DontDestroyOnLoad(this);
playerSchedule = scheduleMaster.AddComponent <ScheduleManager>();
}
public void ScheduleMaster_CanReturnRoundScheduleDataForParticularTeam()
{
var cut = new ScheduleMaster();
var result = cut.GetSchedule(
"Arsenal",
"EPL",
2021);
Assert.NotNull(
result);
foreach (var game in result)
{
_output.WriteLine(
game.ToString());
}
}
public void ScheduleMaster_ReturnsNullResultIfNothingOnParticularDay()
{
var leagueCode = "EPL";
var season = 2021;
var cut = new ScheduleMaster();
var result = cut.GetGame(
"Arsenal",
new DateTime(2021, 08, 16),
leagueCode,
season);
Assert.True(
result.Round == 0);
_output.WriteLine(
result.ToString());
}
public async Task <ActionResult <ScheduleMaster_ScheduleMasterDTO> > Get([FromBody] ScheduleMaster_ScheduleMasterDTO ScheduleMaster_ScheduleMasterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
if (!await HasPermission(ScheduleMaster_ScheduleMasterDTO.Id))
{
return(Forbid());
}
ScheduleMaster ScheduleMaster = await ScheduleMasterService.Get(ScheduleMaster_ScheduleMasterDTO.Id);
return(new ScheduleMaster_ScheduleMasterDTO(ScheduleMaster));
}
public void ScheduleMaster_CanReturnRoundDataForParticularDay()
{
var leagueCode = "EPL";
var season = 2021;
var cut = new ScheduleMaster();
var result = cut.GetGame(
"Arsenal",
new DateTime(2021, 08, 14),
leagueCode,
season);
Assert.NotNull(
result.League);
_output.WriteLine(
result.ToString());
}
public void ScheduleMaster_CanReturnRoundData()
{
var cut = new ScheduleMaster();
var leagueCode = "NFL";
var season = 2021;
Assert.True(cut.HasSeason(leagueCode, season));
var result = cut.GetRoundData(1, leagueCode, season);
Assert.NotNull(
result);
foreach (var item in result)
{
_output.WriteLine(
item.ToString());
}
}
public void ScheduleMaster_CanLoadJsonNFLScheduleFile_Ok()
{
var leagueCode = "NFL";
var season = 2021;
var cut = new ScheduleMaster();
Assert.True(cut.HasSeason(leagueCode, season));
var nRounds = cut.Rounds(leagueCode, season);
Assert.Equal(18, nRounds);
_output.WriteLine(
$"League:{leagueCode} has {nRounds} rounds in {season}");
var nGames = cut.Games(leagueCode, season);
Assert.Equal(652, nGames);
_output.WriteLine(
$"League:{leagueCode} has {nGames} games in {season}");
}
public async Task <bool> ValidateId(ScheduleMaster ScheduleMaster)
{
ScheduleMasterFilter ScheduleMasterFilter = new ScheduleMasterFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = ScheduleMaster.Id
},
Selects = ScheduleMasterSelect.Id
};
int count = await UOW.ScheduleMasterRepository.Count(ScheduleMasterFilter);
if (count == 0)
{
ScheduleMaster.AddError(nameof(ScheduleMasterValidator), nameof(ScheduleMaster.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
public void ScheduleMaster_KnowsWhichTeamJuvePlays()
{
var team = "Juventus";
var league = "S-A";
var season = 2021;
var cut = new ScheduleMaster();
var result = cut.GetGame(
team,
new DateTime(2021, 8, 23),
league,
season);
Assert.NotNull(
result);
var opponent = result.OpponentOf("Juventus");
Assert.True(
opponent.Equals("Udinese"));
_output.WriteLine(
$"{result}");
}
public void ScheduleMaster_KnowsWhichTeamNinersPlays()
{
var team = "SF";
var league = "NFL";
var season = 2021;
var cut = new ScheduleMaster();
var result = cut.GetGame(
team,
new DateTime(2021, 9, 13),
league,
season);
Assert.NotNull(
result);
var opponent = result.OpponentOf("SF");
Assert.True(
opponent.Equals("DL"));
_output.WriteLine(
$"{result}");
}
public ScheduleMaster_ScheduleMasterDTO(ScheduleMaster ScheduleMaster)
{
this.Id = ScheduleMaster.Id;
this.ManagerId = ScheduleMaster.ManagerId;
this.SalerId = ScheduleMaster.SalerId;
this.Name = ScheduleMaster.Name;
this.Code = ScheduleMaster.Code;
this.StatusId = ScheduleMaster.StatusId;
this.RecurDays = ScheduleMaster.RecurDays;
this.StartDate = ScheduleMaster.StartDate;
this.EndDate = ScheduleMaster.EndDate;
this.NoEndDate = ScheduleMaster.NoEndDate;
this.StartDayOfWeek = ScheduleMaster.StartDayOfWeek;
this.DisplayOrder = ScheduleMaster.DisplayOrder;
this.Description = ScheduleMaster.Description;
this.Manager = ScheduleMaster.Manager == null ? null : new ScheduleMaster_AppUserDTO(ScheduleMaster.Manager);
this.Saler = ScheduleMaster.Saler == null ? null : new ScheduleMaster_AppUserDTO(ScheduleMaster.Saler);
this.Status = ScheduleMaster.Status == null ? null : new ScheduleMaster_StatusDTO(ScheduleMaster.Status);
this.CreatedAt = ScheduleMaster.CreatedAt;
this.UpdatedAt = ScheduleMaster.UpdatedAt;
this.Errors = ScheduleMaster.Errors;
}
public void ScheduleMaster_KnowsWhichTeamArsenalPlaysFirst()
{
var team = "Arsenal";
var league = "EPL";
var season = 2021;
var round = 1;
var cut = new ScheduleMaster();
var result = cut.GetGame(
team,
league,
season,
round);
Assert.NotNull(
result);
var opponent = result.OpponentOf("Arsenal");
Assert.True(
opponent.Equals("Brentford"));
_output.WriteLine(
$"{team} plays {opponent} in round {round} of {league} {season}");
}
