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)); }