/// <returns>A task that represents the asynchronous operation</returns>
protected virtual async Task SaveStoreMappingsAsync(NewsItem newsItem, NewsItemModel model)
{
newsItem.LimitedToStores = model.SelectedStoreIds.Any();
await _newsService.UpdateNewsAsync(newsItem);
var existingStoreMappings = await _storeMappingService.GetStoreMappingsAsync(newsItem);
var allStores = await _storeService.GetAllStoresAsync();
foreach (var store in allStores)
{
if (model.SelectedStoreIds.Contains(store.Id))
{
//new store
if (existingStoreMappings.Count(sm => sm.StoreId == store.Id) == 0)
{
await _storeMappingService.InsertStoreMappingAsync(newsItem, store.Id);
}
}
else
{
//remove store
var storeMappingToDelete = existingStoreMappings.FirstOrDefault(sm => sm.StoreId == store.Id);
if (storeMappingToDelete != null)
{
await _storeMappingService.DeleteStoreMappingAsync(storeMappingToDelete);
}
}
}
}
protected virtual async Task SaveStoreMappingsAsync(Topic topic, TopicModel model)
{
topic.LimitedToStores = model.SelectedStoreIds.Any();
await _topicService.UpdateTopicAsync(topic);
var existingStoreMappings = await _storeMappingService.GetStoreMappingsAsync(topic);
var allStores = await _storeService.GetAllStoresAsync();
foreach (var store in allStores)
{
if (model.SelectedStoreIds.Contains(store.Id))
{
//new store
if (!existingStoreMappings.Any(sm => sm.StoreId == store.Id))
{
await _storeMappingService.InsertStoreMappingAsync(topic, store.Id);
}
}
else
{
//remove store
var storeMappingToDelete = existingStoreMappings.FirstOrDefault(sm => sm.StoreId == store.Id);
if (storeMappingToDelete != null)
{
await _storeMappingService.DeleteStoreMappingAsync(storeMappingToDelete);
}
}
}
}
protected async Task UpdateStoreMappingsAsync <TEntity>(TEntity entity, List <int> passedStoreIds) where TEntity : BaseEntity, IStoreMappingSupported
{
if (passedStoreIds == null)
{
return;
}
entity.LimitedToStores = passedStoreIds.Any();
var existingStoreMappings = await StoreMappingService.GetStoreMappingsAsync(entity);
var allStores = await StoreService.GetAllStoresAsync();
foreach (var store in allStores)
{
if (passedStoreIds.Contains(store.Id))
{
//new store
if (existingStoreMappings.Count(sm => sm.StoreId == store.Id) == 0)
{
await StoreMappingService.InsertStoreMappingAsync(entity, store.Id);
}
}
else
{
//remove store
var storeMappingToDelete = existingStoreMappings.FirstOrDefault(sm => sm.StoreId == store.Id);
if (storeMappingToDelete != null)
{
await StoreMappingService.DeleteStoreMappingAsync(storeMappingToDelete);
}
}
}
}
private async Task SaveStoreMappingsAsync <TEntity, TModel>(TEntity entity, TModel model)
where TEntity : BaseEntity, IStoreMappingSupported
where TModel : BaseNopEntityModel, IStoreMappingSupportedModel
{
var existingStoreMappings = await _storeMappingService.GetStoreMappingsAsync(entity);
var allStores = await _storeService.GetAllStoresAsync();
foreach (var store in allStores)
{
if (model.SelectedStoreIds.Contains(store.Id))
{
//new store
if (!existingStoreMappings.Any(sm => sm.StoreId == store.Id))
{
await _storeMappingService.InsertStoreMappingAsync(entity, store.Id);
}
}
else
{
//remove store
var storeMappingToDelete = existingStoreMappings.FirstOrDefault(sm => sm.StoreId == store.Id);
if (storeMappingToDelete != null)
{
await _storeMappingService.DeleteStoreMappingAsync(storeMappingToDelete);
}
}
}
}
/// <returns>A task that represents the asynchronous operation</returns>
protected virtual async Task SaveStoreMappingsAsync(Poll poll, PollModel model)
{
poll.LimitedToStores = model.SelectedStoreIds.Any();
await _pollService.UpdatePollAsync(poll);
//manage store mappings
var existingStoreMappings = await _storeMappingService.GetStoreMappingsAsync(poll);
foreach (var store in await _storeService.GetAllStoresAsync())
{
var existingStoreMapping = existingStoreMappings.FirstOrDefault(storeMapping => storeMapping.StoreId == store.Id);
//new store mapping
if (model.SelectedStoreIds.Contains(store.Id))
{
if (existingStoreMapping == null)
{
await _storeMappingService.InsertStoreMappingAsync(poll, store.Id);
}
}
//or remove existing one
else if (existingStoreMapping != null)
{
await _storeMappingService.DeleteStoreMappingAsync(existingStoreMapping);
}
}
}
// currently only doing main store
private async System.Threading.Tasks.Task UnmapFromStoreAsync(Product product, ProductAbcDescription pad)
{
var mainStore = (await _storeService.GetAllStoresAsync())
.Where(s => !s.Name.ToLower().Contains("clearance"))
.First();
var mainStoreMapping = (await _storeMappingService.GetStoreMappingsAsync(product))
.Where(sm => sm.StoreId == mainStore.Id)
.FirstOrDefault();
if (mainStoreMapping != null)
{
await _storeMappingService.DeleteStoreMappingAsync(mainStoreMapping);
}
}