/// <summary> /// Creates a new transport operation. /// </summary> /// <param name="message">The message to dispatch.</param> /// <param name="addressTag">The address to use when routing this message.</param> /// <param name="requiredDispatchConsistency">The required consistency level for the dispatch operation.</param> /// <param name="deliveryConstraints">The delivery constraints that must be honored by the transport.</param> public TransportOperation(OutgoingMessage message, AddressTag addressTag, DispatchConsistency requiredDispatchConsistency = DispatchConsistency.Default, List <DeliveryConstraint> deliveryConstraints = null) { Message = message; AddressTag = addressTag; RequiredDispatchConsistency = requiredDispatchConsistency; DeliveryConstraints = deliveryConstraints ?? new List <DeliveryConstraint>(0); }
/// <summary> /// Coin to receive for the transaction. /// </summary> /// <param name="coinNumber">Number of the coin inside the transaction.</param> /// <param name="asset">Asset of the coin.</param> /// <param name="value">Coin value to receive.</param> /// <param name="address">Address which should receive the coin.</param> /// <param name="addressTag"> /// Optional. /// Receiving address tag. /// </param> /// <param name="addressTagType"> /// Optional. /// Type of the receiving address tag. /// </param> public CoinToReceive( int coinNumber, Asset asset, UMoney value, Address address, AddressTag addressTag = null, AddressTagType?addressTagType = null) { if (coinNumber < 0) { throw RequestValidationException.ShouldBeZeroOrPositiveNumber(coinNumber, nameof(coinNumber)); } if (addressTagType.HasValue && addressTag == null) { throw new RequestValidationException("If the tag type is specified, the tag should be specified too", new [] { nameof(addressTagType), nameof(addressTag) }); } CoinNumber = coinNumber; Asset = asset ?? throw RequestValidationException.ShouldBeNotNull(nameof(asset)); Value = value; Address = address ?? throw RequestValidationException.ShouldBeNotNull(nameof(address)); AddressTag = addressTag; AddressTagType = addressTagType; }
/// <summary> /// Received coin. /// </summary> /// <param name="coinNumber">Number of received coin in the transaction.</param> /// <param name="asset">Asset of the coin.</param> /// <param name="value">Value of the coin.</param> /// <param name="address"> /// Optional. /// Address which received the coin. /// </param> /// <param name="addressTag"> /// Optional. /// Tag of the receiving address. /// </param> /// <param name="addressTagType"> /// Optional. /// Type of the receiving address tag. /// </param> /// <param name="addressNonce"> /// Optional. /// Nonce number of the transaction for the receiving address. /// </param> public ReceivedCoin( int coinNumber, Asset asset, UMoney value, Address address = null, AddressTag addressTag = null, AddressTagType?addressTagType = null, long?addressNonce = null) { if (coinNumber < 0) { throw new ArgumentOutOfRangeException(nameof(coinNumber), coinNumber, "Should be zero or positive number"); } if (addressTag != null && address == null) { throw new ArgumentException("If the tag is specified, the address should be specified too"); } if (addressTagType.HasValue && addressTag == null) { throw new ArgumentException("If the tag type is specified, the tag should be specified too"); } CoinNumber = coinNumber; Asset = asset ?? throw new ArgumentNullException(nameof(asset)); Value = value; Address = address; AddressTag = addressTag; AddressTagType = addressTagType; AddressNonce = addressNonce; }
/// <summary> /// Creates a new transport operation. /// </summary> /// <param name="message">The message to dispatch.</param> /// <param name="addressTag">The address to use when routing this message.</param> /// <param name="requiredDispatchConsistency">The required consistency level for the dispatch operation.</param> /// <param name="properties">Delivery properties of the message.</param> public TransportOperation(OutgoingMessage message, AddressTag addressTag, DispatchProperties properties = null, DispatchConsistency requiredDispatchConsistency = DispatchConsistency.Default) { Message = message; AddressTag = addressTag; Properties = properties ?? new DispatchProperties(); RequiredDispatchConsistency = requiredDispatchConsistency; }
/// <summary> /// Creates a new transport operation. /// </summary> /// <param name="message">The message to dispatch.</param> /// <param name="addressTag">The address to use when routing this message.</param> /// <param name="requiredDispatchConsistency">The required consistency level for the dispatch operation.</param> /// <param name="deliveryConstraints">The delivery constraints that must be honored by the transport.</param> public TransportOperation(OutgoingMessage message, AddressTag addressTag, DispatchConsistency requiredDispatchConsistency = DispatchConsistency.Default, List<DeliveryConstraint> deliveryConstraints = null) { Message = message; AddressTag = addressTag; RequiredDispatchConsistency = requiredDispatchConsistency; DeliveryConstraints = deliveryConstraints ?? DeliveryConstraint.EmptyConstraints; }
/// <summary> /// Change of the address balance made by a transaction /// </summary> /// <param name="transferId"> /// ID of the transfer within the transaction. /// Can group several balance changing operations into the single transfer, /// or can be just the output number. /// </param> /// <param name="asset">Asset.</param> /// <param name="value"> /// Value for which the balance of the address was changed. /// Can be positive to increase the balance or negative to decrease the balance. /// </param> /// <param name="address"> /// Optional. /// Address. /// </param> /// <param name="tag"> /// Optional. /// Tag of the address. /// </param> /// <param name="tagType"> /// Optional. /// Type of the address tag. /// </param> /// <param name="nonce"> /// Optional. /// Nonce number of the transaction for the address. /// </param> public BalanceChange( string transferId, Asset asset, Money value, Address address = null, AddressTag tag = null, AddressTagType?tagType = null, long?nonce = null) { if (string.IsNullOrWhiteSpace(transferId)) { throw new ArgumentException("Should be not empty string", nameof(transferId)); } if (tag != null && address == null) { throw new ArgumentException("If the tag is specified, the address should be specified too"); } if (tagType.HasValue && tag == null) { throw new ArgumentException("If the tag type is specified, the tag should be specified too"); } TransferId = transferId; Asset = asset ?? throw new ArgumentNullException(nameof(asset)); Value = value; Address = address; Tag = tag; TagType = tagType; Nonce = nonce; }
TransportOperation RouteThroughLocalEndpointInstance(RoutingStrategy routingStrategy, IRoutingContext context) { Dictionary <string, string> headers = new Dictionary <string, string>(context.Message.Headers); AddressTag originalTag = routingStrategy.Apply(headers); UnicastAddressTag unicastTag = originalTag as UnicastAddressTag; if (unicastTag == null) { MulticastAddressTag multicastTag = originalTag as MulticastAddressTag; if (multicastTag != null) { headers["$.store-and-forward.eventtype"] = multicastTag.MessageType.AssemblyQualifiedName; } else { throw new Exception("Unsupported type of address tag: " + originalTag.GetType().FullName); } } else { headers["$.store-and-forward.destination"] = unicastTag.Destination; } OutgoingMessage message = new OutgoingMessage(context.Message.MessageId, headers, context.Message.Body); return(new TransportOperation(message, new UnicastAddressTag(localAddress), DispatchConsistency.Default, context.Extensions.GetDeliveryConstraints())); }
string Read(AddressTag addressTag) { if (addressTag is UnicastAddressTag u) { return($"Unicast: {u.Destination}"); } if (addressTag is MulticastAddressTag m) { return($"Multicast: {m.MessageType}"); } throw new ArgumentException( message: "addressTag is not a recognized address type", paramName: nameof(addressTag)); }
static void SerializeAddressTag(AddressTag addressTag, Dictionary <string, string> options) { if (addressTag is UnicastAddressTag direct) { options["Destination"] = direct.Destination; return; } if (addressTag is MulticastAddressTag) { throw new Exception("Token-based deduplication cannot be used with multicast routing."); } throw new Exception($"Unknown routing strategy {addressTag.GetType().FullName}"); }
static void SerializeRoutingStrategy(AddressTag addressTag, Dictionary <string, string> options) { if (addressTag is MulticastAddressTag indirect) { options["EventType"] = indirect.MessageType.AssemblyQualifiedName; return; } if (addressTag is UnicastAddressTag direct) { options["Destination"] = direct.Destination; return; } throw new Exception($"Unknown routing strategy {addressTag.GetType().FullName}"); }
public async Task <ActionResult <AddressValidityResponse> > Validate( [FromRoute] Address address, [FromQuery] AddressTagType?tagType = null, [FromQuery] AddressTag tag = null) { if (address == null) { throw RequestValidationException.ShouldBeNotNull(nameof(address)); } if (tagType.HasValue && tag == null) { throw new RequestValidationException("If the tag type is specified, the tag should be specified too", new [] { nameof(tagType), nameof(tag) }); } var response = await _addressValidator.ValidateAsync(address, tagType, tag); if (response == null) { throw new InvalidOperationException("Not null response object expected"); } return(Ok(response)); }
/// <summary> /// Transfer of the transaction. /// </summary> /// <param name="asset">Asset to transfer.</param> /// <param name="amount">Amount to transfer from the source address to the destination address.</param> /// <param name="sourceAddress">Address to transfer from.</param> /// <param name="destinationAddress">Address to transfer to.</param> /// <param name="sourceAddressContext"> /// Optional. /// Source address context associated with the address. /// </param> /// <param name="sourceAddressNonce"> /// Optional. /// Nonce number of the transaction for the source address. /// </param> /// <param name="destinationAddressTag"> /// Optional. /// Destination address tag. /// </param> /// <param name="destinationAddressTagType"> /// Optional. /// Type of the destination address tag. /// </param> public Transfer( Asset asset, UMoney amount, Address sourceAddress, Address destinationAddress, Base64String sourceAddressContext = null, long?sourceAddressNonce = null, AddressTag destinationAddressTag = null, AddressTagType?destinationAddressTagType = null) { if (destinationAddressTagType.HasValue && destinationAddressTag == null) { throw new RequestValidationException("If the tag type is specified, the tag should be specified too", new [] { nameof(destinationAddressTagType), nameof(destinationAddressTag) }); } Asset = asset ?? throw RequestValidationException.ShouldBeNotNull(nameof(asset)); Amount = amount; SourceAddress = sourceAddress ?? throw RequestValidationException.ShouldBeNotNull(nameof(sourceAddress)); SourceAddressContext = sourceAddressContext; SourceAddressNonce = sourceAddressNonce; DestinationAddress = destinationAddress ?? throw RequestValidationException.ShouldBeNotNull(nameof(destinationAddress)); DestinationAddressTag = destinationAddressTag; DestinationAddressTagType = destinationAddressTagType; }
public void TagInput_ShouldHaveCorrectTagPriorities(string word, AddressTag expectedTag) { Assert.Equal(expectedTag, (AddressTag)Tagger.TagInput(new string[1] { word }).First()); }
public void TagInput_ShouldTagWordIfContainedInReferenceArray(string word, AddressTag expectedTag) { Assert.Equal(expectedTag, (AddressTag)Tagger.TagInput(new string[1] { word }).First()); }
/// <summary> /// Endpoint: [POST] /api/addresses/{address}/tags /// </summary> /// <param name="tag">Generated address tag.</param> /// <param name="tagContext"> /// Optional. /// Any non security sensitive, implementation specific information associated with the address tag. /// </param> public CreateAddressTagResponse(AddressTag tag, Base64String tagContext = null) { Tag = tag ?? throw new ArgumentNullException(nameof(tag)); TagContext = tagContext; }