public Task GenerateStoreSlugAsync(User user)
{
user.StoreSlug = SanitizerHelper.GenerateSlug($"{user.StoreName}",
slug => Users.Any(x => x.Id != user.Id && x.StoreSlug == slug));
return(Task.CompletedTask);
}
public IActionResult FrameworkDescription(DetailFramework detailFramework, string actionname, int frameworkId = 0)
{
if (actionname == "New")
{
if (TempData[MultiPageFormDataFeature.AddNewFramework.TempDataKey] == null)
{
return(StatusCode((int)HttpStatusCode.NotFound));
}
else
{
var sessionNewFramework = multiPageFormService.GetMultiPageFormData <SessionNewFramework>(
MultiPageFormDataFeature.AddNewFramework,
TempData
);
sessionNewFramework.DetailFramework = detailFramework;
multiPageFormService.SetMultiPageFormData(
sessionNewFramework,
MultiPageFormDataFeature.AddNewFramework,
TempData
);
}
return(RedirectToAction("FrameworkType", "Frameworks", new { actionname }));
}
detailFramework.Description = SanitizerHelper.SanitizeHtmlData(detailFramework.Description);
frameworkService.UpdateFrameworkDescription(frameworkId, GetAdminId(), detailFramework.Description);
return(RedirectToAction("ViewFramework", new { tabname = "Details", frameworkId }));
}
public IActionResult EditAssessmentQuestionOptions(AssessmentQuestionDetail assessmentQuestionDetail, int frameworkId, int assessmentQuestionId = 0, int frameworkCompetencyId = 0)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("EditAssessmentQuestionOptions", "Frameworks", new { frameworkId, assessmentQuestionId, frameworkCompetencyId }));
}
assessmentQuestionDetail.ScoringInstructions = SanitizerHelper.SanitizeHtmlData(assessmentQuestionDetail.ScoringInstructions);
SessionAssessmentQuestion sessionAssessmentQuestion = multiPageFormService.GetMultiPageFormData <SessionAssessmentQuestion>(
MultiPageFormDataFeature.EditAssessmentQuestion,
TempData
);
if (sessionAssessmentQuestion != null)
{
sessionAssessmentQuestion.AssessmentQuestionDetail = assessmentQuestionDetail;
multiPageFormService.SetMultiPageFormData(
sessionAssessmentQuestion,
MultiPageFormDataFeature.EditAssessmentQuestion,
TempData
);
}
else
{
return(StatusCode(404));
}
return(RedirectToAction("AssessmentQuestionConfirm", "Frameworks", new { frameworkId, assessmentQuestionId, frameworkCompetencyId }));
}
public IActionResult InsertFramework()
{
var adminId = GetAdminId();
if (TempData[MultiPageFormDataFeature.AddNewFramework.TempDataKey] == null)
{
return(StatusCode((int)HttpStatusCode.NotFound));
}
var sessionNewFramework = multiPageFormService.GetMultiPageFormData <SessionNewFramework>(
MultiPageFormDataFeature.AddNewFramework,
TempData
);
var detailFramework = sessionNewFramework.DetailFramework;
detailFramework = InsertBrandingCategoryTopicIfRequired(detailFramework);
if (detailFramework == null || adminId < 1)
{
logger.LogWarning($"Failed to create framework: adminId: {adminId}");
return(StatusCode(500));
}
detailFramework.Description = SanitizerHelper.SanitizeHtmlData(detailFramework.Description);
var newFramework = frameworkService.CreateFramework(detailFramework, adminId);
TempData.Clear();
return(RedirectToAction("AddCollaborators", "Frameworks", new { actionname = "New", frameworkId = newFramework.ID }));
}
protected Task GenerateSlugAsync(Product product)
{
product.Slug = SanitizerHelper.GenerateSlug(product.Name,
productSlug => GetQuery().Any(x => x.SellerId == product.SellerId && x.Id != product.Id && x.Slug == productSlug));
return(Task.CompletedTask);
}
public Task PrepareStoreAsync(User user, StoreEditModel model)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
user = _mapper.Map(model, user);
user.StoreCategory = model.StoreCategorySelections.MergeEnums();
user.StoreSlug = SanitizerHelper.GenerateSlug(model.StoreSlug);
user.AboutNote = SanitizerHelper.SanitizeHtml(model.AboutNote);
user.TermsNote = SanitizerHelper.SanitizeHtml(model.TermsNote);
user.PrivacyNote = SanitizerHelper.SanitizeHtml(model.PrivacyNote);
user.ReturnsNote = SanitizerHelper.SanitizeHtml(model.ReturnsNote);
user.ReviewsNote = SanitizerHelper.SanitizeHtml(model.ReviewsNote);
user.FacebookLink = SanitizerHelper.AppendUrlScheme(model.FacebookLink);
user.TwitterLink = SanitizerHelper.AppendUrlScheme(model.TwitterLink);
user.YoutubeLink = SanitizerHelper.AppendUrlScheme(model.YoutubeLink);
user.InstagramLink = SanitizerHelper.AppendUrlScheme(model.InstagramLink);
user.LinkedInLink = SanitizerHelper.AppendUrlScheme(model.LinkedInLink);
user.PinterestLink = SanitizerHelper.AppendUrlScheme(model.PinterestLink);
user.WhatsAppNumber = SanitizerHelper.ExtractPhoneNumber(model.WhatsAppNumber);
user.MapLink = SanitizerHelper.AppendUrlScheme(model.MapLink);
return(Task.CompletedTask);
}
public string GenerateCode(string prefixName, string suffixName)
{
var prefixCode = string.Join(string.Empty, SanitizerHelper.ExtractAlpha(prefixName.ToUpperInvariant()).Take(3));
var suffixCode = string.Join(string.Empty, SanitizerHelper.ExtractAlpha(suffixName.ToUpperInvariant()).Take(3));
var code = string.Format("{0}-{1}-{2}", prefixCode, ComputeHelper.GenerateRandomString(4, ComputeHelper.NaturalNumericChars), suffixCode).Trim('-');
return(code);
}
public Task GenerateSlugAsync(Category category, bool uniqueness = true)
{
bool slugExists(string slug) => GetQuery().Any(x => x.SellerId == category.SellerId && x.Id != category.Id && x.Slug == slug);
category.Slug = SanitizerHelper.GenerateSlug(category.Name,
uniqueness ? (Func <string, bool>)slugExists : null);
return(Task.CompletedTask);
}
public HttpResponseMessage Add(Item item)
{
SanitizerHelper.Paranoide(item);
var result = _itemService.Create(item);
if (result.ExecutedSuccesfully)
{
return(Request.CreateResponse(HttpStatusCode.Created, item));
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, new { Message = result.Message }));
}
}
public IActionResult AddEditFrameworkCompetency(int frameworkId, FrameworkCompetency frameworkCompetency, int?frameworkCompetencyGroupId, int frameworkCompetencyId = 0, int[] selectedFlagIds = null)
{
frameworkCompetency.Description = SanitizerHelper.SanitizeHtmlData(frameworkCompetency.Description);
if (!ModelState.IsValid)
{
ModelState.Remove(nameof(FrameworkCompetency.Name));
ModelState.AddModelError(nameof(FrameworkCompetency.Name), "Please enter a valid competency statement (between 3 and 500 characters)");
var detailFramework = frameworkService.GetDetailFrameworkByFrameworkId(frameworkId, GetAdminId());
var competencyFlags = frameworkService.GetCompetencyFlagsByFrameworkId(frameworkId, frameworkCompetency?.CompetencyID).ToList();
if (competencyFlags != null)
{
competencyFlags.ForEach(f => f.Selected = selectedFlagIds.Contains(f.FlagId));
}
if (detailFramework == null)
{
return(StatusCode((int)HttpStatusCode.NotFound));
}
var model = new FrameworkCompetencyViewModel()
{
DetailFramework = detailFramework,
FrameworkCompetencyGroupId = frameworkCompetencyId,
FrameworkCompetency = frameworkCompetency,
CompetencyFlags = competencyFlags
};
return(View("Developer/Competency", model));
}
var adminId = GetAdminId();
var userRole = frameworkService.GetAdminUserRoleForFrameworkId(adminId, frameworkId);
if (userRole < 2)
{
return(StatusCode((int)HttpStatusCode.Forbidden));
}
if (frameworkCompetency.Id > 0)
{
frameworkService.UpdateFrameworkCompetency(frameworkCompetencyId, frameworkCompetency.Name, frameworkCompetency.Description, adminId);
frameworkService.UpdateCompetencyFlags(frameworkId, frameworkCompetency.CompetencyID, selectedFlagIds);
return(new RedirectResult(Url.Action("ViewFramework", new { tabname = "Structure", frameworkId, frameworkCompetencyGroupId, frameworkCompetencyId }) + "#fc-" + frameworkCompetencyId.ToString()));
}
var newCompetencyId = frameworkService.InsertCompetency(frameworkCompetency.Name, frameworkCompetency.Description, adminId);
if (newCompetencyId > 0)
{
var newFrameworkCompetencyId = frameworkService.InsertFrameworkCompetency(newCompetencyId, frameworkCompetencyGroupId, adminId, frameworkId);
frameworkService.UpdateCompetencyFlags(frameworkId, newCompetencyId, selectedFlagIds);
return(new RedirectResult(Url.Action("ViewFramework", new { tabname = "Structure", frameworkId, frameworkCompetencyGroupId, frameworkCompetencyId }) + "#fc-" + newFrameworkCompetencyId.ToString()));
}
logger.LogWarning($"Attempt to add framework competency failed for admin {adminId}.");
return(StatusCode((int)HttpStatusCode.Forbidden));
}
public HttpResponseMessage Get(string title)
{
SanitizerHelper.Paranoide(title);
var result = _itemService.GetItemByName(title);
if (result != null)
{
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, new { Message = "Not found" }));
}
}
public Task PrepareBannerAsync(Banner banner, BannerEditModel model)
{
if (banner == null)
{
throw new ArgumentNullException(nameof(banner));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
banner = _mapper.Map(model, banner);
banner.Permalink = SanitizerHelper.AppendUrlPath(model.Permalink);
return(Task.CompletedTask);
}
public Task PrepareProductAsync(Product product, ProductEditModel model)
{
if (product == null)
{
throw new ArgumentNullException(nameof(product));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
product = _mapper.Map(model, product);
product.Description = SanitizerHelper.SanitizeHtml(model.Description);
return(Task.CompletedTask);
}
private async Task SaveProductTags(Product product, ProductEditModel model)
{
var tagObjects = product.Tags.ToList();
// Ensure the newTageNames are safe to access.
var newTagNames = model.TagNames?.Where(x => !string.IsNullOrWhiteSpace(x)) ?? Enumerable.Empty <string>();
var oldTagNames = tagObjects.Select(x => x.Name).ToList();
var createTagNames = newTagNames.Except(oldTagNames);
var deleteTagNames = oldTagNames.Except(newTagNames);
bool tagPredicate(Tag tag, string slug, string name) => tag.Slug == slug || tag.Name == name;
foreach (var tagName in deleteTagNames)
{
var tagSlug = SanitizerHelper.GenerateSlug(tagName);
var tagObject = tagObjects.FirstOrDefault(x => tagPredicate(x, tagSlug, tagName));
if (tagObject != null)
{
tagObjects.Remove(tagObject);
await _tagService.DeleteAsync(tagObject);
}
}
foreach (var tagName in createTagNames)
{
var tagSlug = SanitizerHelper.GenerateSlug(tagName);
if (!tagObjects.Any(x => tagPredicate(x, tagSlug, tagName)))
{
var tagObject = new Tag
{
Name = tagName,
ProductId = product.Id,
Slug = tagSlug
};
tagObjects.Add(tagObject);
await _tagService.CreateAsync(tagObject);
}
}
}
public Item GetItemByName(string itemName)
{
if (string.IsNullOrEmpty(itemName))
{
return(null);
}
if (!SanitizerHelper.IsClean(itemName))
{
return(null);
}
try
{
return(_itemRepository.GetByFilter(0, 1, x => x.Title.ToLower() == itemName.ToLower()).FirstOrDefault());
}
catch (Exception ex)
{
TaskResult.AddErrorMessage("Could not get");
TaskResult.Exception = ex;
return(null);
}
}
public IActionResult AddEditFrameworkCompetencyGroup(int frameworkId, CompetencyGroupBase competencyGroupBase, int frameworkCompetencyGroupId = 0)
{
if (!ModelState.IsValid)
{
if (ModelState["Name"].ValidationState == ModelValidationState.Invalid)
{
ModelState.Remove(nameof(CompetencyGroupBase.Name));
ModelState.AddModelError(nameof(CompetencyGroupBase.Name), "Please enter a valid competency group name (between 3 and 255 characters)");
}
if (ModelState["Description"].ValidationState == ModelValidationState.Invalid)
{
ModelState.Remove(nameof(CompetencyGroupBase.Description));
ModelState.AddModelError(nameof(CompetencyGroupBase.Description), "Please enter a valid competency group description (between 0 and 1000 characters)");
}
// do something
var detailFramework = frameworkService.GetDetailFrameworkByFrameworkId(frameworkId, GetAdminId());
if (detailFramework == null)
{
return(StatusCode(404));
}
var model = new CompetencyGroupViewModel()
{
DetailFramework = detailFramework,
CompetencyGroupBase = competencyGroupBase
};
return(View("Developer/CompetencyGroup", model));
}
var adminId = GetAdminId();
var userRole = frameworkService.GetAdminUserRoleForFrameworkId(adminId, frameworkId);
if (userRole < 2)
{
return(StatusCode(403));
}
if (competencyGroupBase.ID > 0)
{
frameworkService.UpdateFrameworkCompetencyGroup(frameworkCompetencyGroupId, competencyGroupBase.CompetencyGroupID, competencyGroupBase.Name, SanitizerHelper.SanitizeHtmlData
(competencyGroupBase.Description), adminId);
return(new RedirectResult(Url.Action("ViewFramework", new { tabname = "Structure", frameworkId }) + "#fcgroup-" + frameworkCompetencyGroupId.ToString()));
}
var newCompetencyGroupId = frameworkService.InsertCompetencyGroup(competencyGroupBase.Name, SanitizerHelper.SanitizeHtmlData(competencyGroupBase.Description), adminId);
if (newCompetencyGroupId > 0)
{
var newFrameworkCompetencyGroupId = frameworkService.InsertFrameworkCompetencyGroup(newCompetencyGroupId, frameworkId, adminId);
return(new RedirectResult(Url.Action("ViewFramework", new { tabname = "Structure", frameworkId, frameworkCompetencyGroupId = newFrameworkCompetencyGroupId }) + "#fcgroup-" + newFrameworkCompetencyGroupId.ToString()));
}
logger.LogWarning($"Attempt to add framework competency group failed for admin {adminId}.");
return(StatusCode(403));
}
public Task GenerateUserNameAsync(User user)
{
user.UserName = SanitizerHelper.GenerateSlug($"{user.FirstName} {user.LastName}",
userName => Users.Any(x => x.Id != user.Id && x.UserName == userName));
return(Task.CompletedTask);
}
public static IRuleBuilderOptions <T, string> Slug <T>(this IRuleBuilder <T, string> ruleBuilder)
{
var options = ruleBuilder
.MinimumLength(3)
.MaximumLength(255)
.Must(x => string.IsNullOrWhiteSpace(x) || !string.IsNullOrWhiteSpace(SanitizerHelper.GenerateSlug(x)))
.WithMessage(ValidationHelper.SlugRegexMessage);
return(options);
}
