/// <summary>
/// Inserts an email account
/// </summary>
/// <param name="emailAccount">Email account</param>
public virtual async Task InsertEmailAccount(EmailAccount emailAccount)
{
if (emailAccount == null)
{
throw new ArgumentNullException(nameof(emailAccount));
}
emailAccount.Email = CommonHelper.EnsureNotNull(emailAccount.Email);
emailAccount.DisplayName = CommonHelper.EnsureNotNull(emailAccount.DisplayName);
emailAccount.Host = CommonHelper.EnsureNotNull(emailAccount.Host);
emailAccount.Username = CommonHelper.EnsureNotNull(emailAccount.Username);
emailAccount.Password = CommonHelper.EnsureNotNull(emailAccount.Password);
emailAccount.Email = emailAccount.Email.Trim();
emailAccount.DisplayName = emailAccount.DisplayName.Trim();
emailAccount.Host = emailAccount.Host.Trim();
emailAccount.Username = emailAccount.Username.Trim();
emailAccount.Password = emailAccount.Password.Trim();
emailAccount.Email = CommonHelper.EnsureMaximumLength(emailAccount.Email, 255);
emailAccount.DisplayName = CommonHelper.EnsureMaximumLength(emailAccount.DisplayName, 255);
emailAccount.Host = CommonHelper.EnsureMaximumLength(emailAccount.Host, 255);
emailAccount.Username = CommonHelper.EnsureMaximumLength(emailAccount.Username, 255);
emailAccount.Password = CommonHelper.EnsureMaximumLength(emailAccount.Password, 255);
await _emailAccountRepository.InsertAsync(emailAccount);
//clear cache
await _cacheBase.RemoveByPrefix(CacheKey.EMAILACCOUNT_PATTERN_KEY);
//event notification
await _mediator.EntityInserted(emailAccount);
}
public async Task Handle(EntityUpdated <Product> eventMessage, CancellationToken cancellationToken)
{
await _cacheBase.RemoveByPrefix(CacheKeyConst.HOMEPAGE_BESTSELLERS_IDS_PATTERN_KEY);
await _cacheBase.RemoveByPrefix(string.Format(CacheKeyConst.PRODUCTS_SIMILAR_IDS_PATTERN_KEY, eventMessage.Entity.Id));
await _cacheBase.RemoveAsync(string.Format(CacheKeyConst.PRODUCTS_RELATED_IDS_PATTERN_KEY, eventMessage.Entity.Id));
}
public virtual async Task DeleteShippingByWeightRecord(ShippingByWeightRecord shippingByWeightRecord)
{
if (shippingByWeightRecord == null)
{
throw new ArgumentNullException("shippingByWeightRecord");
}
await _sbwRepository.DeleteAsync(shippingByWeightRecord);
await _cacheBase.RemoveByPrefix(SHIPPINGBYWEIGHT_PATTERN_KEY);
}
/// <summary>
/// Delete a permission
/// </summary>
/// <param name="permission">Permission</param>
public virtual async Task DeletePermission(Permission permission)
{
if (permission == null)
{
throw new ArgumentNullException(nameof(permission));
}
await _permissionRepository.DeleteAsync(permission);
await _cacheBase.RemoveByPrefix(CacheKey.PERMISSIONS_PATTERN_KEY);
}
/// <summary>
/// Inserts a pickup point
/// </summary>
/// <param name="pickupPoint">Pickup point</param>
public virtual async Task InsertStoreShippingPoint(ShippingPoints pickupPoint)
{
if (pickupPoint == null)
{
throw new ArgumentNullException("pickupPoint");
}
await _shippingPointRepository.InsertAsync(pickupPoint);
await _cacheBase.RemoveByPrefix(PICKUP_POINT_PATTERN_KEY);
}
public async Task Handle(EntityDeleted <Discount> notification, CancellationToken cancellationToken)
{
var discount = notification.Entity;
var builder = Builders <BsonDocument> .Filter;
if (discount.DiscountTypeId == DiscountType.AssignedToSkus)
{
var builderproduct = Builders <Product> .Update;
var updatefilter = builderproduct.Pull(x => x.AppliedDiscounts, discount.Id);
await _productRepository.Collection.UpdateManyAsync(new BsonDocument(), updatefilter);
await _cacheBase.RemoveByPrefix(CacheKey.PRODUCTS_PATTERN_KEY);
}
if (discount.DiscountTypeId == DiscountType.AssignedToCategories)
{
var buildercategory = Builders <Category> .Update;
var updatefilter = buildercategory.Pull(x => x.AppliedDiscounts, discount.Id);
await _categoryRepository.Collection.UpdateManyAsync(new BsonDocument(), updatefilter);
await _cacheBase.RemoveByPrefix(CacheKey.CATEGORIES_PATTERN_KEY);
}
if (discount.DiscountTypeId == DiscountType.AssignedToBrands)
{
var builderbrand = Builders <Brand> .Update;
var updatefilter = builderbrand.Pull(x => x.AppliedDiscounts, discount.Id);
await _brandRepository.Collection.UpdateManyAsync(new BsonDocument(), updatefilter);
await _cacheBase.RemoveByPrefix(CacheKey.BRANDS_PATTERN_KEY);
}
if (discount.DiscountTypeId == DiscountType.AssignedToCollections)
{
var buildercollection = Builders <Collection> .Update;
var updatefilter = buildercollection.Pull(x => x.AppliedDiscounts, discount.Id);
await _collectionRepository.Collection.UpdateManyAsync(new BsonDocument(), updatefilter);
await _cacheBase.RemoveByPrefix(CacheKey.COLLECTIONS_PATTERN_KEY);
}
if (discount.DiscountTypeId == DiscountType.AssignedToVendors)
{
var buildervendor = Builders <Vendor> .Update;
var updatefilter = buildervendor.Pull(x => x.AppliedDiscounts, discount.Id);
await _vendorRepository.Collection.UpdateManyAsync(new BsonDocument(), updatefilter);
await _cacheBase.RemoveByPrefix(CacheKey.PRODUCTS_PATTERN_KEY);
}
//remove coupon codes
var filtersCoupon = Builders <DiscountCoupon> .Filter;
var filterCrp = filtersCoupon.Eq(x => x.DiscountId, discount.Id);
await _discountCouponRepository.Collection.DeleteManyAsync(filterCrp);
}
/// <summary>
/// Inserts an activity log type item
/// </summary>
/// <param name="activityLogType">Activity log type item</param>
public virtual async Task InsertActivityType(ActivityLogType activityLogType)
{
if (activityLogType == null)
{
throw new ArgumentNullException(nameof(activityLogType));
}
await _activityLogTypeRepository.InsertAsync(activityLogType);
await _cacheBase.RemoveByPrefix(CacheKey.ACTIVITYTYPE_PATTERN_KEY);
}
/// <summary>
/// Deletes an URL record
/// </summary>
/// <param name="urlRecord">URL record</param>
public virtual async Task DeleteUrlRecord(UrlRecord urlRecord)
{
if (urlRecord == null)
{
throw new ArgumentNullException("urlRecord");
}
await _urlRecordRepository.DeleteAsync(urlRecord);
//cache
await _cacheBase.RemoveByPrefix(CacheKey.URLRECORD_PATTERN_KEY);
}
/// <summary>
/// Delete a slider
/// </summary>
/// <param name="slider">Slider</param>
public virtual async Task DeleteSlider(PictureSlider slide)
{
if (slide == null)
{
throw new ArgumentNullException(nameof(slide));
}
//clear cache
await _cacheBase.RemoveByPrefix(SLIDERS_PATTERN_KEY);
await _reporistoryPictureSlider.DeleteAsync(slide);
}
/// <summary>
/// Inserts an URL Entity
/// </summary>
/// <param name="urlEntity">URL Entity</param>
public virtual async Task InsertEntityUrl(EntityUrl urlEntity)
{
if (urlEntity == null)
{
throw new ArgumentNullException(nameof(urlEntity));
}
await _urlEntityRepository.InsertAsync(urlEntity);
//cache
await _cacheBase.RemoveByPrefix(CacheKey.URLEntity_PATTERN_KEY);
}
/// <summary>
/// Deletes a tax rate
/// </summary>
/// <param name="taxRate">Tax rate</param>
public virtual async Task DeleteTaxRate(TaxRate taxRate)
{
if (taxRate == null)
{
throw new ArgumentNullException("taxRate");
}
await _taxRateRepository.DeleteAsync(taxRate);
await _cacheBase.RemoveByPrefix(TAXRATE_PATTERN_KEY);
//event notification
await _mediator.EntityDeleted(taxRate);
}
/// <summary>
/// Inserts a customer group
/// </summary>
/// <param name="customerGroup">Customer group</param>
public virtual async Task InsertCustomerGroup(CustomerGroup customerGroup)
{
if (customerGroup == null)
{
throw new ArgumentNullException(nameof(customerGroup));
}
await _customerGroupRepository.InsertAsync(customerGroup);
await _cacheBase.RemoveByPrefix(CacheKey.CUSTOMERGROUPS_PATTERN_KEY);
//event notification
await _mediator.EntityInserted(customerGroup);
}
/// <summary>
/// Deletes measure dimension
/// </summary>
/// <param name="measureDimension">Measure dimension</param>
public virtual async Task DeleteMeasureDimension(MeasureDimension measureDimension)
{
if (measureDimension == null)
{
throw new ArgumentNullException("measureDimension");
}
await _measureDimensionRepository.DeleteAsync(measureDimension);
await _cacheBase.RemoveByPrefix(CacheKey.MEASUREDIMENSIONS_PATTERN_KEY);
//event notification
await _mediator.EntityDeleted(measureDimension);
}
/// <summary>
/// Inserts a measure dimension
/// </summary>
/// <param name="measure">Measure dimension</param>
public virtual async Task InsertMeasureDimension(MeasureDimension measure)
{
if (measure == null)
{
throw new ArgumentNullException(nameof(measure));
}
await _measureDimensionRepository.InsertAsync(measure);
await _cacheBase.RemoveByPrefix(CacheKey.MEASUREDIMENSIONS_PATTERN_KEY);
//event notification
await _mediator.EntityInserted(measure);
}
/// <summary>
/// Inserts a country
/// </summary>
/// <param name="country">Country</param>
public virtual async Task InsertCountry(Country country)
{
if (country == null)
{
throw new ArgumentNullException(nameof(country));
}
await _countryRepository.InsertAsync(country);
await _cacheBase.RemoveByPrefix(CacheKey.COUNTRIES_PATTERN_KEY);
//event notification
await _mediator.EntityInserted(country);
}
/// <summary>
/// Inserts a tax category
/// </summary>
/// <param name="taxCategory">Tax category</param>
public virtual async Task InsertTaxCategory(TaxCategory taxCategory)
{
if (taxCategory == null)
{
throw new ArgumentNullException(nameof(taxCategory));
}
await _taxCategoryRepository.InsertAsync(taxCategory);
await _cacheBase.RemoveByPrefix(CacheKey.TAXCATEGORIES_PATTERN_KEY);
//event notification
await _mediator.EntityInserted(taxCategory);
}
/// <summary>
/// Inserts a currency
/// </summary>
/// <param name="currency">Currency</param>
public virtual async Task InsertCurrency(Currency currency)
{
if (currency == null)
{
throw new ArgumentNullException(nameof(currency));
}
await _currencyRepository.InsertAsync(currency);
await _cacheBase.RemoveByPrefix(CacheKey.CURRENCIES_PATTERN_KEY);
//event notification
await _mediator.EntityInserted(currency);
}
/// <summary>
/// Delete a message template
/// </summary>
/// <param name="messageTemplate">Message template</param>
public virtual async Task DeleteMessageTemplate(MessageTemplate messageTemplate)
{
if (messageTemplate == null)
{
throw new ArgumentNullException("messageTemplate");
}
await _messageTemplateRepository.DeleteAsync(messageTemplate);
await _cacheBase.RemoveByPrefix(CacheKey.MESSAGETEMPLATES_PATTERN_KEY);
//event notification
await _mediator.EntityDeleted(messageTemplate);
}
/// <summary>
/// Deletes a state/province
/// </summary>
/// <param name="stateProvince">The state/province</param>
public virtual async Task DeleteStateProvince(StateProvince stateProvince)
{
if (stateProvince == null)
{
throw new ArgumentNullException("stateProvince");
}
await _stateProvinceRepository.DeleteAsync(stateProvince);
await _cacheBase.RemoveByPrefix(CacheKey.STATEPROVINCES_PATTERN_KEY);
//event notification
await _mediator.EntityDeleted(stateProvince);
}
/// <summary>
/// Updates the picture
/// </summary>
/// <param name="pictureId">The picture identifier</param>
/// <param name="pictureBinary">The picture binary</param>
/// <param name="mimeType">The picture MIME type</param>
/// <param name="seoFilename">The SEO filename</param>
/// <param name="altAttribute">"alt" attribute for "img" HTML element</param>
/// <param name="titleAttribute">"title" attribute for "img" HTML element</param>
/// <param name="isNew">A value indicating whether the picture is new</param>
/// <param name="validateBinary">A value indicating whether to validated provided picture binary</param>
/// <returns>Picture</returns>
public virtual async Task <Picture> UpdatePicture(string pictureId, byte[] pictureBinary, string mimeType,
string seoFilename, string altAttribute = null, string titleAttribute = null,
bool isNew = true, bool validateBinary = true)
{
mimeType = CommonHelper.EnsureNotNull(mimeType);
mimeType = CommonHelper.EnsureMaximumLength(mimeType, 20);
seoFilename = CommonHelper.EnsureMaximumLength(seoFilename, 100);
if (validateBinary)
{
pictureBinary = ValidatePicture(pictureBinary, mimeType);
}
var picture = await GetPictureById(pictureId);
if (picture == null)
{
return(null);
}
//delete old thumbs if a picture has been changed
if (seoFilename != picture.SeoFilename)
{
await DeletePictureThumbs(picture);
}
picture.PictureBinary = _mediaSettings.StoreInDb ? pictureBinary : new byte[0];
picture.MimeType = mimeType;
picture.SeoFilename = seoFilename;
picture.AltAttribute = altAttribute;
picture.TitleAttribute = titleAttribute;
picture.IsNew = isNew;
await _pictureRepository.UpdateAsync(picture);
if (!_mediaSettings.StoreInDb)
{
await SavePictureInFile(picture.Id, pictureBinary, mimeType);
}
//event notification
await _mediator.EntityUpdated(picture);
//clare cache
await _cacheBase.RemoveByPrefix(string.Format(CacheKey.PICTURE_BY_ID, picture.Id));
return(picture);
}
/// <summary>
/// Inserts a brand
/// </summary>
/// <param name="brand">Brand</param>
public virtual async Task InsertBrand(Brand brand)
{
if (brand == null)
{
throw new ArgumentNullException(nameof(brand));
}
await _brandRepository.InsertAsync(brand);
//cache
await _cacheBase.RemoveByPrefix(CacheKey.BRANDS_PATTERN_KEY);
//event notification
await _mediator.EntityInserted(brand);
}
/// <summary>
/// Inserts a warehouse
/// </summary>
/// <param name="warehouse">Warehouse</param>
public virtual async Task InsertPickupPoint(PickupPoint pickupPoint)
{
if (pickupPoint == null)
{
throw new ArgumentNullException(nameof(pickupPoint));
}
await _pickupPointsRepository.InsertAsync(pickupPoint);
//clear cache
await _cacheBase.RemoveByPrefix(CacheKey.PICKUPPOINTS_PATTERN_KEY);
//event notification
await _mediator.EntityInserted(pickupPoint);
}
/// <summary>
/// Inserts a sales employee
/// </summary>
/// <param name="salesEmployee">Sales Employee</param>
public virtual async Task InsertSalesEmployee(SalesEmployee salesEmployee)
{
if (salesEmployee == null)
{
throw new ArgumentNullException(nameof(salesEmployee));
}
await _salesEmployeeRepository.InsertAsync(salesEmployee);
//clear cache
await _cacheBase.RemoveByPrefix(CacheKey.SALESEMPLOYEE_PATTERN_KEY);
//event notification
await _mediator.EntityInserted(salesEmployee);
}
/// <summary>
/// Inserts page layout
/// </summary>
/// <param name="pageLayout">Page layout</param>
public virtual async Task InsertPageLayout(PageLayout pageLayout)
{
if (pageLayout == null)
{
throw new ArgumentNullException(nameof(pageLayout));
}
await _pageLayoutRepository.InsertAsync(pageLayout);
//clear cache
await _cacheBase.RemoveByPrefix(CacheKey.PAGE_LAYOUT_PATTERN_KEY);
//event notification
await _mediator.EntityInserted(pageLayout);
}
/// <summary>
/// Deletes an ACL record
/// </summary>
/// <param name="aclRecord">ACL record</param>
public virtual async Task DeleteAclRecord(AclRecord aclRecord)
{
if (aclRecord == null)
{
throw new ArgumentNullException("aclRecord");
}
await _aclRecordRepository.DeleteAsync(aclRecord);
//cache
await _cacheBase.RemoveByPrefix(CacheKey.ACLRECORD_PATTERN_KEY);
//event notification
await _mediator.EntityDeleted(aclRecord);
}
/// <summary>
/// Inserts a order's tag
/// </summary>
/// <param name="orderTag">Order's tag</param>
public virtual async Task InsertOrderTag(OrderTag orderTag)
{
if (orderTag == null)
{
throw new ArgumentNullException(nameof(orderTag));
}
await _orderTagRepository.InsertAsync(orderTag);
//cache
await _cacheBase.RemoveByPrefix(CacheKey.ORDERTAG_PATTERN_KEY);
//event notification
await _mediator.EntityInserted(orderTag);
}
/// <summary>
/// Deletes a language
/// </summary>
/// <param name="language">Language</param>
public virtual async Task DeleteLanguage(Language language)
{
if (language == null)
{
throw new ArgumentNullException("language");
}
await _languageRepository.DeleteAsync(language);
//cache
await _cacheBase.RemoveByPrefix(CacheKey.LANGUAGES_PATTERN_KEY);
//event notification
await _mediator.EntityDeleted(language);
}
/// <summary>
/// Deletes a locale string resource
/// </summary>
/// <param name="localeStringResource">Locale string resource</param>
public virtual async Task DeleteLocaleStringResource(LocaleStringResource localeStringResource)
{
if (localeStringResource == null)
{
throw new ArgumentNullException("localeStringResource");
}
await _lsrRepository.DeleteAsync(localeStringResource);
//cache
await _cacheBase.RemoveByPrefix(CacheKey.LOCALSTRINGRESOURCES_PATTERN_KEY);
//event notification
await _mediator.EntityDeleted(localeStringResource);
}
/// <summary>
/// Inserts a delivery date
/// </summary>
/// <param name="deliveryDate">Delivery date</param>
public virtual async Task InsertDeliveryDate(DeliveryDate deliveryDate)
{
if (deliveryDate == null)
{
throw new ArgumentNullException(nameof(deliveryDate));
}
await _deliveryDateRepository.InsertAsync(deliveryDate);
//clear cache
await _cacheBase.RemoveByPrefix(CacheKey.DELIVERYDATE_PATTERN_KEY);
//event notification
await _mediator.EntityInserted(deliveryDate);
}
/// <summary>
/// Inserts a merchandise return action
/// </summary>
/// <param name="merchandiseReturnAction">Merchandise return action</param>
public virtual async Task InsertMerchandiseReturnAction(MerchandiseReturnAction merchandiseReturnAction)
{
if (merchandiseReturnAction == null)
{
throw new ArgumentNullException(nameof(merchandiseReturnAction));
}
await _merchandiseReturnActionRepository.InsertAsync(merchandiseReturnAction);
//event notification
await _mediator.EntityInserted(merchandiseReturnAction);
//clear cache
await _cacheBase.RemoveByPrefix(CacheKey.MERCHANDISE_RETURN_ACTIONS_ALL_KEY);
}