/// <summary>
/// Do the action after a delay.
/// </summary>
/// <param name="args">Event arguments.</param>
/// <param name="action">Action.</param>
protected virtual IEnumerator DoDelayedAction(EventResponse action, System.EventArgs args)
{
float delayTimer = action.delay;
while (delayTimer > 0.0f)
{
delayTimer -= TimeManager.FrameTime;
yield return true;
}
DoImmediateAction (action, args);
}
/// <summary>
/// Do the action
/// </summary>
/// <param name="args">Event arguments.</param>
/// <param name="action">Action.</param>
protected virtual void DoImmediateAction(EventResponse action, System.EventArgs args)
{
Character character;
CharacterHealth characterHealth = null;
ItemManager itemManager = null;
Animator animator;
Animation animation;
SpecialMovement_PlayAnimation specialMovement;
switch(action.responseType)
{
case EventResponseType.DEBUG_LOG:
Debug.Log (string.Format("Got event, arguments: {0}", args != null ? args.ToString() : "" ));
break;
case EventResponseType.ACTIVATE_GAMEOBJECT:
action.targetGameObject.SetActive(true);
break;
case EventResponseType.DEACTIVATE_GAMEOBJECT:
action.targetGameObject.SetActive(false);
break;
case EventResponseType.SEND_MESSSAGE:
action.targetGameObject.SendMessage(action.message, SendMessageOptions.DontRequireReceiver);
break;
case EventResponseType.ENABLE_BEHAVIOUR:
if (action.targetComponent is Movement) ((Movement)action.targetComponent).Enabled = true;
else if (action.targetComponent is Behaviour) ((Behaviour)action.targetComponent).enabled = true;
else if (action.targetComponent is Renderer) ((Renderer)action.targetComponent).enabled = true;
break;
case EventResponseType.DISABLE_BEHAVIOUR:
if (action.targetComponent is Movement) ((Movement)action.targetComponent).Enabled = false;
else if (action.targetComponent is Behaviour) ((Behaviour)action.targetComponent).enabled = false;
else if (action.targetComponent is Renderer) ((Renderer)action.targetComponent).enabled = false;
break;
case EventResponseType.OVERRIDE_ANIMATON:
if (action.targetComponent is Character) ((Character)action.targetComponent).AddAnimationOverride(action.overrideState);
break;
case EventResponseType.CLEAR_ANIMATION_OVERRIDE:
if (action.targetComponent is Character) ((Character)action.targetComponent).RemoveAnimationOverride(action.overrideState);
break;
case EventResponseType.SPECIAL_MOVE_ANIMATION:
// This is legacy and shoulnd't be used any more
character = null;
if (action.targetComponent is Character)
{
character = (Character) action.targetComponent;
}
else if (args is CharacterEventArgs)
{
character = ((CharacterEventArgs)args).Character;
}
if (character != null)
{
SpecialMovement_PlayAnimation movement = character.GetComponentInChildren<SpecialMovement_PlayAnimation>();
if (movement == null)
{
Debug.LogWarning("Cannot play an animation as the Character does not have a SpecalMovement_PlayAnimation attached");
}
else
{
movement.Play(action.animationState);
}
}
break;
case EventResponseType.PLAY_PARTICLES:
if (action.targetComponent is ParticleSystem) ((ParticleSystem)action.targetComponent).Play();
break;
case EventResponseType.PAUSE_PARTICLES:
if (action.targetComponent is ParticleSystem) ((ParticleSystem)action.targetComponent).Pause();
break;
case EventResponseType.SWITCH_SPRITE:
if (action.targetComponent is SpriteRenderer) ((SpriteRenderer)action.targetComponent).sprite = action.newSprite;
break;
case EventResponseType.PLAY_SFX:
if (action.targetComponent is SoundEffect) ((SoundEffect)action.targetComponent).Play ();
break;
case EventResponseType.PLAY_SONG:
if (action.targetComponent is MusicPlayer) ((MusicPlayer)action.targetComponent).Play (action.message);
break;
case EventResponseType.STOP_SONG:
if (action.targetComponent is MusicPlayer) ((MusicPlayer)action.targetComponent).Stop ();
break;
case EventResponseType.MAKE_INVULNERABLE:
character = null;
if (action.targetComponent is Character)
{
character = (Character) action.targetComponent;
}
else if (args is CharacterEventArgs)
{
character = ((CharacterEventArgs)args).Character;
}
if (character != null)
{
CharacterHealth ch = character.GetComponentInChildren<CharacterHealth>();
if (ch != null)
{
ch.SetInvulnerable();
}
else
{
Debug.LogWarning("Tried to make Character invulnerable but no CharacterHealth found.");
}
}
else if (action.targetComponent is Enemy)
{
((Enemy)action.targetComponent).MakeInvulnerable(99999999);
}
else
{
Debug.LogWarning("Tried to make invulnerable but didn't know how to make the target invulnerable.");
}
break;
case EventResponseType.MAKE_VULNERABLE:
character = null;
if (action.targetComponent is Character)
{
character = (Character) action.targetComponent;
}
else if (args is CharacterEventArgs)
{
character = ((CharacterEventArgs)args).Character;
}
if (character != null)
{
CharacterHealth ch = character.GetComponentInChildren<CharacterHealth>();
if (ch != null)
{
ch.SetVulnerable();
}
else
{
Debug.LogWarning("Tried to make Character vulnerable but no CharacterHealth found.");
}
}
else if (action.targetComponent is Enemy)
{
((Enemy)action.targetComponent).MakeVulnerable();
}
else
{
Debug.LogWarning("Tried to make vulnerable but didn't know how to make the target invulnerable.");
}
break;
case EventResponseType.LEVEL_COMPLETE:
LevelManager.Instance.LevelCompleted();
break;
case EventResponseType.LOAD_SCENE:
foreach (Character c in FindObjectsOfType<Character>()) c.AboutToExitScene(action.message);
#if !UNITY_4_6 && !UNITY_5_1 && !UNITY_5_2
SceneManager.LoadScene(action.message);
#else
Application.LoadLevel (action.message);
#endif
break;
case EventResponseType.LOCK:
LevelManager.Instance.LockLevel (action.message);
break;
case EventResponseType.UNLOCK:
LevelManager.Instance.UnlockLevel (action.message);
break;
case EventResponseType.RESPAWN:
if (args is CharacterEventArgs)
{
LevelManager.Instance.Respawn(((CharacterEventArgs)args).Character, action.message);
}
else Debug.LogWarning("Tried to respawn but the triggering event did not derive from Character.");
break;
case EventResponseType.SET_ACTIVE_RESPAWN:
LevelManager.Instance.ActivateRespawnPoint(action.message);
break;
case EventResponseType.START_EFFECT:
if (action.targetComponent is FX_Base)
{
if (action.targetGameObject != null && action.message != null && action.message != "") ((FX_Base)action.targetComponent).StartEffect(action.targetGameObject, action.message);
else ((FX_Base)action.targetComponent).StartEffect();
}
else Debug.LogWarning("Trying to play an Effect that isn't derived from FX_Base.");
break;
case EventResponseType.FLIP_GRAVITY:
if (args is CharacterEventArgs)
{
FlippableGravity gravity = ((CharacterEventArgs)args).Character.GetComponent<FlippableGravity>();
if (gravity != null)
{
gravity.FlipGravity();
}
else Debug.LogWarning("Tried to flip gravity but the character didn't have a FlippableGravity attached.");
}
else Debug.LogWarning("Tried to flip gravity but the triggering event did not derive from Character.");
break;
case EventResponseType.START_SWIM:
Debug.LogWarning("Swim is not supported in the Lite Edition");
break;
case EventResponseType.STOP_SWIM:
Debug.LogWarning("Swim is not supported in the Lite Edition");
break;
case EventResponseType.ADD_SCORE:
ScoreManager.GetInstanceForType(action.message).AddScore(action.intValue);
break;
case EventResponseType.RESET_SCORE:
ScoreManager.GetInstanceForType(action.message).ResetScore();
break;
case EventResponseType.PLAY_ANIMATION:
character = null;
specialMovement = null;
if (action.targetComponent is Character)
{
character = (Character) action.targetComponent;
}
else if (args is CharacterEventArgs)
{
character = ((CharacterEventArgs)args).Character;
}
if (character != null)
{
specialMovement = character.GetComponentInChildren<SpecialMovement_PlayAnimation>();
if (specialMovement != null)
{
specialMovement.Play(action.animationState);
break;
}
}
animator = action.targetGameObject.GetComponent<Animator>();
if (animator != null)
{
animator.Play (action.message);
break;
}
animation = action.targetGameObject.GetComponent<Animation>();
if (animation != null)
{
animation.Play();
break;
}
Debug.LogWarning("Couldn't find a Special Movement, Animation or Animator on the target GameObject");
break;
case EventResponseType.STOP_ANIMATION:
character = null;
specialMovement = null;
if (action.targetComponent is Character)
{
character = (Character) action.targetComponent;
}
else if (args is CharacterEventArgs)
{
character = ((CharacterEventArgs)args).Character;
}
if (character != null)
{
specialMovement = character.GetComponentInChildren<SpecialMovement_PlayAnimation>();
if (specialMovement != null)
{
specialMovement.StopAnimation();
break;
}
}
animation = action.targetGameObject.GetComponent<Animation>();
if (animation != null)
{
animation.Stop();
break;
}
Debug.LogWarning("Couldn't find a Special Movement or Animation on the target GameObject");
break;
case EventResponseType.UPDATE_LIVES:
if (action.targetComponent is CharacterHealth)
{
characterHealth = (CharacterHealth) action.targetComponent;
}
else if (args is CharacterEventArgs)
{
characterHealth = ((CharacterEventArgs)args).Character.GetComponent<CharacterHealth>();
}
if (characterHealth == null)
{
Debug.LogWarning("No characterHealth found on target, cannot increase max lives");
}
else
{
characterHealth.CurrentLives += action.intValue;
}
break;
case EventResponseType.UPDATE_MAX_LIVES:
if (action.targetComponent is CharacterHealth)
{
characterHealth = (CharacterHealth) action.targetComponent;
}
else if (args is CharacterEventArgs)
{
characterHealth = ((CharacterEventArgs)args).Character.GetComponent<CharacterHealth>();
}
if (characterHealth == null)
{
Debug.LogWarning("No characterHealth found on target, cannot increase max lives");
}
else
{
characterHealth.MaxLives += action.intValue;
}
break;
case EventResponseType.SET_MAX_LIVES:
if (action.targetComponent is CharacterHealth)
{
characterHealth = (CharacterHealth) action.targetComponent;
}
else if (args is CharacterEventArgs)
{
characterHealth = ((CharacterEventArgs)args).Character.GetComponent<CharacterHealth>();
}
if (characterHealth == null)
{
Debug.LogWarning("No characterHealth found on target, cannot increase max lives");
}
else
{
characterHealth.MaxLives = action.intValue;
}
break;
case EventResponseType.UPDATE_MAX_HEALTH:
if (action.targetComponent is CharacterHealth)
{
characterHealth = (CharacterHealth) action.targetComponent;
}
else if (args is CharacterEventArgs)
{
characterHealth = ((CharacterEventArgs)args).Character.GetComponent<CharacterHealth>();
}
if (characterHealth == null)
{
Debug.LogWarning("No characterHealth found on target, cannot increase max health");
}
else
{
characterHealth.MaxHealth += action.intValue;
}
break;
case EventResponseType.SET_MAX_HEALTH:
if (action.targetComponent is CharacterHealth)
{
characterHealth = (CharacterHealth) action.targetComponent;
}
else if (args is CharacterEventArgs)
{
characterHealth = ((CharacterEventArgs)args).Character.GetComponent<CharacterHealth>();
}
if (characterHealth == null)
{
Debug.LogWarning("No characterHealth found on target, cannot decrease max health");
}
else
{
characterHealth.MaxHealth = action.intValue;
}
break;
case EventResponseType.UPDATE_ITEM_MAX:
if (action.targetComponent is ItemManager)
{
itemManager = (ItemManager) action.targetComponent;
}
else if (args is CharacterEventArgs)
{
itemManager = ((CharacterEventArgs)args).Character.GetComponentInChildren<ItemManager>();
}
if (itemManager == null)
{
Debug.LogWarning("No itemManager found on target, cannot increase item max");
}
else
{
itemManager.IncreaseItemMax(action.message, action.intValue);
}
break;
case EventResponseType.SET_ITEM_MAX:
if (action.targetComponent is ItemManager)
{
itemManager = (ItemManager) action.targetComponent;
}
else if (args is CharacterEventArgs)
{
itemManager = ((CharacterEventArgs)args).Character.GetComponentInChildren<ItemManager>();
}
if (itemManager == null)
{
Debug.LogWarning("No itemManager found on target, cannot decrease item max");
}
else
{
itemManager.SetItemMax(action.message, -action.intValue);
}
break;
case EventResponseType.SET_TAGGED_PROPERTY:
character = null;
if (action.targetComponent is Character)
{
character = (Character) action.targetComponent;
}
else if (args is CharacterEventArgs)
{
character = ((CharacterEventArgs)args).Character;
}
if (character != null)
{
character.SetTaggedProperty(action.message, action.floatValue);
}
break;
case EventResponseType.ADD_TO_TAGGED_PROPERTY:
character = null;
if (action.targetComponent is Character)
{
character = (Character) action.targetComponent;
}
else if (args is CharacterEventArgs)
{
character = ((CharacterEventArgs)args).Character;
}
if (character != null)
{
character.AddToTaggedProperty(action.message, action.floatValue);
}
break;
case EventResponseType.MULTIPLY_TAGGED_PROPERTY:
character = null;
if (action.targetComponent is Character)
{
character = (Character) action.targetComponent;
}
else if (args is CharacterEventArgs)
{
character = ((CharacterEventArgs)args).Character;
}
if (character != null)
{
character.MultiplyTaggedProperty(action.message, action.floatValue);
}
break;
case EventResponseType.SPAWN_ITEM:
if (action.targetComponent is RandomItemSpawner)
{
((RandomItemSpawner) action.targetComponent).Spawn();
}
else
{
Debug.LogWarning("No RandomItemSpawner is set.");
}
break;
case EventResponseType.ADD_VELOCITY:
if (action.targetComponent == null && args is CharacterEventArgs)
{
character = ((CharacterEventArgs)args).Character;
float modifier = action.boolValue ? character.LastFacedDirection : 1;
Vector2 currentVelocity = character.Velocity;
currentVelocity += action.vectorValue;
character.SetVelocityX(currentVelocity.x * modifier);
character.SetVelocityY(currentVelocity.y);
}
else if (action.targetComponent is IMob)
{
float modifier = action.boolValue ? ((IMob) action.targetComponent).LastFacedDirection : 1;
Vector2 currentVelocity = ((IMob) action.targetComponent).Velocity;
currentVelocity += action.vectorValue;
((IMob) action.targetComponent).SetVelocityX(currentVelocity.x * modifier);
((IMob) action.targetComponent).SetVelocityY(currentVelocity.y);
}
else if (action.targetComponent is Rigidbody2D)
{
if (action.boolValue)
{
((Rigidbody2D)action.targetComponent).AddRelativeForce(action.vectorValue, ForceMode2D.Impulse);
}
else
{
((Rigidbody2D)action.targetComponent).AddForce(action.vectorValue, ForceMode2D.Impulse);
}
}
else
{
Debug.LogWarning("Tried to add velocity to an object that wasnt a Character, Enemy or Rigidbody2D");
}
break;
case EventResponseType.SET_VELOCITY:
character = ((CharacterEventArgs)args).Character;
if (action.targetComponent == null && args is CharacterEventArgs)
{
float modifier = action.boolValue ? character.LastFacedDirection : 1;
character.SetVelocityX(action.vectorValue.x * modifier);
character.SetVelocityY(action.vectorValue.y);
}
else if (action.targetComponent is IMob)
{
float modifier = action.boolValue ? ((IMob) action.targetComponent).LastFacedDirection : 1;
((IMob) action.targetComponent).SetVelocityX(action.vectorValue.x * modifier);
((IMob) action.targetComponent).SetVelocityY(action.vectorValue.y);
}
else if (action.targetComponent is Rigidbody2D)
{
((Rigidbody2D)action.targetComponent).velocity = action.vectorValue;
}
else
{
Debug.LogWarning("Tried to set velocity on an object that wasnt a Character, Enemy or Rigidbody2D");
}
break;
}
}
/// <summary>
/// Handles the event.
/// </summary>
/// <param name="sender">Sender.</param>
/// <param name="args">Arguments.</param>
protected virtual void DoAction(EventResponse action, System.EventArgs args)
{
if (action.delay == 0.0f) DoImmediateAction (action, args);
else StartCoroutine(DoDelayedAction(action, args));
}
/// <summary>
/// Processes the event. This is called directly from event feed loop
/// </summary>
/// <param name="eventResponse">The event response.</param>
private void ProcessEvent(EventResponse eventResponse)
{
// Must receive en event every 5 seconds or the feed will be shut down
// GOT THE IDEA BUT THIS WAY ??? NO !!!
////_ = ResetTimeout(EventStreamTimeout).ConfigureAwait(false);
var e = eventResponse.Event;
switch (e.EventTypeCase)
{
case Event.EventTypeOneofCase.ConnectionResponse:
RaiseRobotEvents(ConnectionResponse, new ConnectionResponseEventArgs(e));
break;
case Event.EventTypeOneofCase.CubeBattery:
RaiseRobotEvents(CubeBattery, new CubeBatteryEventArgs(e));
break;
case Event.EventTypeOneofCase.WakeWord:
ProcessWakeWord(e);
break;
case Event.EventTypeOneofCase.AttentionTransfer:
RaiseRobotEvents(AttentionTransfer, new AttentionTransferEventArgs(e));
break;
case Event.EventTypeOneofCase.KeepAlive:
RaiseRobotEvents(KeepAlive, new KeepAliveEventArgs(e));
break;
case Event.EventTypeOneofCase.JdocsChanged:
RaiseRobotEvents(JdocsChanged, new JdocsChangedEventArgs(e));
break;
case Event.EventTypeOneofCase.AlexaAuthEvent:
RaiseRobotEvents(AlexaAuth, new AlexaAuthEventArgs(e));
break;
case Event.EventTypeOneofCase.MirrorModeDisabled:
RaiseRobotEvents(MirrorModeDisabled, new MirrorModeDisabledEventArgs(e));
break;
case Event.EventTypeOneofCase.ObjectEvent:
ProcessObjectEvent(e);
break;
case Event.EventTypeOneofCase.PhotoTaken:
RaiseRobotEvents(PhotoTaken, new PhotoTakenEventArgs(e));
break;
case Event.EventTypeOneofCase.RobotChangedObservedFaceId:
RaiseRobotEvents(ChangedObservedFaceId, new RobotChangedObservedFaceIdEventArgs(e));
break;
case Event.EventTypeOneofCase.RobotObservedFace:
RaiseRobotEvents(ObservedFace, new RobotObservedFaceEventArgs(e));
break;
case Event.EventTypeOneofCase.RobotState:
RaiseRobotEvents(RobotState, new RobotStateEventArgs(e));
break;
case Event.EventTypeOneofCase.StimulationInfo:
RaiseRobotEvents(StimulationInfo, new StimulationInfoEventArgs(e));
break;
case Event.EventTypeOneofCase.TimeStampedStatus:
ProcessTimestampedStatus(e);
break;
case Event.EventTypeOneofCase.VisionModesAutoDisabled:
RaiseRobotEvents(VisionModesAutoDisabled, new VisionModesAutoDisabledEventArgs(e));
break;
case Event.EventTypeOneofCase.CheckUpdateStatusResponse:
RaiseRobotEvents(CheckUpdateStatus, new CheckUpdateStatusEventArgs(e));
break;
case Event.EventTypeOneofCase.UserIntent:
RaiseRobotEvents(UserIntent, new UserIntentEventArgs(e));
break;
case Event.EventTypeOneofCase.RobotObservedMotion:
RaiseRobotEvents(RobotObservedMotion, new RobotObservedMotionEventArgs(e));
break;
case Event.EventTypeOneofCase.RobotErasedEnrolledFace:
RaiseRobotEvents(RobotErasedEnrolledFace, new RobotErasedEnrolledFaceEventArgs(e));
break;
case Event.EventTypeOneofCase.RobotRenamedEnrolledFace:
RaiseRobotEvents(RobotRenamedEnrolledFace, new RobotRenamedEnrolledFaceEventArgs(e));
break;
case Event.EventTypeOneofCase.CameraSettingsUpdate:
RaiseRobotEvents(CameraSettingsUpdate, new CameraSettingsUpdateEventArgs(e));
break;
case Event.EventTypeOneofCase.UnexpectedMovement:
RaiseRobotEvents(UnexpectedMovement, new UnexpectedMovementEventArgs(e));
break;
default:
Console.WriteLine(string.Format("Unknown Event: {0}", e.ToString()));
break;
}
}
public void updateEventResponse(EventResponse e)
{
throw new NotImplementedException();
}
/// <summary>
/// 订阅消息（同一类消息可以重复订阅）
/// 作者：郭明
/// 日期：2017年4月3日
/// </summary>
/// <typeparam name="TD"></typeparam>
/// <typeparam name="TH"></typeparam>
/// <param name="QueueName">消息类型名称</param>
/// <param name="EventTypeName">消息类型名称</param>
/// <returns></returns>
public IEventBus Register <TD, TH>(string QueueName, string EventTypeName = "", CancellationToken cancellationToken = default(CancellationToken))
where TD : class
where TH : IEventHandler <TD>
{
var queueName = string.IsNullOrEmpty(QueueName) ? typeof(TH).FullName : QueueName;
var routeKey = string.IsNullOrEmpty(EventTypeName) ? typeof(TD).FullName : EventTypeName;
var eventAction = _lifetimeScope.GetService(typeof(TH)) as IEventHandler <TD>;
if (eventAction == null)
{
eventAction = System.Activator.CreateInstance(typeof(TH)) as IEventHandler <TD>;
}
var persistentConnection = _receiverLoadBlancer.Lease();
if (!persistentConnection.IsConnected)
{
persistentConnection.TryConnect();
}
for (int i = 0; i < _reveiverMaxDegreeOfParallelism; i++)
{
System.Threading.Tasks.Task.Run(() =>
{
try
{
var _channel = persistentConnection.GetConsumer();
//direct fanout topic
try
{
_channel.ExchangeDeclare(_exchange, _exchangeType, true, false, null);
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
}
//在MQ上定义一个持久化队列，如果名称相同不会重复创建
_channel.QueueDeclare(queueName, true, false, false, null);
//绑定交换器和队列
_channel.QueueBind(queueName, _exchange, routeKey);
//绑定交换器和队列
_channel.QueueBind(queueName, _exchange, queueName);
//输入1，那如果接收一个消息，但是没有应答，则客户端不会收到下一个消息
_channel.BasicQos(0, _preFetch, false);
//在队列上定义一个消费者a
EventingBasicConsumer consumer = new EventingBasicConsumer(_channel);
consumer.Received += async(ch, ea) =>
{
using (var tracer = new Hummingbird.Extensions.Tracing.Tracer("AMQP Received"))
{
try
{
#region Ensure IsConnected
if (!persistentConnection.IsConnected)
{
persistentConnection.TryConnect();
}
#endregion
var EventId = -1L;
var MessageId = string.IsNullOrEmpty(ea.BasicProperties.MessageId) ? Guid.NewGuid().ToString("N") : ea.BasicProperties.MessageId;
var TraceId = MessageId;
#region 获取 eventId
if (ea.BasicProperties.Headers != null && ea.BasicProperties.Headers.ContainsKey("x-eventId"))
{
try
{
long.TryParse(ea.BasicProperties.Headers["x-eventId"].ToString(), out EventId);
}
catch (Exception ex)
{
try
{
long.TryParse(System.Text.Encoding.UTF8.GetString(ea.BasicProperties.Headers["x-eventId"] as byte[]), out EventId);
}
catch
{
}
}
}
#endregion
#region 获取 eventId
if (ea.BasicProperties.Headers != null && ea.BasicProperties.Headers.ContainsKey("x-traceId"))
{
try
{
TraceId = System.Text.Encoding.UTF8.GetString(ea.BasicProperties.Headers["x-traceId"] as byte[]);
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
}
}
#endregion
tracer.SetComponent(_compomentName);
tracer.SetTag("queueName", queueName);
tracer.SetTag("x-messageId", MessageId);
tracer.SetTag("x-traceId", TraceId);
tracer.SetTag("x-eventId", EventId);
var eventResponse = new EventResponse()
{
EventId = EventId,
MessageId = MessageId,
TraceId = TraceId,
Headers = ea.BasicProperties.Headers ?? new Dictionary <string, object>(),
QueueName = queueName,
RouteKey = routeKey,
BodySource = Encoding.UTF8.GetString(ea.Body),
Body = default(TD),
};
try
{
#region 设置body
eventResponse.Body = JsonConvert.DeserializeObject <TD>(eventResponse.BodySource);
#endregion
#region 设置header
if (!eventResponse.Headers.ContainsKey("x-exchange"))
{
eventResponse.Headers.Add("x-exchange", _exchange);
}
if (!eventResponse.Headers.ContainsKey("x-exchange-type"))
{
eventResponse.Headers.Add("x-exchange-type", _exchangeType);
}
#endregion
_logger.LogInformation(eventResponse.BodySource);
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
}
#region AMQP ExecuteAsync
using (var tracerExecuteAsync = new Hummingbird.Extensions.Tracing.Tracer("AMQP Execute"))
{
var handlerSuccess = false;
var handlerException = default(Exception);
tracerExecuteAsync.SetComponent(_compomentName);
tracerExecuteAsync.SetTag("queueName", queueName);
tracerExecuteAsync.SetTag("x-messageId", MessageId);
tracerExecuteAsync.SetTag("x-traceId", TraceId);
tracerExecuteAsync.SetTag("x-eventId", EventId);
try
{
handlerSuccess = await _receiverPolicy.ExecuteAsync(async(handlerCancellationToken) =>
{
return(await eventAction.Handle(eventResponse.Body, (Dictionary <string, object>)eventResponse.Headers, handlerCancellationToken));
}, cancellationToken);
if (handlerSuccess)
{
if (_subscribeAckHandler != null)
{
_subscribeAckHandler(new EventResponse[] { eventResponse });
}
//确认消息
_channel.BasicAck(ea.DeliveryTag, false);
}
else
{
tracerExecuteAsync.SetError();
}
}
catch (Exception ex)
{
tracerExecuteAsync.SetError();
handlerException = ex;
_logger.LogError(ex, ex.Message);
}
finally
{
if (!handlerSuccess)
{
//重新入队，默认：是
var requeue = true;
try
{
//执行回调，等待业务层的处理结果
if (_subscribeNackHandler != null)
{
requeue = await _subscribeNackHandler((new EventResponse[] { eventResponse }, handlerException));
}
}
catch (Exception innterEx)
{
_logger.LogError(innterEx, innterEx.Message);
}
//确认消息
_channel.BasicReject(ea.DeliveryTag, requeue);
}
}
}
#endregion
}
catch (Exception ex)
{
tracer.SetError();
_logger.LogError(ex.Message, ex);
}
}
};
consumer.Unregistered += (ch, ea) =>
{
_logger.LogDebug($"MQ:{queueName} Consumer_Unregistered");
};
consumer.Registered += (ch, ea) =>
{
_logger.LogDebug($"MQ:{queueName} Consumer_Registered");
};
consumer.Shutdown += (ch, ea) =>
{
_logger.LogDebug($"MQ:{queueName} Consumer_Shutdown.{ea.ReplyText}");
};
consumer.ConsumerCancelled += (object sender, ConsumerEventArgs e) =>
{
_logger.LogDebug($"MQ:{queueName} ConsumerCancelled");
};
//消费队列，并设置应答模式为程序主动应答
_channel.BasicConsume(queueName, false, consumer);
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
}
});
}
return(this);
}
async Task <string> GetEvents()
{
try
{
DateTimeOffset dateTimeOffset = DateTimeOffset.Now;
string url = AppConstants.GoogleCalendarUrl + "?orderBy=startTime&singleEvents=true&";
var authToken = account.accessToken;
//Debug.WriteLine("AuthToken: " + authToken);
int publicYear = dateTimeOffset.Year;
int publicMonth = dateTimeOffset.Month;
int publicDay = dateTimeOffset.Day;
string timeZoneOffset = dateTimeOffset.ToString();
string[] timeZoneOffsetParsed = timeZoneOffset.Split('-');
int timeZoneNum = Int32.Parse(timeZoneOffsetParsed[1].Substring(0, 2));
string monthString;
string dayString;
string paddedTimeZoneNum;
if (timeZoneNum < 10)
{
paddedTimeZoneNum = timeZoneNum.ToString().PadLeft(2, '0');
}
else
{
paddedTimeZoneNum = timeZoneNum.ToString();
}
if (publicMonth < 10)
{
monthString = publicMonth.ToString().PadLeft(2, '0');
}
else
{
monthString = publicMonth.ToString();
}
if (publicDay < 10)
{
dayString = publicDay.ToString().PadLeft(2, '0');
}
else
{
dayString = publicDay.ToString();
}
string timeMaxMin = String.Format("timeMax={0}-{1}-{2}T23%3A59%3A59-{3}%3A00&timeMin={0}-{1}-{2}T00%3A00%3A01-{3}%3A00", publicYear, monthString, dayString, paddedTimeZoneNum);
string fullURI = url + timeMaxMin;
//Set up the request
var request = new HttpRequestMessage();
//Debug.WriteLine("EVEN URL: " + fullURI);
request.RequestUri = new Uri(fullURI);
request.Method = HttpMethod.Get;
//Format Headers of Request with included Token
string bearerString = string.Format("Bearer {0}", authToken);
request.Headers.Add("Authorization", bearerString);
request.Headers.Add("Accept", "application/json");
//Debug.WriteLine("Manifest.Services.Google.Calendar: Making request to " + fullURI);
var response = await client.SendAsync(request);
if (!response.IsSuccessStatusCode)
{
return("FAILURE");
}
var json = await response.Content.ReadAsStringAsync();
//var json = response.Content;
//Debug.WriteLine("Calendars response:\n" + json);
//var serializer = new JavaScriptSerializer(); //using System.Web.Script.Serialization;
EventResponse eventResponse = JsonConvert.DeserializeObject <EventResponse>(json);
//List<Event> events = eventResponse.ToEvents();
eventsToday = eventResponse.ToEvents();
//Debug.WriteLine("Converted to Events");
EventsToOccurances(eventsToday);
}
catch (Exception e)
{
await DisplayAlert("Alert", "Error in TodaysListTest GetEvents(). Error: " + e.ToString(), "OK");
return("FAILURE");
}
return("SUCCESS");
}
public ExceptionEventArgs(EventResponse exceptionEvent)
{
ExceptionEvent = exceptionEvent;
}
public CompileScriptEventArgs(EventResponse compileScriptEvent)
{
CompileScriptEvent = compileScriptEvent;
}
public EventResponse BookEvent(BookEventRequest model)
{
var response = new EventResponse();
var member = _memberProvider.GetLoggedInMember();
if (member == null)
{
response.Error = "Unable to find logged in member record.";
return(response);
}
var membershipExpiry = member.GetValue <DateTime>(MemberProperty.MembershipExpiry);
bool isMembershipExpired = membershipExpiry < DateTime.Now;
if (isMembershipExpired)
{
response.Error = "Your membership has expired, please renew your membership before booking any events.";
return(response);
}
var memberType = member.GetValue <MembershipTypeEnum>(MemberProperty.membershipType);
var isGuest = memberType == MembershipTypeEnum.Guest;
if (string.Equals(model.EventTypeName, "Open Water Swim", StringComparison.OrdinalIgnoreCase) && !isGuest && !member.GetValue <bool>(MemberProperty.OpenWaterIndemnityAcceptance))
{
response.Error = "You need to signup for open water swimming (on your member details page) before you can book onto open water swim sessions.";
return(response);
}
if (string.Equals(model.EventTypeName, "Pool Swim", StringComparison.OrdinalIgnoreCase) && !CanBookPoolSwim(member, model.EventSlotId))
{
response.Error = "You need to signup for swim subs (on your member details page) before you can book onto pool swim sessions.";
return(response);
}
if (member.GetValue <int>(MemberProperty.TrainingCredits) < model.Cost)
{
response.Error = "You do not have enough training credits to book that event.";
return(response);
}
var eventSlot = _eventSlotRepository.GetById(model.EventSlotId);
if (!eventSlot.HasSpace)
{
response.Error = "There is no space remaining on that training slot.";
return(response);
}
if (eventSlot.EventParticipants.Any(ep => ep.MemberId == member.Id))
{
response.Error = "You are already booked onto that event.";
return(response);
}
var eventParticipant = new EventParticipant()
{
EventSlotId = model.EventSlotId,
AmountPaid = model.Cost,
MemberId = member.Id,
RaceDistance = string.IsNullOrEmpty(model.RaceDistance) ? null : model.RaceDistance
};
//Debit cost from members credits
var credits = member.GetValue <int>(MemberProperty.TrainingCredits);
credits = credits - model.Cost;
member.SetValue(MemberProperty.TrainingCredits, credits);
Services.MemberService.Save(member);
eventParticipant = _eventParticipantRepository.Create(eventParticipant);
Logger.Info(typeof(EventController), $"New event slot booking - Member: {member.Name} , Event: {model.EventTypeName} on {eventSlot.Date.ToString("dd/MM/yyyy")} for £{model.Cost}.");
return(response);
}
public async Task <EventResponseApiResponse> Respond(Guid id, EventResponseType type)
{
EventResponse response = await _eventService.UpdateMemberResponse(GetMemberId(), id, type);
return(_mapper.Map <EventResponseApiResponse>(response));
}
/// <summary>
/// Processes the event. This is called directly from event feed loop
/// </summary>
/// <param name="eventResponse">The event response.</param>
private void ProcessEvent(EventResponse eventResponse)
{
// Must receive en event every 5 seconds or the feed will be shut down
_ = ResetTimeout(EventStreamTimeout).ConfigureAwait(false);
var e = eventResponse.Event;
switch (e.EventTypeCase)
{
case Event.EventTypeOneofCase.ConnectionResponse:
RaiseRobotEvents(ConnectionResponse, new ConnectionResponseEventArgs(e));
break;
case Event.EventTypeOneofCase.CubeBattery:
RaiseRobotEvents(CubeBattery, new CubeBatteryEventArgs(e));
break;
case Event.EventTypeOneofCase.WakeWord:
ProcessWakeWord(e);
break;
case Event.EventTypeOneofCase.AttentionTransfer:
RaiseRobotEvents(AttentionTransfer, new AttentionTransferEventArgs(e));
break;
case Event.EventTypeOneofCase.KeepAlive:
RaiseRobotEvents(KeepAlive, new KeepAliveEventArgs(e));
break;
case Event.EventTypeOneofCase.MirrorModeDisabled:
RaiseRobotEvents(MirrorModeDisabled, new MirrorModeDisabledEventArgs(e));
break;
case Event.EventTypeOneofCase.ObjectEvent:
ProcessObjectEvent(e);
break;
case Event.EventTypeOneofCase.PhotoTaken:
RaiseRobotEvents(PhotoTaken, new PhotoTakenEventArgs(e));
break;
case Event.EventTypeOneofCase.RobotChangedObservedFaceId:
RaiseRobotEvents(ChangedObservedFaceId, new RobotChangedObservedFaceIdEventArgs(e));
break;
case Event.EventTypeOneofCase.RobotObservedFace:
RaiseRobotEvents(ObservedFace, new RobotObservedFaceEventArgs(e));
break;
case Event.EventTypeOneofCase.RobotState:
RaiseRobotEvents(RobotState, new RobotStateEventArgs(e));
break;
case Event.EventTypeOneofCase.StimulationInfo:
RaiseRobotEvents(StimulationInfo, new StimulationInfoEventArgs(e));
break;
case Event.EventTypeOneofCase.TimeStampedStatus:
ProcessTimestampedStatus(e);
break;
case Event.EventTypeOneofCase.VisionModesAutoDisabled:
RaiseRobotEvents(VisionModesAutoDisabled, new VisionModesAutoDisabledEventArgs(e));
break;
case Event.EventTypeOneofCase.UserIntent:
RaiseRobotEvents(UserIntent, new UserIntentEventArgs(e));
break;
}
}
private List<UserModel> GetGoingStatus(UserEvent userEvent, EventResponse eventResponse)
{
var response = eventResponse.ToString();
return _repository.GetEntities<Event>()
.Where(e => e.Id == userEvent.EventId)
.SelectMany(e => e.UserEvents)
.Include(e => e.AspNetUser.UserInfo)
.Where(ue => ue.Response.Equals(response))
.Select(u => new UserModel { FullName = u.AspNetUser.UserInfo.FullName })
.ToList();
}
private void CheckGetResponse(string token, EventResponse actual, LanguageCode languageCode)
{
switch (token)
{
case "667fbd353e8d4e9d9e0611d489d5efb6":
Assert.AreEqual(32, actual.EventToken.Length);
Assert.AreEqual("Dueling over a Grand Regatta", actual.Name);
Assert.AreEqual("DOG2015", actual.FriendlyUrlPath);
Assert.AreEqual(null, actual.Description);
Assert.AreEqual(EventStateEnum.Active, actual.State);
Assert.AreEqual("2015-03-01 00:00:00", actual.StartDatetime.ToString());
Assert.AreEqual("2015-03-27 00:00:00", actual.EndDatetime.ToString());
if (languageCode == LanguageCode.en)
{
Assert.AreEqual(@"By making this payment you expressly authorize the service provider, Peloton Technologies Inc., to charge your credit card for the noted dollar amount.
You can expect that your credit card information will be transmitted securely with the utmost protection by the service provider Peloton Technologies Inc.
If you require an adjustment to your transaction after processing has occurred, please contact one of our representatives prior to contacting the service provider, Peloton Technologies.
If you wish to dispute a charge please contact Peloton Technologies Inc. at {0} or {1}.".Replace("\n", "")
.Replace("\r", ""), actual.TermsAndConditionsContent.Replace("\n", "").Replace("\r", ""));
Assert.AreEqual("For all refunds, please contact one of our representatives.", actual.RefundPolicyContent);
}
if (languageCode == LanguageCode.fr)
{
Assert.AreEqual(@"En faisant ce paiement, vous autorisez expressément le fournisseur de services, Peloton Technologies Inc., de débiter votre carte de crédit pour le montant indiqué.Vous pouvez vous attendre que vos informations de carte de crédit sera transmis en toute sécurité avec la plus grande protection par le fournisseur de services Peloton Technologies Inc.Si vous avez besoin d'un ajustement à votre transaction après le traitement a eu lieu, s'il vous plaît contacter un de nos représentants avant de communiquer avec le fournisseur de services, Peloton Technologies. Si vous souhaitez contester une accusation s'il vous plaît contacter Peloton Technologies Inc. à {0} ou {1}.".Replace("\n", "")
.Replace("\r", ""), actual.TermsAndConditionsContent.Replace("\n", "").Replace("\r", ""));
Assert.AreEqual("Pour tous les remboursements, s'il vous plaît contacter un de nos représentants.", actual.RefundPolicyContent);
}
// TODO: the api only saves/returns one Event Item. The rest are discarded.
//Assert.AreEqual(expected.Items.Count, actual.Items.Count);
Assert.AreEqual(1, actual.Items.Count);
for (var i = 0; i < actual.Items.Count; i++)
{
Debug.WriteLine($"item {i}");
var actualItem = actual.Items.ElementAt(i);
// TODO: the name field is ignored on creation of Event POST
//Assert.AreEqual(expectedItem.Name, actualItem.Name);
// item name actually comes back as the event name
// workaround:
Assert.AreEqual("Dueling over a Grand Regatta", actualItem.Name);
// TODO: the description field is ignored on creation of Event POST
//Assert.AreEqual(expectedItem.Description, actualItem.Description);
// item description comes back as the event description
// workaround:
Assert.AreEqual(null, actualItem.Description);
Assert.AreEqual(false, actualItem.QuantitySelector);
// TODO: the default_unit_quantity field is ignored on creation of Event POST
//Assert.AreEqual(expectedItem.DefaultUnitQuantity, actualItem.DefaultUnitQuantity);
// item default quantity will come back un-set
// workaround:
Assert.AreEqual(default(int), actualItem.DefaultUnitQuantity);
Assert.AreEqual(null, actualItem.UnitQuantityDescription);
Assert.AreEqual(0, actualItem.UnitAmount);
Assert.AreEqual(0, actualItem.Amount);
Assert.AreEqual(true, actualItem.AmountAdjustable);
Assert.AreEqual(5, actualItem.CustomFields.Count);
Debug.WriteLine($"item custom field {0}");
var actualItemCustomField = actualItem.CustomFields.ElementAt(0);
Assert.AreEqual("Race Name", actualItemCustomField.Name);
Assert.AreEqual(null, actualItemCustomField.DefaultValue);
Assert.AreEqual(EventCustomFieldTypeEnum.@string, actualItemCustomField.Type);
Assert.AreEqual(0, actualItemCustomField.DisplayOrder);
Assert.AreEqual(true, actualItemCustomField.Required);
Debug.WriteLine($"item custom field {1}");
actualItemCustomField = actualItem.CustomFields.ElementAt(1);
Assert.AreEqual("Participant Name", actualItemCustomField.Name);
Assert.AreEqual(null, actualItemCustomField.DefaultValue);
Assert.AreEqual(EventCustomFieldTypeEnum.@string, actualItemCustomField.Type);
Assert.AreEqual(1, actualItemCustomField.DisplayOrder);
Assert.AreEqual(true, actualItemCustomField.Required);
Debug.WriteLine($"item custom field {2}");
actualItemCustomField = actualItem.CustomFields.ElementAt(2);
Assert.AreEqual("Other 1", actualItemCustomField.Name);
Assert.AreEqual(null, actualItemCustomField.DefaultValue);
Assert.AreEqual(EventCustomFieldTypeEnum.@string, actualItemCustomField.Type);
Assert.AreEqual(2, actualItemCustomField.DisplayOrder);
Assert.AreEqual(false, actualItemCustomField.Required);
Debug.WriteLine($"item custom field {3}");
actualItemCustomField = actualItem.CustomFields.ElementAt(3);
Assert.AreEqual("Other 2", actualItemCustomField.Name);
Assert.AreEqual(null, actualItemCustomField.DefaultValue);
Assert.AreEqual(EventCustomFieldTypeEnum.@string, actualItemCustomField.Type);
Assert.AreEqual(3, actualItemCustomField.DisplayOrder);
Assert.AreEqual(false, actualItemCustomField.Required);
Debug.WriteLine($"item custom field {4}");
actualItemCustomField = actualItem.CustomFields.ElementAt(4);
Assert.AreEqual("Other 3", actualItemCustomField.Name);
Assert.AreEqual(null, actualItemCustomField.DefaultValue);
Assert.AreEqual(EventCustomFieldTypeEnum.@string, actualItemCustomField.Type);
Assert.AreEqual(4, actualItemCustomField.DisplayOrder);
Assert.AreEqual(false, actualItemCustomField.Required);
}
break;
default:
break;
}
}
protected async Task OnGrpcStreamEvent(EventResponse _event)
{
try
{
EventType eventType = _event.Type;
string payload = _event.Payload;
Console.WriteLine($"{eventType},PayLoad:{payload}");
if (eventType != EventType.Heartbeat)
{
EventHeartbeatPayload eventHeartbeatPayload = new EventHeartbeatPayload()
{
Data = $"onGrpcStreamEvent({eventType.ToString()})"
};
await _localEventBus.PublishAsync(eventHeartbeatPayload);
}
switch (eventType)
{
case EventType.Unspecified:
Logger.LogError("onGrpcStreamEvent() got an EventType.EVENT_TYPE_UNSPECIFIED ?");
break;
case EventType.Heartbeat:
await _localEventBus.PublishAsync(JsonConvert.DeserializeObject <EventHeartbeatPayload>(payload));
break;
case EventType.Message:
await _localEventBus.PublishAsync(JsonConvert.DeserializeObject <EventMessagePayload>(payload));
break;
case EventType.Dong:
await _localEventBus.PublishAsync(JsonConvert.DeserializeObject <EventDongPayload>(payload));
break;
case EventType.Error:
await _localEventBus.PublishAsync(JsonConvert.DeserializeObject <EventErrorPayload>(payload));
break;
case EventType.Friendship:
await _localEventBus.PublishAsync(JsonConvert.DeserializeObject <FriendshipPayload>(payload));
break;
case EventType.RoomInvite:
await _localEventBus.PublishAsync(JsonConvert.DeserializeObject <EventRoomInvitePayload>(payload));
break;
case EventType.RoomJoin:
await _localEventBus.PublishAsync(JsonConvert.DeserializeObject <EventRoomJoinPayload>(payload));
break;
case EventType.RoomLeave:
await _localEventBus.PublishAsync(JsonConvert.DeserializeObject <EventRoomLeavePayload>(payload));
break;
case EventType.RoomTopic:
await _localEventBus.PublishAsync(JsonConvert.DeserializeObject <EventRoomTopicPayload>(payload));
break;
case EventType.Scan:
await _localEventBus.PublishAsync(JsonConvert.DeserializeObject <EventScanPayload>(payload));
break;
case EventType.Ready:
await _localEventBus.PublishAsync(JsonConvert.DeserializeObject <EventReadyPayload>(payload));
break;
case EventType.Reset:
//await _localEventBus.PublishAsync(JsonConvert.DeserializeObject<EventResetPayload>(payload));
//log.warn('PuppetHostie', 'onGrpcStreamEvent() got an EventType.EVENT_TYPE_RESET ?')
// the `reset` event should be dealed not send out
Logger.LogWarning("onGrpcStreamEvent() got an EventType.EVENT_TYPE_RESET ?");
break;
case EventType.Login:
var loginPayload = JsonConvert.DeserializeObject <EventLoginPayload>(payload);
selfId = loginPayload.ContactId;
await _localEventBus.PublishAsync(JsonConvert.DeserializeObject <EventLoginPayload>(payload));
break;
case EventType.Logout:
selfId = string.Empty;
await _localEventBus.PublishAsync(JsonConvert.DeserializeObject <EventLogoutPayload>(payload));
break;
//default:
// Console.WriteLine($"'eventType {_event.Type.ToString()} unsupported! (code should not reach here)");
// //throw new BusinessException($"'eventType {_event.Type.ToString()} unsupported! (code should not reach here)");
// break;
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
Logger.LogError(ex, "OnGrpcStreamEvent exception");
}
}
internal static void CheckResponseAndResult(EventRequest expected, EventResponse actual, EventStateEnum eventStateCode)
{
Assert.AreEqual(32, actual.EventToken.Length);
Assert.AreEqual(expected.Name, actual.Name);
Assert.AreEqual(expected.FriendlyUrlPath, actual.FriendlyUrlPath);
Assert.AreEqual(expected.Description, actual.Description);
Assert.AreEqual(eventStateCode, actual.State);
Assert.AreEqual(expected.StartDatetime.ToString(), actual.StartDatetime.ToString());
Assert.AreEqual(expected.EndDatetime.ToString(), actual.EndDatetime.ToString());
if (String.IsNullOrWhiteSpace(expected.TermsAndConditionsContent))
{
Assert.AreEqual(@"By making this payment you expressly authorize the service provider, Peloton Technologies Inc., to charge your credit card for the noted dollar amount.
You can expect that your credit card information will be transmitted securely with the utmost protection by the service provider Peloton Technologies Inc.
If you require an adjustment to your transaction after processing has occurred, please contact one of our representatives prior to contacting the service provider, Peloton Technologies.
If you wish to dispute a charge please contact Peloton Technologies Inc. at {0} or {1}.".Replace("\n", "")
.Replace("\r", ""), actual.TermsAndConditionsContent.Replace("\n", "").Replace("\r", ""));
}
else
{
Assert.AreEqual(expected.TermsAndConditionsContent, actual.TermsAndConditionsContent);
}
if (String.IsNullOrWhiteSpace(expected.RefundPolicyContent))
{
Assert.AreEqual("For all refunds, please contact one of our representatives.", actual.RefundPolicyContent);
}
else
{
Assert.AreEqual(expected.RefundPolicyContent, actual.RefundPolicyContent);
}
// TODO: the api only saves/returns one Event Item. The rest are discarded.
//Assert.AreEqual(expected.Items.Count, actual.Items.Count);
// workaround:
if (expected.Items.Count >= 2)
{
Assert.AreEqual(1, actual.Items.Count);
}
else
{
Assert.AreEqual(expected.Items.Count, actual.Items.Count);
}
for (var i = 0; i < actual.Items.Count; i++)
{
Debug.WriteLine($"item {i}");
var expectedItem = expected.Items.ElementAt(i);
var actualItem = actual.Items.ElementAt(i);
//var actualItem = actual.Items.Where(ai => ai.Name == expectedItem.Name).Single();
// TODO: the name field is ignored on creation of Event POST
//Assert.AreEqual(expectedItem.Name, actualItem.Name);
// item name actually comes back as the event name
// workaround:
Assert.AreEqual(expected.Name, actualItem.Name);
// TODO: the description field is ignored on creation of Event POST
//Assert.AreEqual(expectedItem.Description, actualItem.Description);
// item description comes back as the event description
// workaround:
Assert.AreEqual(expected.Description, actualItem.Description);
Assert.AreEqual(expectedItem.QuantitySelector, actualItem.QuantitySelector);
// TODO: the default_unit_quantity field is ignored on creation of Event POST
//Assert.AreEqual(expectedItem.DefaultUnitQuantity, actualItem.DefaultUnitQuantity);
// item default quantity will come back un-set
// workaround:
Assert.AreEqual(default(int), actualItem.DefaultUnitQuantity);
Assert.AreEqual(expectedItem.UnitQuantityDescription, actualItem.UnitQuantityDescription);
Assert.AreEqual(expectedItem.UnitAmount, actualItem.UnitAmount);
Assert.AreEqual(expectedItem.Amount, actualItem.Amount);
Assert.AreEqual(expectedItem.AmountAdjustable, actualItem.AmountAdjustable);
Assert.AreEqual(expectedItem.CustomFields.Count, actualItem.CustomFields.Count);
for (var j = 0; j < expectedItem.CustomFields.Count; j++)
{
Debug.WriteLine($"item custom field {j}");
var expectedItemCustomField = expectedItem.CustomFields.ElementAt(j);
var actualItemCustomField = actualItem.CustomFields.ElementAt(j);
Assert.AreEqual(expectedItemCustomField.Name, actualItemCustomField.Name);
Assert.AreEqual(expectedItemCustomField.DefaultValue, actualItemCustomField.DefaultValue);
Assert.AreEqual(expectedItemCustomField.Type, actualItemCustomField.Type);
Assert.AreEqual(expectedItemCustomField.DisplayOrder, actualItemCustomField.DisplayOrder);
Assert.AreEqual(expectedItemCustomField.Required, actualItemCustomField.Required);
}
}
}
public BreakpointEventArgs(EventResponse breakpointEvent)
{
BreakpointEvent = breakpointEvent;
}
/// <summary>
/// 订阅消息（同一类消息可以重复订阅）
/// 作者：郭明
/// 日期：2017年4月3日
/// </summary>
/// <typeparam name="TD"></typeparam>
/// <typeparam name="TH"></typeparam>
/// <param name="QueueName">消息类型名称</param>
/// <param name="EventTypeName">消息类型名称</param>
/// <returns></returns>
public IEventBus Register <TD, TH>(string QueueName, string EventTypeName = "", CancellationToken cancellationToken = default(CancellationToken))
where TD : class
where TH : IEventHandler <TD>
{
var persistentConnection = _receiveLoadBlancer.Lease();
var queueName = string.IsNullOrEmpty(QueueName) ? typeof(TH).FullName : QueueName;
var routeKey = string.IsNullOrEmpty(EventTypeName) ? typeof(TD).FullName : EventTypeName;
var eventAction = _lifetimeScope.GetService(typeof(TH)) as IEventHandler <TD>;
if (eventAction == null)
{
eventAction = System.Activator.CreateInstance(typeof(TH)) as IEventHandler <TD>;
}
for (int i = 0; i < _reveiverMaxDegreeOfParallelism; i++)
{
System.Threading.Tasks.Task.Run(async() =>
{
try
{
var consumer = persistentConnection.GetConsumer();
consumer.Subscribe(routeKey);
while (true)
{
var ea = consumer.Consume(cancellationToken);
// 消息队列空
if (ea.IsPartitionEOF)
{
_logger.LogDebug("Reached end of topic {consumeResult.Topic}, partition {consumeResult.Partition}, offset {consumeResult.Offset}.");
continue;
}
var EventId = -1L;
var MessageId = ea.Key;
var TraceId = MessageId;
using (var tracer = new Hummingbird.Extensions.Tracing.Tracer("AMQP Received", TraceId))
{
#region 获取EventId 和 TracerId
if (ea.Headers != null)
{
try
{
long.TryParse(System.Text.Encoding.UTF8.GetString(ea.Headers.GetLastBytes("x-eventId")), out EventId);
}
catch
{ }
try
{
TraceId = System.Text.Encoding.UTF8.GetString(ea.Headers.GetLastBytes("x-traceId"));
}
catch
{
}
}
#endregion
#region AMQP Received
try
{
tracer.SetComponent(_compomentName);
tracer.SetTag("queueName", queueName);
tracer.SetTag("x-messageId", MessageId);
tracer.SetTag("x-eventId", EventId);
tracer.SetTag("x-traceId", TraceId);
var eventResponse = new EventResponse()
{
EventId = EventId,
MessageId = MessageId,
TraceId = TraceId,
Headers = new Dictionary <string, object>(),
Body = default(TD),
QueueName = queueName,
RouteKey = routeKey,
BodySource = ea.Value
};
try
{
foreach (var key in ea.Headers)
{
eventResponse.Headers.Add(key.Key, Encoding.UTF8.GetString(key.GetValueBytes()));
}
eventResponse.Body = JsonConvert.DeserializeObject <TD>(eventResponse.BodySource);
_logger.LogInformation(eventResponse.BodySource);
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
}
#region AMQP ExecuteAsync
using (var tracerExecuteAsync = new Hummingbird.Extensions.Tracing.Tracer("AMQP ExecuteAsync"))
{
var handlerSuccess = false;
var handlerException = default(Exception);
try
{
handlerSuccess = await _receiverPolicy.ExecuteAsync(async(handlerCancellationToken) =>
{
return(await eventAction.Handle(eventResponse.Body, (Dictionary <string, object>)eventResponse.Headers, handlerCancellationToken));
}, CancellationToken.None);
if (handlerSuccess)
{
if (_subscribeAckHandler != null)
{
_subscribeAckHandler(new EventResponse[] { eventResponse });
}
consumer.Commit(ea);
}
else
{
tracerExecuteAsync.SetError();
}
}
catch (Exception ex)
{
tracerExecuteAsync.SetError();
handlerException = ex;
}
finally
{
if (!handlerSuccess)
{
//重新入队，默认：是
var requeue = true;
try
{
//执行回调，等待业务层的处理结果
if (_subscribeNackHandler != null)
{
requeue = await _subscribeNackHandler((new EventResponse[] { eventResponse }, handlerException));
}
}
catch (Exception innterEx)
{
_logger.LogError(innterEx, innterEx.Message);
}
if (!requeue)
{
consumer.Commit(ea);
}
}
}
}
#endregion
}
catch (Exception ex)
{
tracer.SetError();
_logger.LogError(ex.Message, ex);
}
#endregion
}
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
}
});
}
return(this);
}
/// <summary>
/// 订阅消息（同一类消息可以重复订阅）
/// 作者：郭明
/// 日期：2017年4月3日
/// </summary>
/// <typeparam name="TD"></typeparam>
/// <typeparam name="TH"></typeparam>
/// <param name="EventTypeName">消息类型名称</param>
/// <returns></returns>
public IEventBus RegisterBatch <TD, TH>(string QueueName, string EventTypeName = "", int BatchSize = 50, CancellationToken cancellationToken = default(CancellationToken))
where TD : class
where TH : IEventBatchHandler <TD>
{
var queueName = string.IsNullOrEmpty(QueueName) ? typeof(TH).FullName : QueueName;
var routeKey = string.IsNullOrEmpty(EventTypeName) ? typeof(TD).FullName : EventTypeName;
var eventAction = _lifetimeScope.GetService(typeof(TH)) as IEventBatchHandler <TD>;
if (eventAction == null)
{
eventAction = System.Activator.CreateInstance(typeof(TH)) as IEventBatchHandler <TD>;
}
var persistentConnection = _receiverLoadBlancer.Lease();
if (!persistentConnection.IsConnected)
{
persistentConnection.TryConnect();
}
for (int parallelism = 0; parallelism < _reveiverMaxDegreeOfParallelism; parallelism++)
{
try
{
var _channel = persistentConnection.GetConsumer();
//direct fanout topic
try
{
_channel.ExchangeDeclare(_exchange, _exchangeType, true, false, null);
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
}
//在MQ上定义一个持久化队列，如果名称相同不会重复创建
_channel.QueueDeclare(queueName, true, false, false, null);
//绑定交换器和队列
_channel.QueueBind(queueName, _exchange, routeKey);
_channel.QueueBind(queueName, _exchange, queueName);
//输入1，那如果接收一个消息，但是没有应答，则客户端不会收到下一个消息
_channel.BasicQos(0, (ushort)BatchSize, false);
Task.Run(async() =>
{
while (true)
{
cancellationToken.ThrowIfCancellationRequested();
try
{
var batchPool = new List <(string MessageId, BasicGetResult ea)>();
var batchLastDeliveryTag = 0UL;
#region batch Pull
for (var i = 0; i < BatchSize; i++)
{
var ea = _channel.BasicGet(queueName, false);
if (ea != null)
{
var MessageId = ea.BasicProperties.MessageId;
if (string.IsNullOrEmpty(MessageId))
{
batchPool.Add((Guid.NewGuid().ToString("N"), ea));
}
else
{
batchPool.Add((ea.BasicProperties.MessageId, ea));
}
batchLastDeliveryTag = ea.DeliveryTag;
}
else
{
break;
}
}
#endregion
//队列不为空
if (batchPool.Count > 0)
{
using (var receiveTracer = new Hummingbird.Extensions.Tracing.Tracer("AMQP Received"))
{
var basicGetResults = batchPool.Select(a => a.ea).ToArray();
var Messages = new EventResponse[basicGetResults.Length];
var handlerSuccess = false;
var handlerException = default(Exception);
try
{
for (int i = 0; i < basicGetResults.Length; i++)
{
var ea = basicGetResults[i];
var MessageId = string.IsNullOrEmpty(ea.BasicProperties.MessageId) ? Guid.NewGuid().ToString("N") : ea.BasicProperties.MessageId;
var TraceId = MessageId;
var EventId = -1L;
if (ea.BasicProperties.Headers != null)
{
#region 获取 eventId
if (ea.BasicProperties.Headers.ContainsKey("x-eventId"))
{
try
{
long.TryParse(ea.BasicProperties.Headers["x-eventId"].ToString(), out EventId);
}
catch (Exception ex)
{
try
{
long.TryParse(System.Text.Encoding.UTF8.GetString(ea.BasicProperties.Headers["x-eventId"] as byte[]), out EventId);
}
catch
{
}
}
}
#endregion
#region 获取 traceid
if (!ea.BasicProperties.Headers.ContainsKey("x-traceId"))
{
try
{
TraceId = System.Text.Encoding.UTF8.GetString(ea.BasicProperties.Headers["traceId"] as byte[]);
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
}
}
#endregion
}
using (var tracer = new Hummingbird.Extensions.Tracing.Tracer("AMQP BasicGet"))
{
tracer.SetComponent(_compomentName);
tracer.SetTag("queueName", queueName);
tracer.SetTag("x-messageId", MessageId);
tracer.SetTag("x-eventId", EventId);
tracer.SetTag("x-traceId", TraceId);
Messages[i] = new EventResponse()
{
EventId = EventId,
MessageId = MessageId,
TraceId = TraceId,
Headers = ea.BasicProperties.Headers ?? new Dictionary <string, object>(),
RouteKey = routeKey,
QueueName = queueName,
BodySource = Encoding.UTF8.GetString(ea.Body),
Body = default(TD),
};
#region 设置 header
if (!Messages[i].Headers.ContainsKey("x-exchange"))
{
Messages[i].Headers.Add("x-exchange", _exchange);
}
if (!Messages[i].Headers.ContainsKey("x-exchange-type"))
{
Messages[i].Headers.Add("x-exchange-type", _exchangeType);
}
#endregion
#region 设置body
try
{
Messages[i].Body = JsonConvert.DeserializeObject <TD>(Messages[i].BodySource);
_logger.LogInformation(Messages[i].BodySource);
}
catch (Exception ex)
{
tracer.SetError();
_logger.LogError(ex, ex.Message);
}
#endregion
}
}
if (Messages != null && Messages.Any())
{
using (var executeTracer = new Hummingbird.Extensions.Tracing.Tracer("AMQP Execute"))
{
executeTracer.SetComponent(_compomentName);
executeTracer.SetTag("queueName", queueName);
handlerSuccess = await _receiverPolicy.ExecuteAsync(async(handlerCancellationToken) =>
{
return(await eventAction.Handle(Messages.Select(a => (TD)a.Body).ToArray(), Messages.Select(a => (Dictionary <string, object>)a.Headers).ToArray(), handlerCancellationToken));
}, cancellationToken);
if (handlerSuccess)
{
#region 消息处理成功
if (_subscribeAckHandler != null && Messages.Length > 0)
{
_subscribeAckHandler(Messages);
}
//确认消息被处理
_channel.BasicAck(batchLastDeliveryTag, true);
#endregion
}
else
{
executeTracer.SetError();
}
}
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
receiveTracer.SetError();
handlerException = ex;
}
finally
{
if (!handlerSuccess)
{
#region 消息处理失败
var requeue = true;
try
{
if (_subscribeNackHandler != null && Messages.Length > 0)
{
requeue = await _subscribeNackHandler((Messages, handlerException));
}
}
catch (Exception innterEx)
{
_logger.LogError(innterEx.Message, innterEx);
}
_channel.BasicNack(batchLastDeliveryTag, true, requeue);
#endregion
}
}
}
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
}
System.Threading.Thread.Sleep(1);
}
});
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
}
}
return(this);
}
public override async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default(CancellationToken))
{
await base.OnTurnAsync(turnContext, cancellationToken);
switch (turnContext.Activity.Type)
{
case ActivityTypes.ConversationUpdate:
foreach (var member in turnContext.Activity.MembersAdded)
{
}
break;
case ActivityTypes.Message:
try
{
JToken commandToken = JToken.Parse(turnContext.Activity.Value.ToString());
string action = commandToken["action"].Value <string>();
string eventId = commandToken["eventId"].Value <string>();
int capacity = commandToken["capacity"].Value <int>();
var response = new EventResponse();
response.EventId = Guid.NewGuid().ToString();
response.ResponseContent = action == "true" ? 1 : 0;
response.ResponseUserId = turnContext.Activity.From.Id;
response.ResponseUsesrFirstName = turnContext.Activity.From.Name;
response.EventId = eventId;
response.ResponseDateTime = DateTime.Now;
var yes = $"{turnContext.Activity.From.Name} is attending.";
var no = $"{turnContext.Activity.From.Name} is NOT attending.";
var manager = new EventResponseManager(_tableStoreService);
await manager.Add(response);
var responses = await manager.GetResponsesByEventId(eventId);
var left = capacity - responses.Count(x => x.ResponseContent == 1);
var good = $" Number of spot left: {left}";
var waitlist = $" You are in waiting list: {-left}";
string returnMessage;
if (response.ResponseContent == 1)
{
returnMessage = yes;
if (left < 0)
{
returnMessage += waitlist;
}
else
{
returnMessage += good;
}
}
else
{
returnMessage = no;
}
await turnContext.SendActivityAsync(returnMessage,
cancellationToken : cancellationToken);
//Update primary reply message
var responseNames = responses.Where(x => x.ResponseContent == 1).Select(x => x.ResponseUsesrFirstName).ToArray();
var nameString = string.Join(",", responseNames);
var replyActivity = MessageFactory.Text("Currently enrolled: " + nameString);
await turnContext.SendActivityAsync(replyActivity, cancellationToken);
}
catch (Exception ex)
{
await turnContext.SendActivityAsync(ex.Message, cancellationToken : cancellationToken);
}
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="event"></param>
/// <returns></returns>
protected void OnGrpcStreamEvent(EventResponse @event)
{
try
{
var eventType = @event.Type;
var payload = @event.Payload;
logger.LogInformation($"dateTime:{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} {eventType},PayLoad:{payload}");
if (eventType != EventType.Heartbeat)
{
var eventHeartbeatPayload = new EventHeartbeatPayload()
{
Data = $"onGrpcStreamEvent({eventType})"
};
//await _localEventBus.PublishAsync(eventHeartbeatPayload);
Emit(eventHeartbeatPayload);
}
switch (eventType)
{
case EventType.Unspecified:
Logger.LogError("onGrpcStreamEvent() got an EventType.EVENT_TYPE_UNSPECIFIED ?");
break;
case EventType.Heartbeat:
Emit(JsonConvert.DeserializeObject <EventHeartbeatPayload>(payload));
break;
case EventType.Message:
Emit(JsonConvert.DeserializeObject <EventMessagePayload>(payload));
break;
case EventType.Dong:
Emit(JsonConvert.DeserializeObject <EventDongPayload>(payload));
break;
case EventType.Error:
Emit(JsonConvert.DeserializeObject <EventErrorPayload>(payload));
break;
case EventType.Friendship:
Emit(JsonConvert.DeserializeObject <EventFriendshipPayload>(payload));
break;
case EventType.RoomInvite:
Emit(JsonConvert.DeserializeObject <EventRoomInvitePayload>(payload));
break;
case EventType.RoomJoin:
Emit(JsonConvert.DeserializeObject <EventRoomJoinPayload>(payload));
break;
case EventType.RoomLeave:
Emit(JsonConvert.DeserializeObject <EventRoomLeavePayload>(payload));
break;
case EventType.RoomTopic:
Emit(JsonConvert.DeserializeObject <EventRoomTopicPayload>(payload));
break;
case EventType.Scan:
Emit(JsonConvert.DeserializeObject <EventScanPayload>(payload));
break;
case EventType.Ready:
Emit(JsonConvert.DeserializeObject <EventReadyPayload>(payload));
break;
case EventType.Reset:
//log.warn('PuppetHostie', 'onGrpcStreamEvent() got an EventType.EVENT_TYPE_RESET ?')
// the `reset` event should be dealed not send out
Emit(JsonConvert.DeserializeObject <EventResetPayload>(payload));
Logger.LogWarning("onGrpcStreamEvent() got an EventType.EVENT_TYPE_RESET ?");
break;
case EventType.Login:
var loginPayload = JsonConvert.DeserializeObject <EventLoginPayload>(payload);
SelfId = loginPayload.ContactId;
break;
case EventType.Logout:
SelfId = string.Empty;
Emit(JsonConvert.DeserializeObject <EventLogoutPayload>(payload));
break;
default:
logger.LogWarning($"'eventType {eventType} unsupported! (code should not reach here)");
//throw new BusinessException($"'eventType {_event.Type.ToString()} unsupported! (code should not reach here)");
break;
}
}
catch (Exception ex)
{
Logger.LogError(ex, "OnGrpcStreamEvent exception");
}
}
private void RaiseEventResponse(string eventMessage)
{
EventResponse?.Invoke(this, eventMessage);
}
/// <summary>
/// 订阅消息（同一类消息可以重复订阅）
/// 作者：郭明
/// 日期：2017年4月3日
/// </summary>
/// <typeparam name="TD"></typeparam>
/// <typeparam name="TH"></typeparam>
/// <param name="QueueName"></param>
/// <param name="EventTypeName"></param>
/// <param name="BatchSize"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public IEventBus RegisterBatch <TD, TH>(string QueueName, string EventTypeName = "", int BatchSize = 50, CancellationToken cancellationToken = default(CancellationToken))
where TD : class
where TH : IEventBatchHandler <TD>
{
var persistentConnection = _receiveLoadBlancer.Lease();
var queueName = string.IsNullOrEmpty(QueueName) ? typeof(TH).FullName : QueueName;
var routeKey = string.IsNullOrEmpty(EventTypeName) ? typeof(TD).FullName : EventTypeName;
var eventAction = _lifetimeScope.GetService(typeof(TH)) as IEventBatchHandler <TD>;
if (eventAction == null)
{
eventAction = System.Activator.CreateInstance(typeof(TH)) as IEventBatchHandler <TD>;
}
System.Threading.Tasks.Task.Run(async() =>
{
IConsumer <string, string> consumer = null;
try
{
consumer = persistentConnection.GetConsumer();
consumer.Subscribe(routeKey);
while (!cancellationToken.IsCancellationRequested)
{
try
{
var handlerSuccess = false;
var handlerException = default(Exception);
var eas = consumer.ConsumeBatch(TimeSpan.FromSeconds(5), BatchSize, cancellationToken).ToArray();
var Messages = new EventResponse[eas.Count()];
if (Messages.Length > 0)
{
_logger.LogInformation($"Consumed message '{eas.LastOrDefault().Value}' at: '{eas.LastOrDefault().TopicPartitionOffset}'.");
}
else
{
continue;
}
try
{
#region 批量格式化消息
for (int j = 0; j < eas.Length; j++)
{
var ea = eas[j];
// 消息队列空
if (ea.IsPartitionEOF)
{
_logger.LogDebug("Reached end of topic {consumeResult.Topic}, partition {consumeResult.Partition}, offset {consumeResult.Offset}.");
continue;
}
var EventId = -1L;
var MessageId = ea.Key;
var TraceId = MessageId;
using (var tracer = new Hummingbird.Extensions.Tracing.Tracer("AMQP Received", TraceId))
{
#region 获取EventId & TraceId
if (ea.Headers != null && ea.Headers.Count > 0)
{
try
{
long.TryParse(System.Text.Encoding.UTF8.GetString(ea.Headers.GetLastBytes("x-eventId")), out EventId);
}
catch
{ }
try
{
TraceId = System.Text.Encoding.UTF8.GetString(ea.Headers.GetLastBytes("x-traceId"));
}
catch
{
}
}
#endregion
tracer.SetComponent(_compomentName);
tracer.SetTag("queueName", queueName);
tracer.SetTag("x-messageId", MessageId);
tracer.SetTag("x-eventId", EventId);
tracer.SetTag("x-traceId", TraceId);
Messages[j] = new EventResponse()
{
EventId = EventId,
MessageId = MessageId,
TraceId = TraceId,
Headers = new Dictionary <string, object>(),
Body = default(TD),
QueueName = queueName,
RouteKey = routeKey,
BodySource = ea.Value
};
try
{
#region 设置Body
Messages[j].Body = JsonConvert.DeserializeObject <TD>(Messages[j].BodySource);
#endregion
#region 设置header
foreach (var key in ea.Headers)
{
Messages[j].Headers.Add(key.Key, Encoding.UTF8.GetString(key.GetValueBytes()));
}
if (!Messages[j].Headers.ContainsKey("x-topic"))
{
Messages[j].Headers.Add("x-topic", routeKey);
}
if (!Messages[j].Headers.ContainsKey("x-messageId"))
{
Messages[j].Headers.Add("x-messageId", MessageId);
}
if (!Messages[j].Headers.ContainsKey("x-eventId"))
{
Messages[j].Headers.Add("x-eventId", EventId);
}
if (!Messages[j].Headers.ContainsKey("x-traceId"))
{
Messages[j].Headers.Add("x-traceId", TraceId);
}
#endregion
_logger.LogDebug(Messages[j].BodySource);
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
}
}
}
#endregion
#region 批量处理消息
if (Messages != null && Messages.Any())
{
using (var executeTracer = new Hummingbird.Extensions.Tracing.Tracer("AMQP Execute"))
{
executeTracer.SetComponent(_compomentName);
executeTracer.SetTag("queueName", queueName);
handlerSuccess = await _receiverPolicy.ExecuteAsync(async(handlerCancellationToken) =>
{
return(await eventAction.Handle(Messages.Select(a => (TD)a.Body).ToArray(), Messages.Select(a => (Dictionary <string, object>)a.Headers).ToArray(), handlerCancellationToken));
}, cancellationToken);
if (handlerSuccess)
{
#region 消息处理成功
if (_subscribeAckHandler != null && Messages.Length > 0)
{
_subscribeAckHandler(Messages);
}
consumer.Commit();
#endregion
}
else
{
executeTracer.SetError();
}
}
}
#endregion
}
catch (Exception ex)
{
handlerException = ex;
_logger.LogError(ex, ex.Message);
}
finally
{
if (!handlerSuccess)
{
//重新入队，默认：是
var requeue = true;
try
{
//执行回调，等待业务层的处理结果
if (_subscribeNackHandler != null && Messages != null && Messages.Any())
{
requeue = await _subscribeNackHandler((Messages, handlerException));
}
}
catch (Exception innterEx)
{
_logger.LogError(innterEx, innterEx.Message);
}
if (!requeue)
{
consumer.Commit();
}
else
{
if (eas.Length > 0)
{
consumer.Seek(eas.FirstOrDefault().TopicPartitionOffset);
}
}
}
}
}
catch (ConsumeException ex)
{
_logger.LogError(ex, ex.Message);
consumer.Seek(ex.ConsumerRecord.TopicPartitionOffset);
}
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
if (consumer != null)
{
consumer.Close();
}
}
});
return(this);
}
public void addEventResponse(EventResponse e)
{
_dBContext.EventResponses.Add(e);
_dBContext.SaveChanges();
}
