Пример #1
0
        private async Task Resume(IDialogContext context, IAwaitable <IMessageActivity> result)
        {
            var  activity = (Activity)await result;
            bool sentGreeting;

            if (!state.TryGetValue(activity.Conversation.Id, out sentGreeting))
            {
                state[activity.Conversation.Id] = true;
                await context.PostAsync("Здравствуйте! Я Бот Электронной площадки РТС-тендер.");

                Thread.Sleep(1500);
                CardDialog.PlatformCard(context, activity, ParametrsDialog.CheckParametrs(null, null));
                context.Done <object>(null);
            }
            else if (activity.Type == ActivityTypes.Message)
            {
                await context.Forward(new RootDialog(), async (dialogContext, res) => dialogContext.Done(await res), activity, CancellationToken.None);
            }
        }
Пример #2
0
        private async Task MessageReceivedAsync(IDialogContext context, IAwaitable <object> result)
        {
            var activity = await result as Activity;

            if (_isFirst && activity.ChannelId != "webchat" && activity.ChannelId != "emulator")
            {
                await context.PostAsync("Здравствуйте! Я Бот Электронной площадки РТС-тендер.");

                _isFirst = false;
            }
            // Проверка на разговор с оператором
            if (_operatorsConversation)
            {
                await ToOperator(context, activity);

                if (ResetParametrs.Reset(activity?.Text))
                {
                    MakeReset();
                    await context.PostAsync("До свидания");
                }
                return;
            }
            //-----------------------------------

            if (_answerExistence)
            {
                if (activity.Text.ToLower() != "да" && activity.Text.ToLower() != "нет")
                {
                    await context.PostAsync("Ответьте, пожалуйста, на вопрос. Нам очень важно Ваше мнение.");

                    Thread.Sleep(1500);
                    CardDialog.SatisfyingAnswer(context, activity);
                    return;
                }
                else
                {
                    if (activity.Text.ToLower() == "да")
                    {
                        _correct = true;
                        try
                        {
                            // Работа с Azure Таблицами
                            AddQuestionInAzureTable.UpdateData(_platform, _role, _userQuestion, _answer, activity.ChannelId, true);
                            // Работа с гугл таблицами
                            // AddQuestionInGoogleSheet.SendError(_platform, _role, _userQuestion, _answer, _correct);
                        }
                        catch //(Exception ex)
                        {
                            //throw new Exception(ex.Message);
                            //_userQuestion = null;
                            //_answer = null;
                            //_answerExistence = false;
                            //_correct = false;
                            //return;//await context.PostAsync("Возникли проблемы с обработкой Вашего ответа");
                        }

                        await context.PostAsync("Благодарю, Ваш ответ очень помог нам");

                        Thread.Sleep(1500);
                        await context.PostAsync("Если Вас еще что-то интересует, напишите тему");

                        _userQuestion    = null;
                        _answer          = null;
                        _answerExistence = false;
                        _correct         = false;
                        return;
                    }
                    if (activity.Text.ToLower() == "нет")
                    {
                        try
                        {
                            // Работа с Azure Таблицами
                            AddQuestionInAzureTable.UpdateData(_platform, _role, _userQuestion, _answer, activity.ChannelId, false);
                            // Работа с гугл таблицами
                            // AddQuestionInGoogleSheet.SendError(_platform, _role, _userQuestion, _answer, _correct);
                        }
                        catch //(Exception ex)
                        {
                            //throw new Exception(ex.Message);
                            //return; //await context.PostAsync("Возникли проблемы с обработкой Вашего ответа");
                        }

                        await context.PostAsync("Большое спасибо. Ваше сообщение передано в службу технической поддержки. Приносим извинения за неудобство");

                        Thread.Sleep(1500);
                        await context.PostAsync("Если Вас еще что-то интересует, напишите тему");

                        _answer          = null;
                        _userQuestion    = null;
                        _answerExistence = false;
                        return;
                    }
                }
            }

            try
            {
                if (ResetParametrs.Reset(activity?.Text))
                {
                    MakeReset();
                }
            }
            catch
            {
                await context.PostAsync("Возникли проблемы с работой сервиса. Приносим извинения за неудобство");
            }

            if (_parametrs == false)
            {
                if (string.IsNullOrEmpty(_platform) || string.IsNullOrEmpty(_role))
                {
                    if (!string.IsNullOrWhiteSpace(activity?.Text))
                    {
                        var apiAiResponse = ApiAiRequest.ApiAiBotRequest(activity.Text);

                        // Если есть ошибки
                        if (apiAiResponse.Errors != null && apiAiResponse.Errors.Count > 0)
                        {
                            await context.PostAsync("Что-то пошло не так");
                        }

                        // Если нет ошибок
                        else
                        {
                            // Проверка наличия, добавление или редактирование параметра "Площадка"
                            if (!string.IsNullOrEmpty(_platform))
                            {
                                if ((_platform != apiAiResponse.Platform) &&
                                    (!string.IsNullOrEmpty(apiAiResponse.Platform)))
                                {
                                    _platform = apiAiResponse.Platform;
                                }
                            }
                            else
                            {
                                _platform = apiAiResponse.Platform;
                            }

                            // Проверка наличия, добавление или редактирование параметра "Роль"
                            if (!string.IsNullOrEmpty(_role))
                            {
                                if ((_role != apiAiResponse.Role) && (!string.IsNullOrEmpty(apiAiResponse.Role)))
                                {
                                    _role = apiAiResponse.Role;
                                }
                            }
                            else
                            {
                                _role = apiAiResponse.Role;
                            }
                        }
                    }
                    else
                    {
                        await context.PostAsync("Что-то пошло не так");
                    }

                    // Идет проверка наличия всех заполненных и незаполненных параметров с последующим информированием пользователя
                    if (string.IsNullOrEmpty(_platform) || string.IsNullOrEmpty(_role))
                    {
                        string checkParametrs = ParametrsDialog.CheckParametrs(_platform, _role);

                        if (string.IsNullOrEmpty(_platform))
                        {
                            try
                            {
                                CardDialog.PlatformCard(context, activity, checkParametrs);
                            }
                            catch
                            {
                                await context.PostAsync("Что-то пошло не так");
                            }
                        }

                        if (string.IsNullOrEmpty(_role) && !string.IsNullOrEmpty(_platform))
                        {
                            if (_platform == "Имущественные торги")
                            {
                                try
                                {
                                    CardDialog.RoleCardImuchestvo(context, activity, checkParametrs);
                                    return;
                                }
                                catch
                                {
                                    await context.PostAsync("Что-то пошло не так");
                                }
                            }
                            if (_platform == "Электронный магазин ЗМО")
                            {
                                try
                                {
                                    CardDialog.RoleCardRTS(context, activity, checkParametrs);
                                    return;
                                }
                                catch
                                {
                                    await context.PostAsync("Что-то пошло не так");
                                }
                            }
                            if (_platform == "615-ПП РФ")
                            {
                                try
                                {
                                    CardDialog.RoleCard615(context, activity, checkParametrs);
                                    return;
                                }
                                catch
                                {
                                    await context.PostAsync("Что-то пошло не так");
                                }
                            }
                            else
                            {
                                try
                                {
                                    CardDialog.RoleCard(context, activity, checkParametrs);
                                    return;
                                }
                                catch
                                {
                                    await context.PostAsync("Что-то пошло не так");
                                }
                            }
                        }
                    }
                    else
                    {
                        _parametrs = true;
                        await context.PostAsync(
                            "Напишите теперь интересующую Вас тему. Для возврата в исходное состояние наберите слово *сброс*");

                        activity.Text = null;
                    }
                }
                else
                {
                    _parametrs = true;
                    await context.PostAsync("Напишите теперь интересующую Вас тему.");
                }
            }

            if (!string.IsNullOrEmpty(activity?.Text) && _parametrs)
            {
                try
                {
                    _userQuestion = activity.Text;
                    try
                    {
                        var qnaDialog = new QnADialog();
                        _answer = await qnaDialog.QnABotResponse(_platform, _role, _userQuestion);
                    }
                    catch// (Exception ex)
                    {
                        //throw new Exception(ex.Message);
                        await context.PostAsync("Что-то пошло не так");
                    }

                    if (_answer == "Прошу прощения, но я не понял вопроса. Попробуйте перефразировать его.")
                    {
                        await context.PostAsync(_answer);

                        _answerExistence = false;

                        // Для включения/выключения функции перенаправления оператору
                        // await ToOperator(context, activity);
                        //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
                        return;
                    }

                    try
                    {
                        // Работа с Azure Таблицами
                        AddQuestionInAzureTable.AddData(_platform, _role, _userQuestion, _answer, activity.ChannelId);
                    }
                    catch { }
                    string strRegex       = @"(\!\[(alt text)?\])\((ht|f)tp(s?)\:\/\/[0-9a-zA-Z]([-.\w]*[0-9a-zA-Z])*(:(0-9)*)*(\/?)([a-zA-Z0-9А-Яа-я \-\.\?\,\'\/\\\+&amp;%\$#_]*)?([ ])?(\""?[a-zA-Z0-9А-Яа-я]*\""?)?\)([;\.,\!\?])?";
                    Regex  myRegex        = new Regex(strRegex);
                    string imageSubanswer = String.Empty;

                    // Создание копии ответа, для корректного занесения в таблицу ответов
                    string copyAnswer = _answer;

                    int intervalPoint = activity.ChannelId == "facebook" ? 600 : 3500;
                    // Проверка длины сообщения. Делается потому, как некоторые мессенджеры имеют ограничения на длину сообщения
                    if (_answer.Length > intervalPoint)
                    {
                        bool wasImages  = false;
                        int  startPoint = 0;
                        while (copyAnswer.Length > intervalPoint)
                        {
                            var substringPoint = intervalPoint;
                            // Данный цикл обрабатывает возможность корректного разделения больших сообщений на более мелкие
                            // Причем разделение проводится по предложениям (Ориентиром является точка)
                            while (copyAnswer[substringPoint] != '.')
                            {
                                substringPoint--;
                            }

                            var  subanswer = copyAnswer.Substring(0, substringPoint + 1);
                            bool img       = false;


                            foreach (Match myMatch in myRegex.Matches(subanswer))
                            {
                                if (!myMatch.Success)
                                {
                                    await context.PostAsync(subanswer);

                                    continue;
                                }
                                wasImages      = true;
                                imageSubanswer = subanswer.Substring(startPoint, (myMatch.Index - startPoint) + myMatch.Length);

                                await context.PostAsync(imageSubanswer);

                                startPoint = myMatch.Index + myMatch.Length;

                                img = true;
                            }

                            if (!wasImages)
                            {
                                await context.PostAsync(subanswer.Substring(startPoint));
                            }
                            _answerExistence = true;
                            if (img)
                            {
                                copyAnswer = copyAnswer.Remove(0, startPoint);
                                startPoint = 0;
                            }
                            else
                            {
                                copyAnswer = copyAnswer.Remove(0, substringPoint + 1);
                            }
                        }

                        startPoint = 0;

                        foreach (Match myMatch in myRegex.Matches(copyAnswer))
                        {
                            if (!myMatch.Success)
                            {
                                await context.PostAsync(copyAnswer.Substring(startPoint));

                                continue;
                            }

                            imageSubanswer = copyAnswer.Substring(startPoint, (myMatch.Index - startPoint) + myMatch.Length);
                            wasImages      = true;
                            await context.PostAsync(imageSubanswer);

                            startPoint = myMatch.Index + myMatch.Length;
                        }
                        if (!wasImages)
                        {
                            await context.PostAsync(copyAnswer);
                        }
                        else
                        {
                            await context.PostAsync(copyAnswer.Substring(startPoint));
                        }

                        _answerExistence = true;
                    }
                    else
                    {
                        int startPoint = 0;
                        foreach (Match myMatch in myRegex.Matches(copyAnswer))
                        {
                            if (!myMatch.Success)
                            {
                                await context.PostAsync(_answer);

                                continue;
                            }
                            imageSubanswer = copyAnswer.Substring(startPoint, (myMatch.Index - startPoint) + myMatch.Length);

                            await context.PostAsync(imageSubanswer);

                            startPoint = myMatch.Index + myMatch.Length;
                        }
                        await context.PostAsync(copyAnswer.Substring(startPoint));

                        _answerExistence = true;
                    }

                    Thread.Sleep(1500);
                    CardDialog.SatisfyingAnswer(context, activity);
                }
                catch //(Exception ex)
                {
                    //throw new Exception(ex.Message);
                    await context.PostAsync("Что-то пошло не так");
                }
            }
            context.Wait(MessageReceivedAsync);
        }