public void PostChallenge(ChallengeDto challenge)
{
// var ch = _challengeRepository.PostChallenge(challenge);
var challengeDto = _mapper.Map <Challenges>(challenge);
_challengeRepository.PostChallenge(challengeDto);
}
public ChallengeDto GetChallange(int challengeId)
{
var challangeDto = new ChallengeDto();
db.Open();
var fetchColumns = new string[] { "CHALLENGE_ID", "NAME", "DURATION" };
var whereClause = string.Format("CHALLENGE_ID = {0}", challengeId);
var cursor = db.GetFromTable("CHALLENGE", fetchColumns, whereClause);
if (cursor.Count == 0)
{
return(null);
}
cursor.MoveToFirst();
return(new ChallengeDto
{
Id = cursor.GetInt(0),
Name = cursor.GetString(1),
Duration = cursor.GetInt(2),
});
}
public IActionResult Post([FromBody] ChallengeDto challengeDto)
{
try
{
var challenge = _challengeRepository.GetAll().SingleOrDefault(c => c.IsSent != true && c.Id == challengeDto.Id);
if (challenge == null)
{
return(Ok(JsonConvert.SerializeObject("Answer received too late")));
}
challenge.IsSent = true;
challenge.IsAnswered = challengeDto.CandidateSelectedOptions.Count > 0 ? true : false;
challenge.StartTime = challengeDto.StartTime;
challenge.AnsweredTime = challengeDto.AnsweredTime;
challenge.CandidateSelectedOptions = Mapper.Map <List <CandidateSelectedOption> >(challengeDto.CandidateSelectedOptions);
foreach (var item in challenge.CandidateSelectedOptions)
{
item.Challenge = challenge;
item.Option = _optionRepository.GetSingle(item.OptionId);
}
_challengeRepository.Edit(challenge);
_challengeRepository.Commit();
return(Ok(JsonConvert.SerializeObject("Success")));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, JsonConvert.SerializeObject(ex.Message + ex.InnerException.Message)));
}
}
private void SetUpChallenge(ChallengeDto challenge, Challenge dbChallenge)
{
dbChallenge.Description = challenge.Description;
dbChallenge.Name = challenge.Name;
dbChallenge.Suggested_Time_UnitsId = challenge.Suggested_Time_UnitsId;
dbChallenge.Suggested_Time_Number = challenge.Suggested_Time_Number;
dbChallenge.User_ID = challenge.User_Id;
}
private async void RunTimer(ChallengeDto currentChallengeDto)
{
this.source = new CancellationTokenSource();
//source.CancelAfter(TimeSpan.FromSeconds(currentChallengeDto.Question.TimeInSeconds));
await Task.Delay((currentChallengeDto.Question.TimeInSeconds * 1000) + 8000); //8 buffer seconds for latency
Task <bool> task = Task.Run(() => UpdateQuestionAfterTimer(currentChallengeDto, source.Token), source.Token);
}
// POST tables/Challenge
public async Task <IHttpActionResult> PostChallenge(ChallengeDto item)
{
var challenger = _context.Athletes.SingleOrDefault(a => a.Id == item.ChallengerAthleteId);
var challengee = _context.Athletes.SingleOrDefault(a => a.Id == item.ChallengeeAthleteId);
_authController.EnsureHasPermission(challenger, Request);
if (challenger == null || challengee == null)
{
throw "The opponent in this challenge no longer belongs to this league.".ToException(Request);
}
var challengerMembership = _context.Memberships.SingleOrDefault(m => m.AbandonDate == null && m.AthleteId == challenger.Id && m.LeagueId == item.LeagueId);
var challengeeMembership = _context.Memberships.SingleOrDefault(m => m.AbandonDate == null && m.AthleteId == challengee.Id && m.LeagueId == item.LeagueId);
if (challengerMembership == null || challengeeMembership == null)
{
throw "The opponent in this challenge no longer belongs to this league.".ToException(Request);
}
//Check to see if there are any ongoing challenges between both athletes
var challengeeOngoing = _context.Challenges.Where(c => ((c.ChallengeeAthleteId == item.ChallengeeAthleteId || c.ChallengerAthleteId == item.ChallengeeAthleteId) &&
(c.ChallengeeAthleteId == item.ChallengerAthleteId || c.ChallengerAthleteId == item.ChallengerAthleteId) &&
c.LeagueId == item.LeagueId && c.DateCompleted == null) && !c.Deleted);
if (challengeeOngoing.Count() > 0)
{
throw "{0} already has an existing challenge underway with {1}.".Fmt(challengee.Alias, challenger.Alias).ToException(Request);
}
var league = _context.Leagues.SingleOrDefault(l => l.Id == item.LeagueId);
try
{
var challenge = item.ToChallenge();
var json = Newtonsoft.Json.JsonConvert.SerializeObject(challenge);
Challenge current = await InsertAsync(challenge);
var result = CreatedAtRoute("Tables", new { id = current.Id }, current.ToChallengeDto());
var message = "{0}: You have been challenged to a duel by {1}!".Fmt(league.Name, challenger.Alias);
var payload = new NotificationPayload
{
Action = PushActions.ChallengePosted,
Payload = { { "challengeId", current.Id }, { "leagueId", current.LeagueId } }
};
_notificationController.NotifyByTag(message, current.ChallengeeAthleteId, payload);
return(result);
}
catch (Exception e)
{
return(null);
}
//Not awaiting so the user's result is not delayed
}
public List <ChallengeDto> GetChallanges()
{
var challangeDtos = new List <ChallengeDto>();
db.Open();
var query = string.Format(@"SELECT
c.CHALLENGE_ID,
c.NAME,
c.DURATION,
count(ce.CHALLENGE_ENTRY_ID) as ENTRY_COUNT,
MAX(ce.ENTRY_DATE) as MAX_DATE,
f.FREQUENCY_ID,
f.VALUE,
ft.FREQUENCY_TYPE_ID
FROM
CHALLENGE c
left JOIN CHALLENGE_ENTRY ce on c.CHALLENGE_ID = ce.CHALLENGE_ID
left join FREQUENCY f on f.FREQUENCY_ID = c.FREQUENCY_ID
left join CT_FREQUENCY_TYPE ft on ft.FREQUENCY_TYPE_ID = f.FREQUENCY_TYPE_ID
GROUP BY
c.CHALLENGE_ID" , Utils.Utils.DateFormat);
var cursor = db.ExecuteQuery(query);
if (cursor.Count == 0)
{
return(challangeDtos);
}
while (cursor.MoveToNext())
{
var challenge = new ChallengeDto
{
Id = cursor.GetInt(0),
Name = cursor.GetString(1),
Duration = cursor.GetInt(2),
EntriesCompleted = cursor.GetInt(3),
LastEntryDate = Utils.Utils.ToDateTimeNull(cursor.GetString(4)),
Frequency = new Frequency
{
Id = cursor.GetInt(5),
Value = cursor.GetInt(6),
Type = Utils.Utils.ToFrequencyType(cursor.GetInt(7)),
}
};
challangeDtos.Add(challenge);
}
cursor.Dispose();
db.Close();
return(challangeDtos);
}
private async Task <bool> SetExerciseNameAsync(ChallengeDto dto)
{
var exercise = await _exerciseRepository.FindAsync(dto.ExerciseId);
if (exercise == null)
{
LogError(nameof(SetExerciseNameAsync), $"No exercises found with id{dto.ExerciseId}. Check Database");
return(false);
}
dto.ExerciseName = exercise.Name;
return(true);
}
public HttpResponseMessage UpdateChallenge(ChallengeDto challenge)
{
try
{
_challengeService.UpdateChallenge(challenge);
return(Request.CreateResponse(HttpStatusCode.OK, challenge));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
private bool UpdateQuestionAfterTimer(ChallengeDto currentChallengeDto, CancellationToken cancellationToken)
{
var currentChallenge = _challengeRepository.GetSingleUsingNewContext(currentChallengeDto.Id);
if (currentChallenge.IsSent != true)
{
currentChallenge.IsSent = true;
_challengeRepository.UpdateWithNewContext(currentChallenge);
}
return(true);
}
public static Challenge ToDbEntity(this ChallengeDto challenge)
{
return(new Challenge()
{
Challenge_ID = challenge.Id,
Description = challenge.Description,
Name = challenge.Name,
Suggested_Time_Number = challenge.Suggested_Time_Number,
Suggested_Time_UnitsId = challenge.Suggested_Time_UnitsId,
User_ID = challenge.User_Id
});
}
public ActionResult <ApiResultDto <bool> > Post(ChallengeDto challengeDto)
{
var result = new ApiResultDto <bool>();
if (challengeDto == null || string.IsNullOrEmpty(challengeDto.Input))
{
result.BadRequestResult(HardCode.Errors.Standard.InvalidObject);
}
var response = _challengeAppService.EncryptAndSaveData(_mapper.Map <Challenge>(challengeDto));
return(result.OK(response));
}
public void AddChallenge(ChallengeDto challenge)
{
try
{
_unitOfWork.ChallengeRepository.Create(challenge.ToDbEntity());
_unitOfWork.ChallengeRepository.Save();
_unitOfWork.Commit();
}
catch (Exception)
{
_unitOfWork.RollBack();
throw;
}
}
public HttpResponseMessage AddChallenge(ChallengeDto challenge)
{
try
{
challenge.User_Id = SessionState.LoggedInUser == null?_userService.GetUserById(challenge.User_Id).AspNetUserId : SessionState.LoggedInUser.AspNetUserId;
_challengeService.AddChallenge(challenge);
return(Request.CreateResponse(HttpStatusCode.Created, challenge));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public ChallengeDto CreateQuestion()
{
ChallengeDto challengeDto = new ChallengeDto();
Random random = new Random();
int indexQuestion = random.Next(0, CommonVariable.Max_Number_Answers);
int maxLengthMeaning = DataSet.Where(m => !m.DELETED).Count();
string strMeaningId = "";
//create test
while (challengeDto.AnswersList.Count() < CommonVariable.Max_Number_Answers)
{
Thread.Sleep(200);
int skipNumber = random.Next(1, maxLengthMeaning);
MEANING meaning = DataSet.Where(m => !m.DELETED)
.OrderBy(m => Guid.NewGuid())
.Skip(skipNumber)
.Take(1)
.FirstOrDefault();
if (meaning != null && !strMeaningId.Contains(meaning.ID.ToString()))
{
strMeaningId += meaning.ID.ToString() + "-";
if (challengeDto.AnswersList.Count() == indexQuestion)
{
challengeDto.Question.WordId = meaning.WORD_ID;
challengeDto.Question.WordText = meaning.WORD.TEXT;
challengeDto.Question.TypeWordText = meaning.WORD.TYPE_WORD.TYPE_TEXT;
challengeDto.Question.Pronounce = meaning.WORD.PRONOUNCE;
challengeDto.Question.Sound = meaning.WORD.SOUND;
}
challengeDto.AnswersList.Add(new AnswerDto()
{
WordId = meaning.WORD_ID,
MeaningId = meaning.ID,
MeaningText = meaning.TEXT,
});
}
}
//find corrected answer
foreach (AnswerDto answerDto in challengeDto.AnswersList)
{
if (answerDto.WordId == challengeDto.Question.WordId)
{
answerDto.IsCorrected = true;
}
}
return(challengeDto);
}
public static Challenge ToChallenge(this ChallengeDto dto)
{
return(new Challenge
{
Id = dto.Id,
UpdatedAt = dto.UpdatedAt,
ChallengerAthleteId = dto.ChallengerAthleteId,
ChallengeeAthleteId = dto.ChallengeeAthleteId,
LeagueId = dto.LeagueId,
BattleForRank = dto.BattleForRank,
ProposedTime = dto.ProposedTime,
DateAccepted = dto.DateAccepted,
DateCompleted = dto.DateCompleted,
CustomMessage = dto.CustomMessage
});
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
bundle = Intent.Extras;
SetContentView(Resource.Layout.ViewChallenge);
prefHelper = new PreferenceHelper(this);
dataManager = new DataManger(this);
var toolbar = FindViewById <Toolbar>(Resource.Id.toolbar);
checkButton = FindViewById <BiggerFloatingActionButton>(Resource.Id.checkButton);
var challengeName = FindViewById <TextView>(Resource.Id.challengeName);
challange = new ChallengeDto
{
Id = bundle.GetInt("CHALLENGE_ID"),
Name = bundle.GetString("NAME"),
Duration = bundle.GetInt("DURATION"),
EntriesCompleted = bundle.GetInt("ENTRIES_COMPLETED"),
LastEntryDate = Utils.ToDateTimeNull(bundle.GetString("LAST_ENTRY_DATE"))
};
position = bundle.GetInt("POSITION");
if (challange.CanCheck)
{
checkButton.BackgroundTintList = ColorStateList.ValueOf(Resources.GetColor(Resource.Color.colorPrimary));
checkButton.Clickable = true;
checkButton.Click += CheckButton_Click;
}
else
{
checkButton.BackgroundTintList = ColorStateList.ValueOf(Resources.GetColor(Resource.Color.lightGray));
checkButton.Clickable = false;
}
challengeName.Text = challange.Name;
SetActionBar(toolbar);
ActionBar.Title = "Check It";
ActionBar.SetDisplayHomeAsUpEnabled(true);
ActionBar.SetHomeButtonEnabled(true);
}
private void YesBtn_Click(object sender, EventArgs e)
{
Dialog.Dismiss();
var result = new ChallengeDto
{
Name = challengeName.Text,
Duration = seekBarDuration.Progress,
Frequency = new Frequency
{
Value = (switchOption.Checked) ? Convert.ToInt32(days.Text) : frequencies[spinner.SelectedItemPosition].Id,
Type = (switchOption.Checked) ? Data.Utils.Enums.FrequencyType.Custom : Data.Utils.Enums.FrequencyType.Predefined,
}
};
dataManager.ChallangeData.InsertChallenge(result);
ChallangeAdded?.Invoke(this, result);
}
private async Task <bool> SetDisplayNameAsync(ChallengeDto dto)
{
var challenger = await _userRepository.FindAsync(dto.ChallengerId);
var challengee = await _userRepository.FindAsync(dto.ChallengeeId);
if (challenger != null)
{
dto.ChallengerDisplayName = challenger.DisplayName;
}
if (challengee == null)
{
LogError(nameof(SetExerciseNameAsync),
$"No challengee user found with id{dto.ChallengeeId}. Check Database");
return(false);
}
dto.ChallengeeDisplayName = challengee.DisplayName;
return(true);
}
public IActionResult PostChallenge([FromBody] ChallengeDto challenge)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
challenge.CreatedAt = DateTime.Today;
_challengeService.PostChallenge(challenge);
string newUri = Url.Link("GetChallenges", new { id = challenge.Id });
return(Created(newUri, challenge));
}
catch (Exception err)
{
Console.WriteLine(err);
}
return(BadRequest());
}
public RepeatedField <ChallengeParticipantDto> Resolve(
IChallenge challenge,
ChallengeDto challengeResponse,
IReadOnlyCollection <Participant> participants,
RepeatedField <ChallengeParticipantDto> participantResponses,
ResolutionContext context
)
{
foreach (var participant in participants)
{
var participantResponse = context.Mapper.Map <ChallengeParticipantDto>(participant);
participantResponse.Score = participant.ComputeScore(challenge.BestOf)?.ToDecimal();
participantResponse.ChallengeId = challenge.Id;
participantResponses.Add(participantResponse);
}
return(participantResponses);
}
public void UpdateChallenge(ChallengeDto challenge)
{
try
{
var dbChallenge = _unitOfWork.ChallengeRepository.GetById(challenge.Id);
if (dbChallenge == null)
{
AddChallenge(challenge);
}
else
{
SetUpChallenge(challenge, dbChallenge);
_unitOfWork.ChallengeRepository.Save();
_unitOfWork.Commit();
}
}
catch (Exception ex)
{
_unitOfWork.RollBack();
throw;
}
}
public static ChallengeAggregate Map(ChallengeDto challenge, ChallengePayoutDto payout, IEnumerable <DoxatagDto> doxatags)
{
return(new ChallengeAggregate
{
Id = challenge.Id,
Name = challenge.Name,
Game = challenge.Game,
State = challenge.State,
BestOf = challenge.BestOf,
Entries = challenge.Entries,
Timeline = challenge.Timeline,
SynchronizedAt = challenge.SynchronizedAt,
Scoring =
{
challenge.Scoring
},
Payout = payout,
Participants =
{
challenge.Participants.Select(participant => Map(challenge.Id, participant, doxatags))
.OrderByDescending(participant => participant.Score?.ToDecimal())
}
});
}
public void AddNewChallenge(ChallengeDto challenge)
{
challenges.Add(challenge);
NotifyDataSetChanged();
}
public ChallengeResponseAssertions(ChallengeDto challengeResponse) : base(challengeResponse)
{
}
private void OnChallengeUpdated(object sender, ChallengeDto challenge)
{
adapter.UpdateChallenge(challenge);
}
private void OnChallengeAdded(object sender, ChallengeDto challenge)
{
adapter.AddNewChallenge(challenge);
}
// POST tables/Challenge
public async Task <IHttpActionResult> PostChallenge(ChallengeDto item)
{
var challenger = _context.Athletes.SingleOrDefault(a => a.Id == item.ChallengerAthleteId);
var challengee = _context.Athletes.SingleOrDefault(a => a.Id == item.ChallengeeAthleteId);
_authController.EnsureHasPermission(new Athlete[] { challenger, challengee }, Request);
if (challenger == null || challengee == null)
{
throw "The opponent in this challenge no longer belongs to this league".ToException(Request);
}
var challengerMembership = _context.Memberships.SingleOrDefault(m => m.AbandonDate == null && m.AthleteId == challenger.Id && m.LeagueId == item.LeagueId);
var challengeeMembership = _context.Memberships.SingleOrDefault(m => m.AbandonDate == null && m.AthleteId == challengee.Id && m.LeagueId == item.LeagueId);
if (challengerMembership == null || challengeeMembership == null)
{
throw "The opponent in this challenge no longer belongs to this league".ToException(Request);
}
//Check to see if there are any ongoing challenges between either athlete
var challengeeOngoing = _context.Challenges.Where(c => (c.ChallengeeAthleteId == item.ChallengeeAthleteId || c.ChallengerAthleteId == item.ChallengeeAthleteId) &&
c.LeagueId == item.LeagueId && c.DateCompleted == null);
if (challengeeOngoing.Count() > 0)
{
throw "{0} already has an existing challenge underway.".Fmt(challengee.Alias).ToException(Request);
}
var challengerOngoing = _context.Challenges.Where(c => (c.ChallengerAthleteId == item.ChallengerAthleteId || c.ChallengeeAthleteId == item.ChallengerAthleteId) &&
c.LeagueId == item.LeagueId && c.DateCompleted == null);
if (challengerOngoing.Count() > 0)
{
throw "You already have an existing challenge underway.".ToException(Request);
}
//Check to see if there is already a challenge between the two athletes for this league
var history = _context.Challenges.Where(c => ((c.ChallengeeAthleteId == item.ChallengeeAthleteId && c.ChallengerAthleteId == item.ChallengerAthleteId) ||
(c.ChallengeeAthleteId == item.ChallengerAthleteId && c.ChallengerAthleteId == item.ChallengeeAthleteId)) &&
c.LeagueId == item.LeagueId).OrderByDescending(c => c.DateCompleted);
var league = _context.Leagues.SingleOrDefault(l => l.Id == item.LeagueId);
var lastChallenge = history.FirstOrDefault();
if (lastChallenge != null && lastChallenge.DateCompleted != null &&
lastChallenge.ChallengerAthleteId == item.ChallengerAthleteId && //is it the same athlete challenging again
lastChallenge.GetChallengerWinningGames().Count() < lastChallenge.GetChallengeeWinningGames().Count() && //did the challenger lose the previous match
DateTime.UtcNow.Subtract(lastChallenge.DateCompleted.Value.UtcDateTime).TotalHours < league.MinHoursBetweenChallenge) //has enough time passed
{
throw "You must wait at least {0} hours before challenging again".Fmt(league.MinHoursBetweenChallenge).ToException(Request);
}
Challenge current = await InsertAsync(item.ToChallenge());
var result = CreatedAtRoute("Tables", new { id = current.Id }, current.ToChallengeDto());
var message = "{0}: You have been challenged to a duel by {1}!".Fmt(league.Name, challenger.Alias);
var payload = new NotificationPayload
{
Action = PushActions.ChallengePosted,
Payload = { { "challengeId", current.Id }, { "leagueId", current.LeagueId } }
};
//Not awaiting so the user's result is not delayed
_notificationController.NotifyByTag(message, current.ChallengeeAthleteId, payload);
return(result);
}
internal void UpdateChallenge(ChallengeDto challenge)
{
throw new NotImplementedException();
}
public static ChallengeResponseAssertions Should(this ChallengeDto response)
{
return(new ChallengeResponseAssertions(response));
}
