public void SetupTests()
{
license = new ClientLicense();
license.UniqueId = Guid.NewGuid();
license.LicenseSets = new NotifyList <LicenseSet>();
LicenseSet ls = new LicenseSet();
ls.SupportedLicenseTypes = LicenseKeyTypeFlag.SingleUser;
ls.Name = "Standard License Set";
ls.UniquePad = new Guid();
license.LicenseSets.Add(ls);
generationOptions = new LicenseGenerationOptions();
license.Product = new Product();
license.Product.Name = "My Great Uber Cool Product, with new juice!";
license.Product.ProductId = 1;
packingService = new PackingService(numberDataGenerationProvider);
clientLicenseRepository = new ClientLicenseRepository(objectSerializationProvider, symmetricEncryptionProvider);
clientLicenseService = new ClientLicenseService(clientLicenseRepository);
string productHash = hashingProvider.Checksum32(license.GetLicenseProductIdentifier()).ToString("X");
LicenseActiviationProvider licenseActiviationProvider = new LicenseActiviationProvider(asymmetricEncryptionProvider, symmetricEncryptionProvider, objectSerializationProvider);
staticKeyGenerator = new KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider);
staticKeyGeneratorLarge = new Scutex.Generators.StaticKeyGeneratorLarge.KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider, hardwareFingerprintService);
licenseKeyService = new LicenseKeyService(staticKeyGenerator, staticKeyGeneratorLarge, packingService, clientLicenseService);
}
public LicenseActivationService(ILicenseKeyService licenseKeyService, IPackingService packingService, ILicenseActiviationProvider licenseActiviationProvider, IClientLicenseService clientLicenseService)
{
_licenseKeyService = licenseKeyService;
_packingService = packingService;
_licenseActiviationProvider = licenseActiviationProvider;
_clientLicenseService = clientLicenseService;
}
public LicenseActivationService(ILicenseKeyService licenseKeyService, IPackingService packingService,
ILicenseActiviationProvider licenseActiviationProvider, IClientLicenseService clientLicenseService)
{
_licenseKeyService = licenseKeyService;
_packingService = packingService;
_licenseActiviationProvider = licenseActiviationProvider;
_clientLicenseService = clientLicenseService;
}
public ControlService(ISymmetricEncryptionProvider symmetricEncryptionProvider, IKeyPairService keyPairService,
IPackingService packingService, IMasterService masterService, IObjectSerializationProvider objectSerializationProvider,
IAsymmetricEncryptionProvider asymmetricEncryptionProvider)
{
_symmetricEncryptionProvider = symmetricEncryptionProvider;
_packingService = packingService;
_masterService = masterService;
_keyPairService = keyPairService;
_objectSerializationProvider = objectSerializationProvider;
_asymmetricEncryptionProvider = asymmetricEncryptionProvider;
}
public LicenseKeyService(ISmallKeyGenerator staticSmallKeyGenerator, ILargeKeyGenerator staticLargeKeyGenerator,
IPackingService packingService, IClientLicenseService clientLicenseService)
{
keyGenerator = staticSmallKeyGenerator;
_largeKeyGenerator = staticLargeKeyGenerator;
_packingService = packingService;
_clientLicenseService = clientLicenseService;
// Need to find a way to get these passed in correctly
//keyGenerator = ObjectLocator.GetInstance<IKeyGenerator>(InstanceNames.SmallKeyGenerator);
//_largeKeyGenerator = ObjectLocator.GetInstance<IKeyGenerator>(InstanceNames.LargeKeyGenerator);
}
public LicenseKeyService(ISmallKeyGenerator staticSmallKeyGenerator, ILargeKeyGenerator staticLargeKeyGenerator,
IPackingService packingService, IClientLicenseService clientLicenseService)
{
keyGenerator = staticSmallKeyGenerator;
_largeKeyGenerator = staticLargeKeyGenerator;
_packingService = packingService;
_clientLicenseService = clientLicenseService;
// Need to find a way to get these passed in correctly
//keyGenerator = ObjectLocator.GetInstance<IKeyGenerator>(InstanceNames.SmallKeyGenerator);
//_largeKeyGenerator = ObjectLocator.GetInstance<IKeyGenerator>(InstanceNames.LargeKeyGenerator);
}
public ServicesService(IServicesRepository servicesRepository, IServiceStatusProvider serviceStatusProvider,
IPackingService packingService, ILicenseActiviationProvider licenseActiviationProvider, ILicenseKeyService licenseKeyService,
ILicenseService licenseService, ILicenseSetService licenseSetService, IClientLicenseService clientLicenseService,
IProductsProvider productsProvider)
{
_servicesRepository = servicesRepository;
_serviceStatusProvider = serviceStatusProvider;
_packingService = packingService;
_licenseActiviationProvider = licenseActiviationProvider;
_licenseKeyService = licenseKeyService;
_licenseService = licenseService;
_licenseSetService = licenseSetService;
_clientLicenseService = clientLicenseService;
_productsProvider = productsProvider;
}
public ServicesService(IServicesRepository servicesRepository, IServiceStatusProvider serviceStatusProvider,
IPackingService packingService, ILicenseActiviationProvider licenseActiviationProvider, ILicenseKeyService licenseKeyService,
ILicenseService licenseService, ILicenseSetService licenseSetService, IClientLicenseService clientLicenseService,
IProductsProvider productsProvider)
{
_servicesRepository = servicesRepository;
_serviceStatusProvider = serviceStatusProvider;
_packingService = packingService;
_licenseActiviationProvider = licenseActiviationProvider;
_licenseKeyService = licenseKeyService;
_licenseService = licenseService;
_licenseSetService = licenseSetService;
_clientLicenseService = clientLicenseService;
_productsProvider = productsProvider;
}
public OrderService(IPackingService packingService)
{
Factories = new ConcurrentDictionary <OrderRuleTypeEnum, IQueue <PendingOrder> >();
PackingService = packingService;
foreach (OrderRuleTypeEnum action in Enum.GetValues(typeof(OrderRuleTypeEnum)))
{
var idString = Type.GetType($"Queue.{action}`1, Queue");
var type = idString.MakeGenericType(typeof(PendingOrder));
var ret = (IQueue <PendingOrder>)Activator.CreateInstance(type);
ret.OrderAdded += AutoQueue_OrderAdded;
Factories.TryAdd(action, ret);
}
}
public ActionResult GetList()
{
using (IPackingService server = GetService <IPackingService>())
{
Expression <Func <VD_Packing, bool> > where = null;
if (!Request.QueryString["keyword"].IsEmpty())
{
var qs = JsonHelper.ToObject <List <QuickSearch> >(Request.QueryString["keyword"]);
var props = typeof(VD_Customer).GetPropertiesEx();
foreach (var q in qs)
{
if (!q.SearchValue.IsEmpty())
{
var p = props.FirstOrDefault(w => w.Name == q.FieldName);
if (p != null)
{
switch (p.Name)
{
case "PackingCode":
where = where.And(w => w.PackingCode.Contains(q.SearchValue));
break;
case "PackingName":
where = where.And(w => w.PackingName.Contains(q.SearchValue));
break;
default:
break;
}
}
}
}
}
var pageinfo = new PageInfo()
{
PageIndex = Request.QueryString["page"].IsEmpty() ? 1 : int.Parse(Request.QueryString["page"]),
PageSize = Request.QueryString["limit"].IsEmpty() ? 20 : int.Parse(Request.QueryString["limit"])
};
var list = server.GetList(where, ref pageinfo);
return(JsonNet(CreateJsonData_DataTable(pageinfo.RowCount, list)));
//return JsonNet(CreateJsonData_DataGrid(pageinfo.RowCount, list));
}
}
public void SetupTests()
{
license = new ClientLicense();
license.UniqueId = Guid.NewGuid();
license.LicenseSets = new NotifyList<LicenseSet>();
LicenseSet ls = new LicenseSet();
ls.SupportedLicenseTypes = LicenseKeyTypeFlag.SingleUser;
ls.Name = "Standard License Set";
ls.UniquePad = new Guid();
license.LicenseSets.Add(ls);
generationOptions = new LicenseGenerationOptions();
license.Product = new Product();
license.Product.Name = "My Great Uber Cool Product, with new juice!";
license.Product.ProductId = 1;
packingService = new PackingService(numberDataGenerationProvider);
clientLicenseRepository = new ClientLicenseRepository(objectSerializationProvider, symmetricEncryptionProvider);
clientLicenseService = new ClientLicenseService(clientLicenseRepository);
string productHash = hashingProvider.Checksum32(license.GetLicenseProductIdentifier()).ToString("X");
LicenseActiviationProvider licenseActiviationProvider = new LicenseActiviationProvider(asymmetricEncryptionProvider, symmetricEncryptionProvider, objectSerializationProvider);
staticKeyGenerator = new KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider);
licenseKeyService = new LicenseKeyService(staticKeyGenerator, packingService, clientLicenseService);
}
public ReportingService(IReportingProvider reportingProvider, IPackingService packingService)
{
_reportingProvider = reportingProvider;
_packingService = packingService;
}
public ReportingService(IReportingProvider reportingProvider, IPackingService packingService)
{
_reportingProvider = reportingProvider;
_packingService = packingService;
}
public BookOrder(IPackingService packingService, ICommissionService commissionService) : base(packingService, commissionService)
{
_packingService = packingService;
}
public PhysicalItemOrder(IPackingService packingService, ICommissionService commissionService)
{
_packingService = packingService;
_commissionService = commissionService;
}
public LicenseKeyService(IKeyGenerator keyGenerator, IPackingService packingService, IClientLicenseService clientLicenseService)
{
this.keyGenerator = keyGenerator;
_packingService = packingService;
_clientLicenseService = clientLicenseService;
}
private void btnGenerateKeys_Click(object sender, System.Windows.RoutedEventArgs e)
{
if (IsGenerationFormValid())
{
loadingAnimation.Visibility = Visibility.Visible;
BackgroundWorker worker = new BackgroundWorker();
LicenseGenerationOptions licenseGenerationOptions = new LicenseGenerationOptions();
int keysToGenerate = int.Parse(txtKeysToGenerate.Text);
if (cboSingleUser.IsChecked.HasValue && cboSingleUser.IsChecked.Value)
{
licenseGenerationOptions.LicenseKeyType = LicenseKeyTypes.SingleUser;
}
else if (cboMultiUser.IsChecked.HasValue && cboMultiUser.IsChecked.Value)
{
licenseGenerationOptions.LicenseKeyType = LicenseKeyTypes.MultiUser;
}
else if (cboHardwareLock.IsChecked.HasValue && cboHardwareLock.IsChecked.Value)
{
licenseGenerationOptions.LicenseKeyType = LicenseKeyTypes.HardwareLock;
}
else if (cboUnlimited.IsChecked.HasValue && cboUnlimited.IsChecked.Value)
{
licenseGenerationOptions.LicenseKeyType = LicenseKeyTypes.Unlimited;
}
else if (cboEnterprise.IsChecked.HasValue && cboEnterprise.IsChecked.Value)
{
licenseGenerationOptions.LicenseKeyType = LicenseKeyTypes.Enterprise;
}
else if (cboHardwareLockLocal.IsChecked.HasValue && cboHardwareLockLocal.IsChecked.Value)
{
licenseGenerationOptions.LicenseKeyType = LicenseKeyTypes.HardwareLockLocal;
licenseGenerationOptions.HardwareFingerprint = txtHardwareKeyData.Text;
keysToGenerate = 1; // Can only generate 1 local hardware locked key at a time.
}
licenseGenerationOptions.LicenseSetId = ((LicenseSet)cboLicenseSet.SelectedValue).LicenseSetId;
worker.DoWork += delegate(object s, DoWorkEventArgs args)
{
object[] data = args.Argument as object[];
ISmallKeyGenerator smallKeygen = ObjectLocator.GetInstance <ISmallKeyGenerator>();
ILargeKeyGenerator largeKeygen = ObjectLocator.GetInstance <ILargeKeyGenerator>();
ILicenseActiviationProvider licenseActiviationProvider = ObjectLocator.GetInstance <ILicenseActiviationProvider>();
IPackingService packingService = ObjectLocator.GetInstance <IPackingService>();
IClientLicenseService clientLicenseService = ObjectLocator.GetInstance <IClientLicenseService>();
if ((string)data[2] == InstanceNames.SmallKeyGenerator)
{
((LicenseGenerationOptions)data[0]).GeneratorType = KeyGeneratorTypes.StaticSmall;
}
else
{
((LicenseGenerationOptions)data[0]).GeneratorType = KeyGeneratorTypes.StaticLarge;
}
LicenseKeyService service = new LicenseKeyService(smallKeygen, largeKeygen, packingService, clientLicenseService);
List <string> keys = service.GenerateLicenseKeys(UIContext.License.KeyPair.PrivateKey,
UIContext.License,
(LicenseGenerationOptions)data[0],
int.Parse(data[1].ToString()));
args.Result = keys;
};
worker.RunWorkerCompleted += delegate(object s, RunWorkerCompletedEventArgs args)
{
LicenseKeys = new BindingList <string>((List <string>)args.Result);
lstLicenseKeys.ItemsSource = LicenseKeys;
loadingAnimation.Visibility = Visibility.Collapsed;
};
worker.RunWorkerAsync(new object[]
{
licenseGenerationOptions,
keysToGenerate,
GetGeneratorName()
});
}
else
{
MessageBox.Show("Please select a license set, license type to generate and a amount.");
}
}
