public CountReport CountArchivedItems()
{
var stopWatch = new Stopwatch();
stopWatch.Start();
var progressReport = new CountReport()
{
TotalElapsedTime = stopWatch.Elapsed
};
//progressReport.TotalFiles = Directory.EnumerateFiles(Destination, "*.*", SearchOption.AllDirectories)
//.Count(fn => !Path.GetFileName(fn).StartsWith(".", StringComparison.InvariantCultureIgnoreCase));
//var filesToCheck = Directory.EnumerateFiles(Destination, "[arc]*.*", SearchOption.AllDirectories);
var filesToCheck = Directory.EnumerateFiles(Destination, "*.*", SearchOption.AllDirectories)
.Where(fn => !Path.GetFileName(fn).StartsWith(".", StringComparison.InvariantCultureIgnoreCase));
foreach (var fn in filesToCheck)
{
var fInfo = new FileInfo(fn);
if (!Path.GetFileName(fn).StartsWith("[arc]", StringComparison.InvariantCultureIgnoreCase))
{
progressReport.SignalNonValidFile(fInfo.Length);
continue;
}
var fileExtension = Path.GetExtension(fn).ToLowerInvariant();
if (ValidImageExtensions.Contains(fileExtension))
{
progressReport.SignalImageFile(fInfo.Length);
}
else if (ValidVideoExtensions.Contains(fileExtension))
{
progressReport.SignalVideoFile(fInfo.Length);
}
else
{
progressReport.SignalOtherFile(fInfo.Length, fileExtension);
}
}
stopWatch.Stop();
progressReport.TotalElapsedTime = stopWatch.Elapsed;
return(progressReport);
}
/*
* /// <summary>
* /// Sets image source to file.
* /// </summary>
* /// <returns>The file.</returns>
* /// <param name="path">Path.</param>
* public static Xamarin.Forms.ImageSource FromFile(string path) {
* var imageSource = Xamarin.Forms.ImageSource.FromFile (path);
* if (imageSource != null) {
* imageSource.SetValue (ImageSource.PathProperty, path);
* }
* return imageSource;
* }
*
* /// <summary>
* /// Froms the URI.
* /// </summary>
* /// <returns>The URI.</returns>
* public static Xamarin.Forms.ImageSource FromUri(Uri uri) {
* var imageSource = Xamarin.Forms.ImageSource.FromUri (uri);
* if (imageSource != null) {
* imageSource.SetValue (ImageSource.PathProperty, uri.AbsolutePath);
* }
* return imageSource;
* }
*
* /// <summary>
* /// Froms the stream.
* /// </summary>
* /// <returns>The stream.</returns>
* public static Xamarin.Forms.ImageSource FromStream(Func<System.IO.Stream> stream) {
* var imageSource = Xamarin.Forms.ImageSource.FromStream (stream);
* if (imageSource != null) {
* imageSource.SetValue (ImageSource.PathProperty, stream.ToString());
* }
* return imageSource;
* }
*/
#endregion
#region Path Parsing
static Tuple <string, string> GetiOSBasePathAndExt(string pathString)
{
if (pathString == null)
{
return(null);
}
var reqResExt = null as string;
var reqResBasePath = pathString;
//var reqResSplit = pathString.Split(new char[] { '.', '/', '\\' });
var reqResSplit = pathString.Split('.');
if (reqResSplit.Length > 1 && ValidImageExtensions.Contains(reqResSplit[reqResSplit.Length - 1].ToLower()))
{
reqResExt = reqResSplit[reqResSplit.Length - 1];
reqResBasePath = pathString.Substring(0, pathString.Length - reqResExt.Length - 1);
}
if (reqResExt == "png" && reqResSplit.Length > 2 && reqResSplit[reqResSplit.Length - 2] == "9")
{
reqResExt = "9.png";
reqResBasePath = reqResBasePath.Substring(0, reqResBasePath.Length - 2);
}
return(new Tuple <string, string>(reqResBasePath, reqResExt));
}
public async Task <IActionResult> ProgramImages(ProgramImagesViewModel model)
{
var settings = await _performerSchedulingService.GetSettingsAsync();
var schedulingStage = _performerSchedulingService.GetSchedulingStage(settings);
if (schedulingStage != PsSchedulingStage.RegistrationOpen)
{
return(RedirectToAction(nameof(Index)));
}
var userId = GetId(ClaimType.UserId);
var performer = await _performerSchedulingService.GetPerformerByUserIdAsync(userId);
if (performer?.RegistrationCompleted != true)
{
return(RedirectToAction(nameof(Information)));
}
if (model.Images == null)
{
ModelState.AddModelError("Images", "Please attach an image to submit.");
}
else if (model.Images.Count > 0)
{
var extensions = model.Images.Select(_ => Path.GetExtension(_.FileName).ToLower());
if (extensions.Any(_ => !ValidImageExtensions.Contains(_)))
{
ModelState.AddModelError("Images", $"Image must be one of the following types: {string.Join(", ", ValidImageExtensions)}");
}
else if (model.Images.Sum(_ => _.Length) > MaxUploadMB * MBSize)
{
ModelState.AddModelError("Images", $"Please limit uploads to a max of {MaxUploadMB}MB.");
}
}
if (ModelState.IsValid)
{
foreach (var image in model.Images)
{
using (var fileStream = image.OpenReadStream())
{
using (var ms = new MemoryStream())
{
fileStream.CopyTo(ms);
await _performerSchedulingService.AddProgramImageAsync(
model.ProgramId, ms.ToArray(), Path.GetExtension(image.FileName));
}
}
}
ShowAlertSuccess("Image(s) added!");
return(RedirectToAction(nameof(ProgramImages), new { id = model.ProgramId }));
}
PsProgram program;
try
{
program = await _performerSchedulingService.GetProgramByIdAsync(model.ProgramId,
includeImages : true);
}
catch (GraException gex)
{
ShowAlertDanger("Unable to view program images: ", gex);
return(RedirectToAction(nameof(Index)));
}
program.Images.ForEach(_ => _.Filename = _pathResolver.ResolveContentPath(_.Filename));
model.IsEditable = schedulingStage == PsSchedulingStage.RegistrationOpen;
model.MaxUploadMB = MaxUploadMB;
model.ProgramTitle = program.Title;
model.ProgramImages = program.Images;
return(View(model));
}
public async Task <IActionResult> Program(ProgramViewModel model)
{
var settings = await _performerSchedulingService.GetSettingsAsync();
var schedulingStage = _performerSchedulingService.GetSchedulingStage(settings);
if (schedulingStage != PsSchedulingStage.RegistrationOpen)
{
return(RedirectToAction(nameof(Index)));
}
var userId = GetId(ClaimType.UserId);
var performer = await _performerSchedulingService.GetPerformerByUserIdAsync(userId);
if (performer == null)
{
return(RedirectToAction(nameof(Information)));
}
else if (!performer.SetSchedule)
{
return(RedirectToAction(nameof(Schedule)));
}
var ageGroups = await _performerSchedulingService.GetAgeGroupsAsync();
var ageSelection = ageGroups
.Where(_ => model.AgeSelection?.Contains(_.Id) == true)
.Select(_ => _.Id)
.ToList();
if (ageSelection.Count == 0)
{
ModelState.AddModelError("AgeSelection", "Please select age groups.");
}
if (model.Images?.Count > 0)
{
var extensions = model.Images.Select(_ => Path.GetExtension(_.FileName).ToLower());
if (extensions.Any(_ => !ValidImageExtensions.Contains(_)))
{
ModelState.AddModelError("Images", $"Image must be one of the following types: {string.Join(", ", ValidImageExtensions)}");
}
else if (model.Images.Sum(_ => _.Length) > MaxUploadMB * MBSize)
{
ModelState.AddModelError("Images", $"Please limit uploads to a max of {MaxUploadMB}MB.");
}
}
if (ModelState.IsValid)
{
if (model.EditingProgram)
{
try
{
var program = await _performerSchedulingService.UpdateProgramAsync(
model.Program, ageSelection);
ShowAlertSuccess("Program saved!");
return(RedirectToAction(nameof(ProgramDetails), new { id = program.Id }));
}
catch (GraException gex)
{
ShowAlertDanger("Unable to update Program: ", gex);
return(RedirectToAction(nameof(Dashboard)));
}
}
else
{
model.Program.PerformerId = performer.Id;
var program = await _performerSchedulingService.AddProgramAsync(model.Program,
ageSelection);
if (model.Images != null)
{
foreach (var image in model.Images)
{
using (var fileStream = image.OpenReadStream())
{
using (var ms = new MemoryStream())
{
fileStream.CopyTo(ms);
await _performerSchedulingService.AddProgramImageAsync(
program.Id, ms.ToArray(), Path.GetExtension(image.FileName));
}
}
}
}
}
if (!performer.RegistrationCompleted)
{
await _performerSchedulingService.SetPerformerRegistrationCompeltedAsync(
performer.Id);
ShowAlertSuccess("Registration completed!");
}
else
{
ShowAlertSuccess("Program added!");
}
return(RedirectToAction(nameof(Dashboard)));
}
var ageList = new SelectList(ageGroups, "Id", "Name");
if (ageList.Count() == 1)
{
ageList.First().Selected = true;
}
model.AgeList = ageList;
model.MaxUploadMB = MaxUploadMB;
return(View(model));
}
public async Task <IActionResult> Information(InformationViewModel model)
{
var settings = await _performerSchedulingService.GetSettingsAsync();
var schedulingStage = _performerSchedulingService.GetSchedulingStage(settings);
if (schedulingStage != PsSchedulingStage.RegistrationOpen)
{
return(RedirectToAction(nameof(Index)));
}
var userId = GetId(ClaimType.UserId);
var currentPerformer = await _performerSchedulingService
.GetPerformerByUserIdAsync(userId);
if (currentPerformer?.RegistrationCompleted == false)
{
return(RedirectToAction(nameof(Schedule)));
}
var systems = await _performerSchedulingService
.GetSystemListWithoutExcludedBranchesAsync();
var branchIds = systems.SelectMany(_ => _.Branches).Select(_ => _.Id);
var BranchAvailability = JsonConvert.DeserializeObject
<List <int> >(model.BranchAvailabilityString)
.Where(_ => branchIds.Contains(_)).ToList();
if (BranchAvailability.Count == 0)
{
ModelState.AddModelError("BranchAvailability", "Please select the libraries where you are willing to perform.");
}
if (currentPerformer == null)
{
if (model.Images == null)
{
ModelState.AddModelError("Images", "Please attach an image to submit.");
}
else if (model.Images?.Count > 0)
{
var extensions = model.Images.Select(_ => Path.GetExtension(_.FileName).ToLower());
if (extensions.Any(_ => !ValidImageExtensions.Contains(_)))
{
ModelState.AddModelError("Images", $"Image must be one of the following types: {string.Join(", ", ValidImageExtensions)}");
}
else if (model.Images.Sum(_ => _.Length) > MaxUploadMB * MBSize)
{
ModelState.AddModelError("Images", $"Please limit uploads to a max of {MaxUploadMB}MB.");
}
}
if (model.References == null)
{
ModelState.AddModelError("References", "Please attach a list of references to submit.");
}
}
if (model.References != null &&
!string.Equals(Path.GetExtension(model.References.FileName),
".pdf",
StringComparison.OrdinalIgnoreCase))
{
ModelState.AddModelError("References", "Please attach a .pdf file.");
}
if (ModelState.IsValid)
{
var performer = model.Performer;
performer.AllBranches = BranchAvailability.Count == branchIds.Count();
if (currentPerformer?.RegistrationCompleted == true)
{
performer.Id = currentPerformer.Id;
performer = await _performerSchedulingService.EditPerformerAsync(performer,
BranchAvailability);
}
else
{
performer = await _performerSchedulingService.AddPerformerAsync(performer,
BranchAvailability);
}
if (model.References != null)
{
using (var fileStream = model.References.OpenReadStream())
{
using (var ms = new MemoryStream())
{
fileStream.CopyTo(ms);
await _performerSchedulingService.SetPerformerReferencesAsync(
performer.Id, ms.ToArray(),
Path.GetExtension(model.References.FileName));
}
}
}
if (!performer.RegistrationCompleted)
{
foreach (var image in model.Images)
{
using (var fileStream = image.OpenReadStream())
{
using (var ms = new MemoryStream())
{
fileStream.CopyTo(ms);
await _performerSchedulingService.AddPerformerImageAsync(
performer.Id, ms.ToArray(), Path.GetExtension(image.FileName));
}
}
}
return(RedirectToAction(nameof(Schedule)));
}
else
{
ShowAlertSuccess("Information saved!");
return(RedirectToAction(nameof(Dashboard)));
}
}
model.BranchCount = systems.Sum(_ => _.Branches.Count);
model.BranchAvailability = BranchAvailability;
model.MaxUploadMB = MaxUploadMB;
model.Settings = settings;
model.Systems = systems;
PageTitle = "Performer Information";
return(View(model));
}
public ArchiveProgressReport Archive(IProgress <ArchiveProgressReport> progress, ArchiveOptionsEnum options = ArchiveOptionsEnum.SimulateOnly)
{
var stopWatch = new Stopwatch();
stopWatch.Start();
var progressReport = new ArchiveProgressReport()
{
TotalElapsedTime = stopWatch.Elapsed
};
var ptCultureInfo = System.Globalization.CultureInfo.CreateSpecificCulture("pt-PT");
var validExtensions = new List <string>();
validExtensions.AddRange(ValidImageExtensions);
validExtensions.AddRange(ValidVideoExtensions);
progressReport.TotalFilesInSource = Directory.EnumerateFiles(Source, "*.*", SearchOption.AllDirectories)
.Count(fn => !Path.GetFileName(fn).StartsWith(".", StringComparison.InvariantCultureIgnoreCase));
progressReport.TotalFilesToProcess = FileProcessor.EnumerateSpecificFiles(Source, validExtensions, SearchOption.AllDirectories).Count();
var sourceFiles = FileProcessor.EnumerateSpecificFiles(Source, validExtensions, SearchOption.AllDirectories);
foreach (var srcFile in sourceFiles)
{
if (stopWatch.Elapsed - progressReport.TotalElapsedTime > TimeSpan.FromMilliseconds(1000))
{
// send progress notification
progressReport.TotalElapsedTime = stopWatch.Elapsed;
progress.Report(progressReport);
}
var fInfo = new FileInfo(srcFile);
var srcHash = FileProcessor.CalculateHash(srcFile);
var srcHashFileSafe = FileProcessor.MakeFileNameSafeHash(srcHash);
var fileExtension = Path.GetExtension(srcFile).ToLowerInvariant();
var estimatedFileDate = fInfo.CreationTime.Year <= 1970 ? fInfo.LastWriteTime : fInfo.CreationTime;
if (estimatedFileDate.Year <= 1980 || (estimatedFileDate > DateTime.Now.AddDays(1)))
{
var ddd = fInfo.LastWriteTime;
var zzz = ddd;
}
//if (fInfo.CreationTime.Year <= 1980)
//{
// var xx = "";
//}
if (ValidImageExtensions.Any(ext => ext.Equals(fileExtension, StringComparison.InvariantCultureIgnoreCase)))
{
var dt = GetBestDateForImage(srcFile);
if (dt.HasValue)
{
estimatedFileDate = dt.Value;
}
}
var destFile = FindFileInDestination(srcHashFileSafe);
//if (destFile != null && srcHash != FileProcessor.CalculateHash(destFile.FullName))
//{
// Console.WriteLine($"[Critical Event] [{srcFile}][{srcHash}][{destFile.FullName}] Hashes(filename) match but Hashes(real non file-name-safe) do NOT match!");
//}
if (destFile != null)
{
progressReport.SignalFileExcludedDuplicate(fInfo.Length);
}
else
{
var isImage = ValidImageExtensions.Contains(fileExtension);
var isVideo = ValidVideoExtensions.Contains(fileExtension);
var destFolder = $"{Destination}";
if (options.HasFlag(ArchiveOptionsEnum.UseInboxFolder))
{
destFolder = Path.Combine(destFolder, "inbox");
}
if (options.HasFlag(ArchiveOptionsEnum.KeepSourceStructure))
{
destFolder = Path.Combine(destFolder, Path.GetDirectoryName(Path.GetRelativePath(Source, srcFile)));
}
else
{
var mediaType = isImage ? "fotos" : (isVideo ? "videos" : "misc");
destFolder = Path.Combine(destFolder, mediaType, estimatedFileDate.Year.ToString(), ptCultureInfo.DateTimeFormat.GetMonthName(estimatedFileDate.Month));
//destFolder = $"/{mediaType}/{estimatedFileDate.Year}/{estimatedFileDate.Month.ToString().PadLeft(2, '0')}";
}
var destfFilename = $"[arc]{srcHashFileSafe}-{fInfo.Name}";
if (!options.HasFlag(ArchiveOptionsEnum.SimulateOnly))
{
if (!Directory.Exists(destFolder))
{
Directory.CreateDirectory(destFolder);
}
File.Copy(srcFile, Path.Combine(destFolder, destfFilename), overwrite: false);
}
if (isImage)
{
progressReport.SignalImageFileAdded(fInfo.Length);
}
else if (isVideo)
{
progressReport.SignalVideoFileAdded(fInfo.Length);
}
else
{
progressReport.SignalOtherFileAdded(fInfo.Length);
}
}
}
stopWatch.Stop();
progressReport.TotalElapsedTime = stopWatch.Elapsed;
return(progressReport);
}
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(ProgramDetailViewModel model)
{
byte[] badgeBytes = null;
var currentProgram = await _siteService.GetProgramByIdAsync(model.Program.Id);
if (string.IsNullOrWhiteSpace(model.Program.JoinBadgeName) &&
(!string.IsNullOrWhiteSpace(model.BadgeMakerImage) ||
model.BadgeUploadImage != null ||
currentProgram.JoinBadgeId.HasValue))
{
ModelState.AddModelError("Program.JoinBadgeName", "Please provide a name for the badge");
}
if (!string.IsNullOrWhiteSpace(model.Program.JoinBadgeName) &&
string.IsNullOrWhiteSpace(model.BadgeMakerImage) &&
model.BadgeUploadImage == null &&
!currentProgram.JoinBadgeId.HasValue)
{
ModelState.AddModelError("BadgemakerImage", "Please provide an image for the badge.");
}
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)}");
}
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.Program.AgeMaximum < model.Program.AgeMinimum)
{
ModelState.AddModelError("Program.AgeMaximum", "The maximum age cannot be lower than the minimum age.");
}
if (ModelState.IsValid)
{
try
{
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);
}
if (model.Program.JoinBadgeId.HasValue)
{
var existing = await _badgeService
.GetByIdAsync(model.Program.JoinBadgeId.Value);
existing.Filename = Path.GetFileName(model.BadgePath);
await _badgeService.ReplaceBadgeFileAsync(existing,
badgeBytes,
model.BadgeUploadImage.FileName);
}
else
{
var newBadge = new Badge
{
Filename = filename
};
var badge = await _badgeService.AddBadgeAsync(newBadge, badgeBytes);
model.Program.JoinBadgeId = badge.Id;
}
}
if (!string.IsNullOrWhiteSpace(model.Program.JoinBadgeName))
{
model.Program.JoinBadgeName = model.Program.JoinBadgeName.Trim();
}
model.Program.AskAge = model.AgeValues >= 1;
model.Program.AgeRequired = model.AgeValues == 2;
model.Program.AskSchool = model.SchoolValues >= 1;
model.Program.SchoolRequired = model.SchoolValues == 2;
model.Program.Name = model.Program.Name.Trim();
await _siteService.UpdateProgramAsync(model.Program);
ShowAlertSuccess($"Saved Program \"{model.Program.Name}\"!");
return(RedirectToAction(nameof(Edit), new { id = model.Program.Id }));
}
catch (GraException gex)
{
ShowAlertDanger("Unable to edit Program: ", gex);
}
}
var dailyLiteracyTipList = await _dailyLiteracyTipService.GetListAsync();
var pointTranslationList = await _pointTranslationService.GetListAsync();
model.DailyLiteracyTipList = new SelectList(dailyLiteracyTipList, "Id", "Name");
model.PointTranslationList = new SelectList(pointTranslationList, "Id",
"TranslationName");
PageTitle = "Edit Program";
return(View("Detail", model));
}
public async Task <IActionResult> Edit(ChallengesDetailViewModel model, string Submit)
{
byte[] badgeBytes = null;
model.IgnorePointLimits = UserHasPermission(Permission.IgnorePointLimits);
model.MaxPointLimit = await _challengeService
.GetMaximumAllowedPointsAsync(GetCurrentSiteId());
if (model.Challenge.TasksToComplete.HasValue &&
model.Challenge.TasksToComplete != 0 &&
model.Challenge.PointsAwarded != 0 &&
!model.IgnorePointLimits)
{
double pointsPerChallenge =
(double)model.Challenge.PointsAwarded / model.Challenge.TasksToComplete.Value;
if (pointsPerChallenge > model.MaxPointLimit)
{
ModelState.AddModelError("Challenge.PointsAwarded",
$"A challenge with {model.Challenge.TasksToComplete} tasks may award a maximum of {model.MaxPointLimit.Value * model.Challenge.TasksToComplete} points.");
}
}
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)}");
}
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 (ModelState.IsValid)
{
var challenge = model.Challenge;
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);
}
if (challenge.BadgeId == null)
{
var newBadge = new Badge
{
Filename = filename
};
var badge = await _badgeService.AddBadgeAsync(newBadge, badgeBytes);
challenge.BadgeId = badge.Id;
}
else
{
var existing = await _badgeService
.GetByIdAsync((int)challenge.BadgeId);
existing.Filename = Path.GetFileName(model.BadgePath);
await _badgeService.ReplaceBadgeFileAsync(existing,
badgeBytes,
model.BadgeUploadImage.FileName);
}
}
try
{
var serviceResult = await _challengeService.EditChallengeAsync(challenge);
if (serviceResult.Status == ServiceResultStatus.Warning &&
!string.IsNullOrWhiteSpace(serviceResult.Message))
{
ShowAlertWarning(serviceResult.Message);
}
AlertSuccess = $"Challenge '<strong>{challenge.Name}</strong>' was successfully modified";
var hasPermissions = UserHasPermission(Permission.ActivateAllChallenges) ||
UserHasPermission(Permission.ActivateSystemChallenges);
if (Submit == "Activate" &&
hasPermissions &&
challenge.RelatedSystemId == GetId(ClaimType.SystemId) &&
serviceResult.Data.IsValid)
{
await _challengeService.ActivateChallengeAsync(serviceResult.Data);
AlertSuccess = $"Challenge '<strong>{challenge.Name}</strong>' was successfully modified and activated";
}
}
catch (GraException gex)
{
ShowAlertWarning("Unable to edit challenge: ", gex.Message);
}
return(RedirectToAction("Edit", new { id = model.Challenge.Id }));
}
else
{
var tasks = await _challengeService.GetChallengeTasksAsync(model.Challenge.Id);
model.Challenge.Tasks = tasks.ToList();
PageTitle = $"Edit Challenge - {model.Challenge.Name}";
model = await GetDetailLists(model);
model.DependentTriggers = await _challengeService
.GetDependentsAsync(model.Challenge.Id);
model.Groups = await _challengeService.GetGroupsByChallengeId(model.Challenge.Id);
model.RelatedEvents = await _eventService.GetByChallengeIdAsync(model.Challenge.Id);
if (model.MaxPointLimit.HasValue)
{
model.MaxPointsMessage = $"(Up to {model.MaxPointLimit.Value} points per required task)";
var currentChallenge = await _challengeService
.MCGetChallengeDetailsAsync(model.Challenge.Id);
if (currentChallenge.TasksToComplete.HasValue)
{
double pointsPerChallenge = (double)currentChallenge.PointsAwarded
/ currentChallenge.TasksToComplete.Value;
if (pointsPerChallenge > model.MaxPointLimit.Value)
{
model.MaxPointsWarningMessage = $"This Challenge exceeds the maximum of {model.MaxPointLimit.Value} points per required task - only Administrators can edit it.";
}
}
}
return(View(model));
}
}
public async Task <IActionResult> Create(ChallengesDetailViewModel model)
{
byte[] badgeBytes = null;
model.IgnorePointLimits = UserHasPermission(Permission.IgnorePointLimits);
model.MaxPointLimit = await _challengeService
.GetMaximumAllowedPointsAsync(GetCurrentSiteId());
if (!model.IgnorePointLimits &&
model.Challenge.TasksToComplete.HasValue &&
model.Challenge.TasksToComplete != 0)
{
double pointsPerChallenge = (double)model.Challenge.PointsAwarded / model.Challenge.TasksToComplete.Value;
if (pointsPerChallenge > model.MaxPointLimit)
{
ModelState.AddModelError("Challenge.PointsAwarded",
$"A challenge with {model.Challenge.TasksToComplete} tasks may award a maximum of {model.MaxPointLimit * model.Challenge.TasksToComplete} points.");
}
}
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)}");
}
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 (ModelState.IsValid)
{
try
{
var challenge = model.Challenge;
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
};
var badge = await _badgeService.AddBadgeAsync(newBadge, badgeBytes);
challenge.BadgeId = badge.Id;
}
var serviceResult = await _challengeService.AddChallengeAsync(challenge);
if (serviceResult.Status == ServiceResultStatus.Warning &&
!string.IsNullOrWhiteSpace(serviceResult.Message))
{
ShowAlertWarning(serviceResult.Message);
}
AlertSuccess = $"Challenge '<strong>{serviceResult.Data.Name}</strong>' was successfully created";
return(RedirectToAction("Edit", new { id = serviceResult.Data.Id }));
}
catch (GraException gex)
{
ShowAlertWarning("Unable to add challenge: ", gex.Message);
}
}
PageTitle = "Create Challenge";
model = await GetDetailLists(model);
if (model.MaxPointLimit.HasValue)
{
model.MaxPointsMessage = $"(Up to {model.MaxPointLimit.Value} points per required task)";
}
return(View(model));
}
