public void UpdateSubscriptionLog(IList <string> partnerIds, int eventCode, string protocolType, string messageId)
        {
            if (partnerIds == null || string.IsNullOrEmpty(protocolType))
            {
                return;
            }
            try
            {
                var context = new VontobelDBConnection();

                var subscribedPartners = (from p in context.Partners
                                          join ps in context.PartnerSubscriptions
                                          on p equals ps.Partner
                                          where ps.MessageProtocol.Name == protocolType &&
                                          ps.Event.Code == eventCode &&
                                          partnerIds.Contains(p.Id)
                                          select ps);

                subscribedPartners.ToList().ForEach(
                    x => context.SubscriptionMessageLogs.Add(
                        new SubscriptionMessageLog
                {
                    Id = Guid.NewGuid().ToString("N"),
                    PartnerSubscriptionId = x.Id,
                    Picked    = 1,
                    MessageId = messageId
                }));

                context.SaveChanges();
            }
            catch (Exception e)
            {
                throw;
            }
        }
        public void MarkAsPicked(string messageId)
        {
            var context = new VontobelDBConnection();

            context.Messages.Where(x => x.Id == messageId).FirstOrDefault().Picked = 1;
            context.SaveChanges();
        }
        public void Save(DataMessage message)
        {
            try
            {
                var context    = new VontobelDBConnection();
                var newMessage = new Message
                {
                    CreatedOn      = DateTime.Now,
                    Id             = Guid.NewGuid().ToString("N"),
                    IsDeleted      = false,
                    MessageContent = new MessageContent {
                        Content = message.Content, CreatedOn = DateTime.Now
                    },
                };

                foreach (var param in message.Parameters)
                {
                    newMessage.MessageParameters.Add(new MessageParameter
                    {
                        Id        = Guid.NewGuid().ToString("N"),
                        IsDeleted = false,
                        Key       = param.Key,
                        Value     = param.Value
                    });
                }

                context.Messages.Add(newMessage);
                context.SaveChanges();
            }
            catch (Exception ex)
            {
                throw;
            }
        }
        public DataMessage GetUnpickedMessage()
        {
            DataMessage dataMessage = null;

            var context = new VontobelDBConnection();

            var oldestUnpickedMessage = context.Messages
                                        .Where(x => x.Picked == 0)
                                        .OrderBy(x => x.CreatedOn)
                                        .FirstOrDefault();

            if (oldestUnpickedMessage == null)
            {
                return(null);
            }

            dataMessage = new DataMessage
            {
                Content = oldestUnpickedMessage.MessageContent.Content,
                Id      = oldestUnpickedMessage.Id
            };

            dataMessage.Parameters = new Dictionary <string, string>();
            oldestUnpickedMessage.MessageParameters.ToList().ForEach(
                x =>
                dataMessage.Parameters.Add(x.Key, x.Value)
                );

            return(dataMessage);
        }
        public IList <Contracts.Model.Partner> GetSubscriptions(int eventCode, string protocolType, string messageId)
        {
            List <Contracts.Model.Partner> eligiblePartners = new List <Contracts.Model.Partner>();
            var context = new VontobelDBConnection();

            var subscribedPartners = (from p in context.Partners
                                      join ps in context.PartnerSubscriptions
                                      on p equals ps.Partner
                                      where ps.MessageProtocol.Name == protocolType &&
                                      ps.Event.Code == eventCode
                                      select ps);

            foreach (var subscribedPartner in subscribedPartners)
            {
                var successfulLog = subscribedPartner.SubscriptionMessageLogs.Where(x => x.Picked == 1);
                if (successfulLog.Select(x => x.MessageId).Contains(messageId))
                {
                    continue;
                }

                var eligiblePartner = new Contracts.Model.Partner()
                {
                    Name       = subscribedPartner.Partner.Name,
                    Email      = subscribedPartner.Partner.Email,
                    Id         = subscribedPartner.Partner.Id,
                    Parameters = new Dictionary <string, string>()
                };
                foreach (var parameter in subscribedPartner.PartnerSubscriptionParameters)
                {
                    eligiblePartner.Parameters.Add(parameter.Key, parameter.Value);
                }

                eligiblePartners.Add(eligiblePartner);
            }

            return(eligiblePartners);
        }