示例#1
0
        public static void Register(HttpConfiguration config)
        {
            // Json settings
            config.Formatters.JsonFormatter.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
            config.Formatters.JsonFormatter.SerializerSettings.ContractResolver  = new CamelCasePropertyNamesContractResolver();
            config.Formatters.JsonFormatter.SerializerSettings.Formatting        = Formatting.Indented;
            JsonConvert.DefaultSettings = () => new JsonSerializerSettings()
            {
                ContractResolver  = new CamelCasePropertyNamesContractResolver(),
                Formatting        = Newtonsoft.Json.Formatting.Indented,
                NullValueHandling = NullValueHandling.Ignore,
            };

            // Web API configuration and services

            // Web API routes
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
                );

            TriviaApiClient = new TriviaApiClient();
            TriviaDatastore = new InMemoryTriviaDatastore();
        }
示例#2
0
        private async Task MessageReceivedAsync(IDialogContext context, IAwaitable <object> result)
        {
            var    activity    = await result as Activity;
            string messageText = CleanMessage(activity);

            if (!string.IsNullOrEmpty(messageText))
            {
                TriviaApiClient         triviaApiClient = WebApiConfig.TriviaApiClient;
                InMemoryTriviaDatastore triviaDatastore = WebApiConfig.TriviaDatastore;

                if (messageText.Equals(CommandHelp))
                {
                    await context.PostAsync(HelpMessage);
                }
                else if (messageText.Equals(CommandQuestion))
                {
                    TriviaPlayer triviaPlayer = await GetPlayer(activity);

                    if (triviaPlayer != null)
                    {
                        TriviaQuestion triviaQuestion =
                            await triviaApiClient.GetQuestionAsync(triviaPlayer);

                        if (triviaQuestion != null &&
                            !string.IsNullOrEmpty(triviaQuestion.Text) &&
                            triviaQuestion.QuestionOptions != null &&
                            triviaQuestion.QuestionOptions.Count > 0)
                        {
                            if (triviaDatastore.PendingTriviaQuestions.ContainsKey(triviaPlayer.Id))
                            {
                                triviaDatastore.PendingTriviaQuestions[triviaPlayer.Id] = triviaQuestion.Id;
                            }
                            else
                            {
                                triviaDatastore.PendingTriviaQuestions.Add(triviaPlayer.Id, triviaQuestion.Id);
                            }

                            await context.PostAsync($"{GetFirstName(triviaPlayer)}, your question is:");

                            HeroCard questionCard  = CardFactory.CreateQuestionCard(triviaQuestion);
                            Activity replyActivity = activity.CreateReply();

                            replyActivity.Attachments = new List <Attachment>()
                            {
                                questionCard.ToAttachment()
                            };

                            await context.PostAsync(replyActivity);
                        }
                        else
                        {
                            await context.PostAsync("I'm sorry, I couldn't find a trivia question. Please try again later");
                        }
                    }
                    else
                    {
                        await context.PostAsync("I'm sorry, I couldn't find your player profile. Are you sure you have registered?");
                    }
                }
                else if (messageText.StartsWith(CommandRegister))
                {
                    string serviceUrl = activity.ServiceUrl;
                    var    memebers   = await TeamsApiClient.GetTeamsMembers(activity, serviceUrl, HavocTeamId);

                    if (memebers?.Count > 0)
                    {
                        var triviaRoster = new TriviaRoster
                        {
                            TeamId  = HavocTeamId,
                            Members = memebers
                        };

                        TriviaRegister registerResponse = await triviaApiClient.RegisterAsync(triviaRoster);

                        if (registerResponse != null)
                        {
                            if (registerResponse.Success)
                            {
                                await context.PostAsync("Team registered successfully!");
                            }
                            else
                            {
                                await context.PostAsync($"Failed to register the team: {registerResponse.Message}");
                            }
                        }
                        else
                        {
                            await context.PostAsync($"Failed to register the team, please try again later");
                        }
                    }
                }
                else
                {
                    // Check for answer
                    int  answerId = -1;
                    bool numberParsedSuccessfully = int.TryParse(messageText, out answerId);

                    if (numberParsedSuccessfully && answerId >= 0)
                    {
                        TriviaPlayer triviaPlayer = await GetPlayer(activity);

                        if (triviaPlayer != null)
                        {
                            if (triviaDatastore.PendingTriviaQuestions.ContainsKey(triviaPlayer.Id))
                            {
                                TriviaAnswer triviaAnswer = new TriviaAnswer()
                                {
                                    UserId     = triviaPlayer.Id,
                                    QuestionId = triviaDatastore.PendingTriviaQuestions[triviaPlayer.Id],
                                    AnswerId   = answerId
                                };

                                TriviaAnswerResponse triviaAnswerResponse =
                                    await triviaApiClient.PostAnswerAsync(triviaAnswer);

                                if (triviaAnswerResponse != null)
                                {
                                    triviaDatastore.PendingTriviaQuestions.Remove(triviaPlayer.Id);

                                    if (triviaAnswerResponse.Correct)
                                    {
                                        await context.PostAsync($"{GetFirstName(triviaPlayer)}: That is correct!");
                                    }
                                    else
                                    {
                                        await context.PostAsync($"{GetFirstName(triviaPlayer)}: I'm afraid that is not the correct answer. Better luck next time!");
                                    }
                                }
                                else
                                {
                                    await context.PostAsync("Sorry, something went wrong. Try again later");
                                }
                            }
                            else
                            {
                                await context.PostAsync("I haven't asked you a question yet.");

                                await context.PostAsync(HelpMessage);
                            }
                        }
                        else
                        {
                            await context.PostAsync("I'm sorry, I couldn't find your player profile. Are you sure you have registered?");
                        }
                    }
                    else
                    {
                        await context.PostAsync(HelpMessage);
                    }
                }
            }

            context.Wait(MessageReceivedAsync);
        }