public DomainOperationVo <int> DailyEntry(Guid giveawayId, Guid participantId)
{
GiveawayParticipant existing = repository.GetParticipantById(giveawayId, participantId);
if (existing == null)
{
return(new DomainOperationVo <int>(DomainActionPerformed.None, 0));
}
bool entryAlreadyExists = existing.Entries.Any(x => x.Type == GiveawayEntryType.Daily && x.Date.ToLocalTime().Date == DateTime.Today.ToLocalTime().Date);
if (entryAlreadyExists)
{
return(new DomainOperationVo <int>(DomainActionPerformed.None, 0));
}
existing.Entries.Add(new GiveawayEntry
{
Date = DateTime.Now,
Type = GiveawayEntryType.Daily,
Points = 1
});
repository.UpdateParticipant(giveawayId, existing);
int countDailyEntries = existing.Entries.Where(x => x.Type == GiveawayEntryType.Daily).Sum(x => x.Points);
return(new DomainOperationVo <int>(DomainActionPerformed.Create, countDailyEntries));
}
private bool IsOptionMandatory(GiveawayParticipant participant, KeyValuePair <GiveawayEntryType, int> entrySum)
{
switch (entrySum.Key)
{
case GiveawayEntryType.LoginOrEmail:
return(true);
case GiveawayEntryType.EmailConfirmed:
return(entrySum.Value > 0);
case GiveawayEntryType.ReferralCode:
return(participant.Entries.Any(x => x.Type == GiveawayEntryType.ReferralCode));
case GiveawayEntryType.Daily:
return(participant.Entries.Any(x => x.Type == GiveawayEntryType.Daily && x.Date.ToLocalTime().Date == DateTime.Today.ToLocalTime().Date));
case GiveawayEntryType.FacebookShare:
return(participant.Entries.Any(x => x.Type == GiveawayEntryType.FacebookShare));
case GiveawayEntryType.TwitterShare:
return(participant.Entries.Any(x => x.Type == GiveawayEntryType.TwitterShare));
default:
return(false);
}
}
private void SetEntryOptions(GiveawayParticipationViewModel vm, GiveawayParticipant participant)
{
Dictionary <GiveawayEntryType, int> groupedEntries = participant.Entries.GroupBy(x => x.Type).Select(x => new { EntryType = x.Key, EntryCount = x.Sum(y => y.Points) }).ToDictionary(x => x.EntryType, y => y.EntryCount);
List <GiveawayEntryType> entryOptionsList = Enum.GetValues(typeof(GiveawayEntryType)).Cast <GiveawayEntryType>().ToList();
foreach (GiveawayEntryType entryType in entryOptionsList)
{
KeyValuePair <GiveawayEntryType, int> entrySum = groupedEntries.FirstOrDefault(x => x.Key == entryType);
GiveawayEntryOptionViewModel existing = vm.EntryOptions.FirstOrDefault(x => x.Type == entryType);
if (existing != null)
{
existing.Type = entryType;
existing.Points = entrySum.Value;
existing.IsMandatory = IsOptionMandatory(participant, entrySum);
}
else
{
vm.EntryOptions.Add(new GiveawayEntryOptionViewModel
{
Type = entryType,
Name = entryType.ToUiInfo().Description,
Points = entrySum.Value,
IsMandatory = IsOptionMandatory(participant, entrySum)
});
}
}
}
public void AddParticipant(Guid giveawayId, GiveawayParticipant participant)
{
participant.Id = Guid.NewGuid();
FilterDefinition <Giveaway> filter = Builders <Giveaway> .Filter.Where(x => x.Id == giveawayId);
UpdateDefinition <Giveaway> add = Builders <Giveaway> .Update.AddToSet(c => c.Participants, participant);
Context.AddCommand(() => DbSet.UpdateOneAsync(filter, add));
}
public void DeclareNotWinner(Guid giveawayId, Guid participantId)
{
GiveawayParticipant participant = repository.GetParticipantById(giveawayId, participantId);
if (participant != null)
{
participant.IsWinner = false;
repository.UpdateParticipant(giveawayId, participant);
}
}
public void UpdateParticipantShortUrl(Guid giveawayId, string email, string shortUrl)
{
GiveawayParticipant existing = repository.GetParticipantByEmail(giveawayId, email);
if (existing != null)
{
existing.ShortUrl = shortUrl;
repository.UpdateParticipant(giveawayId, existing);
}
}
public DomainOperationVo <GiveawayParticipant> AddParticipant(Guid giveawayId, string email, bool gdprConsent, bool wantNotifications, string referalCode, string referrer, GiveawayEntryType?entryType)
{
GiveawayParticipant participant;
IQueryable <GiveawayParticipant> existing = repository.GetParticipants(giveawayId);
bool exists = existing.Any(x => x.Email == email);
if (exists)
{
participant = existing.First(x => x.Email == email);
repository.UpdateParticipant(giveawayId, participant);
return(new DomainOperationVo <GiveawayParticipant>(DomainActionPerformed.Update, participant));
}
else
{
participant = new GiveawayParticipant
{
Email = email,
GdprConsent = gdprConsent,
WantNotifications = wantNotifications
};
participant.Entries.Add(new GiveawayEntry
{
Type = GiveawayEntryType.LoginOrEmail,
Points = 1
});
participant.ReferralCode = referalCode;
repository.AddParticipant(giveawayId, participant);
if (!string.IsNullOrWhiteSpace(referrer))
{
GiveawayParticipant referrerParticipant = repository.GetParticipantByReferralCode(giveawayId, referrer);
if (referrerParticipant != null)
{
referrerParticipant.Entries.Add(new GiveawayEntry
{
Type = entryType ?? GiveawayEntryType.ReferralCode,
Points = 1
});
repository.UpdateParticipant(giveawayId, referrerParticipant);
}
}
return(new DomainOperationVo <GiveawayParticipant>(DomainActionPerformed.Create, participant));
}
}
public void ConfirmParticipant(Guid giveawayId, string referralCode)
{
GiveawayParticipant existing = repository.GetParticipantByReferralCode(giveawayId, referralCode);
if (existing != null && !existing.Entries.Any(x => x.Type == GiveawayEntryType.EmailConfirmed))
{
existing.Entries.Add(new GiveawayEntry
{
Type = GiveawayEntryType.EmailConfirmed,
Points = 1
});
repository.UpdateParticipant(giveawayId, existing);
}
}
public void UpdateParticipant(Guid giveawayId, GiveawayParticipant participant)
{
FilterDefinition <Giveaway> filter = Builders <Giveaway> .Filter.And(
Builders <Giveaway> .Filter.Eq(x => x.Id, giveawayId),
Builders <Giveaway> .Filter.ElemMatch(x => x.Participants, x => x.Id == participant.Id));
UpdateDefinition <Giveaway> update = Builders <Giveaway> .Update
.Set(c => c.Participants[-1].Email, participant.Email)
.Set(c => c.Participants[-1].GdprConsent, participant.GdprConsent)
.Set(c => c.Participants[-1].WantNotifications, participant.WantNotifications)
.Set(c => c.Participants[-1].ShortUrl, participant.ShortUrl)
.Set(c => c.Participants[-1].IsWinner, participant.IsWinner)
.Set(c => c.Participants[-1].Entries, participant.Entries);
Context.AddCommand(() => DbSet.UpdateOneAsync(filter, update));
}
public void PickAllWinners(Guid giveawayId)
{
Task <GiveawayBasicInfo> task = Task.Run(async() => await repository.GetBasicGiveawayById(giveawayId));
task.Wait();
GiveawayBasicInfo basicInfo = task.Result;
List <GiveawayParticipant> allParticipants = repository.GetParticipants(giveawayId).ToList();
List <GiveawayParticipant> winners = allParticipants.Where(x => x.IsWinner).ToList();
List <GiveawayParticipant> nonWinners = allParticipants.Where(x => !x.IsWinner).ToList();
var allEntries = (from p in nonWinners
from e in p.Entries
select new
{
Participant = p,
Entry = e
}).ToList();
int winnersToSelect = basicInfo.WinnerAmount - winners.Count;
if (allParticipants.Count < winnersToSelect)
{
winnersToSelect = allParticipants.Count;
}
if (winnersToSelect > 0)
{
Random rand = new Random(DateTime.Now.ToString().GetHashCode());
for (int i = 0; i < winnersToSelect; i++)
{
int index = rand.Next(0, allEntries.Count);
GiveawayParticipant winner = allEntries.ElementAt(index).Participant;
winner.IsWinner = true;
repository.UpdateParticipant(giveawayId, winner);
allEntries = allEntries.Except(allEntries.Where(x => x.Participant.Id == winner.Id)).ToList();
}
}
repository.UpdateGiveawayStatus(giveawayId, GiveawayStatus.Ended);
}
public void PickSingleWinner(Guid giveawayId)
{
List <GiveawayParticipant> nonWinners = repository.GetParticipants(giveawayId).Where(x => !x.IsWinner).ToList();
if (nonWinners.Any())
{
Random rand = new Random(DateTime.Now.ToString().GetHashCode());
int index = rand.Next(0, nonWinners.Count);
GiveawayParticipant winner = nonWinners.ElementAt(index);
winner.IsWinner = true;
repository.UpdateParticipant(giveawayId, winner);
}
}
public OperationResultVo GetGiveawayParticipantInfo(Guid currentUserId, Guid giveawayId, string email)
{
try
{
GiveawayBasicInfo existing = giveawayDomainService.GetGiveawayBasicInfoById(giveawayId);
if (existing == null)
{
return(new OperationResultVo(false, "Giveaway not found!"));
}
GiveawayParticipant participant = giveawayDomainService.GetParticipantByEmail(giveawayId, email);
if (participant == null)
{
return(new OperationResultVo(false, "No participant found for that email!"));
}
GiveawayParticipationViewModel vm = mapper.Map <GiveawayParticipationViewModel>(existing);
SetViewModelState(currentUserId, vm);
vm.EntryCount = participant.Entries.Sum(x => x.Points);
vm.ShareUrl = participant.ShortUrl;
vm.EmailConfirmed = participant.Entries.Any(x => x.Type == GiveawayEntryType.EmailConfirmed);
SetImagesToShow(vm, false);
SetEntryOptions(vm, participant);
vm.ParticipantId = participant.Id;
return(new OperationResultVo <GiveawayParticipationViewModel>(vm));
}
catch (Exception ex)
{
return(new OperationResultVo(ex.Message));
}
}
public GiveawayParticipant GetParticipantById(Guid giveawayId, Guid participantId)
{
GiveawayParticipant model = DbSet.AsQueryable().Where(x => x.Id == giveawayId).SelectMany(x => x.Participants).FirstOrDefault(x => x.Id == participantId);
return(model);
}
public GiveawayParticipant GetParticipantByReferralCode(Guid giveawayId, string referralCode)
{
GiveawayParticipant model = DbSet.AsQueryable().Where(x => x.Id == giveawayId).SelectMany(x => x.Participants).FirstOrDefault(x => x.ReferralCode.Equals(referralCode));
return(model);
}
public GiveawayParticipant GetParticipantByEmail(Guid giveawayId, string email)
{
GiveawayParticipant model = DbSet.AsQueryable().Where(x => x.Id == giveawayId).SelectMany(x => x.Participants).FirstOrDefault(x => x.Email.Equals(email));
return(model);
}
public GiveawayParticipant GetParticipantByEmail(Guid giveawayId, string email)
{
GiveawayParticipant model = repository.GetParticipantByEmail(giveawayId, email);
return(model);
}
