public async Task <IActionResult> Create(TriggersDetailViewModel model)
{
byte[] badgeBytes = null;
var badgeRequiredList = new List <int>();
var challengeRequiredList = new List <int>();
model.IgnorePointLimits = UserHasPermission(Permission.IgnorePointLimits);
model.MaxPointLimit = await _triggerService
.GetMaximumAllowedPointsAsync(GetCurrentSiteId());
if (!model.IgnorePointLimits &&
model.MaxPointLimit.HasValue &&
model.Trigger.AwardPoints > model.MaxPointLimit)
{
ModelState.AddModelError("Trigger.AwardPoints",
$"You may award up to {model.MaxPointLimit} points.");
}
if (!string.IsNullOrWhiteSpace(model.BadgeRequiredList))
{
badgeRequiredList = model.BadgeRequiredList
.Split(',')
.Where(_ => !string.IsNullOrWhiteSpace(_))
.Select(int.Parse)
.ToList();
}
if (!string.IsNullOrWhiteSpace(model.ChallengeRequiredList))
{
challengeRequiredList = model.ChallengeRequiredList
.Split(',')
.Where(_ => !string.IsNullOrWhiteSpace(_))
.Select(int.Parse)
.ToList();
}
var requirementCount = badgeRequiredList.Count + challengeRequiredList.Count;
if (string.IsNullOrWhiteSpace(model.BadgeAltText))
{
ModelState.AddModelError("BadgeAltText", "The badge's alternative text is required.");
}
if (string.IsNullOrWhiteSpace(model.BadgeMakerImage) && model.BadgeUploadImage == null)
{
ModelState.AddModelError("BadgePath", "A badge is required.");
}
else if (model.BadgeUploadImage != null &&
(string.IsNullOrWhiteSpace(model.BadgeMakerImage) || !model.UseBadgeMaker))
{
if (!ValidImageExtensions.Contains(
Path.GetExtension(model.BadgeUploadImage.FileName).ToLowerInvariant()))
{
ModelState.AddModelError("BadgeUploadImage", $"Image must be one of the following types: {string.Join(", ", ValidImageExtensions)}");
}
if (model.BadgeUploadImage != null)
{
try
{
using (var ms = new MemoryStream())
{
await model.BadgeUploadImage.CopyToAsync(ms);
badgeBytes = ms.ToArray();
}
await _badgeService.ValidateBadgeImageAsync(badgeBytes);
}
catch (GraException gex)
{
ModelState.AddModelError("BadgeUploadImage", gex.Message);
}
}
}
if (!model.IsSecretCode)
{
if ((!model.Trigger.Points.HasValue || model.Trigger.Points < 1) &&
requirementCount < 1)
{
ModelState.AddModelError("TriggerRequirements", "Points or a Challenge/Trigger item is required.");
}
else if ((!model.Trigger.ItemsRequired.HasValue || model.Trigger.ItemsRequired < 1) &&
requirementCount >= 1)
{
ModelState.AddModelError("Trigger.ItemsRequired", "Please enter how many of the Challenge/Trigger item are required.");
}
else if (model.Trigger.ItemsRequired > requirementCount)
{
ModelState.AddModelError("Trigger.ItemsRequired", "Items Required can not be greater than the number of Challenge/Trigger items.");
}
}
else if (string.IsNullOrWhiteSpace(model.Trigger.SecretCode))
{
ModelState.AddModelError("Trigger.SecretCode", "The Secret Code field is required.");
}
else if (await _triggerService.CodeExistsAsync(model.Trigger.SecretCode))
{
ModelState.AddModelError("Trigger.SecretCode", "That Secret Code already exists.");
}
if (model.AwardsPrize && string.IsNullOrWhiteSpace(model.Trigger.AwardPrizeName))
{
ModelState.AddModelError("Trigger.AwardPrizeName", "The Prize Name field is required.");
}
if (model.AwardsMail)
{
if (string.IsNullOrWhiteSpace(model.Trigger.AwardMailSubject))
{
ModelState.AddModelError("Trigger.AwardMailSubject", "The Mail Subject field is required.");
}
if (string.IsNullOrWhiteSpace(model.Trigger.AwardMail))
{
ModelState.AddModelError("Trigger.AwardMail", "The Mail Message field is required.");
}
}
if (ModelState.IsValid)
{
try
{
if (model.IsSecretCode)
{
model.Trigger.Points = null;
model.Trigger.ItemsRequired = null;
model.Trigger.LimitToSystemId = null;
model.Trigger.LimitToBranchId = null;
model.Trigger.LimitToProgramId = null;
model.Trigger.SecretCode = model
.Trigger.SecretCode
.Trim()
.ToLowerInvariant();
model.Trigger.BadgeIds = new List <int>();
model.Trigger.ChallengeIds = new List <int>();
}
else
{
model.Trigger.SecretCode = null;
model.Trigger.BadgeIds = badgeRequiredList;
model.Trigger.ChallengeIds = challengeRequiredList;
}
if (!model.AwardsPrize)
{
model.Trigger.AwardPrizeName = "";
model.Trigger.AwardPrizeRedemptionInstructions = "";
}
if (!model.AwardsMail)
{
model.Trigger.AwardMailSubject = "";
model.Trigger.AwardMail = "";
}
if (model.BadgeUploadImage != null ||
!string.IsNullOrWhiteSpace(model.BadgeMakerImage))
{
string filename;
if (!string.IsNullOrWhiteSpace(model.BadgeMakerImage) &&
(model.BadgeUploadImage == null || model.UseBadgeMaker))
{
var badgeString = model.BadgeMakerImage.Split(',').Last();
badgeBytes = Convert.FromBase64String(badgeString);
filename = "badge.png";
}
else
{
if (badgeBytes == null)
{
using (var ms = new MemoryStream())
{
await model.BadgeUploadImage.CopyToAsync(ms);
badgeBytes = ms.ToArray();
}
}
filename = Path.GetFileName(model.BadgeUploadImage.FileName);
}
var newBadge = new Badge
{
Filename = filename,
AltText = model.BadgeAltText
};
var badge = await _badgeService.AddBadgeAsync(newBadge, badgeBytes);
model.Trigger.AwardBadgeId = badge.Id;
}
var trigger = await _triggerService.AddAsync(model.Trigger);
ShowAlertSuccess($"Trigger '<strong>{trigger.Name}</strong>' was successfully created");
return(RedirectToAction("Index"));
}
catch (GraException gex)
{
ShowAlertWarning("Unable to add trigger: ", gex.Message);
}
}
model.Action = "Create";
model.SystemList = new SelectList(await _siteService.GetSystemList(), "Id", "Name");
if (model.Trigger.LimitToSystemId.HasValue)
{
model.BranchList = new SelectList(
await _siteService.GetBranches(model.Trigger.LimitToSystemId.Value), "Id", "Name");
}
else
{
model.BranchList = new SelectList(await _siteService.GetAllBranches(), "Id", "Name");
}
model.ProgramList = new SelectList(await _siteService.GetProgramList(), "Id", "Name");
model.TriggerRequirements = await _triggerService
.GetRequirementsByIdsAsync(badgeRequiredList, challengeRequiredList);
foreach (var requirement in model.TriggerRequirements)
{
requirement.BadgePath = _pathResolver.ResolveContentPath(requirement.BadgePath);
}
if (model.EditVendorCode)
{
model.VendorCodeTypeList = new SelectList(
await _vendorCodeService.GetTypeAllAsync(), "Id", "Description");
}
if (model.EditAvatarBundle)
{
model.UnlockableAvatarBundleList = new SelectList(
await _avatarService.GetAllBundlesAsync(true), "Id", "Name");
}
if (model.MaxPointLimit.HasValue)
{
model.MaxPointsMessage = $"(Up to {model.MaxPointLimit.Value} points)";
}
PageTitle = "Create Trigger";
return(View("Detail", model));
}
public async Task <IActionResult> Create(TriggersDetailViewModel model)
{
List <int> badgeRequiredList = new List <int>();
List <int> challengeRequiredList = new List <int>();
if (!string.IsNullOrWhiteSpace(model.BadgeRequiredList))
{
badgeRequiredList = model.BadgeRequiredList
.Replace("<", "")
.Split('>')
.Where(_ => !string.IsNullOrWhiteSpace(_))
.Select(Int32.Parse)
.ToList();
}
if (!string.IsNullOrWhiteSpace(model.ChallengeRequiredList))
{
challengeRequiredList = model.ChallengeRequiredList
.Replace("<", "")
.Split('>')
.Where(_ => !string.IsNullOrWhiteSpace(_))
.Select(Int32.Parse)
.ToList();
}
var requirementCount = badgeRequiredList.Count + challengeRequiredList.Count;
if (string.IsNullOrWhiteSpace(model.BadgeMakerImage) && model.BadgeUploadImage == null)
{
ModelState.AddModelError("BadgePath", "A badge is required.");
}
else if (model.BadgeUploadImage != null &&
(string.IsNullOrWhiteSpace(model.BadgeMakerImage) || !model.UseBadgeMaker) &&
(Path.GetExtension(model.BadgeUploadImage.FileName).ToLower() != ".jpg" &&
Path.GetExtension(model.BadgeUploadImage.FileName).ToLower() != ".jpeg" &&
Path.GetExtension(model.BadgeUploadImage.FileName).ToLower() != ".png"))
{
ModelState.AddModelError("BadgeUploadImage", "Please use a .jpg or .png image.");
}
if (!model.IsSecretCode)
{
if ((!model.Trigger.Points.HasValue || model.Trigger.Points < 1) &&
requirementCount < 1)
{
ModelState.AddModelError("TriggerRequirements", "Points or a Challenge/Trigger item is required.");
}
else if ((!model.Trigger.ItemsRequired.HasValue || model.Trigger.ItemsRequired < 1) &&
requirementCount >= 1)
{
ModelState.AddModelError("Trigger.ItemsRequired", "Please enter how many of the Challenge/Trigger item are required.");
}
else if (model.Trigger.ItemsRequired > requirementCount)
{
ModelState.AddModelError("Trigger.ItemsRequired", "Items Required can not be greater than the number of Challenge/Trigger items.");
}
}
else if (string.IsNullOrWhiteSpace(model.Trigger.SecretCode))
{
ModelState.AddModelError("Trigger.SecretCode", "The Secret Code field is required.");
}
else if (await _triggerService.CodeExistsAsync(model.Trigger.SecretCode))
{
ModelState.AddModelError("Trigger.SecretCode", "That Secret Code already exists.");
}
if (ModelState.IsValid)
{
try
{
if (model.IsSecretCode)
{
model.Trigger.Points = null;
model.Trigger.ItemsRequired = null;
model.Trigger.LimitToSystemId = null;
model.Trigger.LimitToBranchId = null;
model.Trigger.LimitToProgramId = null;
model.Trigger.SecretCode = model.Trigger.SecretCode.Trim().ToLower();
model.Trigger.BadgeIds = new List <int>();
model.Trigger.ChallengeIds = new List <int>();
}
else
{
model.Trigger.SecretCode = null;
model.Trigger.BadgeIds = badgeRequiredList;
model.Trigger.ChallengeIds = challengeRequiredList;
}
if (model.BadgeUploadImage != null ||
!string.IsNullOrWhiteSpace(model.BadgeMakerImage))
{
byte[] badgeBytes;
string filename;
if (!string.IsNullOrWhiteSpace(model.BadgeMakerImage) &&
(model.BadgeUploadImage != null || model.UseBadgeMaker))
{
var badgeString = model.BadgeMakerImage.Split(',').Last();
badgeBytes = Convert.FromBase64String(badgeString);
filename = "badge.png";
}
else
{
using (var fileStream = model.BadgeUploadImage.OpenReadStream())
{
using (var ms = new MemoryStream())
{
fileStream.CopyTo(ms);
badgeBytes = ms.ToArray();
}
}
filename = Path.GetFileName(model.BadgeUploadImage.FileName);
}
Badge newBadge = new Badge()
{
Filename = filename
};
var badge = await _badgeService.AddBadgeAsync(newBadge, badgeBytes);
model.Trigger.AwardBadgeId = badge.Id;
}
var trigger = await _triggerService.AddAsync(model.Trigger);
ShowAlertSuccess($"Trigger '<strong>{trigger.Name}</strong>' was successfully created");
return(RedirectToAction("Index"));
}
catch (GraException gex)
{
ShowAlertWarning("Unable to add trigger: ", gex.Message);
}
}
model.Action = "Create";
model.SystemList = new SelectList((await _siteService.GetSystemList()), "Id", "Name");
if (model.Trigger.LimitToSystemId.HasValue)
{
model.BranchList = new SelectList(
(await _siteService.GetBranches(model.Trigger.LimitToSystemId.Value)), "Id", "Name");
}
else
{
model.BranchList = new SelectList((await _siteService.GetAllBranches()), "Id", "Name");
}
model.ProgramList = new SelectList((await _siteService.GetProgramList()), "Id", "Name");
model.VendorCodeTypeList = new SelectList(
(await _vendorCodeService.GetTypeAllAsync()), "Id", "Name");
model.TriggerRequirements = await _triggerService
.GetRequirementsByIdsAsync(badgeRequiredList, challengeRequiredList);
foreach (var requirement in model.TriggerRequirements)
{
requirement.BadgePath = _pathResolver.ResolveContentPath(requirement.BadgePath);
}
PageTitle = "Create Trigger";
return(View("Detail", model));
}
