public void Before_each_test()
{
//ServicesRepository servicesRepository = new ServicesRepository(new ScutexEntities());
//CommonRepository commonRepository = new CommonRepository(new ScutexServiceEntities());
AsymmetricEncryptionProvider asymmetricEncryptionProvider = new AsymmetricEncryptionProvider();
SymmetricEncryptionProvider symmetricEncryptionProvider = new SymmetricEncryptionProvider();
ObjectSerializationProvider objectSerializationProvider = new ObjectSerializationProvider();
NumberDataGenerator numberDataGenerator = new NumberDataGenerator();
PackingService packingService = new PackingService(numberDataGenerator);
MasterService masterService = new MasterService(commonRepository);
CommonService commonService = new CommonService();
KeyPairService keyPairService = new KeyPairService(commonService, commonRepository);
ServiceStatusProvider serviceStatusProvider = new ServiceStatusProvider(symmetricEncryptionProvider, objectSerializationProvider, asymmetricEncryptionProvider);
servicesService = new ServicesService(servicesRepository, serviceStatusProvider, packingService, null, null, null, null, null, null);
controlService = new ControlService(symmetricEncryptionProvider, keyPairService, packingService, masterService, objectSerializationProvider, asymmetricEncryptionProvider);
service = new Scutex.Model.Service();
service.OutboundKeyPair = asymmetricEncryptionProvider.GenerateKeyPair(BitStrengths.High);
service.InboundKeyPair = asymmetricEncryptionProvider.GenerateKeyPair(BitStrengths.High);
service.ManagementInboundKeyPair = asymmetricEncryptionProvider.GenerateKeyPair(BitStrengths.High);
service.ManagementOutboundKeyPair = asymmetricEncryptionProvider.GenerateKeyPair(BitStrengths.High);
}
public List <ContainerPackingResult> Post([FromBody] ContainerPackingRequest request)
{
return(PackingService.Pack(request.Containers, request.ItemsToPack, new List <int>()
{
1
})); //request.AlgorithmTypeIDs
}
public static void HashTokenWithSalt()
{
HashingProvider provider = new HashingProvider();
Console.WriteLine(provider.ComputeHashWithSalt("b$7SDt%43J*a!9", "SHA256", null));
PackingService service = new PackingService(new NumberDataGenerator());
Token t = new Token();
t.Data = "MXLBEcLe6/i1CjdyomC7T0vTlACTXpdRmnxcDXDE8yDuCal0xA==";
t.Timestamp = DateTime.Now;
Console.WriteLine(service.PackToken(t));
SymmetricEncryptionProvider encryption = new SymmetricEncryptionProvider();
EncryptionInfo ei = new EncryptionInfo();
ei.HashAlgorithm = "SHA1";
ei.InitVector = "a01JQ3481Ahnqwe9";
ei.Iterations = 2;
ei.KeySize = 256;
ei.PassPhrase = "Da*eW6_EzU4_swuk8*hU";
ei.SaltValue = "VuW9uDrE";
Console.WriteLine(encryption.Encrypt("861641072009MXLBEcLe6/i1CjdyomC7T0vTlACTXpdRmnxcDXDE8yDuCal0xA==41410860", ei));
Console.WriteLine();
Console.WriteLine("Press enter to exit.");
Console.ReadLine();
}
private static void PackAndAssert(string[] containerDims, List <Item> itemsToPack, string[] testResults)
{
List <Container> containers = new List <Container>();
containers.Add(new Container(0, Convert.ToDecimal(containerDims[0]), Convert.ToDecimal(containerDims[1]),
Convert.ToDecimal(containerDims[2])));
List <ContainerPackingResult> result =
PackingService.Pack(containers, itemsToPack, new List <int> {
(int)AlgorithmType.EB_AFIT
});
// Assert that the number of items we tried to pack equals the number stated in the published reference.
Assert.AreEqual(
result[0].AlgorithmPackingResults[0].PackedItems.Count +
result[0].AlgorithmPackingResults[0].UnpackedItems.Count, Convert.ToDecimal(testResults[1]));
// Assert that the number of items successfully packed equals the number stated in the published reference.
Assert.AreEqual(result[0].AlgorithmPackingResults[0].PackedItems.Count, Convert.ToDecimal(testResults[2]));
// Assert that the packed container volume percentage is equal to the published reference result.
// Make an exception for a couple of tests where this algorithm yields 87.20% and the published result
// was 87.21% (acceptable rounding error).
Assert.IsTrue(
result[0].AlgorithmPackingResults[0].PercentContainerVolumePacked == Convert.ToDecimal(testResults[3]) ||
(result[0].AlgorithmPackingResults[0].PercentContainerVolumePacked == 87.20M &&
Convert.ToDecimal(testResults[3]) == 87.21M));
// Assert that the packed item volume percentage is equal to the published reference result.
Assert.AreEqual(result[0].AlgorithmPackingResults[0].PercentItemVolumePacked, Convert.ToDecimal(testResults[4]));
}
public void Before_each_test()
{
//ServicesRepository servicesRepository = new ServicesRepository(new ScutexEntities());
//CommonRepository commonRepository = new CommonRepository(new ScutexServiceEntities());
AsymmetricEncryptionProvider asymmetricEncryptionProvider = new AsymmetricEncryptionProvider();
SymmetricEncryptionProvider symmetricEncryptionProvider = new SymmetricEncryptionProvider();
ObjectSerializationProvider objectSerializationProvider = new ObjectSerializationProvider();
NumberDataGenerator numberDataGenerator = new NumberDataGenerator();
PackingService packingService = new PackingService(numberDataGenerator);
MasterService masterService = new MasterService(commonRepository);
CommonService commonService = new CommonService();
KeyPairService keyPairService = new KeyPairService(commonService, commonRepository);
ServiceStatusProvider serviceStatusProvider = new ServiceStatusProvider(symmetricEncryptionProvider, objectSerializationProvider, asymmetricEncryptionProvider);
servicesService = new ServicesService(servicesRepository, serviceStatusProvider, packingService, null, null, null, null, null, null);
controlService = new ControlService(symmetricEncryptionProvider, keyPairService, packingService, masterService, objectSerializationProvider, asymmetricEncryptionProvider);
service = new Scutex.Model.Service();
service.OutboundKeyPair = asymmetricEncryptionProvider.GenerateKeyPair(BitStrengths.High);
service.InboundKeyPair = asymmetricEncryptionProvider.GenerateKeyPair(BitStrengths.High);
service.ManagementInboundKeyPair = asymmetricEncryptionProvider.GenerateKeyPair(BitStrengths.High);
service.ManagementOutboundKeyPair = asymmetricEncryptionProvider.GenerateKeyPair(BitStrengths.High);
}
public FoxlinkSfcController()
{
var unitOfWork = new UnitOfWork();
packService = new PackingService(unitOfWork);
smtService = new SMTService(unitOfWork);
testService = new TestService(unitOfWork);
}
public override void Export(IDocumentComponent docs, string destDirFullPath)
{
this.exporter.Export(docs, destDirFullPath);
var packingService = new PackingService();
packingService.Pack(destDirFullPath, docs.Name);
}
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 static void BatchSmallLicenseKeyGenrationTest()
{
IAsymmetricEncryptionProvider asymmetricEncryptionProvider = new AsymmetricEncryptionProvider();
ISymmetricEncryptionProvider symmetricEncryptionProvider = new SymmetricEncryptionProvider();
IHashingProvider hashingProvider = new HashingProvider();
IObjectSerializationProvider objectSerializationProvider = new ObjectSerializationProvider();
ILicenseActiviationProvider licenseActiviationProvider = new LicenseActiviationProvider(
asymmetricEncryptionProvider, symmetricEncryptionProvider, objectSerializationProvider);
INumberDataGeneratorProvider numberDataGeneratorProvider = new NumberDataGenerator();
IPackingService packingService = new PackingService(numberDataGeneratorProvider);
IHardwareFingerprintService hardwareFingerprintService = new HardwareFingerprintService(new WmiDataProvider(), hashingProvider);
IClientLicenseRepository clientLicenseRepository = new ClientLicenseRepository(objectSerializationProvider,
symmetricEncryptionProvider);
IClientLicenseService clientLicenseService = new ClientLicenseService(clientLicenseRepository);
ISmallKeyGenerator smallKeyGenerator = new WaveTech.Scutex.Generators.StaticKeyGeneratorSmall.KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider);
ILargeKeyGenerator staticKeyGeneratorLarge = new WaveTech.Scutex.Generators.StaticKeyGeneratorLarge.KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider, hardwareFingerprintService);
LicenseKeyService licenseKeyService = new LicenseKeyService(smallKeyGenerator, staticKeyGeneratorLarge, packingService, clientLicenseService);
ClientLicense license = new ClientLicense();
LicenseGenerationOptions generationOptions = new LicenseGenerationOptions();
license.UniqueId = Guid.NewGuid();
license.Product = new Product();
license.Product.Name = "My Great Uber Cool Product, with new juice!";
license.Product.ProductId = 1;
string productHash = hashingProvider.Checksum32(license.GetLicenseProductIdentifier()).ToString("X");
DateTime start = DateTime.Now;
List <string> licenseKeys = licenseKeyService.GenerateLicenseKeys("TEST", license, generationOptions, 100000);
Dictionary <string, string> doubleCheck = new Dictionary <string, string>();
DateTime end = DateTime.Now;
foreach (string s in licenseKeys)
{
doubleCheck.Add(s, "");
Console.WriteLine(s);
}
Console.WriteLine();
Console.WriteLine("=================================");
Console.WriteLine(string.Format("Key Generation took {0}", end - start));
Console.WriteLine(string.Format("Generated {0} unique license keys", licenseKeys.Count));
Console.WriteLine();
Console.WriteLine("Press enter to exit.");
Console.ReadLine();
}
static void Main(string[] args)
{
var container = new Container(1, 300, 200, 100);
var itemsToPack = new List <Item>()
{
new Item(1, 150, 100, 50, 1),
};
var result = PackingService.Pack(container, itemsToPack);
PackingService.RenderPackingResult(container, result);
}
public void calcular(List <produto> produtos)
{
using (Entities ef = new Entities())
{
List <pacote> pacotes = ef.pacotes.ToList();
List <BinContainer> containers = new List <BinContainer>();
List <Item> items = new List <Item>();
List <int> algorithms = new List <int>();
algorithms.Add((int)AlgorithmType.EB_AFIT);
foreach (pacote item in pacotes)
{
containers.Add(new BinContainer(item.PAid, item.PAprofundidade, item.PAlargura, item.PAaltura));
}
foreach (produto produto in produtos)
{
items.Add(new Item(produto.PRid, produto.PRprofundidade, produto.PRlargura, produto.PRaltura, Convert.ToInt32(produto.PRquantidade)));
}
List <ContainerPackingResult> result = PackingService.Pack(containers, items, algorithms);
List <ItemTabelaResultado> resultado = new List <ItemTabelaResultado>();
foreach (ContainerPackingResult container in result)
{
pacote pct = ef.pacotes.Find(container.ContainerID);
ItemTabelaResultado tblItem = new ItemTabelaResultado(pct.PAtipo);
foreach (AlgorithmPackingResult algResult in container.AlgorithmPackingResults)
{
foreach (Item altItem in algResult.PackedItems)
{
if (altItem.IsPacked)
{
produto p = ef.produtos.Find(altItem.ID);
tblItem.produtos = tblItem.produtos + p.PRnome + Environment.NewLine;
}
}
}
resultado.Add(tblItem);
}
dgvResultado.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.AllCells;
dgvResultado.Columns[1].DefaultCellStyle.WrapMode = DataGridViewTriState.True;
dgvResultado.DataSource = resultado;
}
}
public static void LicenseKeyGenerationTest()
{
IAsymmetricEncryptionProvider asymmetricEncryptionProvider = new AsymmetricEncryptionProvider();
ISymmetricEncryptionProvider symmetricEncryptionProvider = new SymmetricEncryptionProvider();
IHashingProvider hashingProvider = new HashingProvider();
IObjectSerializationProvider objectSerializationProvider = new ObjectSerializationProvider();
ILicenseActiviationProvider licenseActiviationProvider = new LicenseActiviationProvider(
asymmetricEncryptionProvider, symmetricEncryptionProvider, objectSerializationProvider);
INumberDataGeneratorProvider numberDataGeneratorProvider = new NumberDataGenerator();
IPackingService packingService = new PackingService(numberDataGeneratorProvider);
IHardwareFingerprintService hardwareFingerprintService = new HardwareFingerprintService(new WmiDataProvider(), hashingProvider);
IClientLicenseRepository clientLicenseRepository = new ClientLicenseRepository(objectSerializationProvider,
symmetricEncryptionProvider);
IClientLicenseService clientLicenseService = new ClientLicenseService(clientLicenseRepository);
KeyGenerator staticKeyGenerator = new KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider);
ILargeKeyGenerator staticKeyGeneratorLarge = new WaveTech.Scutex.Generators.StaticKeyGeneratorLarge.KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider, hardwareFingerprintService);
LicenseKeyService licenseKeyService = new LicenseKeyService(staticKeyGenerator, staticKeyGeneratorLarge, packingService, clientLicenseService);
ClientLicense license = new ClientLicense();
LicenseGenerationOptions generationOptions = new LicenseGenerationOptions();
license.UniqueId = Guid.NewGuid();
license.Product = new Product();
license.Product.Name = "My Great Uber Cool Product, with new juice!";
license.Product.ProductId = 1;
string productHash = hashingProvider.Checksum32(license.GetLicenseProductIdentifier()).ToString("X");
Dictionary <string, string> licenseKeys = new Dictionary <string, string>();
DateTime start = DateTime.Now;
for (int i = 0; i < 100000; i++)
{
string key = licenseKeyService.GenerateLicenseKey("TEST", license, generationOptions);
licenseKeys.Add(key, key.GetHashCode().ToString());
Console.WriteLine(key);
}
DateTime end = DateTime.Now;
Console.WriteLine(start - end);
}
public void CanPackAndUnpackToken()
{
NumberDataGenerator numberDataGenerator = new NumberDataGenerator();
PackingService packingService = new PackingService(numberDataGenerator);
Token t = new Token();
t.Data = tokenData;
t.Timestamp = DateTime.Now;
string packedToken = packingService.PackToken(t);
Token unpackedToken = packingService.UnpackToken(packedToken);
Assert.AreEqual(tokenData, unpackedToken.Data);
Assert.AreEqual(t.Timestamp.Day, unpackedToken.Timestamp.Day);
Assert.AreEqual(t.Timestamp.Month, unpackedToken.Timestamp.Month);
Assert.AreEqual(t.Timestamp.Year, unpackedToken.Timestamp.Year);
Assert.AreEqual(t.Timestamp.Hour, unpackedToken.Timestamp.Hour);
Assert.AreEqual(t.Timestamp.Minute, unpackedToken.Timestamp.Minute);
}
public void TestLicenseKeyHashing()
{
IAsymmetricEncryptionProvider asymmetricEncryptionProvider = new AsymmetricEncryptionProvider();
ISymmetricEncryptionProvider symmetricEncryptionProvider = new SymmetricEncryptionProvider();
IHashingProvider hashingProvider = new HashingProvider();
IObjectSerializationProvider objectSerializationProvider = new ObjectSerializationProvider();
ILicenseActiviationProvider licenseActiviationProvider = new LicenseActiviationProvider(
asymmetricEncryptionProvider, symmetricEncryptionProvider, objectSerializationProvider);
INumberDataGeneratorProvider numberDataGeneratorProvider = new NumberDataGenerator();
IHardwareFingerprintService hardwareFingerprintService = new HardwareFingerprintService(new WmiDataProvider(), new HashingProvider());
IPackingService packingService = new PackingService(numberDataGeneratorProvider);
IClientLicenseRepository clientLicenseRepository = new ClientLicenseRepository(objectSerializationProvider,
symmetricEncryptionProvider);
IClientLicenseService clientLicenseService = new ClientLicenseService(clientLicenseRepository);
ILargeKeyGenerator largeKeyGenerator = new KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider, hardwareFingerprintService);
ISmallKeyGenerator smallKeyGenerator = new WaveTech.Scutex.Generators.StaticKeyGeneratorSmall.KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider);
LicenseKeyService licenseKeyService = new LicenseKeyService(smallKeyGenerator, largeKeyGenerator, packingService, clientLicenseService);
ClientLicense license = new ClientLicense();
LicenseGenerationOptions generationOptions = new LicenseGenerationOptions();
license.UniqueId = Guid.NewGuid();
license.Product = new Product();
license.Product.Name = "My Great Uber Cool Product, with new juice!";
license.Product.ProductId = 1;
string productHash = hashingProvider.Checksum32(license.GetLicenseProductIdentifier()).ToString("X");
Dictionary <string, string> licenseKeys = new Dictionary <string, string>();
List <string> keys = licenseKeyService.GenerateLicenseKeys("TEST", license, generationOptions, 100000);
foreach (string key in keys)
{
string hash = hashingProvider.ComputeHash(key, "SHA256");
licenseKeys.Add(hash, key);
Console.WriteLine(key + "\t" + hash);
Assert.IsTrue(hash.Equals(hashingProvider.ComputeHash(key, "SHA256")));
Assert.IsFalse(hash.Contains("'"));
}
}
public void Before_each_test()
{
asymmetricEncryptionProvider = new AsymmetricEncryptionProvider();
hashingProvider = new HashingProvider();
objectSerializationProvider = new ObjectSerializationProvider();
numberDataGenerator = new NumberDataGenerator();
packingService = new PackingService(numberDataGenerator);
servicesService = new ServicesService(null, null, packingService, null, null, null, null, null, null);
string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetName().CodeBase);
path = path.Replace("file:\\", "");
string serviceData;
using (TextReader reader = new StreamReader(path + "\\Data\\Service.dat"))
{
serviceData = reader.ReadToEnd().Trim();
}
service = objectSerializationProvider.Deserialize<Service>(serviceData);
}
public void Before_each_test()
{
asymmetricEncryptionProvider = new AsymmetricEncryptionProvider();
hashingProvider = new HashingProvider();
objectSerializationProvider = new ObjectSerializationProvider();
numberDataGenerator = new NumberDataGenerator();
packingService = new PackingService(numberDataGenerator);
servicesService = new ServicesService(null, null, packingService, null, null, null, null, null, null);
string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetName().CodeBase);
path = path.Replace("file:\\", "");
string serviceData;
using (TextReader reader = new StreamReader(path + "\\Data\\Service.dat"))
{
serviceData = reader.ReadToEnd().Trim();
}
service = objectSerializationProvider.Deserialize <Service>(serviceData);
}
public LicenseHelper()
{
asymmetricEncryptionProvider = new AsymmetricEncryptionProvider();
hashingProvider = new HashingProvider();
encodingService = new EncodingService();
objectSerializationProvider = new ObjectSerializationProvider();
symmetricEncryptionProvider = new SymmetricEncryptionProvider();
clientLicenseRepository = new ClientLicenseRepository(objectSerializationProvider, symmetricEncryptionProvider);
clientLicenseService = new ClientLicenseService(clientLicenseRepository);
serviceStatusProvider = new ServiceStatusProvider(symmetricEncryptionProvider, objectSerializationProvider, asymmetricEncryptionProvider);
numberDataGenerator = new NumberDataGenerator();
packingService = new PackingService(numberDataGenerator);
hardwareFingerprintService = new HardwareFingerprintService(new WmiDataProvider(), new HashingProvider());
keygen = new KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider);
keyGeneratorLarge = new Scutex.Generators.StaticKeyGeneratorLarge.KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider, hardwareFingerprintService);
licenseActiviationProvider = new LicenseActiviationProvider(asymmetricEncryptionProvider, symmetricEncryptionProvider, objectSerializationProvider);
service = new LicenseKeyService(keygen, keyGeneratorLarge, packingService, clientLicenseService);
productsProvider = new ProductsProvider(symmetricEncryptionProvider, objectSerializationProvider, asymmetricEncryptionProvider);
zipCompressionProvider = new ZipCompressionProvider();
wcfPackagingService = new WcfPackagingService(zipCompressionProvider);
//licenseSetsRepository = new LicenseSetsRepository();
//licenseSetService = new LicenseSetService();
//licenseService = new LicenseService();
License = new License();
License.Name = "UnitTest License";
License.UniqueId = Guid.NewGuid();
License.KeyPair = asymmetricEncryptionProvider.GenerateKeyPair(BitStrengths.High);
//string path = System.Reflection.Assembly.GetAssembly(typeof(LicenseHelper)).Location;
string path = Helper.AssemblyDirectory;
DllHash = encodingService.Encode(hashingProvider.HashFile(path + "\\WaveTech.Scutex.Licensing.dll"));
PublicKey = encodingService.Encode(License.KeyPair.PublicKey);
}
public void EB_AFIT_Passes_700_Standard_Reference_Tests()
{
// ORLibrary.txt is an Embedded Resource in this project.
var resourceName = "CromulentBisgetti.ContainerPackingTests.DataFiles.ORLibrary.txt";
var assembly = Assembly.GetExecutingAssembly();
using (var stream = assembly.GetManifestResourceStream(resourceName))
{
using (var reader = new StreamReader(stream))
{
// Counter to control how many tests are run in dev.
var counter = 1;
while (reader.ReadLine() != null && counter <= 700)
{
var itemsToPack = new List <Item>();
// First line in each test case is an ID. Skip it.
// Second line states the results of the test, as reported in the EB-AFIT master's thesis, appendix E.
var testResults = reader.ReadLine().Split(' ');
// Third line defines the container dimensions.
var containerDims = reader.ReadLine().Split(' ');
// Fourth line states how many distinct item types we are packing.
var itemTypeCount = Convert.ToInt32(reader.ReadLine());
for (var i = 0; i < itemTypeCount; i++)
{
var itemArray = reader.ReadLine().Split(' ');
var item = new Item(0, Convert.ToDecimal(itemArray[1]), Convert.ToDecimal(itemArray[3]), Convert.ToDecimal(itemArray[5]), Convert.ToInt32(itemArray[7]));
itemsToPack.Add(item);
}
var containers = new List <Container>();
containers.Add(new Container(0, Convert.ToDecimal(containerDims[0]), Convert.ToDecimal(containerDims[1]), Convert.ToDecimal(containerDims[2])));
var result = PackingService.Pack(containers, itemsToPack, new List <Int32> {
(Int32)AlgorithmType.EB_AFIT
});
// Assert that the number of items we tried to pack equals the number stated in the published reference.
Assert.AreEqual(result[0].AlgorithmPackingResults[0].PackedItems.Count + result[0].AlgorithmPackingResults[0].UnpackedItems.Count, Convert.ToDecimal(testResults[1]));
// Assert that the number of items successfully packed equals the number stated in the published reference.
Assert.AreEqual(result[0].AlgorithmPackingResults[0].PackedItems.Count, Convert.ToDecimal(testResults[2]));
// Assert that the packed container volume percentage is equal to the published reference result.
// Make an exception for a couple of tests where this algorithm yields 87.20% and the published result
// was 87.21% (acceptable rounding error).
Assert.IsTrue(result[0].AlgorithmPackingResults[0].PercentContainerVolumePacked == Convert.ToDecimal(testResults[3]) ||
(result[0].AlgorithmPackingResults[0].PercentContainerVolumePacked == 87.20M && Convert.ToDecimal(testResults[3]) == 87.21M));
// Assert that the packed item volume percentage is equal to the published reference result.
Assert.AreEqual(result[0].AlgorithmPackingResults[0].PercentItemVolumePacked, Convert.ToDecimal(testResults[4]));
counter++;
}
}
}
}
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);
hardwareFingerprintService = new HardwareFingerprintService(new WmiDataProvider(), new HashingProvider());
keyGeneratorLarge = new Scutex.Generators.StaticKeyGeneratorLarge.KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider, hardwareFingerprintService);
var mockActivationLogRepository = new Mock <IActivationLogRepoistory>();
mockActivationLogRepository.Setup(log => log.SaveActivationLog(It.IsAny <Scutex.Model.ActivationLog>()));
activationLogService = new ActivationLogService(mockActivationLogRepository.Object, hashingProvider);
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);
masterService = new MasterService(mockCommonRepository.Object);
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, keyGeneratorLarge, packingService, clientLicenseService);
keyService = new KeyManagementService(clientRepository, licenseKeyService, activationLogService, hashingProvider, serviceProductsRepository);
activationService = new ActivationService(controlService, keyService, keyPairService, objectSerializationProvider, asymmetricEncryptionProvider, activationLogService, masterService, commonService, null);
string serviceData;
using (TextReader reader = new StreamReader(path + "\\Data\\Service.dat"))
{
serviceData = reader.ReadToEnd().Trim();
}
service = objectSerializationProvider.Deserialize <Service>(serviceData);
}
/// <summary>
/// Auto packing implementation. Reference: https://github.com/davidmchapman/3DContainerPacking
/// </summary>
public bool PackingItems()
{
//retrieve the container size
Vector3 containerSize = m_MyCar.GetComponent <MyCar>().GetTrunkSize();
//map the item id to the GameObject on the left-UI pane
Dictionary <int, GameObject> UIItemMap = new Dictionary <int, GameObject>();
//container for the packing algorithm
List <Container> containers = new List <Container>();
//items for the packing algorithm
List <Item> itemsToPack = new List <Item>();
//the packing algorithm
List <int> algorithms = new List <int>();
m_MyCar.GetComponent <MyCar>().ClearTrunk();
float scale = 1000f;
containers.Add(new Container(1, new Decimal(containerSize.x * scale), new Decimal(containerSize.y * scale), new Decimal(containerSize.z * scale)));
//convert items to the Item instances
for (int i = 0; i < this.transform.childCount; i++)
{
GameObject child = this.transform.GetChild(i).gameObject;
if (child == this.AddIcon)
{
continue;
}
Vector3 dims = child.GetComponent <ARItem>().size;
int id = child.GetComponent <ARItem>().id;
itemsToPack.Add(new Item(id, new Decimal(dims.x * scale), new Decimal(dims.y * scale), new Decimal(dims.z * scale), 1));
UIItemMap[id] = child;
}
algorithms.Add((int)AlgorithmType.EB_AFIT);
List <ContainerPackingResult> result = PackingService.Pack(containers, itemsToPack, algorithms);
if (result.Count < 1)
{
return(false);
}
AlgorithmPackingResult resultDetail = result[0].AlgorithmPackingResults[0];
float total_volume = (float)containers[0].Volume;
float item_volume = 0;
//check the packing result
foreach (Item i in resultDetail.PackedItems)
{
Vector3 localPosition = new Vector3((float)i.CoordX / scale, (float)i.CoordY / scale, (float)i.CoordZ / scale);
Vector3 size = new Vector3((float)i.Dim1 / scale, (float)i.Dim2 / scale, (float)i.Dim3 / scale);
//Debug.Log("[BMWAR] item #+"+i.ID+": "+ localPosition + " size: " + size);
//visualize it in the trunk
GameObject itemInContainer = m_MyCar.GetComponent <MyCar>().AddObjectToTrunk(localPosition, size);
if (UIItemMap.ContainsKey(i.ID))
{
//change the UI color
UIItemMap[i.ID].GetComponent <ARItem>().proxyItemBox = itemInContainer;
UIItemMap[i.ID].GetComponent <RawImage>().color = PackedItemColor;
UIItemMap.Remove(i.ID);
}
item_volume += (float)i.Volume;
}
//check the unpacked items and update their colors in the left UI pane.
foreach (var key in UIItemMap.Keys)
{
UIItemMap[key].GetComponent <ARItem>().proxyItemBox = null;
UIItemMap[key].GetComponent <RawImage>().color = UnPackedItemColor;
}
//calculate and update the free space
float free_space = 100 - (item_volume * 100 / total_volume);
m_MyCar.GetComponent <MyCar>().SetFreeSpace((int)free_space);
if (resultDetail.IsCompletePack)
{
return(true);
}
return(false);
}
public async Task <ActionResult> GetWeatherObject(SearchModel model)
{
if (ModelState.IsValid)
{
var vm = new WeatherViewModel();
var trip = new Trip()
{
Location = model.Location,
StartDate = model.StartDate,
Duration = model.Duration
};
var tripId = _tripPackingService.CreateTrip(trip);
var historicalWeather = await _weatherClient.GetHistoricalWeather(model.Location, model.StartDate, model.Duration);
var cityName = historicalWeather.Select(x => x.Location).Select(x => x.Name).Distinct().FirstOrDefault();
var regionName = historicalWeather.Select(x => x.Location).Select(x => x.Region).Distinct().FirstOrDefault();
vm.Historicals = MapForecast(historicalWeather);
vm.CityName = cityName;
vm.RegionName = regionName;
vm.StartDate = model.StartDate.ToString("d");
vm.EndDate = model.StartDate.AddDays(model.Duration - 1).ToString("d");
if (model.StartDate <= DateTime.Now.AddDays(5))
{
TimeSpan interval = model.StartDate - DateTime.Today;
var days = model.Duration + interval.Days;
if (days > 10)
{
var forecastWeather10Days = await _weatherClient.GetForecastWeather(model.Location, 10);
vm.Forecasts = MapForecast(forecastWeather10Days);
}
var forecastWeather = await _weatherClient.GetForecastWeather(model.Location, days);
vm.Forecasts = MapForecast(forecastWeather);
}
// the ?: is a ternary operator: this is what it does
// if vm.forecasts is not null, then get items based on forcasts; otherwise, get items based on historicals
var itemsToPack = GetPackingItems(
vm.Forecasts != null
? vm.Forecasts
: vm.Historicals,
model.Duration, tripId);
List <Container> containers = new List <Container>();
containers.Add(new Container(1, "Carry-On", 104M, 20.5M, 15M, 8M)); //samsonite 21" Spinner - 43.5 total
containers.Add(new Container(2, "Medium Suitcase", 144.88M, 23M, 17M, 9M)); //samsonite 27" Spinner (27M, 18.5M,9.5M) - 55 total
containers.Add(new Container(3, "Large Suitcase", 145.6M, 29.5M, 20.5M, 11M)); //62" (must be 62" and 50 lbs or less)
List <Item> itemsToContainer = new List <Item>();
foreach (var item in itemsToPack)
{
itemsToContainer.Add(new Item(item.Name, item.Height, item.Length, item.Width, Convert.ToInt32(item.Quantity)));
}
List <int> algorithms = new List <int>();
algorithms.Add((int)AlgorithmType.EB_AFIT);
List <ContainerPackingResult> packingResults = new List <ContainerPackingResult>();
var totalItemWeight = itemsToPack.Select(x => x.TotalWeight).Sum();
for (int i = containers.Count - 1; i >= 0; i--)
{
packingResults = PackingService.Pack(containers[i], itemsToContainer, algorithms);
var packResult = packingResults.SelectMany(x => x.AlgorithmPackingResults).SelectMany(x => x.UnpackedItems).Count();
if (packResult == 0)
{
var containerWeight = packingResults.Select(x => x.Weight).Sum();
var totalWeight = (containerWeight + totalItemWeight) * .0625M; //converts weight in ounces to pounds
vm.PackingItems = itemsToPack;
vm.ContainerPackingResults = packingResults;
vm.TotalWeightInLbs = totalWeight;
}
}
return(View("Result", vm));
}
return(RedirectToAction("Index", "Home"));
}
public IPackingAlgorithm Get(int algorithmTypeId)
{
return(PackingService.GetPackingAlgorithmFromTypeID(algorithmTypeId));
}
public ContainerPackingResultSummary Calculate([FromBody] ContainerCalculateRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
return(PackingService.Packing(request.Container, request.ItemsToPack, cancellationToken));
}
public ActionResult <List <ContainerPackingResult> > Post([FromBody] ContainerPackingRequest request)
{
return(PackingService.Pack(request.Containers, request.ItemsToPack, request.AlgorithmTypeIDs));
}
public List <ContainerPackingResult> Post([FromBody] ContainerPackingRequest request)
{
return(PackingService.Pack(request.Containers, request.ItemsToPack.OrderByDescending(i => i.Volume).ToList(), request.AlgorithmTypeIDs));
}
private void PackingInMoreBox(List <Model.Item> list, List <int> boxID)
{
List <Box> boxes = new List <Box>();
foreach (var i in boxID)
{
boxes.Add(boxDAO.getBox(i));
}
List <Packing.Item> itemsToPack = convertListItem(list);
List <int> algorithms = new List <int>();
algorithms.Add((int)AlgorithmType.EB_AFIT);
if (list.Count != 0)
{
foreach (var z in boxes)
{
Console.WriteLine("Provo pacco " + z.Name);
if (itemsToPack.Count != 0)
{
boxDAO.resetBox(z.Id);
List <Packing.Entities.Container> containers = new List <Packing.Entities.Container>();
containers.Add(convertBox(z));
//Avvio algoritmo EB-AFIT
List <ContainerPackingResult> result = PackingService.Pack(containers, itemsToPack, algorithms);
List <Packing.Item> listPacked = new List <Packing.Item>();
List <Packing.Item> listUnpacked = new List <Packing.Item>();
var container = 0;
foreach (var a in result)
{
container = a.ContainerID;
foreach (var i in a.AlgorithmPackingResults)
{
listPacked = i.PackedItems;
listUnpacked = i.UnpackedItems;
}
}
foreach (var v in listPacked)
{
var item = itemDAO.getItem(v.ID);
item.updateCoordinate(v.CoordX, v.CoordY, v.CoordZ, v.PackDimX, v.PackDimY, v.PackDimZ);
itemDAO.updateItem(item);
}
insertPackedItem(listPacked, container);
itemsToPack = listUnpacked;
}
else
{
alert("Completato", "tutti gli oggetti sono stati imballati", "ok");
break;
}
}
if (itemsToPack.Count != 0)
{
alert("Non tutti gli oggetti entrano nei pacchi", "Apri i dettagli del pacco per controllare quali sono stati inseriti", "ok");
}
}
}
private void PackingInOneBox(List <Model.Item> list, int boxID)
{
var box = boxDAO.getBox(boxID);
if (list.Count != 0)
{
boxDAO.resetBox(boxID);
List <Packing.Item> itemsToPack = convertListItem(list);
List <Packing.Entities.Container> containers = new List <Packing.Entities.Container>();
containers.Add(convertBox(box));
List <int> algorithms = new List <int>();
algorithms.Add((int)AlgorithmType.EB_AFIT);
//Avvio algoritmo EB-AFIT
List <ContainerPackingResult> result = PackingService.Pack(containers, itemsToPack, algorithms);
List <Packing.Item> listPacked = new List <Packing.Item>();
List <Packing.Item> listUnpacked = new List <Packing.Item>();
var container = 0;
foreach (var a in result)
{
container = a.ContainerID;
foreach (var i in a.AlgorithmPackingResults)
{
listPacked = i.PackedItems;
listUnpacked = i.UnpackedItems;
}
}
foreach (var v in listPacked)
{
var item = itemDAO.getItem(v.ID);
item.updateCoordinate(v.CoordX, v.CoordY, v.CoordZ, v.PackDimX, v.PackDimY, v.PackDimZ);
itemDAO.updateItem(item);
}
if (listUnpacked.Count == 0 && listPacked.Count == 0)
{
alert("Impossibile completare", "Non è stato possibile inserire nessun oggetto nel pacco", "ok");
}
else
{
if (listUnpacked.Count == 0)
{
alert("Completato", "Tutti gli oggetti sono stati inseriti", "ok");
insertPackedItem(listPacked, container);
}
else
{
alert("Non tutti gli oggetti entrano nel pacco", "Apri i dettagli del pacco per controllare quali sono stati inseriti", "ok");
insertPackedItem(listPacked, container);
}
}
}
}
