public LicenseActivationService(ILicenseKeyService licenseKeyService, IPackingService packingService, ILicenseActiviationProvider licenseActiviationProvider, IClientLicenseService clientLicenseService)
{
_licenseKeyService = licenseKeyService;
_packingService = packingService;
_licenseActiviationProvider = licenseActiviationProvider;
_clientLicenseService = clientLicenseService;
}
public void Before_each_test()
{
clientLicenseRepoistory = new ClientLicenseRepository(objectSerializationProvider, symmetricEncryptionProvider);
clientLicenseService = new ClientLicenseService(clientLicenseRepoistory);
serviceProductsRepository = new ServiceProductsRepository(new ScutexServiceEntities());
symmetricEncryptionProvider = new SymmetricEncryptionProvider();
asymmetricEncryptionProvider = new AsymmetricEncryptionProvider();
hashingProvider = new HashingProvider();
objectSerializationProvider = new ObjectSerializationProvider();
numberDataGenerator = new NumberDataGenerator();
packingService = new PackingService(numberDataGenerator);
commonRepository = new CommonRepository(new ScutexServiceEntities());
clientRepository = new ClientRepository(new ScutexServiceEntities());
keyGenerator = new KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider);
masterService = new MasterService(commonRepository);
activationLogRepository = new ActivationLogRepoistory(new ScutexServiceEntities());
activationLogService = new ActivationLogService(activationLogRepository, hashingProvider);
keyService = new KeyManagementService(clientRepository, licenseKeyService, activationLogService, hashingProvider, serviceProductsRepository);
commonService = new CommonService();
string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetName().CodeBase);
path = path.Replace("file:\\", "");
var mockCommonService = new Mock<ICommonService>();
mockCommonService.Setup(common => common.GetPath()).Returns(path + "\\Data\\Client\\");
string masterServiceDataText;
using (TextReader reader = new StreamReader(path + "\\Data\\MasterService.dat"))
{
masterServiceDataText = reader.ReadToEnd().Trim();
}
masterServiceData = objectSerializationProvider.Deserialize<MasterServiceData>(masterServiceDataText);
var mockCommonRepository = new Mock<ICommonRepository>();
mockCommonRepository.Setup(repo => repo.GetMasterServiceData()).Returns(masterServiceData);
keyPairService = new KeyPairService(mockCommonService.Object, mockCommonRepository.Object);
controlService = new ControlService(symmetricEncryptionProvider, keyPairService, packingService, masterService, objectSerializationProvider, asymmetricEncryptionProvider);
servicesRepository = new ServicesRepository(new ScutexEntities());
serviceStatusProvider = new ServiceStatusProvider(symmetricEncryptionProvider, objectSerializationProvider, asymmetricEncryptionProvider);
licenseActiviationProvider = new LicenseActiviationProvider(asymmetricEncryptionProvider, symmetricEncryptionProvider, objectSerializationProvider);
servicesService = new ServicesService(servicesRepository, serviceStatusProvider, packingService, licenseActiviationProvider, null, null, null, null, null);
licenseKeyService = new LicenseKeyService(keyGenerator, packingService, clientLicenseService);
activationService = new ActivationService(controlService, keyService, keyPairService, objectSerializationProvider, asymmetricEncryptionProvider, null, null);
string serviceData;
using (TextReader reader = new StreamReader(path + "\\Data\\Service.dat"))
{
serviceData = reader.ReadToEnd().Trim();
}
service = objectSerializationProvider.Deserialize<Service>(serviceData);
}
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;
}
/// <summary>
/// Override constructor to instantiate the Licensing Manager and
/// point it to an object that it's the running executable.
/// </summary>
/// <remarks>
/// This constructor is useful when running an application and calling
/// Scutex via a CCW (COM Callable Wrapper) and the executing assembly
/// (i.e. Access) does not contain the security attribute.
/// </remarks>
/// <param name="instance">
/// Reference to an object were the required attributes can be located
/// </param>
public LicensingManager(object instance)
{
this.instance = instance;
Bootstrapper.Configure();
InterfaceInteraction = new TrialInterfaceInteraction();
hashingProvider = ObjectLocator.GetInstance<IHashingProvider>();
encodingService = ObjectLocator.GetInstance<IEncodingService>();
licenseManagerService = ObjectLocator.GetInstance<ILicenseManagerService>();
_clientLicenseService = ObjectLocator.GetInstance<IClientLicenseService>();
_comBypassProvider = ObjectLocator.GetInstance<IComBypassProvider>();
_registerService = ObjectLocator.GetInstance<IRegisterService>();
SetCriticalVerificationData();
VerifyLicensingAssembly();
}
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 LicenseKeyService(IKeyGenerator keyGenerator, IPackingService packingService, IClientLicenseService clientLicenseService)
{
this.keyGenerator = keyGenerator;
_packingService = packingService;
_clientLicenseService = clientLicenseService;
}
public LicenseManagerService(IClientLicenseService clientLicenseService, INetworkTimeProvider networkTimeProvider)
{
_clientLicenseService = clientLicenseService;
_networkTimeProvider = networkTimeProvider;
}
