public async Task <IActionResult> Create()
{
var site = await GetCurrentSiteAsync();
var siteUrl = await _siteService.GetBaseUrl(Request.Scheme, Request.Host.Value);
var viewModel = new TriggersDetailViewModel
{
Action = "Create",
IsSecretCode = true,
BadgeMakerUrl = GetBadgeMakerUrl(siteUrl, site.FromEmailAddress),
UseBadgeMaker = true,
EditAvatarBundle = UserHasPermission(Permission.ManageAvatars),
EditMail = UserHasPermission(Permission.ManageTriggerMail),
EditVendorCode = UserHasPermission(Permission.ManageVendorCodes),
SystemList = new SelectList((await _siteService.GetSystemList()), "Id", "Name"),
BranchList = new SelectList((await _siteService.GetAllBranches()), "Id", "Name"),
ProgramList = new SelectList((await _siteService.GetProgramList()), "Id", "Name")
};
if (viewModel.EditVendorCode)
{
viewModel.VendorCodeTypeList = new SelectList(
(await _vendorCodeService.GetTypeAllAsync()), "Id", "Description");
}
if (viewModel.EditAvatarBundle)
{
viewModel.UnlockableAvatarBundleList = new SelectList(
await _dynamicAvatarService.GetAllBundlesAsync(true), "Id", "Name");
}
PageTitle = "Create Trigger";
return(View("Detail", viewModel));
}
public async Task <IActionResult> Edit(int id)
{
var trigger = await _triggerService.GetByIdAsync(id);
var site = await GetCurrentSiteAsync();
var siteUrl = await _siteService.GetBaseUrl(Request.Scheme, Request.Host.Value);
TriggersDetailViewModel viewModel = new TriggersDetailViewModel()
{
Trigger = trigger,
Action = "Edit",
IsSecretCode = !string.IsNullOrWhiteSpace(trigger.SecretCode),
BadgeMakerUrl = GetBadgeMakerUrl(siteUrl, site.FromEmailAddress),
UseBadgeMaker = true,
DependentTriggers = await _triggerService.GetDependentsAsync(trigger.AwardBadgeId),
TriggerRequirements = await _triggerService.GetTriggerRequirementsAsync(trigger),
BadgeRequiredList = string.Join("", trigger.BadgeIds
.Select(_ => "<" + _.ToString() + ">")),
ChallengeRequiredList = string.Join("", trigger.ChallengeIds
.Select(_ => "<" + _.ToString() + ">")),
SystemList = new SelectList((await _siteService.GetSystemList()), "Id", "Name"),
BranchList = new SelectList((await _siteService.GetAllBranches()), "Id", "Name"),
ProgramList = new SelectList((await _siteService.GetProgramList()), "Id", "Name"),
VendorCodeTypeList = new SelectList(
(await _vendorCodeService.GetTypeAllAsync()), "Id", "Name")
};
foreach (var requirement in viewModel.TriggerRequirements)
{
if (!string.IsNullOrWhiteSpace(requirement.BadgePath))
{
requirement.BadgePath = _pathResolver.ResolveContentPath(requirement.BadgePath);
}
}
if (!string.IsNullOrWhiteSpace(viewModel.Trigger.AwardBadgeFilename))
{
viewModel.BadgePath = _pathResolver.ResolveContentPath(viewModel.Trigger.AwardBadgeFilename);
}
PageTitle = $"Edit Trigger - {viewModel.Trigger.Name}";
return(View("Detail", viewModel));
}
public async Task <IActionResult> Create()
{
var site = await GetCurrentSiteAsync();
var siteUrl = await _siteService.GetBaseUrl(Request.Scheme, Request.Host.Value);
TriggersDetailViewModel viewModel = new TriggersDetailViewModel()
{
Action = "Create",
IsSecretCode = true,
BadgeMakerUrl = GetBadgeMakerUrl(siteUrl, site.FromEmailAddress),
UseBadgeMaker = true,
SystemList = new SelectList((await _siteService.GetSystemList()), "Id", "Name"),
BranchList = new SelectList((await _siteService.GetAllBranches()), "Id", "Name"),
ProgramList = new SelectList((await _siteService.GetProgramList()), "Id", "Name"),
VendorCodeTypeList = new SelectList(
(await _vendorCodeService.GetTypeAllAsync()), "Id", "Name")
};
PageTitle = "Create Trigger";
return(View("Detail", viewModel));
}
public async Task <IActionResult> Edit(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 (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 (string.IsNullOrWhiteSpace(model.BadgeAltText))
{
ModelState.AddModelError("BadgeAltText", "The badge's alternative text is required.");
}
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, model.Trigger.Id))
{
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 = "";
}
var existing = await _badgeService
.GetByIdAsync(model.Trigger.AwardBadgeId);
string fileName;
if (model.BadgeUploadImage != null ||
!string.IsNullOrWhiteSpace(model.BadgeMakerImage))
{
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);
}
if (model.Trigger.AwardBadgeId == null)
{
var newBadge = new Badge
{
Filename = fileName,
AltText = model.BadgeAltText
};
var badge = await _badgeService.AddBadgeAsync(newBadge, badgeBytes);
model.Trigger.AwardBadgeId = badge.Id;
}
else
{
if (!string.Equals(existing.AltText, model.BadgeAltText,
StringComparison.OrdinalIgnoreCase))
{
existing.AltText = model.BadgeAltText;
await _badgeService.ReplaceBadgeFileAsync(existing, null, null);
}
existing.Filename = Path.GetFileName(model.BadgePath);
existing.AltText = model.BadgeAltText;
await _badgeService.ReplaceBadgeFileAsync(existing,
badgeBytes,
fileName);
}
}
else if (!string.Equals(existing.AltText, model.BadgeAltText,
StringComparison.OrdinalIgnoreCase))
{
existing.AltText = model.BadgeAltText;
await _badgeService.ReplaceBadgeFileAsync(existing, null, null);
}
var savedtrigger = await _triggerService.UpdateAsync(model.Trigger);
ShowAlertSuccess($"Trigger '<strong>{savedtrigger.Name}</strong>' was successfully modified");
return(RedirectToAction("Index"));
}
catch (GraException gex)
{
ShowAlertWarning("Unable to edit trigger: ", gex.Message);
}
}
model.Action = "Edit";
model.DependentTriggers = await _triggerService.GetDependentsAsync(model.Trigger.Id);
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");
}
else if (model.Trigger.AwardVendorCodeTypeId.HasValue)
{
model.VendorCodeType = (await _vendorCodeService
.GetTypeById(model.Trigger.AwardVendorCodeTypeId.Value)).Description;
}
if (model.EditAvatarBundle)
{
model.UnlockableAvatarBundleList = new SelectList(
await _avatarService.GetAllBundlesAsync(true), "Id", "Name");
}
else if (model.Trigger.AwardAvatarBundleId.HasValue)
{
model.UnlockableAvatarBundle = (await _avatarService
.GetBundleByIdAsync(model.Trigger.AwardAvatarBundleId.Value)).Name;
}
if (model.MaxPointLimit.HasValue)
{
model.MaxPointsMessage = $"(Up to {model.MaxPointLimit.Value} points)";
var currentTrigger = await _triggerService.GetByIdAsync(model.Trigger.Id);
if (currentTrigger.AwardPoints > model.MaxPointLimit.Value)
{
model.MaxPointsWarningMessage = $"This Trigger exceeds the maximum of {model.MaxPointLimit.Value} points per required task. Only Administrators can edit the points awarded.";
}
}
PageTitle = $"Edit Trigger - {model.Trigger.Name}";
return(View("Detail", model));
}
public async Task <IActionResult> Edit(int id)
{
var trigger = await _triggerService.GetByIdAsync(id);
if (trigger == null)
{
ShowAlertWarning($"Could not find trigger id {id}, possibly it has been deleted.");
return(RedirectToAction("Index"));
}
var site = await GetCurrentSiteAsync();
var siteUrl = await _siteService.GetBaseUrl(Request.Scheme, Request.Host.Value);
var badge = await _badgeService.GetByIdAsync(trigger.AwardBadgeId);
var viewModel = new TriggersDetailViewModel
{
Trigger = trigger,
CreatedByName = await _userService.GetUsersNameByIdAsync(trigger.CreatedBy),
CanViewParticipants = UserHasPermission(Permission.ViewParticipantDetails),
Action = "Edit",
IsSecretCode = !string.IsNullOrWhiteSpace(trigger.SecretCode),
BadgeMakerUrl = GetBadgeMakerUrl(siteUrl, site.FromEmailAddress),
UseBadgeMaker = true,
EditAvatarBundle = UserHasPermission(Permission.ManageAvatars),
EditMail = UserHasPermission(Permission.ManageTriggerMail),
EditVendorCode = UserHasPermission(Permission.ManageVendorCodes),
AwardsMail = !string.IsNullOrWhiteSpace(trigger.AwardMailSubject),
AwardsPrize = !string.IsNullOrWhiteSpace(trigger.AwardPrizeName),
DependentTriggers = await _triggerService.GetDependentsAsync(trigger.AwardBadgeId),
TriggerRequirements = await _triggerService.GetTriggerRequirementsAsync(trigger),
BadgeRequiredList = string.Join(",", trigger.BadgeIds),
ChallengeRequiredList = string.Join(",", trigger.ChallengeIds),
SystemList = new SelectList(await _siteService.GetSystemList(), "Id", "Name"),
ProgramList = new SelectList(await _siteService.GetProgramList(), "Id", "Name"),
IgnorePointLimits = UserHasPermission(Permission.IgnorePointLimits),
MaxPointLimit =
await _triggerService.GetMaximumAllowedPointsAsync(GetCurrentSiteId()),
BadgeAltText = badge.AltText
};
if (viewModel?.MaxPointLimit != null)
{
viewModel.MaxPointsMessage = $"(Up to {viewModel.MaxPointLimit.Value} points)";
}
if (trigger.AwardPoints > viewModel.MaxPointLimit)
{
viewModel.MaxPointsWarningMessage = $"This Trigger exceeds the maximum of {viewModel.MaxPointLimit.Value} points per required task. Only Administrators can edit the points awarded.";
}
if (viewModel.EditVendorCode)
{
viewModel.VendorCodeTypeList = new SelectList(
await _vendorCodeService.GetTypeAllAsync(), "Id", "Description");
}
else if (viewModel.Trigger.AwardVendorCodeTypeId.HasValue)
{
viewModel.VendorCodeType = (await _vendorCodeService
.GetTypeById(viewModel.Trigger.AwardVendorCodeTypeId.Value)).Description;
}
if (viewModel.EditAvatarBundle)
{
viewModel.UnlockableAvatarBundleList = new SelectList(
await _avatarService.GetAllBundlesAsync(true), "Id", "Name");
}
else if (viewModel.Trigger.AwardAvatarBundleId.HasValue)
{
viewModel.UnlockableAvatarBundle = (await _avatarService
.GetBundleByIdAsync(viewModel.Trigger.AwardAvatarBundleId.Value)).Name;
}
if (viewModel.Trigger.LimitToSystemId.HasValue)
{
viewModel.BranchList = new SelectList(
await _siteService.GetBranches(viewModel.Trigger.LimitToSystemId.Value), "Id", "Name");
}
else
{
viewModel.BranchList = new SelectList(await _siteService.GetAllBranches(), "Id", "Name");
}
foreach (var requirement in viewModel.TriggerRequirements)
{
if (!string.IsNullOrWhiteSpace(requirement.BadgePath))
{
requirement.BadgePath = _pathResolver.ResolveContentPath(requirement.BadgePath);
}
}
if (!string.IsNullOrWhiteSpace(viewModel.Trigger.AwardBadgeFilename))
{
viewModel.BadgePath = _pathResolver.ResolveContentPath(viewModel.Trigger.AwardBadgeFilename);
}
if (UserHasPermission(Permission.ManageEvents))
{
viewModel.RelatedEvents = await _eventService.GetRelatedEventsForTriggerAsync(id);
}
PageTitle = $"Edit Trigger - {viewModel.Trigger.Name}";
return(View("Detail", viewModel));
}
public async Task <IActionResult> Edit(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 (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("BadgeImage", "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, model.Trigger.Id))
{
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);
}
var existing = await _badgeService
.GetByIdAsync(model.Trigger.AwardBadgeId);
existing.Filename = Path.GetFileName(model.BadgePath);
await _badgeService.ReplaceBadgeFileAsync(existing, badgeBytes);
}
var savedtrigger = await _triggerService.UpdateAsync(model.Trigger);
ShowAlertSuccess($"Trigger '<strong>{savedtrigger.Name}</strong>' was successfully modified");
return(RedirectToAction("Index"));
}
catch (GraException gex)
{
ShowAlertWarning("Unable to edit trigger: ", gex.Message);
}
}
model.Action = "Edit";
model.DependentTriggers = await _triggerService.GetDependentsAsync(model.Trigger.Id);
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 = $"Edit Trigger - {model.Trigger.Name}";
return(View("Detail", model));
}
public async Task <IActionResult> Edit(int id)
{
var trigger = await _triggerService.GetByIdAsync(id);
var site = await GetCurrentSiteAsync();
var siteUrl = await _siteService.GetBaseUrl(Request.Scheme, Request.Host.Value);
var viewModel = new TriggersDetailViewModel
{
Trigger = trigger,
Action = "Edit",
IsSecretCode = !string.IsNullOrWhiteSpace(trigger.SecretCode),
BadgeMakerUrl = GetBadgeMakerUrl(siteUrl, site.FromEmailAddress),
UseBadgeMaker = true,
EditAvatarBundle = UserHasPermission(Permission.ManageAvatars),
EditMail = UserHasPermission(Permission.ManageTriggerMail),
EditVendorCode = UserHasPermission(Permission.ManageVendorCodes),
AwardsMail = !string.IsNullOrWhiteSpace(trigger.AwardMailSubject),
AwardsPrize = !string.IsNullOrWhiteSpace(trigger.AwardPrizeName),
DependentTriggers = await _triggerService.GetDependentsAsync(trigger.AwardBadgeId),
TriggerRequirements = await _triggerService.GetTriggerRequirementsAsync(trigger),
BadgeRequiredList = string.Join(",", trigger.BadgeIds),
ChallengeRequiredList = string.Join(",", trigger.ChallengeIds),
SystemList = new SelectList((await _siteService.GetSystemList()), "Id", "Name"),
ProgramList = new SelectList((await _siteService.GetProgramList()), "Id", "Name")
};
if (viewModel.EditVendorCode)
{
viewModel.VendorCodeTypeList = new SelectList(
(await _vendorCodeService.GetTypeAllAsync()), "Id", "Description");
}
else if (viewModel.Trigger.AwardVendorCodeTypeId.HasValue)
{
viewModel.VendorCodeType = (await _vendorCodeService
.GetTypeById(viewModel.Trigger.AwardVendorCodeTypeId.Value)).Description;
}
if (viewModel.EditAvatarBundle)
{
viewModel.UnlockableAvatarBundleList = new SelectList(
await _dynamicAvatarService.GetAllBundlesAsync(true), "Id", "Name");
}
else if (viewModel.Trigger.AwardAvatarBundleId.HasValue)
{
viewModel.UnlockableAvatarBundle = (await _dynamicAvatarService
.GetBundleByIdAsync(viewModel.Trigger.AwardAvatarBundleId.Value)).Name;
}
if (viewModel.Trigger.LimitToSystemId.HasValue)
{
viewModel.BranchList = new SelectList(
(await _siteService.GetBranches(viewModel.Trigger.LimitToSystemId.Value)), "Id", "Name");
}
else
{
viewModel.BranchList = new SelectList((await _siteService.GetAllBranches()), "Id", "Name");
}
foreach (var requirement in viewModel.TriggerRequirements)
{
if (!string.IsNullOrWhiteSpace(requirement.BadgePath))
{
requirement.BadgePath = _pathResolver.ResolveContentPath(requirement.BadgePath);
}
}
if (!string.IsNullOrWhiteSpace(viewModel.Trigger.AwardBadgeFilename))
{
viewModel.BadgePath = _pathResolver.ResolveContentPath(viewModel.Trigger.AwardBadgeFilename);
}
if (UserHasPermission(Permission.ManageEvents))
{
viewModel.RelatedEvents = await _eventService.GetRelatedEventsForTriggerAsync(id);
}
PageTitle = $"Edit Trigger - {viewModel.Trigger.Name}";
return(View("Detail", viewModel));
}
public async Task <IActionResult> Create(TriggersDetailViewModel model)
{
var badgeRequiredList = new List <int>();
var challengeRequiredList = new List <int>();
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.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 (model.AwardsPrize)
{
if (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().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.AwardsPrize)
{
model.Trigger.AwardPrizeName = "";
model.Trigger.AwardPrizeRedemptionInstructions = "";
}
if (!model.AwardsMail)
{
model.Trigger.AwardMailSubject = "";
model.Trigger.AwardMail = "";
}
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);
}
var 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.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 _dynamicAvatarService.GetAllBundlesAsync(true), "Id", "Name");
}
PageTitle = "Create Trigger";
return(View("Detail", model));
}
