/// <summary>
        /// Get the queue data
        /// </summary>
        private IdentifiedData GetQueueData(ISynchronizationQueueEntry queueEntry)
        {
            var queueData = ApplicationServiceContext.Current.GetService <IQueueFileProvider>().GetQueueData(queueEntry?.DataFileKey, Type.GetType(queueEntry.Type));

            if (queueData == null)
            {
                throw new KeyNotFoundException($"error.queueentry.notfound.{queueEntry.DataFileKey}");
            }
            return(queueData);
        }
Beispiel #2
0
        public AmiCollection GetQueueEntry()
        {
            var search = NameValueCollection.ParseQueryString(MiniHdsiServer.CurrentContext.Request.Url.Query);

            int offset       = Int32.Parse(MiniHdsiServer.CurrentContext.Request.QueryString["_offset"] ?? "0"),
                count        = Int32.Parse(MiniHdsiServer.CurrentContext.Request.QueryString["_count"] ?? "100"),
                totalResults = 0;

            var explId = MiniHdsiServer.CurrentContext.Request.QueryString["_id"];

            if (!String.IsNullOrEmpty(explId))
            {
                ISynchronizationQueueEntry retVal = null;
                // Get the queue
                switch (MiniHdsiServer.CurrentContext.Request.QueryString["_queue"])
                {
                case "inbound":
                    retVal = this.m_queueService.Inbound.Get(Int32.Parse(explId));
                    break;

                case "outbound":
                    retVal = this.m_queueService.Outbound.Get(Int32.Parse(explId));
                    break;

                case "admin":
                    retVal = this.m_queueService.Admin.Get(Int32.Parse(explId));
                    break;

                case "dead":
                    retVal = this.m_queueService.DeadLetter.Get(Int32.Parse(explId));
                    break;

                default:
                    throw new KeyNotFoundException();
                }

                retVal.Data = Convert.ToBase64String(ApplicationContext.Current.GetService <IQueueFileProvider>().GetQueueData(retVal.Data));

                return(new AmiCollection()
                {
                    CollectionItem = new List <Object>()
                    {
                        retVal
                    }
                });
            }
            else
            {
                IEnumerable <ISynchronizationQueueEntry> results = null;
                // Get the queue
                switch (MiniHdsiServer.CurrentContext.Request.QueryString["_queue"])
                {
                case "inbound":
                    results = this.m_queueService.Inbound.Query(search, offset, count, out totalResults)
                              .ToList();
                    break;

                case "outbound":
                    results = this.m_queueService.Outbound.Query(search, offset, count, out totalResults)
                              .ToList();
                    break;

                case "admin":
                    results = this.m_queueService.Admin.Query(search, offset, count, out totalResults)
                              .ToList();
                    break;

                case "dead":
                    results = this.m_queueService.Admin.Query(search, offset, count, out totalResults)
                              .OfType <ISynchronizationQueueRetryEntry>()
                              .ToList();
                    break;

                default:
                    throw new KeyNotFoundException();
                }

                // Null out data
                foreach (var r in results)
                {
                    r.Data = null;
                }

                // Results
                return(new AmiCollection(results.OfType <Object>(), offset, totalResults));
            }
        }