protected override async Task ProcessMessage(ExternalEventNotification notification, CancellationToken cancellationToken)
        {
            string lockName = $"extevt:{notification.Id}";

            if (!await _distributedLock.TryAcquireLock(lockName, cancellationToken))
            {
                return;
            }

            try
            {
                var subscriber = await _subscriberRepository.Get(notification.CasePlanInstanceId, notification.CasePlanElementInstanceId, notification.EvtName, cancellationToken);

                if (subscriber == null)
                {
                    throw new InvalidOperationException("subscriber doesn't exist");
                }

                subscriber.IsCaptured = true;
                subscriber.Parameters = notification.Parameters;
                await _subscriberRepository.Update(subscriber, cancellationToken);

                await MessageBroker.QueueCasePlanInstance(notification.CasePlanInstanceId, cancellationToken);
            }
            finally
            {
                await _distributedLock.ReleaseLock(lockName, cancellationToken);
            }
        }
        public async Task <string> UpdateSubscriber(string id, [FromBody] Subscriber subscriber)
        {
            if (string.IsNullOrEmpty(id))
            {
                return("Invalid id");
            }

            return(await _subscriberRepository.Update(id, subscriber));
        }
 public BaseResponse UpdateSubscriber(SubscriberModel subscriber)
 {
     try
     {
         ISubscriberRepository subscriberRepository = RepositoryClassFactory.GetInstance().GetSubscriberRepository();
         var _sub = MapperUtil.CreateMapper().Mapper.Map <SubscriberModel, Subscriber>(subscriber);
         subscriberRepository.Update(_sub);
         return(new BaseResponse
         {
             ErrorCode = (int)ErrorCode.None,
             Message = Resources.Resource.msg_update_success
         });
     }
     catch (Exception ex)
     {
         return(new BaseResponse
         {
             ErrorCode = (int)ErrorCode.Error,
             Message = ex.Message
         });
     }
 }
Esempio n. 4
0
        public async Task <bool> Execute(string casePlanInstanceId, string casePlanElementInstanceId, Dictionary <string, string> parameters, CancellationToken token)
        {
            var casePlanInstance = await _casePlanInstanceCommandRepository.Get(casePlanInstanceId, token);

            if (casePlanInstance == null)
            {
                throw new UnknownCasePlanInstanceException(casePlanInstanceId);
            }

            if (!string.IsNullOrWhiteSpace(casePlanElementInstanceId))
            {
                var elt = casePlanInstance.GetChild(casePlanElementInstanceId);
                if (elt == null)
                {
                    throw new UnknownCasePlanElementInstanceException(casePlanInstanceId, casePlanElementInstanceId);
                }
            }

            var subscriber = await _subscriberRepository.Get(casePlanInstanceId, casePlanElementInstanceId, EvtName, token);

            if (subscriber == null)
            {
                throw new InvalidOperationException("subscriber doesn't exist");
            }

            subscriber.IsCaptured = true;
            subscriber.Parameters = parameters;
            await _subscriberRepository.Update(subscriber, token);

            await _casePlanInstanceProcessor.Execute(casePlanInstance, token);

            await _casePlanInstanceCommandRepository.Update(casePlanInstance, token);

            await _casePlanInstanceCommandRepository.SaveChanges(token);

            return(true);
        }