Try your search with a different keyword or use * as a wildcard.
using Nop.Core;
using Nop.Core.Domain.Affiliates;
using Nop.Core.Domain.Common;
using Nop.Core.Domain.Orders;
using Nop.Core.Domain.Seo;
using Nop.Data;
using Nop.Services.Common;
using Nop.Services.Seo;
namespace Nop.Services.Affiliates;
/// <summary>
/// Affiliate service
/// </summary>
public partial class AffiliateService : IAffiliateService
{
#region Fields
protected readonly IAddressService _addressService;
protected readonly IRepository<Address> _addressRepository;
protected readonly IRepository<Affiliate> _affiliateRepository;
protected readonly IRepository<Order> _orderRepository;
protected readonly IUrlRecordService _urlRecordService;
protected readonly IWebHelper _webHelper;
protected readonly SeoSettings _seoSettings;
#endregion
#region Ctor
public AffiliateService(IAddressService addressService,
IRepository<Address> addressRepository,
IRepository<Affiliate> affiliateRepository,
IRepository<Order> orderRepository,
IUrlRecordService urlRecordService,
IWebHelper webHelper,
SeoSettings seoSettings)
{
_addressService = addressService;
_addressRepository = addressRepository;
_affiliateRepository = affiliateRepository;
_orderRepository = orderRepository;
_urlRecordService = urlRecordService;
_webHelper = webHelper;
_seoSettings = seoSettings;
}
#endregion
#region Methods
/// <summary>
/// Gets an affiliate by affiliate identifier
/// </summary>
/// <param name="affiliateId">Affiliate identifier</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the affiliate
/// </returns>
public virtual async Task<Affiliate> GetAffiliateByIdAsync(int affiliateId)
{
return await _affiliateRepository.GetByIdAsync(affiliateId, cache => default, useShortTermCache: true);
}
/// <summary>
/// Gets an affiliate by friendly URL name
/// </summary>
/// <param name="friendlyUrlName">Friendly URL name</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the affiliate
/// </returns>
public virtual async Task<Affiliate> GetAffiliateByFriendlyUrlNameAsync(string friendlyUrlName)
{
if (string.IsNullOrWhiteSpace(friendlyUrlName))
return null;
var query = from a in _affiliateRepository.Table
orderby a.Id
where a.FriendlyUrlName == friendlyUrlName
select a;
var affiliate = await query.FirstOrDefaultAsync();
return affiliate;
}
/// <summary>
/// Marks affiliate as deleted
/// </summary>
/// <param name="affiliate">Affiliate</param>
/// <returns>A task that represents the asynchronous operation</returns>
public virtual async Task DeleteAffiliateAsync(Affiliate affiliate)
{
await _affiliateRepository.DeleteAsync(affiliate);
}
/// <summary>
/// Gets all affiliates
/// </summary>
/// <param name="friendlyUrlName">Friendly URL name; null to load all records</param>
/// <param name="firstName">First name; null to load all records</param>
/// <param name="lastName">Last name; null to load all records</param>
/// <param name="loadOnlyWithOrders">Value indicating whether to load affiliates only with orders placed (by affiliated customers)</param>
/// <param name="ordersCreatedFromUtc">Orders created date from (UTC); null to load all records. It's used only with "loadOnlyWithOrders" parameter st to "true".</param>
/// <param name="ordersCreatedToUtc">Orders created date to (UTC); null to load all records. It's used only with "loadOnlyWithOrders" parameter st to "true".</param>
/// <param name="pageIndex">Page index</param>
/// <param name="pageSize">Page size</param>
/// <param name="showHidden">A value indicating whether to show hidden records</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the affiliates
/// </returns>
public virtual async Task<IPagedList<Affiliate>> GetAllAffiliatesAsync(string friendlyUrlName = null,
string firstName = null, string lastName = null,
bool loadOnlyWithOrders = false,
DateTime? ordersCreatedFromUtc = null, DateTime? ordersCreatedToUtc = null,
int pageIndex = 0, int pageSize = int.MaxValue,
bool showHidden = false)
{
return await _affiliateRepository.GetAllPagedAsync(query =>
{
if (!string.IsNullOrWhiteSpace(friendlyUrlName))
query = query.Where(a => a.FriendlyUrlName.Contains(friendlyUrlName));
if (!string.IsNullOrWhiteSpace(firstName))
query = from aff in query
join addr in _addressRepository.Table on aff.AddressId equals addr.Id
where addr.FirstName.Contains(firstName)
select aff;
if (!string.IsNullOrWhiteSpace(lastName))
query = from aff in query
join addr in _addressRepository.Table on aff.AddressId equals addr.Id
where addr.LastName.Contains(lastName)
select aff;
if (!showHidden)
query = query.Where(a => a.Active);
query = query.Where(a => !a.Deleted);
if (loadOnlyWithOrders)
{
var ordersQuery = _orderRepository.Table;
if (ordersCreatedFromUtc.HasValue)
ordersQuery = ordersQuery.Where(o => ordersCreatedFromUtc.Value <= o.CreatedOnUtc);
if (ordersCreatedToUtc.HasValue)
ordersQuery = ordersQuery.Where(o => ordersCreatedToUtc.Value >= o.CreatedOnUtc);
ordersQuery = ordersQuery.Where(o => !o.Deleted);
query = from a in query
join o in ordersQuery on a.Id equals o.AffiliateId
select a;
}
query = query.Distinct().OrderByDescending(a => a.Id);
return query;
}, pageIndex, pageSize);
}
/// <summary>
/// Inserts an affiliate
/// </summary>
/// <param name="affiliate">Affiliate</param>
/// <returns>A task that represents the asynchronous operation</returns>
public virtual async Task InsertAffiliateAsync(Affiliate affiliate)
{
await _affiliateRepository.InsertAsync(affiliate);
}
/// <summary>
/// Updates the affiliate
/// </summary>
/// <param name="affiliate">Affiliate</param>
/// <returns>A task that represents the asynchronous operation</returns>
public virtual async Task UpdateAffiliateAsync(Affiliate affiliate)
{
await _affiliateRepository.UpdateAsync(affiliate);
}
/// <summary>
/// Get full name
/// </summary>
/// <param name="affiliate">Affiliate</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the affiliate full name
/// </returns>
public virtual async Task<string> GetAffiliateFullNameAsync(Affiliate affiliate)
{
ArgumentNullException.ThrowIfNull(affiliate);
var affiliateAddress = await _addressService.GetAddressByIdAsync(affiliate.AddressId);
if (affiliateAddress == null)
return string.Empty;
var fullName = $"{affiliateAddress.FirstName} {affiliateAddress.LastName}";
return fullName;
}
/// <summary>
/// Generate affiliate URL
/// </summary>
/// <param name="affiliate">Affiliate</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the generated affiliate URL
/// </returns>
public virtual Task<string> GenerateUrlAsync(Affiliate affiliate)
{
ArgumentNullException.ThrowIfNull(affiliate);
var storeUrl = _webHelper.GetStoreLocation();
var url = !string.IsNullOrEmpty(affiliate.FriendlyUrlName) ?
//use friendly URL
_webHelper.ModifyQueryString(storeUrl, NopAffiliateDefaults.AffiliateQueryParameter, affiliate.FriendlyUrlName) :
//use ID
_webHelper.ModifyQueryString(storeUrl, NopAffiliateDefaults.AffiliateIdQueryParameter, affiliate.Id.ToString());
return Task.FromResult(url);
}
/// <summary>
/// Validate friendly URL name
/// </summary>
/// <param name="affiliate">Affiliate</param>
/// <param name="friendlyUrlName">Friendly URL name</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the valid friendly name
/// </returns>
public virtual async Task<string> ValidateFriendlyUrlNameAsync(Affiliate affiliate, string friendlyUrlName)
{
ArgumentNullException.ThrowIfNull(affiliate);
//ensure we have only valid chars
friendlyUrlName = await _urlRecordService.GetSeNameAsync(friendlyUrlName, _seoSettings.ConvertNonWesternChars, _seoSettings.AllowUnicodeCharsInUrls);
//max length
//(consider a store URL + probably added {0}-{1} below)
friendlyUrlName = CommonHelper.EnsureMaximumLength(friendlyUrlName, NopAffiliateDefaults.FriendlyUrlNameLength);
//ensure this name is not reserved yet
//empty? nothing to check
if (string.IsNullOrEmpty(friendlyUrlName))
return friendlyUrlName;
//check whether such friendly URL name already exists (and that is not the current affiliate)
var i = 2;
var tempName = friendlyUrlName;
while (true)
{
var affiliateByFriendlyUrlName = await GetAffiliateByFriendlyUrlNameAsync(tempName);
var reserved = affiliateByFriendlyUrlName != null && affiliateByFriendlyUrlName.Id != affiliate.Id;
if (!reserved)
break;
tempName = $"{friendlyUrlName}-{i}";
i++;
}
friendlyUrlName = tempName;
return friendlyUrlName;
}
#endregion
}