public async Task <IActionResult> GetTopicList([FromBody] TopicRequest request)
        {
            JsonResponse <IEnumerable <TopicList> > objResult = new JsonResponse <IEnumerable <TopicList> >();

            try
            {
                IEnumerable <TopicList> lists = new List <TopicList>();
                lists = await this._superAdminService.GetTopicList(request);

                if (lists != null && lists.Count() > 0)
                {
                    objResult.Data    = lists;
                    objResult.Status  = StaticResource.SuccessStatusCode;
                    objResult.Message = StaticResource.SuccessMessage;
                    return(new OkObjectResult(objResult));
                }
                else
                {
                    objResult.Data    = null;
                    objResult.Status  = StaticResource.NotFoundStatusCode;
                    objResult.Message = StaticResource.NotFoundMessage;
                    return(new OkObjectResult(objResult));
                }
            }
            catch (Exception ex)
            {
                HttpContext.RiseError(ex);
                objResult.Data    = null;
                objResult.Status  = StaticResource.FailStatusCode;
                objResult.Message = StaticResource.FailMessage;
            }
            return(new OkObjectResult(objResult));
        }
Exemple #2
0
        public void TopicGetChannelTopic()
        {
            var request = new TopicRequest(ChannelRequests.TopicGetChannelTopic);

            request.Parse();
            Assert.Equal("#GSP!room!test", request.ChannelName);
        }
        public void TestSerializeMetadataRequest()
        {
            var meta = new TopicRequest
            {
                Topics = new[] { "poulpe", "banana" }
            };

            using (var serialized = meta.Serialize(new ReusableMemoryStream(null), 61, ClientId, null))
            {
                CheckHeader(Basics.ApiKey.MetadataRequest, 0, 61, TheClientId, serialized);
                Assert.AreEqual(2, BigEndianConverter.ReadInt32(serialized));
                Assert.AreEqual("poulpe", Basics.DeserializeString(serialized));
                Assert.AreEqual("banana", Basics.DeserializeString(serialized));
            }

            meta = new TopicRequest
            {
                Topics = null
            };
            using (var serialized = meta.Serialize(new ReusableMemoryStream(null), 61, ClientId, null))
            {
                CheckHeader(Basics.ApiKey.MetadataRequest, 0, 61, TheClientId, serialized);
                Assert.AreEqual(0, BigEndianConverter.ReadInt32(serialized));
                Assert.AreEqual(serialized.Length, serialized.Position);
            }
        }
        public void SetUp()
        {
            document = new XmlDocument();
            document.Load("Topics.xml");

            var parser = new TopicParser();

            theTop = parser.Parse(theRootDirectory, document);
        }
        public TopicResponse Put(TopicRequest updated)
        {
            var entity = db.Topics.SingleOrDefault(t => t.Id == updated.Id);

            entity.UpdateFieldsFromRequest(updated);
            db.SaveChanges();
            var result = mapper.Map <TopicResponse>(entity);

            return(result);
        }
 public async Task <IEnumerable <TopicList> > GetTopicList(TopicRequest request)
 {
     try
     {
         return(await this._superAdminRepo.GetTopicList(request));
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Exemple #7
0
        public void GetTopics()
        {
            var randomText = new RandomText();

            var request = new TopicRequest();

            for (int i = 1; i <= 200; i++)
            {
                request.Documents.Add(new TopicDocument()
                {
                    Id = i.ToString(), Text = randomText.Next()
                });
            }

            var client      = new TopicClient(apiKey);
            var opeationUrl = client.StartTopicProcessing(request);

            TopicResponse response       = null;
            var           startTime      = DateTime.Now;
            var           timeoutTime    = startTime.AddMinutes(30);
            var           doneProcessing = false;

            while (!doneProcessing)
            {
                response = client.GetTopicResponse(opeationUrl);

                if (response.Status == TopicOperationStatus.Cancelled)
                {
                    Assert.Fail("Operation Cancelled");
                }
                else if (response.Status == TopicOperationStatus.Failed)
                {
                    Assert.Fail("Operation Failed");
                }
                else if (response.Status == TopicOperationStatus.Succeeded)
                {
                    doneProcessing = true;
                }
                else
                {
                    if (DateTime.Now >= timeoutTime)
                    {
                        Assert.Fail("Operation Timeout");
                    }
                    else
                    {
                        Thread.Sleep(60000);
                    }
                }
            }

            Assert.IsTrue(response.OperationProcessingResult.TopicAssignments.Count > 0);
            Assert.IsTrue(response.OperationProcessingResult.Topics.Count > 0);
        }
        public TopicResponse Post(TopicRequest created)
        {
            var entity = new Topic();

            entity.UpdateFieldsFromRequest(created);
            db.Add(entity);
            db.SaveChanges();
            var result = mapper.Map <TopicResponse>(entity);

            return(result);
        }
 public override Task <VoidMessage> handleTopic(TopicRequest request, ServerCallContext context)
 {
     if (_state.program is ComputerProgram computerProgram)
     {
         computerProgram.HandleTopic(request.TopicId, request.Data);
     }
     else
     {
         throw new Exception("Invalid type.");
     }
     return(Task.FromResult(new VoidMessage()));
 }
Exemple #10
0
        public virtual string GetTopics(TopicRequest request)
        {
            try {
                var result = TextAnalyticsRepository.GetTopics(request);

                return(result);
            } catch (Exception ex) {
                Logger.Error("SentimentService.GetTopics failed", this, ex);
            }

            return(null);
        }
Exemple #11
0
 public virtual string GetTopics(TopicRequest request)
 {
     return(PolicyService.ExecuteRetryAndCapture400Errors(
                "TextAnalyticsService.GetTopics",
                ApiKeys.TextAnalyticsRetryInSeconds,
                () =>
     {
         var result = TextAnalyticsRepository.GetTopics(request);
         return result;
     },
                null));
 }
Exemple #12
0
        public async Task RequestRandomTopic(ChatInfo chat = null)
        {
            EnsureChatActive();

            chat ??= ActiveChats.First();

            var topicRequest = new TopicRequest(chat.Key);

            var randtopicPacket = new EventPacket("_randtopic", topicRequest, ClientEventID);

            await SendEventPacket(randtopicPacket);
        }
        public IActionResult CreateTopic([FromBody] TopicRequest topicDataModel)
        {
            var token = Request.Headers["Authorization"];

            var isCreated = _topicService.CreateTopic(topicDataModel, token);

            if (isCreated)
            {
                return(Ok());
            }

            return(Unauthorized());
        }
        public async Task <List <TopicExtended> > PostTopic(List <TopicPostRequest> topic, List <PeopleInEpisode> people)
        {
            try
            {
                HttpResponseMessage response = null;

                // Send Topic to API
                using (var requestMessage =
                           new HttpRequestMessage(HttpMethod.Post,
                                                  $"{_httpClient.BaseAddress}topic"))
                {
                    requestMessage.Headers.Authorization =
                        new AuthenticationHeaderValue("Bearer", (await _userSession.GetToken()).AccessToken);

                    TopicRequest request = new TopicRequest(people, topic);

                    string json = JsonSerializer.Serialize(request);

                    StringContent stringContent = new StringContent(json, Encoding.UTF8, "application/json");
                    requestMessage.Content = stringContent;

                    response = await _httpClient.SendAsync(requestMessage);
                }

                if (response != null)
                {
                    if (response.IsSuccessStatusCode)
                    {
                        // Get created topic information
                        string json = response.Content.ReadAsStringAsync().Result;
                        List <TopicExtended> topicResponse =
                            JsonSerializer.Deserialize <List <TopicExtended> >(json);

                        // Get the servers current state of the object and return it
                        return(topicResponse);
                    }
                }

                if (response.StatusCode == HttpStatusCode.NotFound)
                {
                    _toastService.ShowError("Error 404: Backend server is offline.");
                    SentrySdk.CaptureMessage("API: Error 404");
                }
            }
            catch (Exception e)
            {
                SentrySdk.CaptureException(e);
            }

            return(null);
        }
Exemple #15
0
        public void ValidateTest_DuplicateDocumentId()
        {
            var request = new TopicRequest();

            for (int i = 1; i <= 101; i++)
            {
                request.Documents.Add(new TopicDocument()
                {
                    Id = "01", Text = "doc1"
                });
            }

            request.Validate();
        }
Exemple #16
0
        public void ValidateTest_DocumentIdRequired()
        {
            var request = new TopicRequest();

            for (int i = 1; i <= 101; i++)
            {
                request.Documents.Add(new TopicDocument()
                {
                    Text = "doc1"
                });
            }

            request.Validate();
        }
Exemple #17
0
        public void ValidateTest_MinDocumentSize()
        {
            var request = new TopicRequest();

            for (int i = 1; i <= 101; i++)
            {
                request.Documents.Add(new TopicDocument()
                {
                    Id = i.ToString()
                });
            }

            request.Validate();
        }
        public async Task <ActionResult <List <TopicExtended> > > PostTopicList([FromBody] TopicRequest request)
        {
            if (request.Topics == null)
            {
                return(BadRequest("Topic list is null!"));
            }

            try
            {
                User user = await _auth.GetUserFromValidToken(Request);

                Episode claimedEpisode = await _claims.GetUserByClaimedEpisodeAsync(user.Id);

                // Topics and Subtopics
                await _database.DeleteTopicAndSubtopicAsync(claimedEpisode.Id);

                await _database.ResetIdentityForTopicAndSubtopicsAsync();

                for (int i = 0; i < request.Topics.Count; i++)
                {
                    await _database.InsertTopicAsync(new ProcessedTopicPostRequest(request.Topics[i]), claimedEpisode.Id, user.Id);
                }

                // People
                await _database.DeletePeopleFromEpisodeByEpisodeIdAsync(claimedEpisode.Id);

                await _database.ResetIdentityForPersonInEpisodeTableAsync();

                await _database.InsertPeopleInEpisodeAsync(request.People, claimedEpisode.Id);

                EpisodeExtendedExtra episode = await _database.GetEpisodeAsync(claimedEpisode.Id, true, user.Id);

                return(Ok(episode));
            }
            catch (TokenDoesNotExistException e)
            {
                return(Unauthorized());
            }
            catch (Exception e)
            {
                if (e.Message.Contains("Sequence contains no elements"))
                {
                    return(Unauthorized("User has no claimed episode!"));
                }

                SentrySdk.CaptureException(e);
                _logger.LogError("Error while trying to post a list of topics. Error:\n" + e.Message);
                return(Problem());
            }
        }
Exemple #19
0
        public void ValidateTest_MaxDocumentSize()
        {
            int count = 10241 * 3;
            var text  = new string('*', count);

            var request = new TopicRequest();

            for (int i = 1; i <= 101; i++)
            {
                request.Documents.Add(new TopicDocument()
                {
                    Id = i.ToString(), Text = text
                });
            }

            request.Validate();
        }
Exemple #20
0
        public void ValidateTest_MaxDocumentCollectionSize()
        {
            var count = 1024 * 31;
            var text  = new string('*', 1024);

            var request = new TopicRequest();

            for (int i = 1; i <= count; i++)
            {
                request.Documents.Add(new TopicDocument()
                {
                    Id = i.ToString(), Text = text
                });
            }

            request.Validate();
        }
        public void add_the_second_topic_that_is_a_child_to_the_parent()
        {
            var root = document.DocumentElement;
            var top  = theStack.AddTopic(root);

            theStack.PushTopic(top);
            theStack.PushFolder("HowTo");

            var element = document.DocumentElement.FirstChild.FirstChild;

            var request = theStack.AddTopic((XmlElement)element);

            top.Children.ShouldContain(request);

            request.Namespace.ShouldEqual("HowTo");
            request.TopicName.ShouldEqual(TopicRequest.GetNameFromTitle(request.Title));

            // Screws up in Mono and I do *NOT* have a clue why.  Shouldn't even be possible, but of course it is
            //request.FullTopicClassName.ShouldEqual("WidgetPro.Core.HowTo." + request.TopicName);
        }
Exemple #22
0
        public bool CreateTopic(TopicRequest topicDataModel, string token)
        {
            var tokenClient = _tokenService.DecodeToken(token);
            var client      = _clientRepository.GetByID(tokenClient.ID);

            if (client == null)
            {
                return(false);
            }

            var newTopic = _mapper.Map <TopicEntity>(topicDataModel);

            newTopic.Client = client;

            _topicRepository.Add(newTopic);

            Console.WriteLine($"Title:{topicDataModel.Title} Subtopic:{topicDataModel.Subtitle}");

            return(true);
        }
Exemple #23
0
        internal async Task <MetadataResponse> MetadataRequest(TopicRequest request, BrokerMeta broker = null, bool noTransportErrors = false)
        {
            TcpClient  tcp;
            Connection conn;

            if (broker != null)
            {
                conn = broker.Conn;
                tcp  = await conn.GetClientAsync(noTransportErrors);
            }
            else
            {
                var clientAndConnection = await _cluster.GetAnyClientAsync();

                conn = clientAndConnection.Item1;
                tcp  = clientAndConnection.Item2;
            }

            //var tcp = await (broker != null ? broker.Conn.GetClientAsync() : _cluster.GetAnyClientAsync());
            _log.Debug("Sending MetadataRequest to {0}", tcp.Client.RemoteEndPoint);
            if (_etw.IsEnabled())
            {
                _etw.ProtocolMetadataRequest(request.ToString());
            }

            var response = await conn.Correlation.SendAndCorrelateAsync(
                id => Serializer.Serialize(request, id),
                Serializer.DeserializeMetadataResponse,
                tcp, CancellationToken.None);

            if (_etw.IsEnabled())
            {
                _etw.ProtocolMetadataResponse(response.ToString(),
                                              broker != null ? broker.Host : "",
                                              broker != null ? broker.Port : -1,
                                              broker != null ? broker.NodeId : -1);
            }


            return(response);
        }
Exemple #24
0
 public async Task <IEnumerable <TopicList> > GetTopicList(TopicRequest request)
 {
     try
     {
         IEnumerable <TopicList> topicLists = new List <TopicList>();
         using (IDbConnection con = new SqlConnection(_connectionString))
         {
             topicLists = await con.QueryAsync <TopicList>("dbo.SSP_getTopicList", new
             {
                 TopicName = request.TopicName,
                 OffSet    = request.OffSet,
                 Limit     = request.Limit
             }, commandType : CommandType.StoredProcedure);
         }
         return(topicLists);
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Exemple #25
0
        public static byte[] Serialize(TopicRequest request, int correlationId)
        {
            var stream = new MemoryStream();

            WriteRequestHeader(stream, correlationId, ApiKey.MetadataRequest);
            if (request.Topics == null || request.Topics.Length == 0)
            {
                stream.Write(_zero32, 0, 4);
            }
            else
            {
                BigEndianConverter.Write(stream, request.Topics.Length);
                foreach (var t in request.Topics)
                {
                    Write(stream, t);
                }
            }

            stream.Close();

            return(WriteMessageLength(stream));
        }
        private async void Detect_Topics(string text)
        {
            try
            {
                var source     = text.Split(new string[] { Environment.NewLine }, StringSplitOptions.None).ToList();
                var randomText = new RandomText(source);

                var request = new TopicRequest();

                for (int i = 0; i < 100; i++)
                {
                    request.Documents.Add(new TopicDocument()
                    {
                        Id = i.ToString(), Text = randomText.Next()
                    });
                }

                MainWindow mainWindow  = Window.GetWindow(this) as MainWindow;
                var        client      = new TopicClient(mainWindow._scenariosControl.SubscriptionKey);
                var        opeationUrl = await client.StartTopicProcessingAsync(request);

                TopicResponse response       = null;
                var           doneProcessing = false;

                while (!doneProcessing)
                {
                    response = await client.GetTopicResponseAsync(opeationUrl);

                    switch (response.Status)
                    {
                    case TopicOperationStatus.Cancelled:
                        Log("Operation Status: Cancelled");
                        doneProcessing = true;
                        break;

                    case TopicOperationStatus.Failed:
                        Log("Operation Status: Failed");
                        doneProcessing = true;
                        break;

                    case TopicOperationStatus.NotStarted:
                        Log("Operation Status: Not Started");
                        Thread.Sleep(100);
                        break;

                    case TopicOperationStatus.Running:
                        Log("Operation Status: Running");
                        Thread.Sleep(100);
                        break;

                    case TopicOperationStatus.Succeeded:
                        Log("Operation Status: Succeeded");
                        doneProcessing = true;
                        break;
                    }
                }

                foreach (var topic in response.OperationProcessingResult.Topics)
                {
                    var score = topic.Score * 100;
                    Log(string.Format("{0} ({1}%)", topic.KeyPhrase, score));
                }
            }
            catch (Exception ex)
            {
                Log(ex.Message);
            }
        }
 public virtual string GetTopics(TopicRequest request)
 {
     return(RepositoryClient.SendOperationPost(ApiKeys.TextAnalytics, $"{ApiKeys.TextAnalyticsEndpoint}{topicUrl}", JsonConvert.SerializeObject((object)request)));
 }
 /// <summary>
 /// This takes in at least 100 documents and returns a url to the operation where you check for the status of the result
 /// </summary>
 /// <param name="request"></param>
 /// <returns></returns>
 public virtual async Task <string> GetTopicsAsync(TopicRequest request)
 {
     return(await RepositoryClient.SendOperationPostAsync(ApiKeys.TextAnalytics, $"{ApiKeys.TextAnalyticsEndpoint}{topicUrl}", JsonConvert.SerializeObject((object)request)));
 }
        static async Task MainAsync()
        {
            var apiKey = "YOUR-TEXT-ANALYTICS-API-SUBSCRIPTION-KEY";

            var randomText = new RandomText();

            var request = new TopicRequest();

            for (int i = 1; i <= 200; i++)
            {
                request.Documents.Add(new TopicDocument()
                {
                    Id = i.ToString(), Text = randomText.Next()
                });
            }

            var client       = new TopicClient(apiKey);
            var operationUrl = await client.StartTopicProcessingAsync(request);

            TopicResponse response       = null;
            var           doneProcessing = false;

            while (!doneProcessing)
            {
                response = await client.GetTopicResponseAsync(operationUrl);

                switch (response.Status)
                {
                case TopicOperationStatus.Cancelled:
                    Console.WriteLine("Status: Operation Cancelled");
                    doneProcessing = true;
                    break;

                case TopicOperationStatus.Failed:
                    Console.WriteLine("Status: Operation Failed");
                    doneProcessing = true;
                    break;

                case TopicOperationStatus.NotStarted:
                    Console.WriteLine("Status: Operation Not Started");
                    Thread.Sleep(60000);
                    break;

                case TopicOperationStatus.Running:
                    Console.WriteLine("Status: Operation Running");
                    Thread.Sleep(60000);
                    break;

                case TopicOperationStatus.Succeeded:
                    Console.WriteLine("Status: Operation Succeeded");
                    doneProcessing = true;
                    break;
                }
            }

            foreach (var topic in response.OperationProcessingResult.Topics)
            {
                Console.WriteLine("{0} | {1}", topic.KeyPhrase, topic.Score);
            }

            Console.WriteLine("Press any key to exit...");
            Console.ReadLine();
        }
Exemple #30
0
        public void ValidateTest_MinDocumentCollectionCount()
        {
            var request = new TopicRequest();

            request.Validate();
        }