/// <summary>
/// Updates settings for a store.
/// </summary>
/// <param name="settings">Settings class instance.</param>
/// <param name="form">Form value collection.</param>
/// <param name="storeId">Store identifier.</param>
/// <param name="settingService">Setting service.</param>
/// <param name="propertyNameMapper">Function to map property names. Return <c>null</c> to skip a property.</param>
public async Task UpdateSettingsAsync(
object settings,
IFormCollection form,
int storeId,
Func <string, string> propertyNameMapper = null)
{
var settingType = settings.GetType();
var settingName = settingType.Name;
var settingProperties = FastProperty.GetProperties(settingType).Values;
foreach (var prop in settingProperties)
{
var name = propertyNameMapper?.Invoke(prop.Name) ?? prop.Name;
if (!name.HasValue())
{
continue;
}
var key = string.Concat(settingName, ".", name);
if (storeId == 0 || IsOverrideChecked(key, form))
{
dynamic value = prop.GetValue(settings);
await _settingService.ApplySettingAsync(key, value ?? string.Empty, storeId);
}
else if (storeId > 0)
{
await _settingService.RemoveSettingAsync(key, storeId);
}
}
await _db.SaveChangesAsync();
}
/// <summary>
/// Applies given media storage <paramref name="item"/> to <paramref name="media"/> entity as blob.
/// </summary>
/// <param name="media">Media item</param>
/// <param name="item">The source item</param>
/// <param name="save">Whether to commit changes to <paramref name="media"/> entity to database immediately.</param>
public async Task ApplyBlobAsync(IMediaAware media, MediaStorageItem item, bool save = false)
{
Guard.NotNull(media, nameof(media));
if (item == null)
{
media.ApplyBlob(null);
if (save)
{
await _db.SaveChangesAsync();
}
return;
}
using (item)
{
if (_db.DataProvider.CanStreamBlob)
{
await SaveFast(media, item);
}
else
{
// BLOB stream unsupported
var buffer = await item.SourceStream.ToByteArrayAsync();
media.ApplyBlob(buffer);
media.Size = buffer.Length;
if (save)
{
await _db.SaveChangesAsync();
}
}
}
}
public async Task SaveAsync(MediaFile mediaFile, MediaStorageItem item)
{
Guard.NotNull(mediaFile, nameof(mediaFile));
if (item == null)
{
mediaFile.ApplyBlob(null);
await _db.SaveChangesAsync();
return;
}
using (item)
{
if (_db.DataProvider.CanStreamBlob)
{
await SaveFast(mediaFile, item);
}
else
{
// BLOB stream unsupported
var buffer = await item.SourceStream.ToByteArrayAsync();
mediaFile.ApplyBlob(buffer);
mediaFile.Size = buffer.Length;
await _db.SaveChangesAsync();
}
}
}
public async Task <IActionResult> ProductUpdate(ProductOverviewModel model)
{
var product = await _db.Products.FindByIdAsync(model.Id);
product.Name = model.Name;
product.Sku = model.Sku;
product.Price = model.Price;
product.StockQuantity = model.StockQuantity;
product.Published = model.Published;
product.ManufacturerPartNumber = model.ManufacturerPartNumber;
product.Gtin = model.Gtin;
product.MinStockQuantity = model.MinStockQuantity;
product.OldPrice = model.OldPrice;
product.AvailableStartDateTimeUtc = model.AvailableStartDateTimeUtc;
product.AvailableEndDateTimeUtc = model.AvailableEndDateTimeUtc;
try
{
await _db.SaveChangesAsync();
return(Json(new { success = true }));
}
catch (Exception ex)
{
NotifyError(ex.GetInnerMessage());
return(Json(new { success = false }));
}
}
public virtual Task InsertTaskAsync(TaskDescriptor task)
{
Guard.NotNull(task, nameof(task));
_db.TaskDescriptors.Add(task);
return(_db.SaveChangesAsync());
}
public async Task MigrateAsync(IEnumerable <SettingEntry> entries)
{
Guard.NotNull(entries, nameof(entries));
if (!entries.Any())
{
return;
}
var toDelete = new List <Setting>();
var toAdd = new List <Setting>();
using var scope = new DbContextScope(_db, autoDetectChanges: false, minHookImportance: HookImportance.Essential);
// First perform DELETE actions
foreach (var entry in entries.Where(x => x.Value == null))
{
bool isPattern = entry.KeyIsGroup;
if (!await HasSettingsAsync(entry.Key, isPattern))
{
continue; // nothing to delete
}
var dbSettings = await GetSettingsAsync(entry.Key, isPattern);
_settings.RemoveRange(dbSettings);
}
await _db.SaveChangesAsync();
// Then perform ADD actions
foreach (var entry in entries.Where(x => x.Value.HasValue()))
{
var existing = toAdd.FirstOrDefault(x => x.Name.Equals(entry.Key, StringComparison.InvariantCultureIgnoreCase));
if (existing != null)
{
existing.Value = entry.Value;
continue;
}
if (await HasSettingsAsync(entry.Key, false))
{
continue; // skip existing (we don't perform updates)
}
_settings.Add(new Setting
{
Name = entry.Key,
Value = entry.Value,
StoreId = 0
});
}
await _db.SaveChangesAsync();
}
public async Task <IActionResult> Delete(QueuedEmailModel model)
{
var email = await _db.QueuedEmails.FindByIdAsync(model.Id);
if (email == null)
{
return(RedirectToAction("List"));
}
_db.QueuedEmails.Remove(email);
await _db.SaveChangesAsync();
NotifySuccess(T("Admin.System.QueuedEmails.Deleted"));
return(RedirectToAction("List"));
}
public async Task <IActionResult> GenericAttributeInsert(GenericAttributeModel model, string entityName, int entityId)
{
model.Key = model.Key.TrimSafe();
model.Value = model.Value.TrimSafe() ?? string.Empty;
if (ModelState.IsValid)
{
var storeId = Services.StoreContext.CurrentStore.Id;
var(readPermission, updatePermission) = GetGenericAttributesInfos(entityName);
if (updatePermission.HasValue() && !Services.Permissions.Authorize(updatePermission))
{
NotifyError(await Services.Permissions.GetUnauthorizedMessageAsync(updatePermission));
return(Json(new { success = false }));
}
else
{
var attr = await _db.GenericAttributes
.Where(x => x.EntityId == entityId && x.KeyGroup == entityName && x.Key == model.Key && x.StoreId == storeId)
.FirstOrDefaultAsync();
if (attr == null)
{
_db.GenericAttributes.Add(new GenericAttribute
{
StoreId = storeId,
KeyGroup = entityName,
EntityId = entityId,
Key = model.Key,
Value = model.Value
});
await _db.SaveChangesAsync();
return(Json(new { success = true }));
}
else
{
NotifyWarning(T("Admin.Common.GenericAttributes.NameAlreadyExists", model.Key));
return(Json(new { success = false }));
}
}
}
else
{
var modelStateErrorMessages = ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage);
NotifyError(modelStateErrorMessages.FirstOrDefault());
return(Json(new { success = false }));
}
}
public override async Task OnAfterSaveCompletedAsync(IEnumerable <IHookedEntity> entries, CancellationToken cancelToken)
{
// Update HasDiscountsApplied property.
var manufacturers = entries
.Select(x => x.Entity)
.OfType <Manufacturer>()
.ToList();
foreach (var manufacturersChunk in manufacturers.Slice(100))
{
var manufacturerIdsChunk = manufacturersChunk
.Select(x => x.Id)
.ToArray();
var appliedManufacturerIds = await _db.Discounts
.SelectMany(x => x.AppliedToManufacturers)
.Where(x => manufacturerIdsChunk.Contains(x.Id))
.Select(x => x.Id)
.Distinct()
.ToListAsync(cancelToken);
manufacturersChunk.Each(x => x.HasDiscountsApplied = appliedManufacturerIds.Contains(x.Id));
}
await _db.SaveChangesAsync(cancelToken);
_requestCache.RemoveByPattern(ManufacturerService.PRODUCTMANUFACTURERS_PATTERN_KEY);
}
public virtual async Task <int> SendNotificationsToSubscribersAsync(Product product)
{
Guard.NotNull(product, nameof(product));
var numberOfMessages = 0;
var subscriptionQuery = _db.BackInStockSubscriptions.ApplyStandardFilter(0, product.Id, 0);
var pager = new FastPager <BackInStockSubscription>(subscriptionQuery);
while ((await pager.ReadNextPageAsync <BackInStockSubscription>()).Out(out var subscriptions))
{
foreach (var subscription in subscriptions)
{
// Ensure that the customer is registered (simple and fast way).
if (subscription?.Customer?.Email?.IsEmail() ?? false)
{
await _messageFactory.SendBackInStockNotificationAsync(subscription);
++numberOfMessages;
}
}
_db.BackInStockSubscriptions.RemoveRange(subscriptions);
await _db.SaveChangesAsync();
}
return(numberOfMessages);
}
/// <inheritdoc />
public override async Task <SignInResult> PasswordSignInAsync(Customer user, string password, bool isPersistent, bool lockoutOnFailure)
{
if (user == null || user.Deleted)
{
return(SignInResult.Failed);
}
if (!user.Active)
{
// TODO: (mh) (core) We should return an error message for the user saying "Please check you email account for an activation link".
return(SignInResult.NotAllowed);
}
if (!user.IsRegistered())
{
return(SignInResult.NotAllowed);
}
var result = await base.PasswordSignInAsync(user, password, isPersistent, lockoutOnFailure);
if (result.Succeeded)
{
user.LastLoginDateUtc = DateTime.UtcNow;
_db.TryUpdate(user);
await _db.SaveChangesAsync();
}
return(result);
}
public virtual async Task Run(TaskExecutionContext ctx, CancellationToken cancelToken = default)
{
cancelToken.ThrowIfCancellationRequested();
// Delete all media records which are in transient state since at least 3 hours.
var olderThan = DateTime.UtcNow.AddHours(-3);
var numDeleted = 0;
using (var scope = new DbContextScope(_db, autoDetectChanges: false, hooksEnabled: false))
{
var files = await _db.MediaFiles.Where(x => x.IsTransient && x.UpdatedOnUtc < olderThan).ToListAsync(cancelToken);
foreach (var file in files)
{
await _mediaService.DeleteFileAsync(file, true);
numDeleted += 1;
}
await _db.SaveChangesAsync(cancelToken);
numDeleted += await _db.Downloads.Where(x => x.IsTransient && x.UpdatedOnUtc < olderThan).BatchDeleteAsync(cancelToken);
if (numDeleted > 0 && _db.DataProvider.CanShrink)
{
try
{
await _db.DataProvider.ShrinkDatabaseAsync(cancelToken);
}
catch { }
}
}
}
public override async Task OnAfterSaveCompletedAsync(IEnumerable <IHookedEntity> entries, CancellationToken cancelToken)
{
// Update HasDiscountsApplied property.
var categories = entries
.Select(x => x.Entity)
.OfType <Category>()
.ToList();
foreach (var categoriesChunk in categories.Slice(100))
{
var categoryIdsChunk = categoriesChunk
.Select(x => x.Id)
.ToArray();
var appliedCategoryIds = await _db.Discounts
.SelectMany(x => x.AppliedToCategories)
.Where(x => categoryIdsChunk.Contains(x.Id))
.Select(x => x.Id)
.Distinct()
.ToListAsync();
categoriesChunk.Each(x => x.HasDiscountsApplied = appliedCategoryIds.Contains(x.Id));
}
await _db.SaveChangesAsync();
}
public virtual async Task <bool> SendMailsAsync(IEnumerable <QueuedEmail> queuedEmails, CancellationToken cancelToken = default)
{
var result = false;
var saveToDisk = ShouldSaveToDisk();
var groupedQueuedEmails = queuedEmails.GroupBy(x => x.EmailAccountId);
foreach (var group in groupedQueuedEmails)
{
var account = group.FirstOrDefault().EmailAccount;
if (cancelToken.IsCancellationRequested)
{
break;
}
// Create a new connection for each account in current batch.
await using (var client = await _mailService.ConnectAsync(account))
{
// Limit email chunks to 100.
foreach (var batch in group.Slice(100))
{
if (cancelToken.IsCancellationRequested)
{
break;
}
result = await ProcessMailBatchAsync(batch, client, saveToDisk, cancelToken);
await _db.SaveChangesAsync(cancelToken);
}
}
}
return(result);
}
public async Task Run(TaskExecutionContext ctx, CancellationToken cancelToken = default)
{
if (!_currencySettings.AutoUpdateEnabled)
{
return;
}
var exchangeRates = await _currencyService
.GetCurrencyLiveRatesAsync(_storeContext.CurrentStore.PrimaryExchangeRateCurrency.CurrencyCode);
var currencyCodes = exchangeRates.Select(x => x.CurrencyCode).Distinct().ToArray();
var currencies = await _db.Currencies
.Where(x => currencyCodes.Contains(x.CurrencyCode))
.ToDictionaryAsync(x => x.CurrencyCode, StringComparer.OrdinalIgnoreCase);
foreach (var exchageRate in exchangeRates)
{
if (currencies.TryGetValue(exchageRate.CurrencyCode, out var currency) && currency.Rate != exchageRate.Rate)
{
currency.Rate = exchageRate.Rate;
}
}
await _db.SaveChangesAsync(cancelToken);
}
/// <inheritdoc />
public override async Task <SignInResult> PasswordSignInAsync(Customer user, string password, bool isPersistent, bool lockoutOnFailure)
{
if (user == null || user.Deleted)
{
return(SignInResult.Failed);
}
if (!user.Active)
{
return(SignInResult.NotAllowed);
}
if (!user.IsRegistered())
{
return(SignInResult.NotAllowed);
}
var result = await base.PasswordSignInAsync(user, password, isPersistent, lockoutOnFailure);
if (result.Succeeded)
{
user.LastLoginDateUtc = DateTime.UtcNow;
_db.TryUpdate(user);
await _db.SaveChangesAsync();
}
return(result);
}
/// <summary>
/// Called from migration seeder and only processes product entities without MainPictureId value.
/// </summary>
/// <param name="db">Database context.</param>
/// <returns>The total count of fixed and updated product entities.</returns>
internal static async Task <int> FixProductMainPictureIds(SmartDbContext db, bool initial, DateTime?ifModifiedSinceUtc = null)
{
var query =
from p in db.Products.AsNoTracking()
where (!initial || p.MainPictureId == null) && (ifModifiedSinceUtc == null || p.UpdatedOnUtc >= ifModifiedSinceUtc.Value)
orderby p.Id
select new { p.Id, p.MainPictureId };
// Key = ProductId, Value = MainPictureId
var toUpdate = new Dictionary <int, int?>();
// 1st pass
var pageIndex = -1;
while (true)
{
var products = await query.ToPagedList(++pageIndex, 500).LoadAsync();
var map = await GetPoductPictureMap(db, products.Select(x => x.Id).ToArray());
foreach (var p in products)
{
int?fixedPictureId = null;
if (map.ContainsKey(p.Id))
{
// Product has still a pic.
fixedPictureId = map[p.Id].FirstOrDefault();
}
// Update only if fixed PictureId differs from current
if (fixedPictureId != p.MainPictureId)
{
toUpdate.Add(p.Id, fixedPictureId);
}
}
if (!products.HasNextPage)
{
break;
}
}
// 2nd pass.
foreach (var chunk in toUpdate.Slice(1000))
{
using var transaction = await db.Database.BeginTransactionAsync();
foreach (var kvp in chunk)
{
db.Database.ExecuteSqlRaw("Update Product Set MainPictureId = {0} WHERE Id = {1}", kvp.Value, kvp.Key);
}
await db.SaveChangesAsync();
await transaction.CommitAsync();
}
return(toUpdate.Count);
}
public async Task <IActionResult> AccountActivation(string token, string email)
{
var customer = await _userManager.FindByEmailAsync(email);
if (customer == null)
{
NotifyError(T("Account.AccountActivation.InvalidEmailOrToken"));
return(RedirectToRoute("Homepage"));
}
// Validate token & set user to active.
var confirmed = await _userManager.ConfirmEmailAsync(customer, token);
if (!confirmed.Succeeded)
{
NotifyError(T("Account.AccountActivation.InvalidEmailOrToken"));
return(RedirectToRoute("HomePage"));
}
// If token wasn't proved invalid by ConfirmEmailAsync() a few lines above, Customer.Active was set to true & AccountActivationToken was resetted in UserStore.
// So we better save here.
await _db.SaveChangesAsync();
// Send welcome message.
await _messageFactory.SendCustomerWelcomeMessageAsync(customer, Services.WorkContext.WorkingLanguage.Id);
ViewBag.ActivationResult = T("Account.AccountActivation.Activated");
return(View());
}
public virtual async Task CancelOrderAsync(Order order, bool notifyCustomer)
{
Guard.NotNull(order, nameof(order));
if (!order.CanCancelOrder())
{
throw new SmartException(T("Order.CannotCancel"));
}
await SetOrderStatusAsync(order, OrderStatus.Cancelled, notifyCustomer);
order.AddOrderNote(T("Admin.OrderNotice.OrderCancelled"));
// Cancel recurring payments.
var recurringPayments = await _db.RecurringPayments
.ApplyStandardFilter(order.Id)
.ToListAsync();
foreach (var rp in recurringPayments)
{
await CancelRecurringPaymentAsync(rp);
}
// Adjust inventory.
foreach (var orderItem in order.OrderItems)
{
await _productService.AdjustInventoryAsync(orderItem, false, orderItem.Quantity);
}
await _db.SaveChangesAsync();
}
public async Task PublishAsync(ExportDeployment deployment, ExportDeploymentContext context, CancellationToken cancellationToken)
{
var emailAddresses = deployment.EmailAddresses
.SplitSafe(",")
.Where(x => x.IsEmail())
.ToArray();
if (!emailAddresses.Any())
{
return;
}
var emailAccount = await _db.EmailAccounts.FindByIdAsync(deployment.EmailAccountId, false, cancellationToken);
var fromEmailAddress = emailAccount.ToMailAddress();
var files = await context.GetDeploymentFilesAsync(cancellationToken);
var canStreamBlob = _db.DataProvider.CanStreamBlob;
var num = 0;
foreach (var emailAddress in emailAddresses)
{
var queuedEmail = new QueuedEmail
{
From = fromEmailAddress,
SendManually = false,
To = emailAddress,
Subject = deployment.EmailSubject.NaIfEmpty(),
Body = deployment.EmailSubject.NaIfEmpty(),
CreatedOnUtc = DateTime.UtcNow,
EmailAccountId = deployment.EmailAccountId
};
foreach (var file in files)
{
var name = file.Name;
var attachment = new QueuedEmailAttachment
{
StorageLocation = EmailAttachmentStorageLocation.Blob,
Name = name,
MimeType = MimeTypes.MapNameToMimeType(name)
};
using var item = MediaStorageItem.FromFile(file);
await _dbMediaStorageProvider.ApplyBlobAsync(attachment, item, false);
queuedEmail.Attachments.Add(attachment);
}
_db.QueuedEmails.Add(queuedEmail);
// Blob data could be large, so better not bulk commit here.
num += await _db.SaveChangesAsync(cancellationToken);
}
context.Log.Info($"{num} email(s) created and queued for deployment.");
}
public override async Task OnAfterSaveCompletedAsync(IEnumerable <IHookedEntity> entries, CancellationToken cancelToken)
{
// Update HasDiscountsApplied property.
var categories = entries
.Select(x => x.Entity)
.OfType <Category>()
.ToList();
foreach (var categoriesChunk in categories.Slice(100))
{
var categoryIdsChunk = categoriesChunk
.Select(x => x.Id)
.ToArray();
var appliedCategoryIds = await _db.Discounts
.SelectMany(x => x.AppliedToCategories)
.Where(x => categoryIdsChunk.Contains(x.Id))
.Select(x => x.Id)
.Distinct()
.ToListAsync(cancelToken);
categoriesChunk.Each(x => x.HasDiscountsApplied = appliedCategoryIds.Contains(x.Id));
}
await _db.SaveChangesAsync(cancelToken);
// Validate category hierarchy.
var invalidCategoryIds = new HashSet <int>();
var modifiedCategories = entries
.Where(x => x.InitialState == Smartstore.Data.EntityState.Modified)
.Select(x => x.Entity)
.OfType <Category>()
.ToList();
foreach (var category in modifiedCategories)
{
var valid = await IsValidCategoryHierarchy(category.Id, category.ParentCategoryId, cancelToken);
if (!valid)
{
invalidCategoryIds.Add(category.Id);
}
}
if (invalidCategoryIds.Any())
{
var num = await _db.Categories
.Where(x => invalidCategoryIds.Contains(x.Id))
.BatchUpdateAsync(x => new Category {
ParentCategoryId = 0
}, cancelToken);
}
_requestCache.RemoveByPattern(CategoryService.CATEGORIES_PATTERN_KEY);
_requestCache.RemoveByPattern(CategoryService.PRODUCTCATEGORIES_PATTERN_KEY);
}
public async Task <IActionResult> Create(StoreModel model, bool continueEditing)
{
if (ModelState.IsValid)
{
var store = await MapperFactory.MapAsync <StoreModel, Store>(model);
// Ensure we have "/" at the end.
store.Url = store.Url.EnsureEndsWith("/");
_db.Stores.Add(store);
await _db.SaveChangesAsync();
NotifySuccess(T("Admin.Configuration.Stores.Added"));
return(continueEditing ? RedirectToAction("Edit", new { id = store.Id }) : RedirectToAction("List"));
}
await PrepareStoreModelAsync(model, null);
return(View(model));
}
/// <summary>
/// Imports all template xml files to <see cref="MessageTemplate"/> table.
/// </summary>
/// <param name="virtualRootPath">The virtual root path of templates to import, e.g. "~/Modules/MyModule/EmailTemplates". Default is "~/App_Data/EmailTemplates".</param>
public async Task ImportAllAsync(Language language, string virtualRootPath = null)
{
var sourceTemplates = LoadAll(language, virtualRootPath);
var dbTemplatesMap = (await _db.MessageTemplates
.ToListAsync())
.ToMultimap(x => x.Name, x => x, StringComparer.OrdinalIgnoreCase);
foreach (var source in sourceTemplates)
{
if (dbTemplatesMap.ContainsKey(source.Name))
{
foreach (var target in dbTemplatesMap[source.Name])
{
if (source.To.HasValue())
{
target.To = source.To;
}
if (source.ReplyTo.HasValue())
{
target.ReplyTo = source.ReplyTo;
}
if (source.Subject.HasValue())
{
target.Subject = source.Subject;
}
if (source.ModelTypes.HasValue())
{
target.ModelTypes = source.ModelTypes;
}
if (source.Body.HasValue())
{
target.Body = source.Body;
}
}
}
else
{
var template = new MessageTemplate
{
Name = source.Name,
To = source.To,
ReplyTo = source.ReplyTo,
Subject = source.Subject,
ModelTypes = source.ModelTypes,
Body = source.Body,
IsActive = true,
EmailAccountId = (_defaultEmailAccount?.Id).GetValueOrDefault(),
};
_db.MessageTemplates.Add(template);
}
}
await _db.SaveChangesAsync();
}
public async Task <IActionResult> Create(TopicModel model, bool continueEditing)
{
if (ModelState.IsValid)
{
if (!model.IsPasswordProtected)
{
model.Password = null;
}
// TODO: (mh) (core) Implement & use mapping extensions.
var topic = await MapperFactory.MapAsync <TopicModel, Topic>(model);
if (model.WidgetZone != null)
{
topic.WidgetZone = string.Join(',', model.WidgetZone);
}
topic.CookieType = (CookieType?)model.CookieType;
_db.Topics.Add(topic);
await _db.SaveChangesAsync();
var slugResult = await topic.ValidateSlugAsync(model.SeName, true);
model.SeName = slugResult.Slug;
await _urlService.ApplySlugAsync(slugResult, true);
await SaveStoreMappingsAsync(topic, model.SelectedStoreIds);
await SaveAclMappingsAsync(topic, model.SelectedCustomerRoleIds);
await UpdateLocalesAsync(topic, model);
AddCookieTypes(model, model.CookieType);
await Services.EventPublisher.PublishAsync(new ModelBoundEvent(model, topic, Request.Form));
NotifySuccess(T("Admin.ContentManagement.Topics.Updated"));
return(continueEditing ? RedirectToAction("Edit", new { id = topic.Id }) : RedirectToAction("List"));
}
// If we got this far something failed. Redisplay form.
return(View(model));
}
protected virtual async Task AddItemToCartAsync(AddToCartContext ctx)
{
if (ctx.Item != null)
{
ctx.Customer.ShoppingCartItems.Add(ctx.Item);
if (!ctx.ChildItems.IsNullOrEmpty())
{
foreach (var childItem in ctx.ChildItems)
{
childItem.ParentItemId = ctx.Item.Id;
}
ctx.Customer.ShoppingCartItems.AddRange(ctx.ChildItems);
}
_db.TryUpdate(ctx.Customer);
await _db.SaveChangesAsync();
}
}
public async Task <IActionResult> Category(int categoryId, CatalogSearchQuery query)
{
var category = await _db.Categories.FindByIdAsync(categoryId, false);
if (category == null || category.Deleted)
{
return(NotFound());
}
// Check whether the current user has a "Manage catalog" permission.
// It allows him to preview a category before publishing.
if (!category.Published && !await Services.Permissions.AuthorizeAsync(Permissions.Catalog.Category.Read))
{
return(NotFound());
}
// ACL (access control list).
if (!await _aclService.AuthorizeAsync(category))
{
return(NotFound());
}
// Store mapping.
if (!await _storeMappingService.AuthorizeAsync(category))
{
return(NotFound());
}
var customer = Services.WorkContext.CurrentCustomer;
// 'Continue shopping' URL.
if (!customer.IsSystemAccount)
{
customer.GenericAttributes.LastContinueShoppingPage = Services.WebHelper.GetCurrentPageUrl(false);
await _db.SaveChangesAsync();
}
// TODO: (mh) (core) Continue CatalogController.Category()
return(Content($"Category --> Id: {category.Id}, Name: {category.Name}"));
}
public async Task <IActionResult> ChangeStoreScopeConfiguration(int storeid, string returnUrl = "")
{
var store = Services.StoreContext.GetStoreById(storeid);
if (store != null || storeid == 0)
{
Services.WorkContext.CurrentCustomer.GenericAttributes.AdminAreaStoreScopeConfiguration = storeid;
await _db.SaveChangesAsync();
}
return(RedirectToReferrer(returnUrl, () => RedirectToAction("Index", "Home", new { area = "Admin" })));
}
public Task InsertTaskAsync(ITaskDescriptor task)
{
Guard.IsTypeOf <TaskDescriptor>(task);
_db.TaskDescriptors.Add((TaskDescriptor)task);
return(_db.SaveChangesAsync());
}
protected virtual async Task AddItemToCartAsync(AddToCartContext ctx)
{
Guard.NotNull(ctx, nameof(ctx));
Guard.NotNull(ctx.Item, nameof(ctx.Item));
var customer = ctx.Customer ?? _workContext.CurrentCustomer;
customer.ShoppingCartItems.Add(ctx.Item);
if (ctx.ChildItems.Any())
{
foreach (var childItem in ctx.ChildItems)
{
childItem.ParentItemId = ctx.Item.Id;
}
customer.ShoppingCartItems.AddRange(ctx.ChildItems);
}
_db.TryUpdate(customer);
await _db.SaveChangesAsync();
}
public virtual async Task <Customer> CreateGuestCustomerAsync(Guid?customerGuid = null)
{
var customer = new Customer
{
CustomerGuid = customerGuid ?? Guid.NewGuid(),
Active = true,
CreatedOnUtc = DateTime.UtcNow,
LastActivityDateUtc = DateTime.UtcNow,
};
// Add to 'Guests' role
var guestRole = await GetRoleBySystemNameAsync(SystemCustomerRoleNames.Guests);
if (guestRole == null)
{
throw new SmartException("'Guests' role could not be loaded");
}
// Ensure that entities are saved to db in any case
customer.CustomerRoleMappings.Add(new CustomerRoleMapping {
CustomerId = customer.Id, CustomerRoleId = guestRole.Id
});
_db.Customers.Add(customer);
await _db.SaveChangesAsync();
var clientIdent = _webHelper.GetClientIdent();
if (clientIdent.HasValue())
{
customer.GenericAttributes.ClientIdent = clientIdent;
await _db.SaveChangesAsync();
}
//Logger.DebugFormat("Guest account created for anonymous visitor. Id: {0}, ClientIdent: {1}", customer.CustomerGuid, clientIdent ?? "n/a");
return(customer);
}
