public void GetFailureThrowsIfKeyNotFoundTest()
{
Assert.Throws <InvalidOperationException>(() =>
{
var actual = FailureStrings.Get("Fake");
});
}
public void AllCultures()
{
var original = CultureInfo.DefaultThreadCurrentCulture;
try
{
var cultures = new[]
{
"en-US",
"ru-RU"
};
foreach (var c in cultures)
{
var ci = new CultureInfo(c);
CultureInfo.DefaultThreadCurrentCulture = ci;
Thread.CurrentThread.CurrentUICulture = ci;
foreach (var key in FailureStrings.GetKeys().Where(x => x.EndsWith("Code")))
{
var actual = FailureStrings.Get(key);
Assert.NotNull(actual);
}
}
}
finally
{
CultureInfo.DefaultThreadCurrentCulture = original;
}
}
public void GetFailureTest()
{
var actual = FailureStrings.Get(FailureStrings.ACT00Code);
Assert.Equal("ACT.00", actual.Code);
Assert.Equal("Activation failed.", actual.Message);
Assert.Equal("Your product is having trouble connecting with License servers.", actual.HowToResolve);
}
public void AllKeysValid()
{
foreach (var key in FailureStrings.GetKeys().Where(x => x.EndsWith("Code")))
{
var actual = FailureStrings.Get(key);
Assert.NotNull(actual);
}
}
public async Task <LicenseRegisterResult> CreateAsync(LicenseRegisterRequest request, string userName)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (string.IsNullOrWhiteSpace(userName))
{
throw new ArgumentNullException(nameof(userName));
}
try
{
_logger.LogDebug(JsonSerializer.Serialize(request));
var failure = await ValidateAsync(request);
if (failure != null)
{
return(new LicenseRegisterResult
{
Failure = (GeneralValidationFailure)failure
});
}
string attributesJson = null;
string attributesChecksum = null;
if (request.Attributes != null && request.Attributes.Any())
{
attributesJson = JsonSerializer.Serialize(request.Attributes);
attributesChecksum = Utils.GetSha256HashFromString(attributesJson);
}
var activationId = Guid.NewGuid();
var product = _context.Products.Single(x => x.LicenseProductId == request.ProductUuid);
var registration = _context.Registrations.Single(x => x.LicenseRegistrationId == request.LicenseUuid);
var licenseString = await CreateLicenseAsync(request, registration, product, activationId);
await CreateLicenseRecordAsync(registration, licenseString, attributesJson, attributesChecksum, userName, activationId);
var result = new LicenseRegisterResult();
result.License = licenseString;
return(result);
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
return(new LicenseRegisterResult
{
Failure = (GeneralValidationFailure)FailureStrings.Get(FailureStrings.ACT06Code)
});
}
}
/// <summary>
/// Validates if the license has been expired.
/// </summary>
/// <param name="validationChain">The current <see cref="IStartValidationChain"/>.</param>
/// <returns>An instance of <see cref="IStartValidationChain"/>.</returns>
public static IValidationChain ExpirationDate(this IStartValidationChain validationChain)
{
var validationChainBuilder = (validationChain as ValidationChainBuilder);
var validator = validationChainBuilder.StartValidatorChain();
validator.Validate = license => license.ExpirationUtc > DateTime.UtcNow;
validator.FailureResult = FailureStrings.Get(FailureStrings.VAL03Code);
return(validationChainBuilder);
}
/// <summary>
/// Validates the <see cref="License.Signature"/>.
/// </summary>
/// <param name="validationChain">The current <see cref="IStartValidationChain"/>.</param>
/// <returns>An instance of <see cref="IStartValidationChain"/>.</returns>
public static IValidationChain Signature(this IStartValidationChain validationChain)
{
var validationChainBuilder = (validationChain as ValidationChainBuilder);
var validator = validationChainBuilder.StartValidatorChain();
validator.Validate = license => license.VerifySignature();
validator.FailureResult = FailureStrings.Get(FailureStrings.VAL02Code);
return(validationChainBuilder);
}
protected override Task <IEnumerable <IValidationFailure> > ValidateInternalAsync(License actual)
{
var failure = FailureStrings.Get(FailureStrings.VAL04Code);
var appId = GetAttributes()[LicenseGlobals.MachineName];
var failures = actual.Validate()
.ExpirationDate()
.When(lic => lic.Type == LicenseType.Standard)
.And()
.Signature()
.And()
.AssertThat(x => string.Equals(appId, x.AdditionalAttributes.Get(LicenseGlobals.MachineName), StringComparison.OrdinalIgnoreCase), failure)
.AssertValidLicense().ToList();
return(Task.FromResult(failures.AsEnumerable()));
}
public Task <IValidationFailure> ValidateAsync(LicenseRegisterRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (request.LicenseUuid == Guid.Empty)
{
return(Task.FromResult(FailureStrings.Get(FailureStrings.ACT01Code)));
}
if (request.ProductUuid == Guid.Empty)
{
return(Task.FromResult(FailureStrings.Get(FailureStrings.ACT02Code)));
}
var registration = _context.Registrations.SingleOrDefault(x => x.LicenseRegistrationId == request.LicenseUuid);
if (registration == null)
{
return(Task.FromResult(FailureStrings.Get(FailureStrings.ACT01Code)));
}
if (registration.ProductId != request.ProductUuid)
{
return(Task.FromResult(FailureStrings.Get(FailureStrings.ACT02Code)));
}
if (registration.IsActive == false)
{
return(Task.FromResult(FailureStrings.Get(FailureStrings.ACT03Code)));
}
if (registration.ExpireUtc != null && registration.ExpireUtc <= DateTime.UtcNow)
{
return(Task.FromResult(FailureStrings.Get(FailureStrings.ACT04Code)));
}
if (registration.Quantity > 1 && (LicenseGetUsage(request.LicenseUuid) >= registration.Quantity))
{
return(Task.FromResult(FailureStrings.Get(FailureStrings.ACT05Code)));
}
return(Task.FromResult <IValidationFailure>(null));
}
public Task <IEnumerable <IValidationFailure> > ValidateAsync(Stream license)
{
if (license == null)
{
throw new ArgumentNullException(nameof(license));
}
var task = Task.Run(() =>
{
var results = new List <IValidationFailure>();
try
{
var actual = License.Load(license);
var failure = FailureStrings.Get(FailureStrings.VAL04Code);
var validationFailures = actual.Validate()
.ExpirationDate()
.When(lic => lic.Type == LicenseType.Standard)
.And()
.Signature()
.And()
.AssertThat(x => string.Equals(AppId, x.AdditionalAttributes.Get(LicenseGlobals.AppId), StringComparison.OrdinalIgnoreCase), failure)
.AssertValidLicense().ToList();
foreach (var f in validationFailures)
{
results.Add(f);
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
var failure = FailureStrings.Get(FailureStrings.VAL01Code);
results.Add(failure);
}
return(results.AsEnumerable());
});
return(task);
}
public IEnumerable <IValidationFailure> AssertValidLicense()
{
CompleteValidatorChain();
while (validators.Count > 0)
{
var validator = validators.Dequeue();
if (validator.ValidateWhen != null && !validator.ValidateWhen(license))
{
continue;
}
if (!validator.Validate(license))
{
yield return(validator.FailureResult
?? FailureStrings.Get(FailureStrings.VAL05Code));
}
}
}
public bool DeepEquals(DestinyVendorDefinition other)
{
return(other != null &&
DisplayProperties.DeepEquals(other.DisplayProperties) &&
VendorProgressionType == other.VendorProgressionType &&
BuyString == other.BuyString &&
SellString == other.SellString &&
DisplayItem.DeepEquals(other.DisplayItem) &&
InhibitBuying == other.InhibitBuying &&
InhibitSelling == other.InhibitSelling &&
Faction.DeepEquals(other.Faction) &&
ResetIntervalMinutes == other.ResetIntervalMinutes &&
ResetOffsetMinutes == other.ResetOffsetMinutes &&
FailureStrings.DeepEqualsReadOnlySimpleCollection(other.FailureStrings) &&
UnlockRanges.DeepEqualsReadOnlyCollections(other.UnlockRanges) &&
VendorIdentifier == other.VendorIdentifier &&
VendorPortrait == other.VendorPortrait &&
VendorBanner == other.VendorBanner &&
Enabled == other.Enabled &&
Visible == other.Visible &&
VendorSubcategoryIdentifier == other.VendorSubcategoryIdentifier &&
ConsolidateCategories == other.ConsolidateCategories &&
Actions.DeepEqualsReadOnlyCollections(other.Actions) &&
Categories.DeepEqualsReadOnlyCollections(other.Categories) &&
OriginalCategories.DeepEqualsReadOnlyCollections(other.OriginalCategories) &&
DisplayCategories.DeepEqualsReadOnlyCollections(other.DisplayCategories) &&
Interactions.DeepEqualsReadOnlyCollections(other.Interactions) &&
InventoryFlyouts.DeepEqualsReadOnlyCollections(other.InventoryFlyouts) &&
ItemList.DeepEqualsReadOnlyCollections(other.ItemList) &&
Services.DeepEqualsReadOnlyCollections(other.Services) &&
AcceptedItems.DeepEqualsReadOnlyCollections(other.AcceptedItems) &&
ReturnWithVendorRequest == other.ReturnWithVendorRequest &&
Locations.DeepEqualsReadOnlyCollections(other.Locations) &&
Groups.DeepEqualsReadOnlyCollections(other.Groups) &&
IgnoreSaleItems.DeepEqualsReadOnlyCollections(other.IgnoreSaleItems) &&
UnlockValueHash == other.UnlockValueHash &&
Blacklisted == other.Blacklisted &&
Hash == other.Hash &&
Index == other.Index &&
Redacted == other.Redacted);
}
/// <summary>
/// Check whether the product build date of the provided assemblies
/// exceeded the <see cref="License.ExpirationUtc"/> date.
/// </summary>
/// <param name="validationChain">The current <see cref="IStartValidationChain"/>.</param>
/// <param name="assemblies">The list of assemblies to check.</param>
/// <returns>An instance of <see cref="IStartValidationChain"/>.</returns>
public static IValidationChain ProductBuildDate(this IStartValidationChain validationChain, Assembly[] assemblies)
{
var validationChainBuilder = (validationChain as ValidationChainBuilder);
var validator = validationChainBuilder.StartValidatorChain();
#if !NEW_REFLECTION
validator.Validate = license => assemblies.All(
asm =>
asm.GetCustomAttributes(typeof(AssemblyBuildDateAttribute), false)
.Cast <AssemblyBuildDateAttribute>()
.All(a => a.BuildDateUtc < license.ExpirationUtc));
#else
validator.Validate = license => assemblies.All(
asm =>
asm.GetCustomAttributes <AssemblyBuildDateAttribute>()
.Cast <AssemblyBuildDateAttribute>()
.All(a => a.BuildDateUtc < license.ExpirationUtc));
#endif
validator.FailureResult = FailureStrings.Get(FailureStrings.VAL03Code);
return(validationChainBuilder);
}
public void Update(DestinyVendorDefinition?other)
{
if (other is null)
{
return;
}
if (!DisplayProperties.DeepEquals(other.DisplayProperties))
{
DisplayProperties.Update(other.DisplayProperties);
OnPropertyChanged(nameof(DisplayProperties));
}
if (VendorProgressionType != other.VendorProgressionType)
{
VendorProgressionType = other.VendorProgressionType;
OnPropertyChanged(nameof(VendorProgressionType));
}
if (BuyString != other.BuyString)
{
BuyString = other.BuyString;
OnPropertyChanged(nameof(BuyString));
}
if (SellString != other.SellString)
{
SellString = other.SellString;
OnPropertyChanged(nameof(SellString));
}
if (DisplayItemHash != other.DisplayItemHash)
{
DisplayItemHash = other.DisplayItemHash;
OnPropertyChanged(nameof(DisplayItemHash));
}
if (InhibitBuying != other.InhibitBuying)
{
InhibitBuying = other.InhibitBuying;
OnPropertyChanged(nameof(InhibitBuying));
}
if (InhibitSelling != other.InhibitSelling)
{
InhibitSelling = other.InhibitSelling;
OnPropertyChanged(nameof(InhibitSelling));
}
if (FactionHash != other.FactionHash)
{
FactionHash = other.FactionHash;
OnPropertyChanged(nameof(FactionHash));
}
if (ResetIntervalMinutes != other.ResetIntervalMinutes)
{
ResetIntervalMinutes = other.ResetIntervalMinutes;
OnPropertyChanged(nameof(ResetIntervalMinutes));
}
if (ResetOffsetMinutes != other.ResetOffsetMinutes)
{
ResetOffsetMinutes = other.ResetOffsetMinutes;
OnPropertyChanged(nameof(ResetOffsetMinutes));
}
if (!FailureStrings.DeepEqualsListNaive(other.FailureStrings))
{
FailureStrings = other.FailureStrings;
OnPropertyChanged(nameof(FailureStrings));
}
if (!UnlockRanges.DeepEqualsList(other.UnlockRanges))
{
UnlockRanges = other.UnlockRanges;
OnPropertyChanged(nameof(UnlockRanges));
}
if (VendorIdentifier != other.VendorIdentifier)
{
VendorIdentifier = other.VendorIdentifier;
OnPropertyChanged(nameof(VendorIdentifier));
}
if (VendorPortrait != other.VendorPortrait)
{
VendorPortrait = other.VendorPortrait;
OnPropertyChanged(nameof(VendorPortrait));
}
if (VendorBanner != other.VendorBanner)
{
VendorBanner = other.VendorBanner;
OnPropertyChanged(nameof(VendorBanner));
}
if (Enabled != other.Enabled)
{
Enabled = other.Enabled;
OnPropertyChanged(nameof(Enabled));
}
if (Visible != other.Visible)
{
Visible = other.Visible;
OnPropertyChanged(nameof(Visible));
}
if (VendorSubcategoryIdentifier != other.VendorSubcategoryIdentifier)
{
VendorSubcategoryIdentifier = other.VendorSubcategoryIdentifier;
OnPropertyChanged(nameof(VendorSubcategoryIdentifier));
}
if (ConsolidateCategories != other.ConsolidateCategories)
{
ConsolidateCategories = other.ConsolidateCategories;
OnPropertyChanged(nameof(ConsolidateCategories));
}
if (!Actions.DeepEqualsList(other.Actions))
{
Actions = other.Actions;
OnPropertyChanged(nameof(Actions));
}
if (!Categories.DeepEqualsList(other.Categories))
{
Categories = other.Categories;
OnPropertyChanged(nameof(Categories));
}
if (!OriginalCategories.DeepEqualsList(other.OriginalCategories))
{
OriginalCategories = other.OriginalCategories;
OnPropertyChanged(nameof(OriginalCategories));
}
if (!DisplayCategories.DeepEqualsList(other.DisplayCategories))
{
DisplayCategories = other.DisplayCategories;
OnPropertyChanged(nameof(DisplayCategories));
}
if (!Interactions.DeepEqualsList(other.Interactions))
{
Interactions = other.Interactions;
OnPropertyChanged(nameof(Interactions));
}
if (!InventoryFlyouts.DeepEqualsList(other.InventoryFlyouts))
{
InventoryFlyouts = other.InventoryFlyouts;
OnPropertyChanged(nameof(InventoryFlyouts));
}
if (!ItemList.DeepEqualsList(other.ItemList))
{
ItemList = other.ItemList;
OnPropertyChanged(nameof(ItemList));
}
if (!Services.DeepEqualsList(other.Services))
{
Services = other.Services;
OnPropertyChanged(nameof(Services));
}
if (!AcceptedItems.DeepEqualsList(other.AcceptedItems))
{
AcceptedItems = other.AcceptedItems;
OnPropertyChanged(nameof(AcceptedItems));
}
if (ReturnWithVendorRequest != other.ReturnWithVendorRequest)
{
ReturnWithVendorRequest = other.ReturnWithVendorRequest;
OnPropertyChanged(nameof(ReturnWithVendorRequest));
}
if (!Locations.DeepEqualsList(other.Locations))
{
Locations = other.Locations;
OnPropertyChanged(nameof(Locations));
}
if (!Groups.DeepEqualsList(other.Groups))
{
Groups = other.Groups;
OnPropertyChanged(nameof(Groups));
}
if (!IgnoreSaleItemHashes.DeepEqualsListNaive(other.IgnoreSaleItemHashes))
{
IgnoreSaleItemHashes = other.IgnoreSaleItemHashes;
OnPropertyChanged(nameof(IgnoreSaleItemHashes));
}
if (Hash != other.Hash)
{
Hash = other.Hash;
OnPropertyChanged(nameof(Hash));
}
if (Index != other.Index)
{
Index = other.Index;
OnPropertyChanged(nameof(Index));
}
if (Redacted != other.Redacted)
{
Redacted = other.Redacted;
OnPropertyChanged(nameof(Redacted));
}
}
public async void CreateAsync()
{
var logger = Substitute.For <ILogger <LicenseService> >();
// In-memory database only exists while the connection is open
var connection = new SqliteConnection("DataSource=:memory:");
connection.Open();
try
{
var contextOptions = new DbContextOptionsBuilder <EfDbContext>()
.UseSqlite(connection)
.Options;
// Create the schema in the database
using (var context = new EfDbContext(contextOptions))
{
context.Database.EnsureCreated();
var service = new LicenseService(context, logger);
var product = CreateProduct();
context.Add(product);
context.SaveChanges();
var expireDate = DateTime.UtcNow.AddDays(1);
var registration = CreateRegistration(product);
registration.Quantity = 2;
registration.ExpireUtc = expireDate;
context.Add(registration);
context.SaveChanges();
var request = new LicenseRegisterRequest
{
LicenseUuid = registration.LicenseRegistrationId,
ProductUuid = registration.ProductId,
Attributes = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
};
request.Attributes.Add("AppId", "app-id-0001");
var result = await service.CreateAsync(request, "test-user");
var lic = context.Licenses.ToArray();
var licenseRecord = await context.Licenses.SingleAsync(x => x.LicenseId == registration.LicenseRegistrationId);
Assert.Null(result.Failure);
Assert.NotNull(result.License);
Assert.NotNull(licenseRecord);
Assert.False(licenseRecord.LicenseActivationId == Guid.Empty);
Assert.Equal(registration.LicenseRegistrationId, licenseRecord.LicenseId);
Assert.Equal(registration.ProductId, licenseRecord.ProductId);
Assert.Equal(registration.CompanyId, licenseRecord.CompanyId);
Assert.NotNull(licenseRecord.LicenseString);
Assert.NotNull(licenseRecord.LicenseAttributes);
Assert.NotNull(licenseRecord.LicenseChecksum);
Assert.NotNull(licenseRecord.AttributesChecksum);
Assert.Equal(Utils.ChecksumType, licenseRecord.ChecksumType);
Assert.Equal(DateTime.UtcNow.ToString("yyyyMMdd"), licenseRecord.CreatedDateTimeUtc.ToString("yyyyMMdd"));
Assert.NotNull(licenseRecord.CreatedByUser);
var license = License.Load(result.License);
var failure = FailureStrings.Get(FailureStrings.VAL04Code);
var failures = license.Validate()
.ExpirationDate()
.When(lic => lic.Type == LicenseType.Standard)
.And()
.Signature()
.And()
.AssertThat(x => string.Equals(request.Attributes["AppId"], x.AdditionalAttributes.Get("AppId"), StringComparison.OrdinalIgnoreCase), failure)
.AssertValidLicense().ToList();
// Valid
Assert.False(failures.Any());
// License
Assert.Equal(licenseRecord.LicenseActivationId, license.ActivationUuid);
Assert.Equal(request.LicenseUuid, license.Id);
Assert.Equal(registration.LicenseType, license.Type);
Assert.Equal(expireDate.ToString("yyyyMMdd"), license.ExpirationUtc.ToString("yyyyMMdd"));
Assert.Equal(2, license.Quantity);
Assert.Equal(registration.LicenseName, license.Customer.Name);
Assert.Equal(registration.LicenseEmail, license.Customer.Email);
Assert.Equal(registration.LicenseName, license.Customer.Company);
Assert.Equal(request.Attributes["AppId"], license.AdditionalAttributes.Get("AppId"));
}
}
finally
{
connection.Close();
}
}
public bool Equals(DestinyVendorDefinition input)
{
if (input == null)
{
return(false);
}
return
((
DisplayProperties == input.DisplayProperties ||
(DisplayProperties != null && DisplayProperties.Equals(input.DisplayProperties))
) &&
(
VendorProgressionType == input.VendorProgressionType ||
(VendorProgressionType != null && VendorProgressionType.Equals(input.VendorProgressionType))
) &&
(
BuyString == input.BuyString ||
(BuyString != null && BuyString.Equals(input.BuyString))
) &&
(
SellString == input.SellString ||
(SellString != null && SellString.Equals(input.SellString))
) &&
(
DisplayItemHash == input.DisplayItemHash ||
(DisplayItemHash.Equals(input.DisplayItemHash))
) &&
(
InhibitBuying == input.InhibitBuying ||
(InhibitBuying != null && InhibitBuying.Equals(input.InhibitBuying))
) &&
(
InhibitSelling == input.InhibitSelling ||
(InhibitSelling != null && InhibitSelling.Equals(input.InhibitSelling))
) &&
(
FactionHash == input.FactionHash ||
(FactionHash.Equals(input.FactionHash))
) &&
(
ResetIntervalMinutes == input.ResetIntervalMinutes ||
(ResetIntervalMinutes.Equals(input.ResetIntervalMinutes))
) &&
(
ResetOffsetMinutes == input.ResetOffsetMinutes ||
(ResetOffsetMinutes.Equals(input.ResetOffsetMinutes))
) &&
(
FailureStrings == input.FailureStrings ||
(FailureStrings != null && FailureStrings.SequenceEqual(input.FailureStrings))
) &&
(
UnlockRanges == input.UnlockRanges ||
(UnlockRanges != null && UnlockRanges.SequenceEqual(input.UnlockRanges))
) &&
(
VendorIdentifier == input.VendorIdentifier ||
(VendorIdentifier != null && VendorIdentifier.Equals(input.VendorIdentifier))
) &&
(
VendorPortrait == input.VendorPortrait ||
(VendorPortrait != null && VendorPortrait.Equals(input.VendorPortrait))
) &&
(
VendorBanner == input.VendorBanner ||
(VendorBanner != null && VendorBanner.Equals(input.VendorBanner))
) &&
(
Enabled == input.Enabled ||
(Enabled != null && Enabled.Equals(input.Enabled))
) &&
(
Visible == input.Visible ||
(Visible != null && Visible.Equals(input.Visible))
) &&
(
VendorSubcategoryIdentifier == input.VendorSubcategoryIdentifier ||
(VendorSubcategoryIdentifier != null && VendorSubcategoryIdentifier.Equals(input.VendorSubcategoryIdentifier))
) &&
(
ConsolidateCategories == input.ConsolidateCategories ||
(ConsolidateCategories != null && ConsolidateCategories.Equals(input.ConsolidateCategories))
) &&
(
Actions == input.Actions ||
(Actions != null && Actions.SequenceEqual(input.Actions))
) &&
(
Categories == input.Categories ||
(Categories != null && Categories.SequenceEqual(input.Categories))
) &&
(
OriginalCategories == input.OriginalCategories ||
(OriginalCategories != null && OriginalCategories.SequenceEqual(input.OriginalCategories))
) &&
(
DisplayCategories == input.DisplayCategories ||
(DisplayCategories != null && DisplayCategories.SequenceEqual(input.DisplayCategories))
) &&
(
Interactions == input.Interactions ||
(Interactions != null && Interactions.SequenceEqual(input.Interactions))
) &&
(
InventoryFlyouts == input.InventoryFlyouts ||
(InventoryFlyouts != null && InventoryFlyouts.SequenceEqual(input.InventoryFlyouts))
) &&
(
ItemList == input.ItemList ||
(ItemList != null && ItemList.SequenceEqual(input.ItemList))
) &&
(
Services == input.Services ||
(Services != null && Services.SequenceEqual(input.Services))
) &&
(
AcceptedItems == input.AcceptedItems ||
(AcceptedItems != null && AcceptedItems.SequenceEqual(input.AcceptedItems))
) &&
(
ReturnWithVendorRequest == input.ReturnWithVendorRequest ||
(ReturnWithVendorRequest != null && ReturnWithVendorRequest.Equals(input.ReturnWithVendorRequest))
) &&
(
Locations == input.Locations ||
(Locations != null && Locations.SequenceEqual(input.Locations))
) &&
(
Groups == input.Groups ||
(Groups != null && Groups.SequenceEqual(input.Groups))
) &&
(
IgnoreSaleItemHashes == input.IgnoreSaleItemHashes ||
(IgnoreSaleItemHashes != null && IgnoreSaleItemHashes.SequenceEqual(input.IgnoreSaleItemHashes))
) &&
(
Hash == input.Hash ||
(Hash.Equals(input.Hash))
) &&
(
Index == input.Index ||
(Index.Equals(input.Index))
) &&
(
Redacted == input.Redacted ||
(Redacted != null && Redacted.Equals(input.Redacted))
));
}
