public OutgoingTransportContext(LogicalMessage message, TransportMessage outgoingTransportMessage, DeliveryOptions options, EndpointConfiguration.ReadOnly configuration, TransportMessage incomingTransportMessage = null)
: base(configuration)
{
this.Set(message);
this.Set(OutgoingTransportMessageKey, outgoingTransportMessage);
this.Set(IncomingTransportMessageKey, incomingTransportMessage);
this.Set(options);
}
public DeliveryOptions GetDeliveryOptions(Shipment shipment)
{
DeliveryOptions options = new DeliveryOptions();
if(shipment.Vendor == "USPS")
{
options.PurchaseInsuranceEnabled = false;
options.RequireSignatureEnabled = false;
}
else
{
options.PurchaseInsuranceEnabled = true;
options.RequireSignatureEnabled = true;
}
return options;
}
public virtual async Task Invoke(LogicalMessage outgoingLogicalMessage, DeliveryOptions options, EndpointConfiguration.ReadOnly configuration, TransportMessage incomingTransportMessage = null)
{
executingLogicalPipeline = new Queue<IOutgoingLogicalStep>(registeredlogicalPipelineSteps);
var logicalContext = new OutgoingLogicalContext(outgoingLogicalMessage, options, configuration);
await InvokeLogical(logicalContext)
.ConfigureAwait(false);
// We assume that someone in the pipeline made transport message
var outgoingTransportMessage = logicalContext.Get<TransportMessage>();
executingTransportPipeline = new Queue<IOutgoingTransportStep>(registeredTransportPipelineSteps);
var transportContext = new OutgoingTransportContext(outgoingLogicalMessage, outgoingTransportMessage, options, configuration, incomingTransportMessage);
await InvokeTransport(transportContext)
.ConfigureAwait(false);
}
public static void FillKafkaProperties(TransportMessage message, DeliveryOptions options, dynamic properties)
{
properties.MessageId = message.Id;
if (!String.IsNullOrEmpty(message.CorrelationId))
{
properties.CorrelationId = message.CorrelationId;
}
if (message.TimeToBeReceived < TimeSpan.MaxValue)
{
properties.Expiration = message.TimeToBeReceived.TotalMilliseconds.ToString();
}
properties.SetPersistent(message.Recoverable);
properties.Headers = message.Headers.ToDictionary(p => p.Key, p => (object)p.Value);
if (message.Headers.ContainsKey(Headers.EnclosedMessageTypes))
{
properties.Type = message.Headers[Headers.EnclosedMessageTypes].Split(new[]
{
','
}, StringSplitOptions.RemoveEmptyEntries).FirstOrDefault();
}
if (message.Headers.ContainsKey(Headers.ContentType))
{
properties.ContentType = message.Headers[Headers.ContentType];
}
else
{
properties.ContentType = "application/octet-stream";
}
var replyToAddress = options.ReplyToAddress ?? message.ReplyToAddress;
if (replyToAddress != null)
{
properties.ReplyTo = replyToAddress.Queue;
}
}
private CachedDeliveryClient GetCachedDeliveryClient(Action mockAction = null, Func <RequestCount, RequestCount> mockFunc = null, RequestCount actualHttpRequests = null)
{
HttpClient httpClient = null;
DeliveryOptions deliveryOptions = null;
if (mockAction != null)
{
InitClientPrerequisites(out httpClient, out deliveryOptions, mockAction: mockAction);
}
else if (mockFunc != null && actualHttpRequests != null)
{
InitClientPrerequisites(out httpClient, out deliveryOptions, mockFunc: mockFunc, actualHttpRequests: actualHttpRequests);
}
var projectOptions = Options.Create(new ProjectOptions
{
CacheTimeoutSeconds = 60,
DeliveryOptions = deliveryOptions
});
var memoryCacheOptions = Options.Create(new MemoryCacheOptions
{
Clock = new TestClock(),
ExpirationScanFrequency = new TimeSpan(0, 0, 5)
});
var cacheManager = new ReactiveCacheManager(projectOptions, new MemoryCache(memoryCacheOptions), new DependentFormatResolver(), new WebhookListener());
return(new CachedDeliveryClient(projectOptions, cacheManager
, new DeliveryClient(deliveryOptions)
{
HttpClient = httpClient
})
{
CodeFirstModelProvider = { TypeProvider = new Models.CustomTypeProvider() }
});
}
public async void Retries_WithMaxRetrySet_SettingReflected()
{
int retryAttempts = 3;
int expectedAttepts = retryAttempts + 1;
int actualHttpRequestCount = 0;
_mockHttp.When($"{_baseUrl}/items")
.Respond((request) => GetResponseAndLogRequest(HttpStatusCode.RequestTimeout, ref actualHttpRequestCount));
var httpClient = _mockHttp.ToHttpClient();
var deliveryOptions = new DeliveryOptions()
{
ProjectId = _guid,
MaxRetryAttempts = retryAttempts
};
var client = new DeliveryClient(deliveryOptions)
{
HttpClient = httpClient
};
await Assert.ThrowsAsync <DeliveryException>(async() => await client.GetItemsAsync());
Assert.Equal(expectedAttepts, actualHttpRequestCount);
}
public void Save(int orderId, DeliveryOptions deliveryOptionsToSave)
{
this.deliveryOptions.Add(orderId, deliveryOptionsToSave);
}
public OutgoingTransportContext(LogicalMessage message, TransportMessage outgoingTransportMessage, DeliveryOptions options, EndpointConfiguration.ReadOnly configuration, TransportMessage incomingTransportMessage = null)
: base(configuration)
{
Set(message);
Set(OutgoingTransportMessageKey, outgoingTransportMessage);
Set(IncomingTransportMessageKey, incomingTransportMessage);
Set(options);
}
/// <summary>
/// Registers a <see cref="IDeliveryClient"/> instance to an <see cref="IDeliveryClient"/> interface in <see cref="ServiceCollection"/>.
/// </summary>
/// <param name="services">A <see cref="ServiceCollection"/> instance for registering and resolving dependencies.</param>
/// <param name="deliveryOptions">A <see cref="DeliveryOptions"/> instance. Options themselves are not further validated (see <see cref="DeliveryOptionsValidator.Validate"/>).</param>
/// <returns>The <paramref name="services"/> instance with <see cref="IDeliveryClient"/> registered in it</returns>
public static IServiceCollection AddDeliveryClient(this IServiceCollection services, DeliveryOptions deliveryOptions)
{
if (deliveryOptions == null)
{
throw new ArgumentNullException(nameof(deliveryOptions), "The Delivery options object is not specified.");
}
return(services
.RegisterOptions(deliveryOptions)
.RegisterDependencies());
}
/// <summary>
/// Registers a delegate that will be used to configure a named <see cref="IDeliveryClient"/> via <see cref="IDeliveryClientFactory"/>
/// </summary>
///<param name="name">The name of the client configuration</param>
/// <param name="services">A <see cref="ServiceCollection"/> instance for registering and resolving dependencies.</param>
/// <param name="deliveryOptions">A <see cref="DeliveryOptions"/> instance. Options themselves are not further validated (see <see cref="DeliveryOptionsValidator.Validate"/>).</param>
/// <returns>The <paramref name="services"/> instance with <see cref="IDeliveryClient"/> registered in it</returns>
public static IServiceCollection AddDeliveryClient(this IServiceCollection services, string name, DeliveryOptions deliveryOptions)
{
if (deliveryOptions == null)
{
throw new ArgumentNullException(nameof(deliveryOptions), "The Delivery options object is not specified.");
}
services.AddTransient <IConfigureOptions <DeliveryClientFactoryOptions> >(s =>
{
return(new ConfigureNamedOptions <DeliveryClientFactoryOptions>(name, options =>
{
options.DeliveryClientsActions.Add(() =>
{
services.AddDeliveryClient(deliveryOptions);
var serviceProvider = services.BuildServiceProvider();
return serviceProvider.GetService <IDeliveryClient>();
});
}));
});
return(services
.Configure <DeliveryClientFactoryOptions>(_ => { })
.RegisterFactoryDependencies());
}
public void Send(Payload payload, DeliveryOptions deliveryOptions, Guid sessionId)
{
_roomSender.Send(payload, deliveryOptions, sessionId);
}
public void ProcessMessage(Payload message, DeliveryOptions deliveryOptions, Guid sessionId)
{
var operationCode = MessageBase.GetOperationCode(message.Buffer, message.Offset);
Trace($"Message {operationCode} received");
}
// Options here are not validated on purpose, it is left to users to validate them if they want to.
private static IServiceCollection RegisterOptions(this IServiceCollection services, DeliveryOptions options, string name = null)
{
void Configure(DeliveryOptions o)
{
o.ProjectId = options.ProjectId;
o.ProductionEndpoint = options.ProductionEndpoint;
o.PreviewEndpoint = options.PreviewEndpoint;
o.PreviewApiKey = options.PreviewApiKey;
o.UsePreviewApi = options.UsePreviewApi;
o.WaitForLoadingNewContent = options.WaitForLoadingNewContent;
o.UseSecureAccess = options.UseSecureAccess;
o.SecureAccessApiKey = options.SecureAccessApiKey;
o.EnableRetryPolicy = options.EnableRetryPolicy;
o.DefaultRetryPolicyOptions = options.DefaultRetryPolicyOptions;
o.IncludeTotalCount = options.IncludeTotalCount;
}
if (name == null)
{
services.Configure <DeliveryOptions>(Configure);
}
else
{
services.Configure <DeliveryOptions>(name, Configure);
}
return(services);
}
public Scenario(IDistributedCache distributedCache, CacheExpirationType cacheExpirationType, HttpClient httpClient, DeliveryOptions deliveryOptions, Dictionary <string, int> requestCounter)
{
_requestCounter = requestCounter;
_cacheManager = new DistributedCacheManager(distributedCache, Options.Create(new DeliveryCacheOptions {
DefaultExpirationType = cacheExpirationType
}));
var baseClient = DeliveryClientBuilder.WithOptions(_ => deliveryOptions).WithDeliveryHttpClient(new DeliveryHttpClient(httpClient)).Build();
CachingClient = new DeliveryClientCache(_cacheManager, baseClient);
}
public PacketInfo(DeliveryOptions deliveryOptions, int maxPacketSize,
IShamanLogger logger, Payload payload) : this(deliveryOptions, maxPacketSize, logger, (int)payload.Length)
{
AppendLength(payload.Length);
AppendPayload(payload);
}
public void EnableOrDisableTheInsuranceAndSignatureCheckboxesWhenShippingOptionChanges()
{
// Setting up the expected set of Delivery options
DeliveryOptions deliveryOptions = new DeliveryOptions();
deliveryOptions.PurchaseInsuranceEnabled = true;
deliveryOptions.RequireSignatureEnabled = false;
// Set up the expectations for coordinating both
// the service and the view
using (mocks.Record())
{
service.CalculateCost(null);
LastCall.IgnoreArguments();
Expect.Call(service.GetDeliveryOptions(presenter.Shipment)).Return(deliveryOptions);
screen.InsuranceEnabled = deliveryOptions.PurchaseInsuranceEnabled;
screen.SignatureEnabled = deliveryOptions.RequireSignatureEnabled;
}
// Perform the work and check the expectations
using (mocks.Playback())
{
presenter.ShippingOptionChanged();
mocks.VerifyAll();
}
}
public void SendToAll(Payload payload, DeliveryOptions deliveryOptions)
{
_roomSender.SendToAll(payload, deliveryOptions);
}
public void SendToAll(Payload payload, DeliveryOptions deliveryOptions, Guid exceptionSessionId)
{
_roomSender.SendToAll(payload, deliveryOptions, exceptionSessionId);
}
public void Send(Payload payload, DeliveryOptions deliveryOptions, IEnumerable <Guid> sessionIds)
{
_roomSender.Send(payload, deliveryOptions, sessionIds);
}
private void ProcessMessage(IPEndPoint endPoint, Payload payload,
DeliveryOptions deliveryOptions,
GamePeer peer)
{
var operationCode = MessageBase.GetOperationCode(payload.Buffer, payload.Offset);
_logger.Debug($"Message received. Operation code: {operationCode}");
if (peer == null)
{
_logger.Warning($"GamePeerListener.OnReceivePacketFromClient error: can not find peer for endpoint {endPoint.Address}:{endPoint.Port}");
return;
}
//listener handles only auth message, others are sent to roomManager
switch (operationCode)
{
case ShamanOperationCode.Connect:
_logger.Error($"Sending ConnectedEvent to peer {peer.GetPeerId()}");
_messageSender.Send(new ConnectedEvent(), peer);
break;
case ShamanOperationCode.Ping:
_messageSender.Send(new PingEvent(), peer);
break;
case ShamanOperationCode.Disconnect:
OnClientDisconnect(endPoint, new SimpleDisconnectInfo(ShamanDisconnectReason.PeerLeave));
break;
case ShamanOperationCode.Authorization:
var authMessage = Serializer.DeserializeAs <AuthorizationRequest>(payload.Buffer, payload.Offset, payload.Length);
if (!Config.IsAuthOn)
{
//if success - send auth success
peer.IsAuthorizing = false;
peer.IsAuthorized = true;
//this sessionID will be got from backend, after we send authToken, which will come in player properties
peer.SetSessionId(authMessage.SessionId);
_messageSender.Send(new AuthorizationResponse(), peer);
}
else
{
//TODO authorizing logic
throw new NotImplementedException();
}
break;
default:
if (!peer.IsAuthorized && Config.IsAuthOn)
{
_messageSender.Send(new AuthorizationResponse()
{
ResultCode = ResultCode.NotAuthorized
}, peer);
return;
}
else
{
if (!peer.IsAuthorized)
{
_messageSender.Send(new AuthorizationResponse(), peer);
}
}
switch (operationCode)
{
default:
_roomManager.ProcessMessage(operationCode, payload, deliveryOptions, peer);
break;
}
break;
}
}
static void SetHeaders(TransportMessage message, DeliveryOptions options, ReadOnlySettings settings, Configure config, BrokeredMessage brokeredMessage)
{
foreach (var header in message.Headers)
{
brokeredMessage.Properties[header.Key] = header.Value;
}
brokeredMessage.Properties[Headers.MessageIntent] = message.MessageIntent.ToString();
brokeredMessage.MessageId = message.Id;
brokeredMessage.CorrelationId = message.CorrelationId;
if (message.ReplyToAddress != null)
{
brokeredMessage.ReplyTo = new DeterminesBestConnectionStringForAzureServiceBus(config.TransportConnectionString()).Determine(settings, message.ReplyToAddress);
}
else if (options.ReplyToAddress != null)
{
brokeredMessage.ReplyTo = new DeterminesBestConnectionStringForAzureServiceBus(config.TransportConnectionString()).Determine(settings, options.ReplyToAddress);
}
}
public async Task <MessageStatus> PublishAsync(object message, DeliveryOptions deliveryOptions)
{
return(await PublishAsync(message, DEFAULT_CHANNEL_NAME, null, deliveryOptions));
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.UseWindowsService()
.ConfigureServices((hostContext, services) =>
{
var configuration = hostContext.Configuration;
// Add logging
Log.Logger = new LoggerConfiguration()
.ReadFrom.Configuration(configuration)
.CreateLogger();
services.AddLogging(c => c.AddSerilog());
// Add application options
services.AddDataRepositories(configuration);
// Add options
services.Configure <DeliveryOptions>(configuration.GetSection(nameof(DeliveryOptions)));
services.Configure <RabbitMqOptions>(configuration.GetSection(nameof(RabbitMqOptions)));
RabbitMqOptions rabbitmqOptions = null;
DeliveryOptions deliveryOptions = null;
IEnumerable <Subscription> subscriptions;
using (var provider = services.BuildServiceProvider())
{
rabbitmqOptions = provider.GetService <IOptions <RabbitMqOptions> >().Value;
deliveryOptions = provider.GetService <IOptions <DeliveryOptions> >().Value;
subscriptions = provider.GetService <ISubscriptonsRepository>().GetSubscriptions(true).Result;
}
#region MassTransit config
services.AddMassTransit(x =>
{
x.AddBus(busContext => Bus.Factory.CreateUsingRabbitMq(config =>
{
config.Host(rabbitmqOptions.Uri, h =>
{
h.Username(rabbitmqOptions.Username);
h.Password(rabbitmqOptions.Password);
});
#region Command consumers
x.AddConsumer <ActivateSubscriptionConsumer>();
config.ReceiveEndpoint(queueName: typeof(ActivateSubscription).FullName, c =>
{
c.ConfigureConsumeTopology = false;
c.ConfigureConsumer <ActivateSubscriptionConsumer>(busContext);
});
x.AddConsumer <DeactivateSubscriptionConsumer>();
config.ReceiveEndpoint(queueName: typeof(DeactivateSubscription).FullName, c =>
{
c.ConfigureConsumeTopology = false;
c.ConfigureConsumer <DeactivateSubscriptionConsumer>(busContext);
});
#endregion
#region Event consumers
foreach (var subscription in subscriptions)
{
var eventType = DomainEventsHelper.GetDomainEventTypes().SingleOrDefault(t => t.FullName == subscription.Event);
if (eventType == null)
{
continue; // TODO: Log invalid event
}
#region Add event consumers
var addConsumerMethod = x.GetType()
.GetMethods().Single(m => m.Name == nameof(IServiceCollectionBusConfigurator.AddConsumer) &&
m.ContainsGenericParameters &&
m.GetParameters().Length == 1 &&
m.GetParameters()[0].ParameterType.IsGenericType &&
m.GetParameters()[0].ParameterType.GetGenericTypeDefinition() == typeof(Action <>)
)
.MakeGenericMethod(typeof(DomainEventConsumer <>).MakeGenericType(eventType));
addConsumerMethod.Invoke(x, new object[] { null });
//x.AddConsumer(eventType);
//x.AddConsumer<DomainEventConsumer<OperationCompletedEvent>>();
#endregion
#region Configure event consumers
config.ReceiveEndpoint(queueName: $"{subscription.Event}_{subscription.Id}", c =>
{
c.Bind(exchangeName: eventType.FullName);
c.UseMessageRetry(r => r.Interval(deliveryOptions.Attempts, TimeSpan.FromSeconds(deliveryOptions.AttemptDelay)));
c.ConfigureConsumeTopology = false;
var configureConsumerMethod = typeof(RegistrationContextExtensions)
.GetMethods().Single(m => m.Name == nameof(RegistrationContextExtensions.ConfigureConsumer) &&
m.ContainsGenericParameters &&
m.GetParameters().Length == 3 &&
m.GetParameters()[0].ParameterType == typeof(IReceiveEndpointConfigurator) &&
m.GetParameters()[1].ParameterType == typeof(IRegistration) &&
m.GetParameters()[2].ParameterType.IsGenericType &&
m.GetParameters()[2].ParameterType.GetGenericTypeDefinition() == typeof(Action <>)
)
.MakeGenericMethod(typeof(DomainEventConsumer <>).MakeGenericType(eventType));
configureConsumerMethod.Invoke(null, new object[] { c, busContext, null });
//c.ConfigureConsumer(busContext, eventType);
//c.ConfigureConsumer<DomainEventConsumer<OperationCompletedEvent>>(busContext);
});
#endregion
}
#endregion
}));
});
services.AddScoped <ActivateSubscriptionConsumer>();
services.AddScoped <DeactivateSubscriptionConsumer>();
foreach (var @event in DomainEventsHelper.GetDomainEventTypes())
{
services.AddScoped(typeof(DomainEventConsumer <>).MakeGenericType(@event));
}
#endregion
#region HttpClientFactory config
services.AddHttpClient(HttpClientNames.WebhookSubscriptionHttpClient, c =>
{
if (deliveryOptions.Timeout > 0)
{
c.Timeout = TimeSpan.FromSeconds(deliveryOptions.Timeout);
}
});
#endregion
services.AddHostedService <Worker>();
});
public async Task <MessageStatus> PublishAsync(object message, string channelName, PublishOptions publishOptions,
DeliveryOptions deliveryOptions)
{
return(await Task.Run(() => Publish( message, channelName, publishOptions, deliveryOptions ))
.ConfigureAwait(false));
}
public IEnumerable <DeliveryPrice> GetDeliveryPrices(DateTime postDate, string originalZipCode, string deliveryZipCode, DeliveryOptions deliveryOptions,
int height, int width, int length, float weight)
{
return(GetDeliveryPricesAsync(postDate, originalZipCode, deliveryZipCode, deliveryOptions, height, width, length, weight).Result);
}
/// <summary>
/// Registers a delegate that will be used to configure a named <see cref="IDeliveryClient"/> via <see cref="IDeliveryClientFactory"/>
/// </summary>
///<param name="name">The name of the client configuration</param>
/// <param name="services">A <see cref="ServiceCollection"/> instance for registering and resolving dependencies.</param>
/// <param name="deliveryOptions">A <see cref="DeliveryOptions"/> instance. Options themselves are not further validated (see <see cref="DeliveryOptionsValidator.Validate"/>).</param>
/// <param name="namedServiceProviderType">A named service provider type.</param>
/// <returns>The <paramref name="services"/> instance with <see cref="IDeliveryClient"/> registered in it</returns>
public static IServiceCollection AddDeliveryClient(this IServiceCollection services, string name, DeliveryOptions deliveryOptions, NamedServiceProviderType namedServiceProviderType = NamedServiceProviderType.None)
{
if (deliveryOptions == null)
{
throw new ArgumentNullException(nameof(deliveryOptions), "The Delivery options object is not specified.");
}
deliveryOptions.Name = name;
return(services
.RegisterOptions(deliveryOptions, name)
.RegisterDependencies(true)
.RegisterNamedServices(namedServiceProviderType));
}
public async Task <MessageStatus> PublishAsync(object message, string channelName, DeliveryOptions deliveryOptions)
{
return(await PublishAsync(message, channelName, null, deliveryOptions));
}
private FormUrlEncodedContent CreateDeliveryPriceRequest(DateTime postDate, string originalZipCode, string deliveryZipCode, DeliveryOptions deliveryOption,
int height, int width, int length, float weight)
{
string deliveryOptionValue = deliveryOption.GetAttributeValue();
var content = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("data", postDate.ToString("dd/MM/yyyy")),
new KeyValuePair <string, string>("dataAtual", DateTime.Now.ToString("dd/MM/yyyy")),
new KeyValuePair <string, string>("cepOrigem", originalZipCode),
new KeyValuePair <string, string>("cepDestino", deliveryZipCode),
new KeyValuePair <string, string>("servico", deliveryOptionValue),
new KeyValuePair <string, string>("embalagem1", "outraEmbalagem1"), //TODO: Give to user the options
new KeyValuePair <string, string>("Altura", height.ToString()),
new KeyValuePair <string, string>("Largura", width.ToString()),
new KeyValuePair <string, string>("Comprimento", length.ToString()),
new KeyValuePair <string, string>("peso", weight.ToString(CultureInfo.InvariantCulture)),
new KeyValuePair <string, string>("Selecao", ""),
new KeyValuePair <string, string>("embalagem2", ""),
new KeyValuePair <string, string>("Selecao1", ""),
new KeyValuePair <string, string>("proCod_in_1", ""),
new KeyValuePair <string, string>("nomeEmbalagemCaixa", ""),
new KeyValuePair <string, string>("TipoEmbalagem1", ""),
new KeyValuePair <string, string>("Selecao2", ""),
new KeyValuePair <string, string>("proCod_in_2", ""),
new KeyValuePair <string, string>("TipoEmbalagem2", ""),
new KeyValuePair <string, string>("Selecao3", ""),
new KeyValuePair <string, string>("proCod_in_3", ""),
new KeyValuePair <string, string>("TipoEmbalagem3", ""),
new KeyValuePair <string, string>("Selecao4", ""),
new KeyValuePair <string, string>("proCod_in_4", ""),
new KeyValuePair <string, string>("TipoEmbalagem4", ""),
new KeyValuePair <string, string>("Selecao5", ""),
new KeyValuePair <string, string>("proCod_in_5", ""),
new KeyValuePair <string, string>("TipoEmbalagem5", ""),
new KeyValuePair <string, string>("Selecao6", ""),
new KeyValuePair <string, string>("proCod_in_6", ""),
new KeyValuePair <string, string>("TipoEmbalagem6", ""),
new KeyValuePair <string, string>("Selecao7", ""),
new KeyValuePair <string, string>("proCod_in_7", ""),
new KeyValuePair <string, string>("TipoEmbalagem7", ""),
new KeyValuePair <string, string>("Selecao8", ""),
new KeyValuePair <string, string>("proCod_in_8", ""),
new KeyValuePair <string, string>("nomeEmbalagemEnvelope", ""),
new KeyValuePair <string, string>("TipoEmbalagem8", ""),
new KeyValuePair <string, string>("Selecao9", ""),
new KeyValuePair <string, string>("proCod_in_9", ""),
new KeyValuePair <string, string>("TipoEmbalagem9", ""),
new KeyValuePair <string, string>("Selecao10", ""),
new KeyValuePair <string, string>("proCod_in_10", ""),
new KeyValuePair <string, string>("Selecao11", ""),
new KeyValuePair <string, string>("proCod_in_11", ""),
new KeyValuePair <string, string>("Selecao12", ""),
new KeyValuePair <string, string>("proCod_in_12", ""),
new KeyValuePair <string, string>("TipoEmbalagem12", ""),
new KeyValuePair <string, string>("Selecao13", ""),
new KeyValuePair <string, string>("proCod_in_13", ""),
new KeyValuePair <string, string>("TipoEmbalagem13", ""),
new KeyValuePair <string, string>("valorDeclarado", ""),
new KeyValuePair <string, string>("Calcular", "Calcular"),
});
return(content);
}
// Options here are not validated on purpose, it is left to users to validate them if they want to.
private static IServiceCollection RegisterOptions(this IServiceCollection services, DeliveryOptions options)
{
services.TryAddSingleton(Options.Options.Create(options));
return(services);
}
public async Task <IEnumerable <DeliveryPrice> > GetDeliveryPricesAsync(DateTime postDate, string originalZipCode, string deliveryZipCode, DeliveryOptions deliveryOptions,
int height, int width, int length, float weight)
{
originalZipCode = originalZipCode.Replace(".", "").Replace("-", "");
deliveryZipCode = deliveryZipCode.Replace(".", "").Replace("-", "");
if (height < 2 || height > 100)
{
throw new PackageSizeException("A altura da caixa deve ter no mínimo 2cm e no máximo 100cm");
}
if (width < 11 || width > 100)
{
throw new PackageSizeException("A largura da caixa deve ter no mínimo 11cm e no máximo 100cm");
}
if (length < 16 || length > 100)
{
throw new PackageSizeException("O comprimento da caixa deve ter no mínimo 16cm e no máximo 100cm");
}
if (height + width + length > 200)
{
throw new PackageSizeException("A soma resultante do comprimento + largura + altura não deve superar 200 cm");
}
if (weight < 0.3f)
{
weight = 0.3f;
}
else if (weight > 0.3f && weight < 1)
{
weight = 1f;
}
else if (weight != 0.3f)
{
weight = (float)Math.Ceiling(weight);
}
Array values = Enum.GetValues(typeof(DeliveryOptions));
List <DeliveryPrice> deliveryPrices = new List <DeliveryPrice>();
foreach (DeliveryOptions option in values)
{
if (deliveryOptions.HasFlag(option))
{
var body = CreateDeliveryPriceRequest(postDate, originalZipCode, deliveryZipCode, option, height, width, length, weight);
using (var response = await _httpClient.PostAsync(DELIVERY_PRICES_ADDRESS_URL, body))
{
var html = response.Content.ReadAsStringAsync().Result;
var price = Parser.ParseDeliveryPrices(option.GetAttributeDescription(), html);
deliveryPrices.Add(price);
}
}
}
return(deliveryPrices);
}
// Options here are not validated on purpose, it is left to users to validate them if they want to.
private static IServiceCollection RegisterOptions(this IServiceCollection services, DeliveryOptions options)
{
services.Configure <DeliveryOptions>(o =>
{
o.ProjectId = options.ProjectId;
o.ProductionEndpoint = options.ProductionEndpoint;
o.PreviewEndpoint = options.PreviewEndpoint;
o.PreviewApiKey = options.PreviewApiKey;
o.UsePreviewApi = options.UsePreviewApi;
o.WaitForLoadingNewContent = options.WaitForLoadingNewContent;
o.UseSecureAccess = options.UseSecureAccess;
o.SecureAccessApiKey = options.SecureAccessApiKey;
o.EnableRetryPolicy = options.EnableRetryPolicy;
o.DefaultRetryPolicyOptions = options.DefaultRetryPolicyOptions;
o.IncludeTotalCount = options.IncludeTotalCount;
});
return(services);
}
/// <summary>
/// Creates a new instance of <see cref="OutgoingContext"/>.
/// </summary>
/// <param name="parentContext">The parent context.</param>
/// <param name="deliveryOptions">The delivery options.</param>
/// <param name="message">The actual message to be sent out.</param>
public OutgoingContext(BehaviorContext parentContext, DeliveryOptions deliveryOptions, LogicalMessage message)
: base(parentContext)
{
Set(deliveryOptions);
Set(OutgoingLogicalMessageKey, message);
}
private static IServiceCollection RegisterOptions(this IServiceCollection services, DeliveryOptions options)
{
return(services.Configure <DeliveryOptions>((o) => o.Configure(options)));
}
public OutgoingLogicalContext(LogicalMessage message, DeliveryOptions options, EndpointConfiguration.ReadOnly configuration)
: base(configuration)
{
Set(message);
Set(options);
}
/// <summary>
/// Creates a new instance of <see cref="OutgoingContext"/>.
/// </summary>
/// <param name="parentContext">The parent context.</param>
/// <param name="deliveryOptions">The delivery options.</param>
/// <param name="message">The actual message to be sent out.</param>
public OutgoingContext(BehaviorContext parentContext, DeliveryOptions deliveryOptions, LogicalMessage message)
: base(parentContext)
{
Set(deliveryOptions);
Set(OutgoingLogicalMessageKey, message);
}
public void ProcessMessage(ushort operationCode, Payload message, DeliveryOptions deliveryOptions,
IPeer peer)
{
try
{
//room manager handles only room flow messages, others are sent to particular room
var sessionId = peer.GetSessionId();
switch (operationCode)
{
case ShamanOperationCode.JoinRandomRoom:
var joinRandomRoomMessage = _serializer.DeserializeAs <DirectJoinRandomRoomRequest>(message.Buffer, message.Offset, message.Length);
var roomToRandomJoin = GetRandomRoomOrCreateOne(sessionId, joinRandomRoomMessage.RoomProperties);
if (roomToRandomJoin == null)
{
var msg = $"Error joining random room";
_logger.Error(msg);
_messageSender.Send(new JoinRoomResponse()
{
ResultCode = ResultCode.RequestProcessingError
}, peer);
}
else
{
JoinRoomAndReport(roomToRandomJoin, sessionId, peer, joinRandomRoomMessage.JoinProperties,
new DirectJoinRandomRoomResponse(roomToRandomJoin.GetRoomId()),
new DirectJoinRandomRoomResponse()
{
ResultCode = ResultCode.RequestProcessingError
});
}
break;
case ShamanOperationCode.JoinRoom:
var joinMessage = _serializer.DeserializeAs <JoinRoomRequest>(message.Buffer, message.Offset, message.Length);
var roomToJoin = GetRoomById(joinMessage.RoomId);
if (roomToJoin == null)
{
var msg = $"Peer {sessionId} attempted to join to non-exist room {joinMessage.RoomId}";
_logger.Error(msg);
_messageSender.Send(new JoinRoomResponse()
{
ResultCode = ResultCode.RequestProcessingError
}, peer);
}
else
{
JoinRoomAndReport(roomToJoin, sessionId, peer, joinMessage.Properties,
new JoinRoomResponse(),
new JoinRoomResponse()
{
ResultCode = ResultCode.RequestProcessingError
});
}
break;
case ShamanOperationCode.LeaveRoom:
PeerDisconnected(peer, new SimpleDisconnectInfo(ShamanDisconnectReason.PeerLeave));
break;
case ShamanOperationCode.Bundle:
if (_sessionsToRooms.TryGetValue(peer.GetSessionId(), out var room))
{
room.ProcessMessage(message, deliveryOptions, peer.GetSessionId());
}
else
{
_logger.Error($"ProcessMessage error: Can not get room for peer {peer.GetSessionId()}");
_messageSender.Send(new ErrorResponse()
{
ResultCode = ResultCode.MessageProcessingError
}, peer);
}
break;
default:
throw new RoomManagerException($"Unknown operation code received: {operationCode}");
}
}
catch (Exception ex)
{
_logger.Error($"RoomManager.ProcessMessage: Error processing {operationCode} message: {ex}");
_messageSender.Send(new ErrorResponse()
{
ResultCode = ResultCode.MessageProcessingError
}, peer);
}
}
public OutgoingLogicalContext(LogicalMessage message, DeliveryOptions options, EndpointConfiguration.ReadOnly configuration)
: base(configuration)
{
this.Set(message);
this.Set(options);
}
public LightDeliveryClient(DeliveryOptions options)
{
Options = options;
}