public async Task TM_UpdateConcepts_SATGroup()
{
var connectionString = ConfigManager.GetValue("ConfigConnectionStringTest");
using var context = new CotorraContext(connectionString);
Expression <Func <ConceptPayment, bool> > expression = exp => exp.Active;
var conceptPayments = await context.ConceptPayment.Where(expression).ToListAsync();
var memoryStorageContext = new MemoryStorageContext();
var accumulateds = memoryStorageContext.GetDefaultAccumulatedType(Guid.Empty, Guid.Empty, Guid.Empty);
(var conceptPaymentsMemory, var pr) = memoryStorageContext.GetDefaultConcept <ConceptPayment>(Guid.Empty, Guid.Empty, Guid.Empty, accumulateds);
conceptPayments.ForEach(conceptInDB =>
{
var conceptFoundInMemory = conceptPaymentsMemory
.FirstOrDefault(p => p.Code == conceptInDB.Code && p.ConceptType == conceptInDB.ConceptType);
if (null != conceptFoundInMemory)
{
conceptInDB.SATGroupCode = conceptFoundInMemory.SATGroupCode;
}
});
var concept22 = conceptPayments.AsParallel().Where(p => p.Code == 22 && p.ConceptType == ConceptType.SalaryPayment);
context.UpdateRange(conceptPayments);
await context.SaveChangesAsync();
}
public async Task <List <ConceptPayment> > CreateDefaultSalaryPaymentConceptsAsync(Guid identityWorkId, Guid instanceID)
{
var memoryStorageContext = new MemoryStorageContext();
var middlewareAccumulates = new MiddlewareManager <AccumulatedType>(new BaseRecordManager <AccumulatedType>(), new AccumulatedTypeValidator());
var accumulatesTypes = await middlewareAccumulates.GetAllAsync(identityWorkId, instanceID);
if (!accumulatesTypes.Any())
{
accumulatesTypes = memoryStorageContext.GetDefaultAccumulatedType(identityWorkId, instanceID, Guid.NewGuid());
await middlewareAccumulates.CreateAsync(accumulatesTypes, identityWorkId);
}
var resultTuple = memoryStorageContext.GetDefaultConcept <ConceptPayment>(identityWorkId, instanceID, Guid.NewGuid(), accumulatesTypes);
var concepts = resultTuple.Item1
.Cast <ConceptPayment>().ToList();
var middlewareManagerConceptPaymentRelationship = new MiddlewareManager <ConceptPaymentRelationship>(new BaseRecordManager <ConceptPaymentRelationship>(),
new ConceptPaymentRelationshipValidator());
var middlewareConcept = new MiddlewareManager <ConceptPayment>(new BaseRecordManager <ConceptPayment>(), new ConceptPaymentValidator());
await middlewareConcept.CreateAsync(concepts, identityWorkId);
var relationships = resultTuple.Item2.Cast <ConceptPaymentRelationship>().ToList();
await middlewareManagerConceptPaymentRelationship.CreateAsync(relationships, identityWorkId);
return(concepts);
}
public void TestStorageListWithNestedMap()
{
var context = new MemoryStorageContext();
var map = new StorageMap("map".AsByteArray(), context);
Assert.IsTrue(map.Count() == 0);
map.Set(1, "hello");
map.Set(3, "world");
var count = map.Count();
Assert.IsTrue(count == 2);
var list = new StorageList("list".AsByteArray(), context);
Assert.IsTrue(list.Count() == 0);
list.Add(map);
count = list.Count();
Assert.IsTrue(count == 1);
var another = list.Get <StorageMap>(0);
count = another.Count();
Assert.IsTrue(count == 2);
}
public void TestStorageMapAllValues()
{
var context = new MemoryStorageContext();
var map = new StorageMap("test".AsByteArray(), context);
Assert.IsTrue(map.Count() == 0);
var big1 = BigInteger.Parse("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
var big2 = BigInteger.Parse("2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222");
var big3 = BigInteger.Parse("3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333");
map.Set <BigInteger, BigInteger>(big1, big1);
map.Set <BigInteger, BigInteger>(big2, big2);
map.Set <BigInteger, BigInteger>(big3, big3);
Assert.IsTrue(map.Count() == 3);
Assert.IsTrue(map.ContainsKey <BigInteger>(big1));
Assert.IsTrue(map.ContainsKey <BigInteger>(big2));
Assert.IsTrue(map.ContainsKey <BigInteger>(big3));
var all = map.AllValues <BigInteger>();
foreach (var x in all)
{
System.Console.WriteLine(x);
}
System.Console.WriteLine("COUNT: " + all.Count());
Assert.IsTrue(all.Count() == 3);
}
public MemoryBlockchain(Block genesisBlock = null)
{
this.shutdownToken = new CancellationToken();
this.random = new Random();
// create the key pair that block rewards will be sent to
var keyPair = TransactionManager.CreateKeyPair();
this._coinbasePrivateKey = keyPair.Item1;
this._coinbasePublicKey = keyPair.Item2;
// initialize unit test storage
this._storageContext = new MemoryStorageContext();
this._cacheContext = new CacheContext(this._storageContext);
// initialize unit test rules
this._rules = new UnitTestRules(this._cacheContext);
// initialize blockchain calculator
this._calculator = new BlockchainCalculator(this._rules, this._cacheContext, this.shutdownToken);
// create and mine the genesis block
this._genesisBlock = genesisBlock ?? MineEmptyBlock(0);
// update genesis blockchain and add to storage
this._rules.SetGenesisBlock(this._genesisBlock);
this._currentBlockchain = this._rules.GenesisBlockchain;
this._genesisChainedBlock = AddBlock(this._genesisBlock, null).Item2;
}
public async Task Should_Get_All_In_Memory_Should_Be_Equal_To_Get_All_DB( )
{
using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
//Arrange
var middlewareManager = new MiddlewareManager <UMI>(new BaseRecordManager <UMI>(), new UMIValidator());
var memoryMgr = new MemoryStorageContext();
//Asserts
//Get
var result = await middlewareManager.GetAllAsync();
Assert.True(result.Any());
var resultMemory = memoryMgr.GetdDefaultUMI();
Assert.True(resultMemory.Any());
Assert.Equal(result.Count(), resultMemory.Count());
resultMemory.ForEach(memory =>
{
var db = result.FirstOrDefault(x => x.ID == memory.ID);
Assert.NotNull(db);
});
}
public async Task Client_Should_Call_Dummy_Async()
{
using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
var iMSSFare = new List <IMSSFare>();
var companyId = Guid.NewGuid();
var instanceId = Guid.NewGuid();
var userId = Guid.NewGuid();
iMSSFare = new MemoryStorageContext().GetDefaultIMSSFare(companyId, instanceId, userId);
var middlewareManager = new MiddlewareManager <IMSSFare>(new BaseRecordManager <IMSSFare>(), new IMSSFareValidator());
//Act
await middlewareManager.CreateAsync(iMSSFare, companyId);
//Asserts
//Get
var result = await middlewareManager
.GetByIdsAsync(iMSSFare.Select(p => p.ID).ToList(), companyId);
Assert.True(result.Any());
//Delete
await middlewareManager.DeleteAsync(iMSSFare.Select(p => p.ID).ToList(), companyId);
//Get it again to verify if the registry it was deleted
var result2 = await middlewareManager
.GetByIdsAsync(iMSSFare.Select(p => p.ID).ToList(), companyId);
Assert.True(!result2.Any());
}
public async Task <List <T> > CreateDefaultAsync <T>(Guid identityWorkId, Guid instanceId) where T : BaseEntity
{
var MonthlyIncomeTaxs = new MemoryStorageContext().GetDefaultMonthlyEmploymentSubsidy(identityWorkId, instanceId, Guid.Empty);
var middlewareManager = new MiddlewareManager <MonthlyEmploymentSubsidy>(new BaseRecordManager <MonthlyEmploymentSubsidy>(), new MonthlyEmploymentSubsidyValidator());
await middlewareManager.CreateAsync(MonthlyIncomeTaxs, identityWorkId);
return(MonthlyIncomeTaxs as List <T>);
}
private async Task SaveWorkshiftDefaultAsync(InitializationParams parameters, Guid companyID, Guid instanceID, Guid user)
{
var memoryTest = new MemoryStorageContext();
var result = memoryTest.GetDefaultWorkShift(companyID, instanceID, user);
var middlewareManager = new MiddlewareManager <Workshift>(new BaseRecordManager <Workshift>(),
new WorkshiftValidator());
await middlewareManager.CreateAsync(result, companyID);
}
private async Task SaveMinimiumSalaryDefaultAsync(InitializationParams parameters, Guid companyID, Guid instanceID, Guid user)
{
var memoryTest = new MemoryStorageContext();
var result = memoryTest.GetDefaultMinimunSalaries(companyID, instanceID, user);
var middlewareManager = new MiddlewareManager <MinimunSalary>(new BaseRecordManager <MinimunSalary>(),
new MinimunSalaryValidator());
await middlewareManager.CreateAsync(result, companyID);
}
private async Task SaveIMSSWorkRiskDefaultAsync(InitializationParams initializationParams, Guid companyID, Guid instanceID, Guid user)
{
var memoryTest = new MemoryStorageContext();
var result = memoryTest.GetDefaultIMSSWorkRisk(companyID, instanceID, user);
var middlewareManager = new MiddlewareManager <IMSSWorkRisk>(new BaseRecordManager <IMSSWorkRisk>(),
new IMSSWorkRiskValidator());
await middlewareManager.CreateAsync(result, companyID);
}
private async Task SaveSettlementCatalogDefaultAsync(InitializationParams initializationParams, Guid companyID, Guid instanceID, Guid user)
{
var memoryTest = new MemoryStorageContext();
var result = memoryTest.GetDefaultSettlementCatalogTable(companyID, instanceID, user);
var middlewareManager = new MiddlewareManager <SettlementCatalog>(new BaseRecordManager <SettlementCatalog>(),
new SettlementCatalogValidator());
await middlewareManager.CreateAsync(result, companyID);
}
public async Task <List <MinimunSalary> > CreateAsync(Guid identityWorkId, Guid instanceID)
{
var middlewareManager = new MiddlewareManager <MinimunSalary>(new BaseRecordManager <MinimunSalary>(), new MinimunSalaryValidator());
var lstMinimunSalary = new MemoryStorageContext().GetDefaultMinimunSalaries(identityWorkId, instanceID, Guid.NewGuid());
await middlewareManager.CreateAsync(lstMinimunSalary, identityWorkId);
return(lstMinimunSalary);
}
public void GetDefaultMonthlyIncomeTax()
{
using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
var memoryTest = new MemoryStorageContext();
var result = memoryTest.GetDefaultMonthlyIncomeTax(Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid());
Assert.True(result.Any());
}
public async Task <List <T> > CreateDefaultAsync <T>(Guid identityWorkId, Guid instanceId) where T : BaseEntity
{
var umas = new MemoryStorageContext().GetdDefaultUMA(identityWorkId, instanceId, Guid.Empty);
var middlewareManager = new MiddlewareManager <UMA>(new BaseRecordManager <UMA>(), new UMAValidator());
await middlewareManager.CreateAsync(umas, identityWorkId);
return(umas as List <T>);
}
private async Task SaveAnualEmploymentSubsidyDefaultAsync(InitializationParams parameters, Guid companyID, Guid instanceID, Guid user)
{
var memoryTest = new MemoryStorageContext();
var result = memoryTest.GetDefaultAnualEmploymentSubsidy(companyID, instanceID, user);
var middlewareManager = new MiddlewareManager <AnualEmploymentSubsidy>(new BaseRecordManager <AnualEmploymentSubsidy>(),
new AnualEmploymentSubsidyValidator());
await middlewareManager.CreateAsync(result, companyID);
}
public void TestStorageMapClearEmpty()
{
var context = new MemoryStorageContext();
var map = new StorageMap("test".AsByteArray(), context);
Assert.IsTrue(map.Count() == 0);
map.Clear();
Assert.IsTrue(map.Count() == 0);
}
public async Task <List <T> > CreateDefaultAsync <T>(Guid identityWorkId, Guid instanceId) where T : BaseEntity
{
var AnualIncomeTaxs = new MemoryStorageContext().GetDefaultAnualIncomeTax(identityWorkId, instanceId, Guid.Empty);
var middlewareManager = new MiddlewareManager <AnualIncomeTax>(new BaseRecordManager <AnualIncomeTax>(),
new AnualIncomeTaxValidator());
await middlewareManager.CreateAsync(AnualIncomeTaxs, identityWorkId);
return(AnualIncomeTaxs as List <T>);
}
private async Task <List <AccumulatedType> > SaveAccumulatedTypeDefaultAsync(InitializationParams parameters, Guid companyID, Guid instanceID, Guid user)
{
var memoryTest = new MemoryStorageContext();
var result = memoryTest.GetDefaultAccumulatedType(companyID, instanceID, user);
var middlewareManager = new MiddlewareManager <AccumulatedType>(new BaseRecordManager <AccumulatedType>(),
new AccumulatedTypeValidator());
await middlewareManager.CreateAsync(result, companyID);
return(result);
}
private async Task <List <IncidentTypeRelationship> > SaveIncidentTypeRelationshipDefaultAsync(InitializationParams parameters, Guid companyID, Guid instanceID, Guid user, List <IncidentType> incidentTypes)
{
var memoryTest = new MemoryStorageContext();
var result = memoryTest.GetDefaultIncidentTypeRelationship(companyID, instanceID, user, incidentTypes);
var middlewareManager = new MiddlewareManager <IncidentTypeRelationship>(new BaseRecordManager <IncidentTypeRelationship>(),
new IncidentTypeRelationshipValidator());
await middlewareManager.CreateAsync(result, companyID);
return(result);
}
public void MemoryTest_IncidentTypeAndAccumulatedDefault()
{
using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
var memoryTest = new MemoryStorageContext();
var resultAccumulatedTypes = memoryTest.GetDefaultAccumulatedType(Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid());
var resultIncidentTypes = memoryTest.GetDefaultIncidentType(Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), resultAccumulatedTypes);
var resultIncidentTypeRelationship = memoryTest.GetDefaultIncidentTypeRelationship(Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), resultIncidentTypes);
Assert.True(resultAccumulatedTypes.Any());
Assert.True(resultIncidentTypes.Any());
}
public void MemoryTest_ConceptDefault()
{
using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
var company = Guid.NewGuid();
var instanceId = Guid.NewGuid();
var user = Guid.NewGuid();
var memoryTest = new MemoryStorageContext();
var accumulates = memoryTest.GetDefaultAccumulatedType(company, instanceId, user);
var resultSalaryPayment = memoryTest.GetDefaultConcept <ConceptPayment>(company, instanceId, user, accumulates);
var relationships = memoryTest.GetDefaultConceptPaymentRelationship(resultSalaryPayment.Item1, accumulates);
var accumulateType = accumulates.FirstOrDefault(p => p.Name.ToLower().Contains("directo"));
var found = relationships.FirstOrDefault(p => p.AccumulatedTypeID == accumulateType.ID);
}
public async Task MemoryTest_BenefitTypeDefault()
{
using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
var memoryTest = new MemoryStorageContext();
var company = Guid.Parse("7535c4e6-4712-4dd6-955d-fca86e054d49");
var instance = Guid.Parse("52a251f8-8fe5-4613-8e6a-181a09f431a1");
var user = Guid.Parse("82ced4f6-a6cf-27e7-5683-95b6891b0b10");
var result = memoryTest.GetDefaultBenefitType(company, instance, user);
//var middlewareManager = new MiddlewareManager<BenefitType>(new BaseRecordManager<BenefitType>(),
// new BenefitTypeValidator());
//await middlewareManager.CreateAsync(result, company);
//scope.Complete();
Assert.True(result.Any());
}
public void Should_Get_All_From_Memory(string date, decimal value)
{
var ValidityDate = DateTime.Parse(date);
using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
//Arrange
var middlewareManager = new MemoryStorageContext();
//Asserts
//Get
var result = middlewareManager.GetdDefaultUMI();
Assert.True(result.Any());
Assert.NotNull(result.FirstOrDefault(x => x.ValidityDate == ValidityDate));
Assert.Equal(value, result.FirstOrDefault(x => x.ValidityDate == ValidityDate).Value);
}
public async Task <List <T> > CreateDefaultAsync <T>(Guid identityWorkId, Guid instanceID) where T : BaseEntity
{
//Act Dependencies
var accumulatedTypes = new MemoryStorageContext().GetDefaultAccumulatedType(identityWorkId, instanceID, Guid.NewGuid());
List <IncidentType> incidentTypes = new MemoryStorageContext().GetDefaultIncidentType(identityWorkId, instanceID, Guid.NewGuid(), accumulatedTypes);
//AcumulatedTypes
var middlewareManagerAccumulatedType = new MiddlewareManager <AccumulatedType>(new BaseRecordManager <AccumulatedType>(), new AccumulatedTypeValidator());
await middlewareManagerAccumulatedType.CreateAsync(accumulatedTypes, identityWorkId);
//IncidentTypes
var middlewareManagerIncidentType = new MiddlewareManager <IncidentType>(new BaseRecordManager <IncidentType>(), new IncidentTypeValidator());
await middlewareManagerIncidentType.CreateAsync(incidentTypes, identityWorkId);
return(incidentTypes as List <T>);
}
public static void Main(string[] args)
{
//TODO
//MainnetRules.BypassValidation = true;
//MainnetRules.BypassExecuteScript = true;
ScriptEngine.BypassVerifySignature = true;
using (var storageContext = new MemoryStorageContext())
using (var cacheContext = new CacheContext(storageContext))
{
var rules = new Testnet2Rules(cacheContext);
using (var blockchainDaemon = new BlockchainDaemon(rules, cacheContext))
using (var knownAddressStorage = new MemoryStorage <NetworkAddressKey, NetworkAddressWithTime>(storageContext))
using (var localClient = new LocalClient(LocalClientType.ComparisonToolTestNet, blockchainDaemon, knownAddressStorage))
{
// start the blockchain daemon
blockchainDaemon.Start();
// start p2p client
localClient.Start();
var projectFolder = Environment.CurrentDirectory;
while (projectFolder.Contains(@"\bin"))
{
projectFolder = Path.GetDirectoryName(projectFolder);
}
File.Delete(Path.Combine(projectFolder, "Bitcoinj-comparison.log"));
var javaProcessStartInfo = new ProcessStartInfo
{
FileName = @"C:\Program Files\Java\jdk1.7.0_25\bin\java.exe",
WorkingDirectory = projectFolder,
Arguments = @"-Djava.util.logging.config.file={0}\bitcoinj.log.properties -jar {0}\bitcoinj.jar".Format2(projectFolder),
UseShellExecute = false
};
var javaProcess = Process.Start(javaProcessStartInfo);
javaProcess.WaitForExit((int)TimeSpan.FromMinutes(5).TotalMilliseconds);
Console.ReadLine();
}
}
}
public void TestStorageMapBigInt()
{
var context = new MemoryStorageContext();
var map = new StorageMap("test".AsByteArray(), context);
Assert.IsTrue(map.Count() == 0);
var big = BigInteger.Parse("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
map.Set <BigInteger, BigInteger>(big, big);
Assert.IsTrue(map.Count() == 1);
Assert.IsTrue(map.ContainsKey <BigInteger>(big));
map.Remove <BigInteger>(big);
Assert.IsTrue(map.Count() == 0);
}
public void TestStorageMapClear()
{
var context = new MemoryStorageContext();
var map = new StorageMap("test".AsByteArray(), context);
Assert.IsTrue(map.Count() == 0);
map.Set(1, "hello");
map.Set(3, "world");
Assert.IsTrue(map.Count() == 2);
Assert.IsFalse(map.ContainsKey(0));
Assert.IsTrue(map.ContainsKey(1));
Assert.IsFalse(map.ContainsKey(2));
Assert.IsTrue(map.ContainsKey(3));
map.Clear();
Assert.IsTrue(map.Count() == 0);
}
private async Task <List <PeriodType> > SavePeriodTypeDefaultAsync(InitializationParams parameters, Guid companyID, Guid instanceID, Guid user)
{
var memoryTest = new MemoryStorageContext();
List <PeriodType> lstPeriodTypes = new List <PeriodType>();
//Quincenal
var forceUpdate = parameters.PayrollCompanyConfiguration.PaymentPeriodicity == PaymentPeriodicity.Biweekly;
lstPeriodTypes.AddRange(memoryTest.GetDefaultPeriodType(companyID, instanceID, user,
PaymentPeriodicity.Biweekly,
parameters.PayrollCompanyConfiguration.PaymentDays,
parameters.PayrollCompanyConfiguration.AdjustmentPay, forceUpdate));
//Mensual
forceUpdate = parameters.PayrollCompanyConfiguration.PaymentPeriodicity == PaymentPeriodicity.Monthly;
lstPeriodTypes.AddRange(memoryTest.GetDefaultPeriodType(companyID, instanceID, user,
PaymentPeriodicity.Monthly,
parameters.PayrollCompanyConfiguration.PaymentDays,
parameters.PayrollCompanyConfiguration.AdjustmentPay, forceUpdate));
//Semanal
forceUpdate = parameters.PayrollCompanyConfiguration.PaymentPeriodicity == PaymentPeriodicity.Weekly;
lstPeriodTypes.AddRange(memoryTest.GetDefaultPeriodType(companyID, instanceID, user,
PaymentPeriodicity.Weekly,
parameters.PayrollCompanyConfiguration.PaymentDays,
parameters.PayrollCompanyConfiguration.AdjustmentPay, forceUpdate, parameters.PayrollCompanyConfiguration.WeeklySeventhDay));
//Extraordinario
forceUpdate = parameters.PayrollCompanyConfiguration.PaymentPeriodicity == PaymentPeriodicity.OtherPeriodicity;
lstPeriodTypes.AddRange(memoryTest.GetDefaultPeriodType(companyID, instanceID, user,
PaymentPeriodicity.OtherPeriodicity,
parameters.PayrollCompanyConfiguration.PaymentDays,
parameters.PayrollCompanyConfiguration.AdjustmentPay, forceUpdate));
var middlewareManager = new MiddlewareManager <PeriodType>(new BaseRecordManager <PeriodType>(),
new PeriodTypeValidator());
await middlewareManager.CreateAsync(lstPeriodTypes, companyID);
return(lstPeriodTypes);
}
public void TestStorageMapWithNestedList()
{
var context = new MemoryStorageContext();
var list = new StorageList("list".AsByteArray(), context);
Assert.IsTrue(list.Count() == 0);
var map = new StorageMap("map".AsByteArray(), context);
Assert.IsTrue(map.Count() == 0);
int key = 123;
map.Set(key, list);
list.Add("hello");
list.Add("world");
var count = list.Count();
Assert.IsTrue(count == 2);
count = map.Count();
Assert.IsTrue(count == 1);
int otherKey = 21;
var other = map.Get <int, StorageList>(otherKey);
Assert.IsTrue(other.Count() == 0);
var another = map.Get <int, StorageList>(key);
count = another.Count();
Assert.IsTrue(count == 2);
// note: here we remove from one list and count the other, should be same since both are references to same storage list
another.RemoveAt(0);
count = list.Count();
Assert.IsTrue(count == 1);
}
