// If deposits are eligable to refund (deposit is expired / consumer hasn't consumed all units yet etc.) // background proccessor will try to refund them every single block proccesed. public void Will_try_to_refund_deposit_while_expired_and_not_consumed() { _processor.Init(); var blockProccesed = Build.A.Block.TestObject; _accountService.GetAddress().Returns(TestItem.AddressB); var dataAsset = new DataAsset(Keccak.OfAnEmptyString, "test", "test", 1, DataAssetUnitType.Unit, 0, 10, new DataAssetRules(new DataAssetRule(1)), new DataAssetProvider(Address.Zero, "test")); _refundClaimant.TryClaimEarlyRefundAsync(Arg.Any <DepositDetails>(), TestItem.AddressB) .Returns(new RefundClaimStatus(Keccak.Zero, true)); var consumedDeposit = new Deposit(Keccak.Zero, 10, 1, 1); var consumedDepositDetails = new DepositDetails(consumedDeposit, dataAsset, null, null, 1, null); consumedDepositDetails.SetConsumedUnits(9); var refundsResult = PagedResult <DepositDetails> .Create( new List <DepositDetails> { consumedDepositDetails }, 1, 1, 1, 1); _depositRepository.BrowseAsync(Arg.Any <GetDeposits>()).Returns(Task.FromResult(refundsResult)); _blockProcessor.BlockProcessed += Raise.EventWith(new BlockProcessedEventArgs(blockProccesed, Array.Empty <TxReceipt>())); _consumerNotifier.Received().SendClaimedEarlyRefundAsync(Arg.Any <Keccak>(), Arg.Any <string>(), Arg.Any <Keccak>()); }
private static DepositDetails BuildDummyDepositDetails() { Deposit deposit = new Deposit(TestItem.KeccakA, 100, 100, 100); DataAssetProvider provider = new DataAssetProvider(TestItem.AddressA, "provider"); DataAsset dataAsset = new DataAsset(TestItem.KeccakA, "data_asset", "desc", 1, DataAssetUnitType.Time, 1000, 10000, new DataAssetRules(new DataAssetRule(1), null), provider, null, QueryType.Stream, DataAssetState.Published, null, false, null); DepositDetails details = new DepositDetails( deposit, dataAsset, TestItem.AddressA, Array.Empty <byte>(), 10, Array.Empty <TransactionInfo>(), 9, false, false, null, Array.Empty <TransactionInfo>(), false, false, null, 0, 6); return(details); }
public void AllFinished() { finishcount++; if (finishcount != 10) { return; } for (int i = 0; i < cars.Length; i++) { cars[i].RunStop(); ranking[i, 0] = i; ranking[i, 1] = cars[i].score; cars[i].transform.position = carPos.position; cars[i].transform.rotation = carPos.rotation; } SortRancing(); father = dataAsset[ranking[0, 0]]; mother = dataAsset[ranking[1, 0]]; for (int i = 0; i < 10; i++) { cars[i].score = 0; cars[i].ItemClear(); } CrossOver(); Mutate(); generation++; mmui.GenTxt("Gen: " + generation); if (mmui.myui.istogglevalue == true) { AllRun(); } }
IResourceSource <Texture2D> MakeResourceSource(DataAsset resource) { if (resource == null) { return(null); } return(new AssetResourceSource <Texture2D>(resource)); }
public void SendDataAsset(DataAsset dataAsset) { if (Logger.IsTrace) { Logger.Trace($"{Session.RemoteNodeId} NDM sending: dataasset"); } Send(new DataAssetMessage(dataAsset)); }
public void Setup() { DataAssetProvider provider = new DataAssetProvider(_providerAddress, "provider"); _asset = new DataAsset(Keccak.Compute("1"), "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Published); _deposit = new Deposit(Keccak.Zero, 1, 2, 3); _details = new DepositDetails(_deposit, _asset, Address.Zero, new byte[0], 1, new TransactionInfo[0]); }
public async Task Can_browse() { IMongoDatabase database = MongoForTest.Provider.GetDatabase(); var repo = new DataAssetMongoRepository(database); DataAsset dataAsset = BuildDummyDataAsset(); await repo.AddAsync(dataAsset); await repo.BrowseAsync(new GetDataAssets()); }
public async Task Can_check_if_exists() { IMongoDatabase database = MongoForTest.Provider.GetDatabase(); var repo = new DataAssetMongoRepository(database); DataAsset dataAsset = BuildDummyDataAsset(); await repo.AddAsync(dataAsset); (await repo.ExistsAsync(dataAsset.Id)).Should().BeTrue(); }
public Consumer(Keccak depositId, uint verificationTimestamp, DataRequest dataRequest, DataAsset dataAsset, bool hasAvailableUnits = true) { DepositId = depositId; VerificationTimestamp = verificationTimestamp; DataRequest = dataRequest; DataAsset = dataAsset; HasAvailableUnits = hasAvailableUnits; }
public void Setup() { DataAssetProvider provider = new DataAssetProvider(_providerAddress, "provider"); _asset = new DataAsset(Keccak.Compute("1"), "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Published); IConsumerDepositApprovalRepository repository = new ConsumerDepositApprovalInMemoryRepository(); _kycVerifier = new KycVerifier(repository, LimboLogs.Instance); }
public async Task Can_get_by_id() { IMongoDatabase database = MongoForTest.Provider.GetDatabase(); var repo = new DataAssetMongoRepository(database); DataAsset dataAsset = BuildDummyDataAsset(); await repo.AddAsync(dataAsset); DataAsset result = await repo.GetAsync(dataAsset.Id); result.Should().BeEquivalentTo(dataAsset); }
public async Task Can_browse_null_query() { IMongoDatabase database = MongoForTest.Provider.GetDatabase(); var repo = new DataAssetMongoRepository(database); DataAsset dataAsset = BuildDummyDataAsset(); await repo.AddAsync(dataAsset); var result = await repo.BrowseAsync(null); result.Items.Should().HaveCount(0); }
private void Init() { mMesh = new Mesh(); mMesh.name = "Cylinder Quad"; GetComponent <MeshFilter> ().sharedMesh = mMesh; if (!File.Exists("Assets/CircularData.asset")) { m_CircleData = ScriptableObject.CreateInstance <DataAsset> (); List <Vertex> vertices = new List <Vertex> (); for (int i = 0; i < m_FaceDetailLevel; i++) { float t = i / (float)m_FaceDetailLevel; float angleInRad = t * Maths.TAU; Vertex currentPoint = new Vertex(); currentPoint.points.x = Mathf.Cos(angleInRad) * m_Radius; currentPoint.points.y = Mathf.Sin(angleInRad) * m_Radius; currentPoint.normals = currentPoint.points.normalized; //2 because of hard edge vertices.Add(currentPoint); Vertex oppPoint = new Vertex(); oppPoint.points = currentPoint.points; oppPoint.normals = -currentPoint.normals; vertices.Add(oppPoint); // Vertex nextPoint = new Vertex (); // nextPoint.points = currentPoint.points; // nextPoint.normals = new Vector2 (Mathf.Cos (angleInRad + (Maths.TAU / 4)), Mathf.Sin (angleInRad + (Maths.TAU / 4))); // vertices.Add (currentPoint); } List <int> lineIndices = new List <int> (); for (int i = 0; i < m_FaceDetailLevel * 2; i++) { lineIndices.Add((i + 1) % (m_FaceDetailLevel * 2)); } m_CircleData.vertices = vertices.ToArray(); m_CircleData.lineIndices = lineIndices.ToArray(); AssetDatabase.CreateAsset(m_CircleData, "Assets/CircularData.asset"); } else { m_CircleData = AssetDatabase.LoadAssetAtPath <DataAsset> ("Assets/CircularData.asset"); } }
/// <summary> Called when the data provider is selected </summary> public override void NfoFieldFocus(plyDataObject data, EditorWindow ed) { // make sure the Component that handles the Rewards is registered to be added to DiaQ EdGlobal.RemoveAutoComponent("DiaQ", typeof(plyRPGDiaQRewardHandler).AssemblyQualifiedName); // make sure old one is not present as it causes problems EdGlobal.RegisterAutoComponent("DiaQ", typeof(InventoryProDiaQRewardHandler).AssemblyQualifiedName); _selected = 0; int.TryParse(data.nfo[0], out _selected); if (_attribsAsset == null) { if (_dataAsset == null) { _dataAsset = EdGlobal.GetDataAsset(); } _attribsAsset = (ActorAttributesAsset)_dataAsset.GetAsset <ActorAttributesAsset>(); if (_attribsAsset == null) { _attribsAsset = (ActorAttributesAsset)EdGlobal.LoadOrCreateAsset <ActorAttributesAsset>(plyEdUtil.DATA_PATH_SYSTEM + "attributes.asset", null); } } if (_itemsAsset == null) { if (_dataAsset == null) { _dataAsset = EdGlobal.GetDataAsset(); } _itemsAsset = (ItemsAsset)_dataAsset.GetAsset <ItemsAsset>(); if (_itemsAsset == null) { _itemsAsset = (ItemsAsset)EdGlobal.LoadOrCreateAsset <ItemsAsset>(plyEdUtil.DATA_PATH_SYSTEM + "items.asset", null); } _itemsAsset.UpdateItemCache(); } _selectedIdent = -1; _attribNames = new string[_attribsAsset.attributes.Count]; for (int i = 0; i < _attribsAsset.attributes.Count; i++) { _attribNames[i] = _attribsAsset.attributes[i].def.screenName; if (_selected == 1 && _selectedIdent < 0) { if (data.nfo[1].Equals(_attribsAsset.attributes[i].id.ToString())) { _selectedIdent = i; data.nfo[2] = _attribsAsset.attributes[_selectedIdent].ToString(); // update cached name just in case it has changed GUI.changed = true; } } } }
public void Message_have_valid_protocol_and_can_serialize_and_deserialize() { DataAsset dataAsset = new DataAsset(Keccak.OfAnEmptyString, "name", "description", 1, DataAssetUnitType.Time, 1000, 10000, new DataAssetRules(new DataAssetRule(1), new DataAssetRule(2)), new DataAssetProvider(Address.SystemUser, "provider")); Signature signature = new Signature(UInt256.One, UInt256.One, 27); Session session = new Session(Keccak.EmptyTreeHash, Keccak.OfAnEmptyString, Keccak.OfAnEmptySequenceRlp, Address.SystemUser, TestItem.PublicKeyA, TestItem.AddressB, TestItem.PublicKeyB, SessionState.ProviderDisconnected, 1, 2, 3, 4, 5, 6, 7, 8); Test(new ConsumerAddressChangedMessage(Address.SystemUser)); Test(new DataAssetDataMessage(Keccak.OfAnEmptySequenceRlp, "client", "data", 1)); Test(new DataAssetMessage(dataAsset)); Test(new DataAssetRemovedMessage(Keccak.OfAnEmptyString)); Test(new DataAssetsMessage(new[] { dataAsset, dataAsset })); Test(new DataAssetStateChangedMessage(Keccak.OfAnEmptyString, DataAssetState.Archived)); Test(new DataAssetStateChangedMessage(Keccak.OfAnEmptyString, DataAssetState.UnderMaintenance)); Test(new DataAssetStateChangedMessage(Keccak.OfAnEmptyString, DataAssetState.Unavailable)); Test(new DataAssetStateChangedMessage(Keccak.OfAnEmptyString, DataAssetState.Published)); Test(new DataAssetStateChangedMessage(Keccak.OfAnEmptyString, DataAssetState.Unpublished)); Test(new DataAvailabilityMessage(Keccak.OfAnEmptyString, DataAvailability.Available)); Test(new DataAvailabilityMessage(Keccak.OfAnEmptyString, DataAvailability.Unknown)); Test(new DataAvailabilityMessage(Keccak.OfAnEmptyString, DataAvailability.SubscriptionEnded)); Test(new DataAvailabilityMessage(Keccak.OfAnEmptyString, DataAvailability.UnitsExceeded)); Test(new DataAvailabilityMessage(Keccak.OfAnEmptyString, DataAvailability.ExpiryRuleExceeded)); Test(new DataAvailabilityMessage(Keccak.OfAnEmptyString, DataAvailability.DataDeliveryReceiptInvalid)); Test(new DataAvailabilityMessage(Keccak.OfAnEmptyString, DataAvailability.DataDeliveryReceiptNotProvided)); Test(new DataDeliveryReceiptMessage(Keccak.OfAnEmptyString, new DataDeliveryReceipt(StatusCodes.Error, 1, 2, signature))); Test(new DataRequestMessage(new DataRequest(Keccak.OfAnEmptyString, 1, 2, 3, new byte[] { 4 }, Address.SystemUser, TestItem.AddressA, signature), 5)); Test(new DataRequestResultMessage(Keccak.OfAnEmptyString, DataRequestResult.DepositUnverified)); Test(new DataStreamDisabledMessage(Keccak.OfAnEmptyString, "client")); Test(new DataStreamEnabledMessage(Keccak.OfAnEmptyString, "client", new string[] { "a", "b", "c" })); Test(new DepositApprovalConfirmedMessage(Keccak.OfAnEmptyString, Address.SystemUser)); Test(new DepositApprovalRejectedMessage(Keccak.OfAnEmptyString, Address.SystemUser)); Test(new DepositApprovalsMessage(new DepositApproval[] { new DepositApproval(Keccak.EmptyTreeHash, Keccak.OfAnEmptyString, "asset", "kyc", Address.SystemUser, TestItem.AddressA, 1, DepositApprovalState.Confirmed) })); Test(new DisableDataStreamMessage(Keccak.OfAnEmptyString, "client")); Test(new EarlyRefundTicketMessage(new EarlyRefundTicket(Keccak.OfAnEmptyString, 1, signature), RefundReason.InvalidDataAsset)); Test(new EnableDataStreamMessage(Keccak.OfAnEmptyString, "client", new string[] { "a", "b", "c" })); Test(new EthRequestedMessage(new FaucetResponse(FaucetRequestStatus.FaucetDisabled, FaucetRequestDetails.Empty))); Test(new FinishSessionMessage(Keccak.OfAnEmptyString)); Test(new GetDataAssetsMessage()); Test(new GetDepositApprovalsMessage()); Test(new GraceUnitsExceededMessage(Keccak.EmptyTreeHash, 1, 2)); Test(new HiMessage(1, TestItem.AddressA, TestItem.AddressB, TestItem.PublicKeyA, signature)); Test(new InvalidDataMessage(Keccak.OfAnEmptyString, InvalidDataReason.InvalidResult)); Test(new ProviderAddressChangedMessage(Address.SystemUser)); Test(new RequestDataDeliveryReceiptMessage(new DataDeliveryReceiptRequest(1, Keccak.OfAnEmptyString, new UnitsRange(2, 3), true, new [] { new DataDeliveryReceiptToMerge(new UnitsRange(7, 8), signature) }))); Test(new RequestDepositApprovalMessage(Keccak.OfAnEmptyString, Address.SystemUser, "kyc")); Test(new RequestEthMessage(Address.SystemUser, UInt256.One)); Test(new SessionFinishedMessage(session)); Test(new SessionStartedMessage(session)); }
public async Task Can_browse_with_query_and_pagination() { IMongoDatabase database = MongoForTest.Provider.GetDatabase(); var repo = new DataAssetMongoRepository(database); DataAsset dataAsset = BuildDummyDataAsset(); await repo.AddAsync(dataAsset); GetDataAssets query = new GetDataAssets(); query.OnlyPublishable = true; query.Page = 0; query.Results = 10; await repo.BrowseAsync(query); }
public async Task Can_remove_async() { IMongoDatabase database = MongoForTest.Provider.GetDatabase(); var repo = new DataAssetMongoRepository(database); DataAsset dataAsset = BuildDummyDataAsset(); await repo.AddAsync(dataAsset); await repo.RemoveAsync(dataAsset.Id); (await repo.ExistsAsync(dataAsset.Id)).Should().BeFalse(); DataAsset result = await repo.GetAsync(dataAsset.Id); result.Should().BeNull(); }
private DataAsset SetAssetsValues(string[] values) { DataAsset dataAsset = new DataAsset(); try { dataAsset.Product = values[0]; dataAsset.Asset = values[1]; } catch (Exception ex) { throw new DataAccessException(ex.Message, ex.InnerException); } return(dataAsset); }
public void Setup() { DataAssetProvider provider = new DataAssetProvider(_providerAddress, "provider"); _asset = new DataAsset(Keccak.Compute("1"), "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Published); _deposit = new Deposit(Keccak.Zero, 1, 2, 3); _details = new DepositDetails(_deposit, _asset, Address.Zero, new byte[0], 1, new TransactionInfo[0]); DepositDetailsInMemoryRepository repository = new DepositDetailsInMemoryRepository(new DepositsInMemoryDb()); repository.AddAsync(_details); ConsumerSessionInMemoryRepository sessionInMemoryRepository = new ConsumerSessionInMemoryRepository(); _depositProvider = new DepositProvider(repository, new DepositUnitsCalculator(sessionInMemoryRepository, Timestamper.Default), LimboLogs.Instance); }
public DataAssetForRpc(DataAsset dataAsset) { Id = dataAsset.Id; Name = dataAsset.Name; Description = dataAsset.Description; UnitPrice = dataAsset.UnitPrice; UnitType = dataAsset.UnitType.ToString().ToLowerInvariant(); QueryType = dataAsset.QueryType.ToString().ToLowerInvariant(); MinUnits = dataAsset.MinUnits; MaxUnits = dataAsset.MaxUnits; Rules = new DataAssetRulesForRpc(dataAsset.Rules); Provider = new DataAssetProviderForRpc(dataAsset.Provider); File = dataAsset.File; State = dataAsset.State.ToString().ToLowerInvariant(); TermsAndConditions = dataAsset.TermsAndConditions; KycRequired = dataAsset.KycRequired; Plugin = dataAsset.Plugin; }
public void Setup() { IConsumerNotifier notifier = new ConsumerNotifier(Substitute.For <INdmNotifier>()); DepositsInMemoryDb db = new DepositsInMemoryDb(); IProviderRepository providerRepository = new ProviderInMemoryRepository(db); DataAssetProvider provider = new DataAssetProvider(_providerAddress, "provider"); DataAssetService dataAssetService = new DataAssetService(providerRepository, notifier, LimboLogs.Instance); _asset1 = new DataAsset(_asset1Id, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1), new DataAssetRule(100)), provider, state: DataAssetState.Published); dataAssetService.AddDiscovered(_asset1, _ndmPeer); _deposit1 = new Deposit(_deposit1Id, 1, 2, 3); _details1 = new DepositDetails(_deposit1, _asset1, Address.Zero, new byte[0], 1, new TransactionInfo[0], 1); _asset2 = new DataAsset(_asset2Id, "name", "desc", 1, DataAssetUnitType.Time, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Published); dataAssetService.AddDiscovered(_asset2, _ndmPeer); _deposit2 = new Deposit(_deposit2Id, 1, 2, 3); _details2 = new DepositDetails(_deposit2, _asset2, Address.Zero, new byte[0], 1, new TransactionInfo[0], 2); _closed = new DataAsset(_closedId, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Closed); dataAssetService.AddDiscovered(_closed, _ndmPeer); _depositForClosed = new Deposit(_depositForClosedId, 1, 2, 3); _depositForClosedDetails = new DepositDetails(_depositForClosed, _closed, Address.Zero, new byte[0], 1, new TransactionInfo[0]); _missingAsset = new DataAsset(_missingAssetId, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Published); _depositForMissing = new Deposit(_depositForMissingId, 1, 2, 3); _depositForMissingDetails = new DepositDetails(_depositForMissing, _missingAsset, Address.Zero, new byte[0], 1, new TransactionInfo[0]); IDepositProvider depositProvider = Substitute.For <IDepositProvider>(); depositProvider.GetAsync(_deposit1Id).Returns(_details1); depositProvider.GetAsync(_deposit2Id).Returns(_details2); depositProvider.GetAsync(_depositForMissingId).Returns(_depositForMissingDetails); depositProvider.GetAsync(_depositForClosedId).Returns(_depositForClosedDetails); _ndmPeer = Substitute.For <INdmPeer>(); _ndmPeer.ProviderAddress.Returns(_providerAddress); _ndmPeer.NodeId.Returns(_providerNodeId); _providerService = new ProviderService(providerRepository, notifier, LimboLogs.Instance); _providerService.Add(_ndmPeer); _sessionRepository = new ConsumerSessionInMemoryRepository(); _sessionService = new SessionService(_providerService, depositProvider, dataAssetService, _sessionRepository, Timestamper.Default, notifier, LimboLogs.Instance); }
public void Setup() { DataAssetProvider provider = new DataAssetProvider(_providerAddress, "provider"); _asset = new DataAsset(Keccak.Compute("1"), "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Published); _closedAsset = new DataAsset(Keccak.Compute("2"), "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Closed); _assetUnderMaintenance = new DataAsset(Keccak.Compute("3"), "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.UnderMaintenance); _withKyc = new DataAsset(Keccak.Compute("4"), "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Published, kycRequired: true); _deposit = new Deposit(Keccak.Zero, 1, 2, 3); _details = new DepositDetails(_deposit, _asset, Address.Zero, new byte[0], 1, new TransactionInfo[0]); INdmBlockchainBridge blockchainBridge = BlockchainBridgeBuilder.BuildABridge(); _wallet = new DevWallet(new WalletConfig(), LimboLogs.Instance); DepositService depositService = new DepositService(blockchainBridge, new AbiEncoder(), _wallet, Address.Zero); IConsumerSessionRepository sessionRepository = new ConsumerSessionInMemoryRepository(); DepositUnitsCalculator unitsCalculator = new DepositUnitsCalculator(sessionRepository, Timestamper.Default); DepositsInMemoryDb depositsInMemoryDb = new DepositsInMemoryDb(); depositsInMemoryDb.Add(_details); IProviderRepository providerRepository = new ProviderInMemoryRepository(depositsInMemoryDb); IConsumerNotifier notifier = new ConsumerNotifier(Substitute.For <INdmNotifier>()); DataAssetService dataAssetService = new DataAssetService(providerRepository, notifier, LimboLogs.Instance); IDepositUnitsCalculator depositUnitsCalculator = Substitute.For <IDepositUnitsCalculator>(); INdmPeer peer = Substitute.For <INdmPeer>(); peer.NodeId.Returns(TestItem.PublicKeyB); peer.ProviderAddress.Returns(_providerAddress); dataAssetService.AddDiscovered(_asset, peer); dataAssetService.AddDiscovered(_closedAsset, peer); dataAssetService.AddDiscovered(_assetUnderMaintenance, peer); dataAssetService.AddDiscovered(_withKyc, peer); _kycVerifier = Substitute.For <IKycVerifier>(); ProviderService providerService = new ProviderService(providerRepository, notifier, LimboLogs.Instance); providerService.Add(peer); _depositManager = new DepositManager(depositService, unitsCalculator, dataAssetService, _kycVerifier, providerService, new AbiEncoder(), new CryptoRandom(), _wallet, Substitute.For <IGasPriceService>(), new DepositDetailsInMemoryRepository(depositsInMemoryDb, depositUnitsCalculator), Timestamper.Default, LimboLogs.Instance, 6, false); }
public void Setup() { INdmPeer peer = Substitute.For <INdmPeer>(); peer.ProviderAddress.Returns(_providerAddress); _providerId = TestItem.PublicKeyB; peer.NodeId.Returns(_providerId); DataAssetProvider provider = new DataAssetProvider(_providerAddress, "name"); DataAsset newPendingAsset = new DataAsset(_newPendingAssetId, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1), null), provider); DataAsset pendingAsset = new DataAsset(_pendingAssetId, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1), null), provider); DataAsset rejectedAsset = new DataAsset(_rejectedAssetId, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1), null), provider); DataAsset confirmedAsset = new DataAsset(_confirmedAssetId, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1), null), provider); DepositsInMemoryDb db = new DepositsInMemoryDb(); ProviderInMemoryRepository providerRepository = new ProviderInMemoryRepository(db); _cdaRepo = new ConsumerDepositApprovalInMemoryRepository(); _ndmNotifier = Substitute.For <INdmNotifier>(); ConsumerNotifier notifier = new ConsumerNotifier(_ndmNotifier); DataAssetService dataAssetService = new DataAssetService(providerRepository, notifier, LimboLogs.Instance); dataAssetService.AddDiscovered(newPendingAsset, peer); dataAssetService.AddDiscovered(pendingAsset, peer); dataAssetService.AddDiscovered(rejectedAsset, peer); dataAssetService.AddDiscovered(confirmedAsset, peer); _providerService = new ProviderService(providerRepository, notifier, LimboLogs.Instance); _providerService.Add(peer); _service = new DepositApprovalService(dataAssetService, _providerService, _cdaRepo, Timestamper.Default, notifier, LimboLogs.Instance); _confirmedApproval = new DepositApproval(Keccak.Compute(Rlp.Encode(Rlp.Encode(_confirmedAssetId), Rlp.Encode(_consumerAddress)).Bytes), _confirmedAssetId, "asset", "kyc", _consumerAddress, _providerAddress, 1, DepositApprovalState.Confirmed); _pendingApproval = new DepositApproval(Keccak.Compute(Rlp.Encode(Rlp.Encode(_pendingAssetId), Rlp.Encode(_consumerAddress)).Bytes), _pendingAssetId, "asset", "kyc", _consumerAddress, _providerAddress, 1, DepositApprovalState.Pending); _rejectedApproval = new DepositApproval(Keccak.Compute(Rlp.Encode(Rlp.Encode(_rejectedAssetId), Rlp.Encode(_consumerAddress)).Bytes), _rejectedAssetId, "asset", "kyc", _consumerAddress, _providerAddress, 1, DepositApprovalState.Rejected); _cdaRepo.AddAsync(_confirmedApproval); _cdaRepo.AddAsync(_pendingApproval); _cdaRepo.AddAsync(_rejectedApproval); }
public DepositDetails(Deposit deposit, DataAsset dataAsset, Address consumer, byte[] pepper, uint timestamp, Keccak transactionHash, uint confirmationTimestamp = 0, bool rejected = false, EarlyRefundTicket earlyRefundTicket = null, Keccak claimedRefundTransactionHash = null, bool refundClaimed = false, string kyc = null, uint confirmations = 0, uint requiredConfirmations = 0) { Id = deposit.Id; Deposit = deposit; DataAsset = dataAsset; Consumer = consumer; Pepper = pepper; Timestamp = timestamp; TransactionHash = transactionHash; SetConfirmationTimestamp(confirmationTimestamp); Rejected = rejected; EarlyRefundTicket = earlyRefundTicket; SetClaimedRefundTransactionHash(claimedRefundTransactionHash); RefundClaimed = refundClaimed; Kyc = kyc; Confirmations = confirmations; RequiredConfirmations = requiredConfirmations; }
public void Setup() { DataAssetProvider provider = new DataAssetProvider(_providerAddress, "provider"); _asset = new DataAsset(Keccak.Compute("1"), "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Published); _deposit = new Deposit(Keccak.Zero, 1, 2, 3); _details = new DepositDetails(_deposit, _asset, Address.Zero, new byte[0], 1, new TransactionInfo[0]); IAccountService accountService = Substitute.For <IAccountService>(); IRefundClaimant refundClaimant = Substitute.For <IRefundClaimant>(); IDepositConfirmationService depositConfirmationService = Substitute.For <IDepositConfirmationService>(); IEthPriceService ethPriceService = Substitute.For <IEthPriceService>(); IGasPriceService gasPriceService = Substitute.For <IGasPriceService>(); _blockProcessor = Substitute.For <IBlockProcessor>(); IConsumerNotifier notifier = new ConsumerNotifier(Substitute.For <INdmNotifier>()); IDepositDetailsRepository repository = new DepositDetailsInMemoryRepository(new DepositsInMemoryDb()); repository.AddAsync(_details); _processor = new ConsumerServicesBackgroundProcessor(accountService, refundClaimant, depositConfirmationService, ethPriceService, gasPriceService, _blockProcessor, repository, notifier, LimboLogs.Instance); }
public DepositDetails(Deposit deposit, DataAsset dataAsset, Address consumer, byte[] pepper, uint timestamp, TransactionInfo transaction, uint confirmationTimestamp = 0, bool rejected = false, EarlyRefundTicket earlyRefundTicket = null, TransactionInfo claimedRefundTransaction = null, bool refundClaimed = false, string kyc = null, uint confirmations = 0, uint requiredConfirmations = 0) { Id = deposit.Id; Deposit = deposit; DataAsset = dataAsset; Consumer = consumer; Pepper = pepper; Timestamp = timestamp; Transaction = transaction; ConfirmationTimestamp = confirmationTimestamp; Rejected = rejected; EarlyRefundTicket = earlyRefundTicket; ClaimedRefundTransaction = claimedRefundTransaction; RefundClaimed = refundClaimed; Kyc = kyc; Confirmations = confirmations; RequiredConfirmations = requiredConfirmations; }
private DepositDetails CreateDeposit(DataAssetUnitType type) { var deposit = new Deposit(Keccak.Zero, units: 100, expiryTime: 100, value: 10); var dataAsset = new DataAsset(Keccak.OfAnEmptyString, name: "TestAsset", description: "Test", unitPrice: 10, unitType: type, minUnits: 1, maxUnits: 100, rules: new DataAssetRules(new DataAssetRule(1)), provider: new DataAssetProvider(TestItem.AddressA, "provider")); return(new DepositDetails(deposit, dataAsset, consumer: TestItem.AddressB, pepper: Array.Empty <byte>(), timestamp: 50, transactions: Array.Empty <TransactionInfo>())); }
public DepositDetails Decode(RlpStream rlpStream, RlpBehaviors rlpBehaviors = RlpBehaviors.None) { rlpStream.ReadSequenceLength(); Deposit deposit = Serialization.Rlp.Rlp.Decode <Deposit>(rlpStream); DataAsset dataAsset = Serialization.Rlp.Rlp.Decode <DataAsset>(rlpStream); Address consumer = rlpStream.DecodeAddress(); var pepper = rlpStream.DecodeByteArray(); uint timestamp = rlpStream.DecodeUInt(); var transactions = Serialization.Rlp.Rlp.DecodeArray <TransactionInfo>(rlpStream); uint confirmationTimestamp = rlpStream.DecodeUInt(); bool rejected = rlpStream.DecodeBool(); bool cancelled = rlpStream.DecodeBool(); EarlyRefundTicket earlyRefundTicket = Serialization.Rlp.Rlp.Decode <EarlyRefundTicket>(rlpStream); var claimedRefundTransactions = Serialization.Rlp.Rlp.DecodeArray <TransactionInfo>(rlpStream); bool refundClaimed = rlpStream.DecodeBool(); bool refundCancelled = rlpStream.DecodeBool(); string kyc = rlpStream.DecodeString(); uint confirmations = rlpStream.DecodeUInt(); uint requiredConfirmations = rlpStream.DecodeUInt(); return(new DepositDetails(deposit, dataAsset, consumer, pepper, timestamp, transactions, confirmationTimestamp, rejected, cancelled, earlyRefundTicket, claimedRefundTransactions, refundClaimed, refundCancelled, kyc, confirmations, requiredConfirmations)); }
public void AddDiscoveredDataAsset(DataAsset dataAsset, INdmPeer peer) => _dataAssetService.AddDiscovered(dataAsset, peer);
internal void ReadParameters(AssetLoader loader, FolderAsset textureFolder) { var reader = loader.Reader; int startIndex = ParameterStartIndex; for (int index = 0; index < ParameterCount; index++) { ParametersList.Add(new ModelMaterialParameter(this, index, startIndex + index, loader)); } if (textureFolder != null) { foreach (ModelMaterialParameter parameter in Parameters) { if (string.IsNullOrEmpty(parameter.Value)) { continue; } string name = Path.GetFileNameWithoutExtension(parameter.Value); DataAsset resource = null; foreach (DataAsset archiveAsset in textureFolder.Children) { var extension = Path.GetExtension(archiveAsset.Name); if (extension != ".tpf" && extension != ".tpfbhd") { continue; } FolderAsset archive = archiveAsset.Contents as FolderAsset; if (archive == null) { continue; } foreach (DataAsset compare in archive.Children) { if (compare.Name.StartsWith(name) && (compare.Name.Length == name.Length || compare.Name[name.Length] == '.')) { if (compare.Name.EndsWith(".tpf.dcx")) { FolderAsset textureArchive = (FolderAsset)compare.Contents; resource = (DataAsset)textureArchive.Children[0]; } else { resource = compare; } break; } } if (resource != null) { break; } } parameter.TextureSource = MakeResourceSource(resource); /*if (parameter.Name == "g_Diffuse") * ModelMaterial.DiffuseMap = MakeResourceSource(resource); * else if (parameter.Name == "g_Specular") * ModelMaterial.SpecularMap = MakeResourceSource(resource); * else if (parameter.Name == "g_Bumpmap") * ModelMaterial.NormalMap = MakeResourceSource(resource);*/ } } }
/// <summary> Called when the data provider is selected </summary> public override void NfoFieldFocus(plyDataObject data, EditorWindow ed) { // make sure the Component that handles the Rewards is registered to be added to DiaQ EdGlobal.RegisterAutoComponent("DiaQ", "plyRPGDiaQRewardHandler"); selected = 0; int.TryParse(data.nfo[0], out selected); if (attribsAsset == null) { if (dataAsset == null) dataAsset = EdGlobal.GetDataAsset(); attribsAsset = (ActorAttributesAsset)dataAsset.GetAsset<ActorAttributesAsset>(); if (attribsAsset == null) attribsAsset = (ActorAttributesAsset)EdGlobal.LoadOrCreateAsset<ActorAttributesAsset>(EdGlobal.DATA_PATH_SYSTEM + "attributes.asset", null); } if (itemsAsset == null) { if (dataAsset == null) dataAsset = EdGlobal.GetDataAsset(); itemsAsset = (ItemsAsset)dataAsset.GetAsset<ItemsAsset>(); if (itemsAsset == null) itemsAsset = (ItemsAsset)EdGlobal.LoadOrCreateAsset<ItemsAsset>(EdGlobal.DATA_PATH_SYSTEM + "items.asset", null); itemsAsset.UpdateItemCache(); } selectedIdent = -1; attribNames = new string[attribsAsset.attributes.Count]; for (int i = 0; i < attribsAsset.attributes.Count; i++) { attribNames[i] = attribsAsset.attributes[i].def.screenName; if (selected == 1 && selectedIdent < 0) { if (data.nfo[1].Equals(attribsAsset.attributes[i].id.ToString())) { selectedIdent = i; data.nfo[2] = attribsAsset.attributes[selectedIdent].def.screenName; // update cached name just in case it has changed GUI.changed = true; } } } if (data.nfo[0] == "2") { if (null == itemsAsset.GetDefinition(new UniqueID(data.nfo[1]))) { data.nfo[1] = ""; data.nfo[2] = ""; GUI.changed = true; } } }
/// <summary> Called when the data provider is selected </summary> public override void NfoFieldFocus(plyDataObject data, EditorWindow ed) { // make sure the Component that handles the Rewards is registered to be added to DiaQ EdGlobal.RemoveAutoComponent("DiaQ", typeof(plyRPGDiaQRewardHandler).AssemblyQualifiedName); // make sure old one is not present as it causes problems EdGlobal.RegisterAutoComponent("DiaQ", typeof(InventoryProDiaQRewardHandler).AssemblyQualifiedName); selected = 0; int.TryParse(data.nfo[0], out selected); if (attribsAsset == null) { if (dataAsset == null) dataAsset = EdGlobal.GetDataAsset(); attribsAsset = (ActorAttributesAsset)dataAsset.GetAsset<ActorAttributesAsset>(); if (attribsAsset == null) attribsAsset = (ActorAttributesAsset)EdGlobal.LoadOrCreateAsset<ActorAttributesAsset>(plyEdUtil.DATA_PATH_SYSTEM + "attributes.asset", null); } if (itemsAsset == null) { if (dataAsset == null) dataAsset = EdGlobal.GetDataAsset(); itemsAsset = (ItemsAsset)dataAsset.GetAsset<ItemsAsset>(); if (itemsAsset == null) itemsAsset = (ItemsAsset)EdGlobal.LoadOrCreateAsset<ItemsAsset>(plyEdUtil.DATA_PATH_SYSTEM + "items.asset", null); itemsAsset.UpdateItemCache(); } selectedIdent = -1; attribNames = new string[attribsAsset.attributes.Count]; for (int i = 0; i < attribsAsset.attributes.Count; i++) { attribNames[i] = attribsAsset.attributes[i].def.screenName; if (selected == 1 && selectedIdent < 0) { if (data.nfo[1].Equals(attribsAsset.attributes[i].id.ToString())) { selectedIdent = i; data.nfo[2] = attribsAsset.attributes[selectedIdent].ToString(); // update cached name just in case it has changed GUI.changed = true; } } } }