├── .dockerignore
├── .gitignore
├── _files
    ├── icon1_00000.jpg
    └── icon_00000.jpg
├── AliceHook
    ├── Models
    │   ├── Abstract
    │   │   ├── ICloneable.cs
    │   │   ├── AliceResponseBase.cs
    │   │   └── AliceRequestBase.cs
    │   ├── AliceRequest.cs
    │   ├── Webhook.cs
    │   ├── AliceResponse.cs
    │   ├── UserData.cs
    │   ├── UserState.cs
    │   ├── SessionState.cs
    │   ├── Example.cs
    │   └── Phrase.cs
    ├── AliceHook.csproj
    ├── Program.cs
    ├── Engine
    │   ├── Modifiers
    │   │   ├── ModifierCancel.cs
    │   │   ├── Abstract
    │   │   │   ├── ModifierBase.cs
    │   │   │   └── ModifierBaseKeywords.cs
    │   │   ├── ModifierExit.cs
    │   │   ├── ModifierAddPhrase.cs
    │   │   ├── ModifierEnter.cs
    │   │   ├── ModifierUnknown.cs
    │   │   ├── ModifierExampleList.cs
    │   │   ├── ModifierAddWebhook.cs
    │   │   ├── ModifierDelete.cs
    │   │   ├── ModifierFinalWebhook.cs
    │   │   ├── ModifierTestRequest.cs
    │   │   ├── ModifierWebhookResponse.cs
    │   │   ├── ModifierExample.cs
    │   │   ├── ModifierList.cs
    │   │   ├── ModifierHelp.cs
    │   │   └── ModifierRunWebhook.cs
    │   └── AliceService.cs
    ├── Startup.cs
    ├── Controllers
    │   └── AliceController.cs
    └── Utils.cs
├── README.md
├── Dockerfile
├── AliceHook.sln.DotSettings
└── AliceHook.sln


/.dockerignore:
--------------------------------------------------------------------------------
1 | bin/
2 | obj/
3 | /packages/
4 | /.idea/


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | bin/
2 | obj/
3 | /packages/
4 | /.idea/
5 | 


--------------------------------------------------------------------------------
/_files/icon1_00000.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DenisNP/AliceHook/HEAD/_files/icon1_00000.jpg


--------------------------------------------------------------------------------
/_files/icon_00000.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DenisNP/AliceHook/HEAD/_files/icon_00000.jpg


--------------------------------------------------------------------------------
/AliceHook/Models/Abstract/ICloneable.cs:
--------------------------------------------------------------------------------
1 | namespace AliceHook.Models.Abstract
2 | {
3 |     public interface ICloneable<out T>
4 |     {
5 |         T Clone();
6 |     }
7 | }


--------------------------------------------------------------------------------
/AliceHook/Models/AliceRequest.cs:
--------------------------------------------------------------------------------
1 | using AliceHook.Models.Abstract;
2 | 
3 | namespace AliceHook.Models
4 | {
5 |     public class AliceRequest : AliceRequestBase<UserState, SessionState> { }
6 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # AliceHook
2 | 
3 | [Навык](https://dialogs.yandex.ru/store/skills/85384c00-moj-ispolnitel) для интеграции Алисы с IFTTT, Zapier и Integromat. 
4 | 
5 | Первая версия делалась на [обучающем стриме](https://www.youtube.com/watch?v=vBg60I3P9Wg). Но текущая уже многим отличается.
6 | 


--------------------------------------------------------------------------------
/AliceHook/Models/Webhook.cs:
--------------------------------------------------------------------------------
 1 | using Google.Cloud.Firestore;
 2 | 
 3 | namespace AliceHook.Models
 4 | {
 5 |     [FirestoreData]
 6 |     public class Webhook
 7 |     {
 8 |         [FirestoreProperty]
 9 |         public int Id { get; set; }
10 |         [FirestoreProperty]
11 |         public string Phrase { get; set; }
12 |         [FirestoreProperty]
13 |         public string Url { get; set; }
14 |     }
15 | }


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM mcr.microsoft.com/dotnet/core/sdk:3.0 AS build-env
 2 | WORKDIR /app
 3 | 
 4 | # Copy, restore and build
 5 | COPY . .
 6 | RUN dotnet restore
 7 | RUN dotnet publish -c Release -o out
 8 | 
 9 | # Build runtime image
10 | FROM mcr.microsoft.com/dotnet/core/aspnet:3.0
11 | WORKDIR /app
12 | COPY --from=build-env /app/out .
13 | EXPOSE 80
14 | 
15 | # Main run command
16 | ENTRYPOINT ["dotnet", "AliceHook.dll"]


--------------------------------------------------------------------------------
/AliceHook/Models/AliceResponse.cs:
--------------------------------------------------------------------------------
 1 | using AliceHook.Models.Abstract;
 2 | 
 3 | namespace AliceHook.Models
 4 | {
 5 |     public class AliceResponse : AliceResponseBase<UserState, SessionState>
 6 |     {
 7 |         public AliceResponse(
 8 |             AliceRequest request,
 9 |             SessionState sessionState = default,
10 |             UserState userState = default
11 |         ) : base(request, sessionState, userState) { }
12 |     }
13 | }


--------------------------------------------------------------------------------
/AliceHook/Models/UserData.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using Google.Cloud.Firestore;
 3 | 
 4 | namespace AliceHook.Models
 5 | {
 6 |     [FirestoreData]
 7 |     public class UserData
 8 |     {
 9 |         [FirestoreProperty]
10 |         public string Id { get; set; }
11 |         [FirestoreProperty]
12 |         public string Token { get; set; }
13 |         [FirestoreProperty]
14 |         public List<Webhook> Webhooks { get; set; } = new List<Webhook>();
15 |     }
16 | }


--------------------------------------------------------------------------------
/AliceHook.sln.DotSettings:
--------------------------------------------------------------------------------
1 | <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
2 | 	<s:Boolean x:Key="/Default/UserDictionary/Words/=webhook/@EntryIndexedValue">True</s:Boolean>
3 | 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Webhooks/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>


--------------------------------------------------------------------------------
/AliceHook/AliceHook.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk.Web">
 2 | 
 3 |     <PropertyGroup>
 4 |         <TargetFramework>netcoreapp3.0</TargetFramework>
 5 |     </PropertyGroup>
 6 | 
 7 |     <ItemGroup>
 8 |       <_ContentIncludedByDefault Remove="Properties\launchSettings.json" />
 9 |     </ItemGroup>
10 | 
11 |     <ItemGroup>
12 |       <PackageReference Include="Google.Cloud.Firestore" Version="2.0.0-beta02" />
13 |       <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
14 |     </ItemGroup>
15 | 
16 | </Project>
17 | 


--------------------------------------------------------------------------------
/AliceHook/Models/UserState.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.Linq;
 3 | 
 4 | namespace AliceHook.Models
 5 | {
 6 |     public class UserState
 7 |     {
 8 |         public List<Webhook> Webhooks { get; } = new List<Webhook>();
 9 |         public Webhook FindWebhook(string phrase)
10 |         {
11 |             return Webhooks.FirstOrDefault(w =>
12 |             {
13 |                 string shorten = w.Phrase.Replace(" ", "");
14 |                 string startPhrase = phrase.SafeSubstring(shorten.Length);
15 |                 return Utils.LevenshteinRatio(startPhrase, shorten) < Utils.PossibleRatio(shorten.Length);
16 |             });
17 |         }
18 |     }
19 | }


--------------------------------------------------------------------------------
/AliceHook/Models/SessionState.cs:
--------------------------------------------------------------------------------
 1 | namespace AliceHook.Models
 2 | {
 3 |     public class SessionState
 4 |     {
 5 |         public Step Step { get; set; } = Step.None;
 6 |         public string TempUrl { get; set; } = "";
 7 |         public string LastResult { get; set; } = "";
 8 |         public string LastError { get; set; } = "";
 9 | 
10 |         public void Clear()
11 |         {
12 |             Step = Step.None;
13 |             TempUrl = "";
14 |             LastError = "";
15 |             LastResult = "";
16 |         }
17 |     }
18 | 
19 |     public enum Step
20 |     {
21 |         None,
22 |         AwaitForUrl,
23 |         AwaitForKeyword,
24 |         AwaitWebhookResponse
25 |     }
26 | }


--------------------------------------------------------------------------------
/AliceHook/Program.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.AspNetCore.Hosting;
 2 | using Microsoft.Extensions.Logging;
 3 | 
 4 | namespace AliceHook
 5 | {
 6 |     public class Program
 7 |     {
 8 |         public static void Main(string[] args)
 9 |         {
10 |             StartServer();
11 |         }
12 | 
13 |         private static void StartServer()
14 |         {
15 |             new WebHostBuilder()
16 |                 .UseKestrel()
17 | #if DEBUG
18 |                 .ConfigureLogging(logging =>
19 |                 {
20 |                     logging.AddDebug();
21 |                     logging.AddConsole();
22 |                 })
23 | #endif                           
24 |                 .UseStartup<Startup>()
25 |                 .Build()
26 |                 .Run();
27 |         }
28 |     }
29 | }


--------------------------------------------------------------------------------
/AliceHook.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AliceHook", "AliceHook\AliceHook.csproj", "{FB49A21C-0EEB-43AB-AF4F-45C3CE3BF6CD}"
 4 | EndProject
 5 | Global
 6 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 7 | 		Debug|Any CPU = Debug|Any CPU
 8 | 		Release|Any CPU = Release|Any CPU
 9 | 	EndGlobalSection
10 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
11 | 		{FB49A21C-0EEB-43AB-AF4F-45C3CE3BF6CD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
12 | 		{FB49A21C-0EEB-43AB-AF4F-45C3CE3BF6CD}.Debug|Any CPU.Build.0 = Debug|Any CPU
13 | 		{FB49A21C-0EEB-43AB-AF4F-45C3CE3BF6CD}.Release|Any CPU.ActiveCfg = Release|Any CPU
14 | 		{FB49A21C-0EEB-43AB-AF4F-45C3CE3BF6CD}.Release|Any CPU.Build.0 = Release|Any CPU
15 | 	EndGlobalSection
16 | EndGlobal
17 | 


--------------------------------------------------------------------------------
/AliceHook/Engine/Modifiers/ModifierCancel.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using AliceHook.Engine.Modifiers.Abstract;
 3 | using AliceHook.Models;
 4 | 
 5 | namespace AliceHook.Engine.Modifiers
 6 | {
 7 |     public class ModifierCancel : ModifierBaseKeywords
 8 |     {
 9 |         protected override List<string> Keywords { get; } = new List<string>
10 |         {
11 |             "отмен"
12 |         };
13 | 
14 |         protected override bool CheckState(SessionState state)
15 |         {
16 |             return state.Step != Step.None;
17 |         }
18 | 
19 |         protected override Phrase Respond(AliceRequest request)
20 |         {
21 |             request.State.Session.Clear();
22 |             return new Phrase(
23 |                 "Отменено. Что теперь?",
24 |                 new []{ "Добавить вебхук", "Примеры", "Список", "Выход" }
25 |             );
26 |         }
27 |     }
28 | }


--------------------------------------------------------------------------------
/AliceHook/Engine/Modifiers/Abstract/ModifierBase.cs:
--------------------------------------------------------------------------------
 1 | using AliceHook.Models;
 2 | 
 3 | namespace AliceHook.Engine.Modifiers.Abstract
 4 | {
 5 |     public abstract class ModifierBase
 6 |     {
 7 |         public bool Run(AliceRequest request, out AliceResponse response)
 8 |         {
 9 |             if (!Check(request))
10 |             {
11 |                 response = null;
12 |                 return false;
13 |             }
14 |             
15 |             response = CreateResponse(request);
16 |             return true;
17 |         }
18 | 
19 |         protected virtual AliceResponse CreateResponse(AliceRequest request)
20 |         {
21 |             Phrase phrase = Respond(request);
22 |             return phrase.Generate(request);
23 |         }
24 | 
25 |         protected abstract bool Check(AliceRequest request);
26 |         protected abstract Phrase Respond(AliceRequest request);
27 |     }
28 | }


--------------------------------------------------------------------------------
/AliceHook/Engine/Modifiers/ModifierExit.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using AliceHook.Engine.Modifiers.Abstract;
 3 | using AliceHook.Models;
 4 | 
 5 | namespace AliceHook.Engine.Modifiers
 6 | {
 7 |     public class ModifierExit : ModifierBaseKeywords
 8 |     {
 9 |         protected override List<string> Keywords { get; } = new List<string>
10 |         {
11 |             "выход",
12 |             "выйти",
13 |             "пока"
14 |         };
15 | 
16 |         protected override bool CheckState(SessionState state)
17 |         {
18 |             return true; // any state
19 |         }
20 | 
21 |         protected override AliceResponse CreateResponse(AliceRequest request)
22 |         {
23 |             AliceResponse resp = base.CreateResponse(request);
24 |             resp.Response.EndSession = true;
25 |             return resp;
26 |         }
27 | 
28 |         protected override Phrase Respond(AliceRequest request)
29 |         {
30 |             return new Phrase("Выхож[+]у. Хорошего дня.");
31 |         }
32 |     }
33 | }


--------------------------------------------------------------------------------
/AliceHook/Startup.cs:
--------------------------------------------------------------------------------
 1 | using AliceHook.Engine;
 2 | using Microsoft.AspNetCore.Builder;
 3 | using Microsoft.AspNetCore.Hosting;
 4 | using Microsoft.AspNetCore.Server.Kestrel.Core;
 5 | using Microsoft.Extensions.Configuration;
 6 | using Microsoft.Extensions.DependencyInjection;
 7 | 
 8 | namespace AliceHook
 9 | {
10 |     public class Startup
11 |     {
12 |         public Startup(IConfiguration configuration)
13 |         {
14 |             Configuration = configuration;
15 |         }
16 | 
17 |         public IConfiguration Configuration { get; }
18 | 
19 |         public void ConfigureServices(IServiceCollection services)
20 |         {
21 |             services.AddControllers();
22 |             services.AddSingleton<AliceService>();
23 |             services.Configure<KestrelServerOptions>(options => { options.AllowSynchronousIO = true; });
24 |         }
25 | 
26 |         public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
27 |         {
28 |             app.UseRouting();
29 |             app.UseEndpoints(endpoints => { endpoints.MapControllers(); });
30 |         }
31 |     }
32 | }


--------------------------------------------------------------------------------
/AliceHook/Engine/Modifiers/ModifierAddPhrase.cs:
--------------------------------------------------------------------------------
 1 | using System.Text.RegularExpressions;
 2 | using AliceHook.Engine.Modifiers.Abstract;
 3 | using AliceHook.Models;
 4 | 
 5 | namespace AliceHook.Engine.Modifiers
 6 | {
 7 |     public class ModifierAddPhrase : ModifierBase
 8 |     {
 9 |         public static readonly Regex UrlRegex 
10 |             = new Regex(@"^(?:http(s)?:\/\/)[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~:/?#[\]@!\$&'\(\)\*\+,;=.]+$");
11 |         
12 |         protected override bool Check(AliceRequest request)
13 |         {
14 |             return request.State.Session.Step == Step.AwaitForUrl && UrlRegex.IsMatch(request.Request.OriginalUtterance);
15 |         }
16 | 
17 |         protected override Phrase Respond(AliceRequest request)
18 |         {
19 |             request.State.Session.Step = Step.AwaitForKeyword;
20 |             request.State.Session.TempUrl = request.Request.OriginalUtterance;
21 | 
22 |             return new Phrase(
23 |                 "А теперь назовите фразу активации:",
24 |                 new []{ "Отмена", "Помощь", "Выход"} 
25 |             );
26 |         }
27 |     }
28 | }


--------------------------------------------------------------------------------
/AliceHook/Engine/Modifiers/Abstract/ModifierBaseKeywords.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.Linq;
 3 | using AliceHook.Models;
 4 | 
 5 | namespace AliceHook.Engine.Modifiers.Abstract
 6 | {
 7 |     public abstract class ModifierBaseKeywords : ModifierBase
 8 |     {
 9 |         protected abstract List<string> Keywords { get; }
10 |         
11 |         protected abstract bool CheckState(SessionState state);
12 |         
13 |         protected override bool Check(AliceRequest request)
14 |         {
15 |             return CheckState(request.State.Session) && CheckTokens(request);
16 |         }
17 |         
18 |         protected bool CheckTokens(AliceRequest request)
19 |         {
20 |             return CheckTokens(request.Request.Nlu.Tokens, Keywords.ToArray());
21 |         }
22 | 
23 |         private bool CheckTokens(IEnumerable<string> tokens, params string[] expected)
24 |         {
25 |             return expected.Any(expectedString =>
26 |             {
27 |                 string[] expectedTokens = expectedString.Split(" ");
28 |                 return expectedTokens.All(tokens.ContainsStartWith);
29 |             });
30 |         }
31 |     }
32 | }


--------------------------------------------------------------------------------
/AliceHook/Engine/Modifiers/ModifierEnter.cs:
--------------------------------------------------------------------------------
 1 | using AliceHook.Engine.Modifiers.Abstract;
 2 | using AliceHook.Models;
 3 | 
 4 | namespace AliceHook.Engine.Modifiers
 5 | {
 6 |     public class ModifierEnter : ModifierBase
 7 |     {
 8 |         protected override bool Check(AliceRequest request)
 9 |         {
10 |             return request.Request.Command == "";
11 |         }
12 | 
13 |         protected override Phrase Respond(AliceRequest request)
14 |         {
15 |             if (request.State.User.Webhooks.Count > 0)
16 |             {
17 |                 return new Phrase(
18 |                     "Слушаю",
19 |                     new []{ "Добавить вебхук", "Список", "Примеры", "Выход" }
20 |                 );
21 |             }
22 |             
23 |             return ModifierHelp.GetHelp(Step.None, request.HasScreen());
24 |         }
25 | 
26 |         protected override AliceResponse CreateResponse(AliceRequest request)
27 |         {
28 |             AliceResponse response = base.CreateResponse(request);
29 |             if (request.State.User.Webhooks.Count == 0)
30 |             {
31 |                 ModifierHelp.AddExamplesTo(response);
32 |             }
33 | 
34 |             return response;
35 |         }
36 |     }
37 | }


--------------------------------------------------------------------------------
/AliceHook/Engine/Modifiers/ModifierUnknown.cs:
--------------------------------------------------------------------------------
 1 | using AliceHook.Engine.Modifiers.Abstract;
 2 | using AliceHook.Models;
 3 | 
 4 | namespace AliceHook.Engine.Modifiers
 5 | {
 6 |     public class ModifierUnknown : ModifierBase
 7 |     {
 8 |         protected override bool Check(AliceRequest request)
 9 |         {
10 |             return true;
11 |         }
12 | 
13 |         protected override Phrase Respond(AliceRequest request)
14 |         {
15 |             if (request.State.Session.Step == Step.None)
16 |             {
17 |                 if (request.HasScreen())
18 |                 {
19 |                     return new Phrase(
20 |                         "Команда не распознана. Вы можете добавить в[screen|е][voice|э]бх[+]ук, " +
21 |                         "или посмотреть список ключевых фраз. Что хотите сделать?",
22 |                         new []{ "Добавить вебхук", "Список", "Помощь", "Выход" }
23 |                     );
24 |                 }
25 |                 
26 |                 // no screen
27 |                 return new Phrase(
28 |                     "Команда не распознана. Вы можете прослушать список ключевых фраз либо выйти. " +
29 |                     "Что хотите сделать?"
30 |                 );
31 |             }
32 |             return ModifierHelp.GetHelp(request.State.Session.Step, request.HasScreen());
33 |         }
34 |     }
35 | }


--------------------------------------------------------------------------------
/AliceHook/Engine/Modifiers/ModifierExampleList.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using AliceHook.Engine.Modifiers.Abstract;
 3 | using AliceHook.Models;
 4 | 
 5 | namespace AliceHook.Engine.Modifiers
 6 | {
 7 |     public class ModifierExampleList : ModifierBaseKeywords
 8 |     {
 9 |         protected override List<string> Keywords { get; } = new List<string>
10 |         {
11 |             "пример",
12 |             "например"
13 |         };
14 |         
15 |         protected override Phrase Respond(AliceRequest request)
16 |         {
17 |             return new Phrase(
18 |                 "Вот список некоторых пользовательских сценариев, которые возможны с помощью этого навыка.",
19 |                 new []{ "Добавить вебхук", "Список вебхуков", "Выход" }
20 |             );
21 |         }
22 | 
23 |         protected override AliceResponse CreateResponse(AliceRequest request)
24 |         {
25 |             AliceResponse response = base.CreateResponse(request);
26 |             ModifierHelp.AddExamplesTo(response);
27 | 
28 |             return response;
29 |         }
30 | 
31 |         protected override bool CheckState(SessionState state)
32 |         {
33 |             return state.Step == Step.None;
34 |         }
35 | 
36 |         protected override bool Check(AliceRequest request)
37 |         {
38 |             return request.HasScreen() && base.Check(request);
39 |         }
40 |     }
41 | }


--------------------------------------------------------------------------------
/AliceHook/Engine/Modifiers/ModifierAddWebhook.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using AliceHook.Engine.Modifiers.Abstract;
 3 | using AliceHook.Models;
 4 | 
 5 | namespace AliceHook.Engine.Modifiers
 6 | {
 7 |     public class ModifierAddWebhook : ModifierBaseKeywords
 8 |     {
 9 |         protected override List<string> Keywords { get; } = new List<string>
10 |         {
11 |             "добав вебхук",
12 |             "новый вебхук",
13 |             "созда вебхук",
14 |             "добав webhook",
15 |             "новый webhook",
16 |             "созда webhook",
17 |             "добав веб хук",
18 |             "новый веб хук",
19 |             "созда веб хук",
20 |         };
21 | 
22 |         protected override bool CheckState(SessionState state)
23 |         {
24 |             return state.Step == Step.None;
25 |         }
26 | 
27 |         protected override Phrase Respond(AliceRequest request)
28 |         {
29 |             if (!request.HasScreen())
30 |             {
31 |                 return new Phrase("Добавлять в[screen|е][voice|э]бх[+]уки можно только на устройстве с экраном");
32 |             }
33 |             
34 |             if (request.State.User.Webhooks.Count >= 20)
35 |             {
36 |                 return new Phrase(
37 |                     "У вас очень много в[screen|е][voice|э]бх[+]уков, удалите что-нибудь сначала с помощью команды \"Список\"",
38 |                     new []{ "Список", "Помощь", "Выход" }
39 |                 );
40 |             }
41 |             
42 |             request.State.Session.Step = Step.AwaitForUrl;
43 |             return new Phrase(
44 |                 "Введите URL в[screen|е][voice|э]бх[+]ука:",
45 |                 new []{ "Отмена", "Помощь", "Выход" }
46 |             );
47 |         }
48 |     }
49 | }


--------------------------------------------------------------------------------
/AliceHook/Engine/Modifiers/ModifierDelete.cs:
--------------------------------------------------------------------------------
 1 | using System.Linq;
 2 | using System.Text.RegularExpressions;
 3 | using AliceHook.Engine.Modifiers.Abstract;
 4 | using AliceHook.Models;
 5 | 
 6 | namespace AliceHook.Engine.Modifiers
 7 | {
 8 |     public class ModifierDelete : ModifierBase
 9 |     {
10 |         protected override bool Check(AliceRequest request)
11 |         {
12 |             return request.State.Session.Step == Step.None 
13 |                    && request.Request.Command.ToLower().StartsWith("удали") 
14 |                    && request.Request.Nlu.Tokens.Count > 1
15 |                    && GetWebhook(request) != null;
16 |         }
17 | 
18 |         protected override Phrase Respond(AliceRequest request)
19 |         {
20 |             Webhook w = GetWebhook(request);
21 | 
22 |             if (w == null)
23 |             {
24 |                 return new Phrase(
25 |                     "Не могу найти в[screen|е][voice|э]бх[+]ук по вашему запросу. Что хотите сделать сейчас?",
26 |                     new []{ "Добавить вебхук", "Примеры", "Список", "Выход" }
27 |                 );
28 |             }
29 |             
30 |             request.State.User.Webhooks.Remove(w);
31 | 
32 |             return new Phrase(
33 |                 $"Удален в[screen|е][voice|э]бх[+]ук: {w.Phrase.CapitalizeFirst()}. Что теперь?", 
34 |                 new []{ "Добавить вебхук", "Список", "Примеры", "Выход" }
35 |             );
36 |         }
37 | 
38 |         private Webhook GetWebhook(AliceRequest request)
39 |         {
40 |             string[] tokens = Regex.Split(request.Request.Command.ToLower(), "\\s+");
41 |             if (tokens.Length <= 1)
42 |             {
43 |                 return null;
44 |             }
45 |             string trimmedCommand = tokens.Skip(1).Join("").Trim();
46 |             return request.State.User.FindWebhook(trimmedCommand);
47 |         }
48 |     }
49 | }


--------------------------------------------------------------------------------
/AliceHook/Engine/Modifiers/ModifierFinalWebhook.cs:
--------------------------------------------------------------------------------
 1 | using AliceHook.Engine.Modifiers.Abstract;
 2 | using AliceHook.Models;
 3 | 
 4 | namespace AliceHook.Engine.Modifiers
 5 | {
 6 |     public class ModifierFinalWebhook : ModifierBase
 7 |     {
 8 |         protected override bool Check(AliceRequest request)
 9 |         {
10 |             return request.State.Session.Step == Step.AwaitForKeyword && request.HasScreen();
11 |         }
12 | 
13 |         protected override Phrase Respond(AliceRequest request)
14 |         {
15 |             Webhook exists = request.State.User.FindWebhook(
16 |                 request.Request.Command
17 |                     .ToLower()
18 |                     .Trim()
19 |                     .Replace(" ", "")
20 |             );
21 |             
22 |             if (exists != null)
23 |             {
24 |                 return new Phrase(
25 |                     $"У вас уже есть вебхук с похожей ключевой фразой: {exists.Phrase.CapitalizeFirst()}. " +
26 |                     "Назовите другую фразу.",
27 |                     new []{ "Отмена", "Помощь", "Выход" }
28 |                 );
29 |             }
30 | 
31 |             var webhook = new Webhook
32 |             {
33 |                 Phrase = request.Request.Command,
34 |                 Url = request.State.Session.TempUrl
35 |             };
36 |             
37 |             request.State.User.Webhooks.Add(webhook);
38 |             request.State.Session.Clear();
39 | 
40 |             return new Phrase(
41 |                 $"Теперь, когда вы скажете фразу, которая начинается на \"{webhook.Phrase.CapitalizeFirst()}" +
42 |                 "\", я вызову этот адрес и передам туда весь ваш текст в параметр [screen|value1][voice|вэлью 1]" +
43 |                 ".[p|1000]\n\nЧто делаем дальше?", 
44 |                 new []{ "Добавить вебхук", "Список", "Примеры", "Выход" }
45 |             );
46 |         }
47 |     }
48 | }


--------------------------------------------------------------------------------
/AliceHook/Engine/Modifiers/ModifierTestRequest.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.Net;
 3 | using System.Net.Http;
 4 | using AliceHook.Engine.Modifiers.Abstract;
 5 | using AliceHook.Models;
 6 | 
 7 | namespace AliceHook.Engine.Modifiers
 8 | {
 9 |     public class ModifierTestRequest : ModifierBase
10 |     {
11 |         protected override bool Check(AliceRequest request)
12 |         {
13 |             if (request.State.Session.Step != Step.None || !request.Request.Command.StartsWith("http"))
14 |             {
15 |                 return false;
16 |             }
17 | 
18 |             return ModifierAddPhrase.UrlRegex.IsMatch(request.Request.OriginalUtterance);
19 |         }
20 | 
21 |         protected override Phrase Respond(AliceRequest request)
22 |         {
23 |             string url = request.Request.OriginalUtterance;
24 | 
25 |             // test post
26 |             using var handler = new HttpClientHandler
27 |             {
28 |                 ServerCertificateCustomValidationCallback
29 |                     = (message, certificate2, arg3, arg4) => true
30 |             };
31 |             using var client = new HttpClient(handler);
32 |             var data = new FormUrlEncodedContent(new Dictionary<string, string>
33 |             {
34 |                 {"value1", "тестовый запрос — сокращённая фраза"},
35 |                 {"value2", "тестовый запрос — полная фраза (ключевая + сокращённая)"}, // full command
36 |                 {"value3", "тестовый запрос — ключевая фраза"}
37 |             });
38 | 
39 |             HttpResponseMessage response = client.PostAsync(url, data).Result;
40 | 
41 |             // response
42 |             return new Phrase(
43 |                 response.StatusCode == HttpStatusCode.OK
44 |                     ? "Отправила тестовый запрос на этот адрес. Что теперь?"
45 |                     : "Какая-то ошибка в процессе вызова адреса. Статус ответа: " + response.StatusCode + ". Что дальше?",
46 |                 new []{ "Добавить вебхук", "Список", "Примеры", "Выход" }
47 |             );
48 |         }
49 |     }
50 | }


--------------------------------------------------------------------------------
/AliceHook/Engine/Modifiers/ModifierWebhookResponse.cs:
--------------------------------------------------------------------------------
 1 | using System.Linq;
 2 | using AliceHook.Engine.Modifiers.Abstract;
 3 | using AliceHook.Models;
 4 | 
 5 | namespace AliceHook.Engine.Modifiers
 6 | {
 7 |     public class ModifierWebhookResponse : ModifierBase
 8 |     {
 9 |         private readonly string[] Yes = {
10 |             "да",
11 |             "ага",
12 |             "давай",
13 |             "узнай",
14 |             "ок",
15 |             "хорошо",
16 |             "угу"
17 |         };
18 |         
19 |         protected override bool Check(AliceRequest request)
20 |         {
21 |             return request.State.Session.Step == Step.AwaitWebhookResponse;
22 |         }
23 | 
24 |         protected override Phrase Respond(AliceRequest request)
25 |         {
26 |             request.State.Session.Step = Step.None;
27 |             
28 |             string command = request.Request.Command;
29 |             if (Yes.Any(x => command.StartsWith(x)))
30 |             {
31 |                 // yes
32 |                 if (!request.State.Session.LastResult.IsNullOrEmpty())
33 |                 {
34 |                     return new Phrase(
35 |                         "Вебхук ответил:\n" + request.State.Session.LastResult,
36 |                         new []{ "Список", "Помощь", "Выход" }
37 |                     );
38 |                 }
39 | 
40 |                 if (!request.State.Session.LastError.IsNullOrEmpty())
41 |                 {
42 |                     return new Phrase(
43 |                         "К сожалению, с вызовом произошла ошибка. Что теперь?",
44 |                         new []{ "Список", "Помощь", "Выход" }
45 |                     );
46 |                 }
47 | 
48 |                 return new Phrase(
49 |                     "К сожалению, получить ответ от вебхука не удалось. Что теперь?",
50 |                     new[] {"Список", "Помощь", "Выход"}
51 |                 );
52 |             }
53 | 
54 |             return new Phrase(
55 |                 "Ожидание ответа от вебхука прекращено. Что дальше?",
56 |                 new []{ "Добавить вебхук", "Список", "Примеры", "Выход" }
57 |             );
58 |         }
59 |     }
60 | }


--------------------------------------------------------------------------------
/AliceHook/Engine/AliceService.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using AliceHook.Engine.Modifiers;
 5 | using AliceHook.Engine.Modifiers.Abstract;
 6 | using AliceHook.Models;
 7 | using AliceHook.Models.Abstract;
 8 | 
 9 | namespace AliceHook.Engine
10 | {
11 |     public class AliceService
12 |     {
13 |         private static readonly List<ModifierBase> Modifiers = new List<ModifierBase>
14 |         {
15 |             new ModifierEnter(),
16 |             new ModifierTestRequest(),
17 |             new ModifierExample(),
18 |             new ModifierExampleList(),
19 |             new ModifierWebhookResponse(),
20 |             new ModifierHelp(),
21 |             new ModifierExit(),
22 |             new ModifierList(),
23 |             new ModifierCancel(),
24 |             new ModifierDelete(),
25 |             new ModifierAddWebhook(),
26 |             new ModifierAddPhrase(),
27 |             new ModifierFinalWebhook(),
28 |             new ModifierRunWebhook(),
29 |             new ModifierUnknown()
30 |         };
31 |         
32 |         public AliceResponse HandleRequest(AliceRequest aliceRequest)
33 |         {
34 |             // respond
35 |             AliceResponse response = null;
36 |             try
37 |             {
38 |                 if (!Modifiers.Any(modifier => modifier.Run(aliceRequest, out response))) {
39 |                     throw new NotSupportedException("No default modifier");
40 |                 }
41 |             }
42 |             catch (Exception e)
43 |             {
44 |                 Console.WriteLine("\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ERROR");
45 |                 Console.WriteLine(e);
46 |                 response = new AliceResponse(aliceRequest)
47 |                 {
48 |                     Response = new Response
49 |                     {
50 |                         Text = "Произошла какая-то ошибка на сервере навыка, разработчик уже уведомлён. " +
51 |                                "Приносим извинения."
52 |                     }
53 |                 };
54 |                 Console.WriteLine("");
55 |             }
56 | 
57 |             return response;
58 |         }
59 |     }
60 | }


--------------------------------------------------------------------------------
/AliceHook/Engine/Modifiers/ModifierExample.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using AliceHook.Engine.Modifiers.Abstract;
 5 | using AliceHook.Models;
 6 | using AliceHook.Models.Abstract;
 7 | 
 8 | namespace AliceHook.Engine.Modifiers
 9 | {
10 |     public class ModifierExample : ModifierBase
11 |     {
12 |         protected override bool Check(AliceRequest request)
13 |         {
14 |             if (request.State.Session.Step != Step.None)
15 |             {
16 |                 return false;
17 |             }
18 |             
19 |             Example example = FindExample(request.Request.Command);
20 |             return example != null;
21 |         }
22 | 
23 |         protected override Phrase Respond(AliceRequest request)
24 |         {
25 |             throw new NotSupportedException("Method should not be invoked");
26 |         }
27 | 
28 |         protected override AliceResponse CreateResponse(AliceRequest request)
29 |         {
30 |             var response = new AliceResponse(request);
31 |             Example example = FindExample(request.Request.Command);
32 |             request.State.Session.Step = Step.None;
33 | 
34 |             response.Response.Text = example.Description + " По кнопке подробная видеоинструкция о том, как это сделать.";
35 |             response.Response.Tts = example.DescriptionTts + " - По кнопке подробная видеоинструкция о том, как это сделать.";
36 |             response.Response.Buttons = new List<Button>
37 |             {
38 |                 new Button
39 |                 {
40 |                     Title = "Открыть видео",
41 |                     Hide = false,
42 |                     Url = example.Link
43 |                 }
44 |             };
45 |             
46 |             var suggests = new [] {"Добавить вебхук", "Примеры", "Список", "Выход"};
47 |             response.Response.Buttons.AddRange(suggests.Select(x => new Button{Title = x}));
48 |             
49 |             return response;
50 |         }
51 | 
52 |         private Example FindExample(string input)
53 |         {
54 |             return Example.List().FirstOrDefault(example => example.Check(input));
55 |         } 
56 |     }
57 | }


--------------------------------------------------------------------------------
/AliceHook/Controllers/AliceController.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.IO;
 3 | using System.Threading.Tasks;
 4 | using AliceHook.Engine;
 5 | using AliceHook.Models;
 6 | using AliceHook.Models.Abstract;
 7 | using Microsoft.AspNetCore.Http;
 8 | using Microsoft.AspNetCore.Mvc;
 9 | using Newtonsoft.Json;
10 | using Newtonsoft.Json.Serialization;
11 | 
12 | namespace AliceHook.Controllers
13 | {
14 |     [ApiController]
15 |     [Route("/")]
16 |     public class AliceController : ControllerBase
17 |     {
18 |         private readonly AliceService _aliceService;
19 | 
20 |         private static readonly JsonSerializerSettings ConverterSettings = new JsonSerializerSettings
21 |         {
22 |             ContractResolver = new DefaultContractResolver
23 |             {
24 |                 NamingStrategy = new SnakeCaseNamingStrategy()
25 |             },
26 |             NullValueHandling = NullValueHandling.Ignore
27 |         };
28 | 
29 |         public AliceController(AliceService aliceService)
30 |         {
31 |             _aliceService = aliceService;
32 |         }
33 |         
34 |         [HttpGet]
35 |         public string Get()
36 |         {
37 |             return "It works!";
38 |         }
39 | 
40 |         [HttpPost]
41 |         public Task Post()
42 |         {
43 |             using var reader = new StreamReader(Request.Body);
44 |             string body = reader.ReadToEnd();
45 | 
46 |             var aliceRequest = JsonConvert.DeserializeObject<AliceRequest>(body, ConverterSettings);
47 |             if (aliceRequest?.IsPing() == true)
48 |             {
49 |                 AliceResponseBase<UserState, SessionState> pongResponse = new AliceResponse(aliceRequest).ToPong();
50 |                 string stringPong = JsonConvert.SerializeObject(pongResponse, ConverterSettings);
51 |                 return Response.WriteAsync(stringPong);
52 |             }
53 |             
54 |             string userId = aliceRequest.Session.UserId;
55 | 
56 |             Console.WriteLine($"REQUEST FROM {userId}:\n{body}\n");
57 | 
58 |             AliceResponse aliceResponse = _aliceService.HandleRequest(aliceRequest);
59 |             string stringResponse = JsonConvert.SerializeObject(aliceResponse, ConverterSettings);
60 | 
61 |             Console.WriteLine($"RESPONSE:\n{stringResponse}\n");
62 |             
63 |             return Response.WriteAsync(stringResponse);
64 |         }
65 |     }
66 | }


--------------------------------------------------------------------------------
/AliceHook/Engine/Modifiers/ModifierList.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.Linq;
 3 | using AliceHook.Engine.Modifiers.Abstract;
 4 | using AliceHook.Models;
 5 | 
 6 | namespace AliceHook.Engine.Modifiers
 7 | {
 8 |     public class ModifierList : ModifierBaseKeywords
 9 |     {
10 |         protected override List<string> Keywords { get; } = new List<string>
11 |         {
12 |             "список",
13 |             "все вебхуки",
14 |             "все веб хуки",
15 |             "все вебхук и",
16 |             "все webhook и",
17 |             "все вебхук",
18 |             "все webhook"
19 |         };
20 |         
21 |         protected override Phrase Respond(AliceRequest request)
22 |         {
23 |             if (request.State.Session.Step == Step.AwaitForKeyword)
24 |             {
25 |                 return new Phrase(
26 |                     "Эта ключевая фраза пересекается с одной из команд данного навыка. Выберите, пожалуйста, другую.",
27 |                     new []{ "Отмена", "Помощь", "Выход" }
28 |                 );
29 |             }
30 |             
31 |             if (request.State.User.Webhooks.Count == 0)
32 |             {
33 |                 return new Phrase(
34 |                     "У вас пока нет в[screen|е][voice|э]бх[+]уков. Самое время добавить. Можете посмотреть примеры сценариев.",
35 |                     new []{ "Добавить вебхук", "Примеры", "Выход" }
36 |                 );
37 |             }
38 | 
39 |             var removeFirst = $"Удалить {request.State.User.Webhooks.First().Phrase.CapitalizeFirst()}";
40 |             IEnumerable<string> list = request.State.User.Webhooks.Select(w => $"[screen|• {w.Phrase}: {w.Url}]");
41 | 
42 |             if (request.HasScreen())
43 |             {
44 |                 return new Phrase(
45 |                     $"Вывела на экран ваши в[screen|е][voice|э]бх[+]уки:\n\n {list.Join("\n")}\n\nДля удаления скажите" +
46 |                            $" \"Удалить\" и ключевую фразу. Например: \"{removeFirst}\"",
47 |                     new[] {removeFirst, "Помощь", "Выход"}
48 |                 );
49 |             }
50 |             
51 |             // no screen
52 |             string wCount = request.State.User.Webhooks.Count.ToPhrase(
53 |                 "ключевая фраза",
54 |                 "ключевые фразы",
55 |                 "ключевых фраз"
56 |             );
57 |             string tts = $"У вас {wCount}: " + request.State.User.Webhooks.Select(w => w.Phrase).Join(" - - ");
58 |             return new Phrase(tts);
59 |         }
60 |         
61 |         protected override bool CheckState(SessionState state)
62 |         {
63 |             return state.Step == Step.None || state.Step == Step.AwaitForKeyword;
64 |         }
65 |     }
66 | }


--------------------------------------------------------------------------------
/AliceHook/Engine/Modifiers/ModifierHelp.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using AliceHook.Engine.Modifiers.Abstract;
 5 | using AliceHook.Models;
 6 | using AliceHook.Models.Abstract;
 7 | 
 8 | namespace AliceHook.Engine.Modifiers
 9 | {
10 |     public class ModifierHelp : ModifierBaseKeywords
11 |     {
12 |         protected override List<string> Keywords { get; } = new List<string>
13 |         {
14 |             "помощ",
15 |             "помог",
16 |             "что ты умеешь",
17 |             "что делать",
18 |         };
19 | 
20 |         protected override bool CheckState(SessionState state)
21 |         {
22 |             return true;
23 |         }
24 | 
25 |         protected override AliceResponse CreateResponse(AliceRequest request)
26 |         {
27 |             AliceResponse response = base.CreateResponse(request);
28 |             if (request.State.Session.Step == Step.None && request.HasScreen())
29 |             {
30 |                 AddExamplesTo(response);
31 |             }
32 | 
33 |             return response;
34 |         }
35 | 
36 |         public static void AddExamplesTo(AliceResponse response)
37 |         {
38 |             response.Response.Buttons ??= new List<Button>();
39 |             response.Response.Buttons.AddRange(
40 |                 Example.List().Select(
41 |                     x => new Button
42 |                     {
43 |                         Title = x.Title,
44 |                         Hide = false
45 |                     }
46 |                 )
47 |             );
48 |         }
49 | 
50 |         protected override Phrase Respond(AliceRequest request)
51 |         {
52 |             return GetHelp(request.State.Session.Step, request.HasScreen());
53 |         }
54 | 
55 |         public static Phrase GetHelp(Step step, bool hasScreen)
56 |         {
57 |             if (!hasScreen)
58 |             {
59 |                 return new Phrase(
60 |                     "В этом навыке вы можете добавлять URL-адрес[+]а, на которые я буду отправлять " +
61 |                     "[screen|POST-запросы][voice|пост запросы]. Добавление новых в[screen|е][voice|э]бх[+]уков " +
62 |                     "возможно только на устройстве с экраном, для этого вам нужно войти на таком " +
63 |                     "устройстве под тем же аккаунтом, что и здесь, и добавить команды. " +
64 |                     "После этого сможете называть колонке ключевые слова.\n\n" +
65 |                     "Для запроса всех в[screen|е][voice|э]бх[+]уков скаж[+]ите \"Список\"."
66 |                 );
67 |             }
68 |             
69 |             return step switch
70 |             {
71 |                 Step.None => new Phrase(
72 |                     "В этом навыке вы можете добавлять URL с ключевыми фразами. Сказали фразу — вызвался " + 
73 |                     "[screen|POST-запрос][voice|пост-запрос] на этот адрес. Это позволит интегрироваться с сервисами " +
74 |                     "автоматизации и интернета вещей, например [screen|IFTTT][voice|иф три тэ], " +
75 |                     "[screen|Zapier][voice|з+эпиер] и [screen|Integromat][voice|интегром+ат].\n\n" +
76 |                     "Сейчас вы можете добавить в[screen|е][voice|э]бх[+]ук или посмотреть список уже добавленных. " +
77 |                     "Что хотите сделать?",
78 |                     new []{ "Добавить вебхук", "Список вебхуков", "Выход" }
79 |                 ),
80 |     
81 |                 Step.AwaitForUrl => new Phrase(
82 |                     "Отправьте мне корректный адрес URL, и я его запомню. Можно отменить это действие.",
83 |                     new []{ "Отмена", "Выход" }
84 |                 ),
85 |                 
86 |                 Step.AwaitForKeyword => new Phrase(
87 |                     "Отправьте мне ключевую фразу, в дальнейшем я буду вызывать указанный URL, когда " +
88 |                     "вы произнесёте эту фразу.",
89 |                     new []{ "Отмена", "Выход" }
90 |                 ),
91 |                 
92 |                 _ => throw new ArgumentException("Unknown Step")
93 |             };
94 |         }
95 |     }
96 | }


--------------------------------------------------------------------------------
/AliceHook/Models/Example.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | 
 5 | namespace AliceHook.Models
 6 | {
 7 |     public class Example
 8 |     {
 9 |         public string Title { get; set; }
10 |         public string Link { get; set; }
11 |         public string Description { get; set; }
12 |         public string DescriptionTts { get; set; }
13 | 
14 |         private static readonly List<Example> Examples = new List<Example>
15 |         {
16 |             new Example
17 |             {
18 |                 Title = "Отправить письмо с заданным текстом",
19 |                 Description = "Вы можете отправить письмо на заранее заданный адрес с тем текстом, который скажете.",
20 |                 DescriptionTts = "Вы можете отправить письмо на заранее заданный адрес с тем текстом, который скажете.",
21 |                 Link = "https://youtu.be/Cs43jCh8VEA"
22 |             },
23 |             new Example
24 |             {
25 |                 Title = "Добавить задачу в GitHub",
26 |                 Description =
27 |                     "Добавление нового issue в GitHub к заданному репозиторию с тем текстом, который вы произнесёте.",
28 |                 DescriptionTts =
29 |                     "Добавление нового ишью в гитхаб к заданному репозиторию с тем текстом, который вы произнесёте.",
30 |                 Link = "https://youtu.be/9TA5xvn1IFI"
31 |             },
32 |             new Example
33 |             {
34 |                 Title = "Дописать строчку в Google таблицу",
35 |                 Description = "Если вы составляете какой-то список, для которого нужен быстрый ввод голосом, то " +
36 |                               "вам поможет комбинация данного навыка и Google таблиц.",
37 |                 DescriptionTts = "Если вы составляете какой-то список, для которого нужен быстрый ввод голосом, то " +
38 |                                  "вам поможет комбинация данного навыка и гугл таблиц.",
39 |                 Link = ""
40 |             },
41 |             new Example
42 |             {
43 |                 Title = "Отправить сообщение в Telegram чат",
44 |                 Description = "Вы можете создать Telegram-бота, который будет отправлять в заданный чат фразы, " +
45 |                               "сказанные голосом. Это может быть полезно для уведомления группы людей о чём-то срочном.",
46 |                 DescriptionTts = "Вы можете создать телеграм б+ота, который будет отправлять в заданный чат фразы, " +
47 |                                  "сказанные голосом. Это может быть полезно для уведомления группы людей о чём-то срочном.",
48 |                 Link = ""
49 |             },
50 |             new Example
51 |             {
52 |                 Title = "Найти и прочитать заметку Evernote",
53 |                 Description = "Можно найти и прочитать с помощью Алисы заметку из сервиса Evernote, не прикасаясь " +
54 |                               "к экрану и не смотря на него.",
55 |                 DescriptionTts = "Можно найти и прочитать с помощью Алисы заметку из сервиса эверноут, не прикасаясь " +
56 |                                  "к экрану и не смотря на него.",
57 |                 Link = ""
58 |             },
59 |             new Example
60 |             {
61 |                 Title = "Узнать телефон из книги контактов",
62 |                 Description =
63 |                     "Функция быстрого чтения вслух любого номера телефона по имени из книги контактов Google.",
64 |                 DescriptionTts =
65 |                     "Функция быстрого чтения вслух любого номера телефона по имени из книги контактов гугл.",
66 |                 Link = "https://youtu.be/ugM0HiI28wM"
67 |             },
68 |             new Example
69 |             {
70 |                 Title = "Узнать последнее видео на YouTube канале",
71 |                 Description = "По голосовому запросу вы можете узнать название и дату добавления последнего ролика " +
72 |                               "на заданном канале YouTube.",
73 |                 DescriptionTts =
74 |                     "По голосовому запросу вы можете узнать название и дату добавления последнего ролика " +
75 |                     "на заданном канале ютуб.",
76 |                 Link = "https://youtu.be/NBfIgCVQrnw"
77 |             }
78 |         };
79 | 
80 |         public static IEnumerable<Example> List()
81 |         {
82 |             return Examples.Where(x => !x.Link.IsNullOrEmpty());
83 |         }
84 | 
85 |         public bool Check(string input)
86 |         {
87 |             return string.Equals(input, Title, StringComparison.CurrentCultureIgnoreCase);
88 |         }
89 |     }
90 | }


--------------------------------------------------------------------------------
/AliceHook/Engine/Modifiers/ModifierRunWebhook.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using System.Net.Http;
  5 | using System.Threading;
  6 | using System.Threading.Tasks;
  7 | using AliceHook.Engine.Modifiers.Abstract;
  8 | using AliceHook.Models;
  9 | 
 10 | namespace AliceHook.Engine.Modifiers
 11 | {
 12 |     public class ModifierRunWebhook : ModifierBase
 13 |     {
 14 |         protected override bool Check(AliceRequest request)
 15 |         {
 16 |             return request.State.Session.Step == Step.None && GetWebhook(request) != null;
 17 |         }
 18 | 
 19 |         protected override AliceResponse CreateResponse(AliceRequest request)
 20 |         {
 21 |             AliceResponse response = base.CreateResponse(request);
 22 |             bool isOutsideCommand = !request.Request.Command.IsNullOrEmpty() && request.Session?.New == true;
 23 |             response.Response.EndSession = request.State.Session.Step != Step.AwaitWebhookResponse && isOutsideCommand;
 24 |             return response;
 25 |         }
 26 | 
 27 |         protected override Phrase Respond(AliceRequest request)
 28 |         {
 29 |             Webhook webhook = GetWebhook(request);
 30 |             string[] tokens = request.Request.Command.ToLower().Split(" ");
 31 |             int skipCount = Utils.OptimalSkipLength(webhook.Phrase, tokens);
 32 |             string textToSend = tokens.Skip(skipCount).Join(" ").CapitalizeFirst();
 33 | 
 34 |             request.State.Session.LastResult = "";
 35 |             request.State.Session.LastError = "";
 36 | 
 37 |             Task.Run(() =>
 38 |             {
 39 |                 DateTime localStarted = DateTime.Now;
 40 |                 using var handler = new HttpClientHandler
 41 |                 {
 42 |                     ServerCertificateCustomValidationCallback 
 43 |                         = (message, certificate2, arg3, arg4) => true
 44 |                 };
 45 |                 using var client = new HttpClient(handler);
 46 |                 var data = new FormUrlEncodedContent(new Dictionary<string, string>
 47 |                 {
 48 |                     { "value1", textToSend },
 49 |                     { "value2", request.Request.Command.CapitalizeFirst() }, // full command
 50 |                     { "value3", webhook.Phrase.ToLower() }
 51 |                 });
 52 | 
 53 |                 try
 54 |                 {
 55 |                     HttpResponseMessage httpResponse = client.PostAsync(webhook.Url, data).Result;
 56 |                     string body = httpResponse.Content.ReadAsStringAsync().Result;
 57 |                     request.State.Session.LastResult = body.IsNullOrEmpty() ? "Выполнено!" : $"{body}";
 58 |                 }
 59 |                 catch (Exception e)
 60 |                 {
 61 |                     Console.WriteLine(e);
 62 |                     request.State.Session.LastError = e.ToString();
 63 |                 }
 64 |                 finally
 65 |                 {
 66 |                     TimeSpan total = DateTime.Now - localStarted;
 67 |                     Console.WriteLine($"Webhook \"{webhook.Phrase}\" {webhook.Url} " +
 68 |                                       $"was finished in {total.TotalMilliseconds}ms\n");
 69 |                 }
 70 |             });
 71 | 
 72 |             DateTime started = DateTime.Now;
 73 |             while (true)
 74 |             {
 75 |                 TimeSpan diff = DateTime.Now - started;
 76 |                 if (
 77 |                     !request.State.Session.LastResult.IsNullOrEmpty()
 78 |                     || !request.State.Session.LastError.IsNullOrEmpty()
 79 |                     || diff > new TimeSpan(0, 0, 0, 1200)
 80 |                 )
 81 |                 {
 82 |                     break;
 83 |                 }
 84 | 
 85 |                 Thread.Sleep(10);
 86 |             }
 87 |             
 88 |             if(!request.State.Session.LastResult.IsNullOrEmpty())
 89 |             {
 90 |                 return new Phrase(
 91 |                     request.State.Session.LastResult,
 92 |                     new []{ "Список", "Помощь", "Выход" }
 93 |                 );
 94 |             }
 95 | 
 96 |             if(!request.State.Session.LastError.IsNullOrEmpty())
 97 |             {
 98 |                 return new Phrase(
 99 |                     "С вызовом произошла ошибка.",
100 |                     new []{ "Список", "Помощь", "Выход" }
101 |                 );
102 |             }
103 | 
104 |             request.State.Session.Step = Step.AwaitWebhookResponse;
105 |             
106 |             // weebhook too long
107 |             return new Phrase(
108 |                 "В[screen|е][voice|э]бх[+]ук отвечает очень долго. Попробовать узнать результат сейчас?",
109 |                 new[] {"Да", "Нет"}
110 |             );
111 |         }
112 | 
113 |         private Webhook GetWebhook(AliceRequest request)
114 |         {
115 |             string requestCommand = request.Request.Command.ToLower().Trim();
116 |             return request.State.User.FindWebhook(requestCommand.Replace(" ", ""));
117 |         }
118 |     }
119 | }


--------------------------------------------------------------------------------
/AliceHook/Utils.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | 
  5 | namespace AliceHook
  6 | {
  7 |     public static class Utils
  8 |     {
  9 |         public static bool ContainsStartWith(this IEnumerable<string> list, string start)
 10 |         {
 11 |             return list.Any(element => element.ToLower().Trim().StartsWith(start));
 12 |         }
 13 | 
 14 |         public static string CapitalizeFirst(this string s)
 15 |         {
 16 |             return s.IsNullOrEmpty() ? "" : s.Substring(0, 1).ToUpper() + s.Substring(1);
 17 |         }
 18 | 
 19 |         public static string SafeSubstring(this string s, int length)
 20 |         {
 21 |             if (s.Length <= length)
 22 |             {
 23 |                 return s;
 24 |             }
 25 | 
 26 |             return s.Substring(0, length);
 27 |         }
 28 | 
 29 |         public static bool IsNullOrEmpty(this string s)
 30 |         {
 31 |             return string.IsNullOrEmpty(s);
 32 |         }
 33 | 
 34 |         public static string Join(this IEnumerable<string> list, string separator)
 35 |         {
 36 |             return string.Join(separator, list);
 37 |         }
 38 |         
 39 |         public static int LevenshteinDistance(string a, string b)
 40 |         {
 41 |             if (string.IsNullOrEmpty(a) && string.IsNullOrEmpty(b))
 42 |             {
 43 |                 return 0;
 44 |             }
 45 |             if (string.IsNullOrEmpty(a))
 46 |             {
 47 |                 return b.Length;
 48 |             }
 49 |             if (string.IsNullOrEmpty(b))
 50 |             {
 51 |                 return a.Length;
 52 |             }
 53 |             var lengthA = a.Length;
 54 |             var lengthB = b.Length;
 55 |             var distances = new int[lengthA + 1, lengthB + 1];
 56 |             for (var i = 0; i <= lengthA; distances[i, 0] = i++) ;
 57 |             for (var j = 0; j <= lengthB; distances[0, j] = j++) ;
 58 | 
 59 |             for (var i = 1; i <= lengthA; i++)
 60 |             for (var j = 1; j <= lengthB; j++)
 61 |             {
 62 |                 var cost = b[j - 1] == a[i - 1] ? 0 : 1;
 63 |                 distances[i, j] = Math.Min
 64 |                 (
 65 |                     Math.Min(distances[i - 1, j] + 1, distances[i, j - 1] + 1),
 66 |                     distances[i - 1, j - 1] + cost
 67 |                 );
 68 |             }
 69 |             return distances[lengthA, lengthB];
 70 |         }
 71 | 
 72 |         public static double LevenshteinRatio(string a, string b)
 73 |         {
 74 |             var maxLen = Math.Max(a.Length, b.Length);
 75 |             if (maxLen == 0)
 76 |             {
 77 |                 return 1.0;
 78 |             }
 79 | 
 80 |             var levDist = LevenshteinDistance(a, b);
 81 |             return (double) levDist / maxLen;
 82 |         }
 83 |         
 84 |         public static string GetNumericPhrase(int num, string one, string few, string many)
 85 |         {
 86 |             num = num < 0 ? 0 : num;
 87 |             string postfix;
 88 | 
 89 |             if (num < 10)
 90 |             {
 91 |                 if (num == 1) postfix = one;
 92 |                 else if (num > 1 && num < 5) postfix = few;
 93 |                 else postfix = many;
 94 |             }
 95 |             else if (num <= 20)
 96 |             {
 97 |                 postfix = many;
 98 |             }
 99 |             else if (num <= 99)
100 |             {
101 |                 var lastOne = num - ((int)Math.Floor((double)num / 10)) * 10;
102 |                 postfix = GetNumericPhrase(lastOne, one, few, many);
103 |             }
104 |             else
105 |             {
106 |                 var lastTwo = num - ((int)Math.Floor((double)num / 100)) * 100;
107 |                 postfix = GetNumericPhrase(lastTwo, one, few, many);
108 |             }
109 |             return postfix;
110 |         }
111 | 
112 |         public static string ToPhrase(this int num, string one, string few, string many)
113 |         {
114 |             return num + " " + GetNumericPhrase(num, one, few, many);
115 |         }
116 | 
117 |         public static int OptimalSkipLength(string matchPhrase, string[] tokens)
118 |         {
119 |             var minDist = int.MaxValue;
120 |             var matchTokens = matchPhrase.Split(" ");
121 |             var matchShort = matchTokens.Join("");
122 |             var bestSkip = matchTokens.Length;
123 |                 
124 |             for (var i = 1; i <= matchTokens.Length + 1; i++)
125 |             {
126 |                 var secondString = tokens.Take(i).Join("");
127 |                 var dist = LevenshteinDistance(matchShort, secondString);
128 |                 if (dist < minDist)
129 |                 {
130 |                     minDist = dist;
131 |                     bestSkip = i;
132 |                 }
133 |             }
134 | 
135 |             return bestSkip;
136 |         }
137 | 
138 |         public static double PossibleRatio(int len)
139 |         {
140 |             if (len <= 6)
141 |             {
142 |                 return 0.15;
143 |             } 
144 |             if (len <= 10)
145 |             {
146 |                 return 0.25;
147 |             }
148 | 
149 |             if (len <= 15)
150 |             {
151 |                 return 0.35;
152 |             }
153 | 
154 |             return 0.4;
155 |         }
156 |     }
157 | }


--------------------------------------------------------------------------------
/AliceHook/Models/Abstract/AliceResponseBase.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | 
  5 | namespace AliceHook.Models.Abstract
  6 | {
  7 |     public class Button
  8 |     {
  9 |         public string Title { get; set; }
 10 |         public Dictionary<string, string> Payload { get; set; }
 11 |         public string Url { get; set; }
 12 |         public bool Hide { get; set; } = true;
 13 | 
 14 |         public Button() { }
 15 | 
 16 |         public Button(string b)
 17 |         {
 18 |             Title = b;
 19 |         }
 20 |     }
 21 | 
 22 |     public class Response
 23 |     {
 24 |         public string Text { get; set; }
 25 |         public string Tts { get; set; }
 26 |         public List<Button> Buttons { get; set; }
 27 |         public ICard Card { get; set; }
 28 |         public bool EndSession { get; set; }
 29 |     }
 30 | 
 31 |     public class ImageMeta
 32 |     {
 33 |         public string ImageId { get; }
 34 |         public Button Button { get;  }
 35 | 
 36 |         public ImageMeta(string imageId, Button button = null)
 37 |         {
 38 |             ImageId = imageId;
 39 |             Button = button;
 40 |         }
 41 |     }
 42 | 
 43 |     public class SingleCard : ImageMeta, ICard
 44 |     {
 45 |         public string Type { get; } = "BigImage";
 46 |         public string Description { get; set; }
 47 | 
 48 |         public SingleCard(string imageId, Button button = null) : base(imageId, button) { }
 49 |     }
 50 | 
 51 |     public class ItemsListCard : ICard
 52 |     {
 53 |         public string Type { get; } = "ItemsList";
 54 |         public ImageMeta[] Items { get; }
 55 |         public ItemsListFooter Footer { get; set; }
 56 | 
 57 |         public ItemsListCard(IEnumerable<ImageMeta> items)
 58 |         {
 59 |             Items = items.ToArray();
 60 |         }
 61 |     }
 62 | 
 63 |     public class ItemsListFooter
 64 |     {
 65 |         public string Text { get; }
 66 | 
 67 |         public ItemsListFooter(string text)
 68 |         {
 69 |             Text = text;
 70 |         }
 71 |     }
 72 | 
 73 |     public class GalleryCard : ICard
 74 |     {
 75 |         public string Type { get; } = "ImageGallery";
 76 |         public GalleryItem[] Items { get; }
 77 | 
 78 |         public GalleryCard(IEnumerable<GalleryItem> items)
 79 |         {
 80 |             Items = items.ToArray();
 81 |         }
 82 |     }
 83 | 
 84 |     public class GalleryItem
 85 |     {
 86 |         public string ImageId { get; }
 87 |         public string Title { get; }
 88 | 
 89 |         public GalleryItem(string imageId, string title = "")
 90 |         {
 91 |             ImageId = imageId;
 92 |             Title = title;
 93 |         }
 94 |     }
 95 | 
 96 |     public interface ICard
 97 |     {
 98 |         string Type { get; }
 99 |     }
100 | 
101 |     public class Analytics
102 |     {
103 |         public List<AliceEvent> Events { get; set; } = new List<AliceEvent>();
104 |     }
105 | 
106 |     public class AliceEvent
107 |     {
108 |         public string Name { get; set; }
109 |         public Dictionary<string, string> Value { get; set; }
110 |     }
111 | 
112 |     public class AliceResponseBase<TUserState, TSessionState>
113 |         where TUserState : class, new()
114 |         where TSessionState : class, new()
115 |     {
116 |         public AliceEmpty StartAccountLinking { get; set; }
117 |         public Response Response { get; set; } = new Response();
118 |         public Session Session { get; set; }
119 |         public string Version { get; set; }
120 | 
121 |         public Analytics Analytics { get; set; } = new Analytics();
122 | 
123 |         public TUserState UserStateUpdate { get; set; }
124 |         public TSessionState SessionState { get; set; }
125 | 
126 |         public AliceResponseBase(
127 |             AliceRequestBase<TUserState, TSessionState> request,
128 |             TSessionState sessionState = default,
129 |             TUserState userState = default
130 |         )
131 |         {
132 |             Session = request.Session;
133 |             Version = request.Version;
134 |             SessionState = sessionState ?? request.State.Session;
135 |             UserStateUpdate = userState ?? request.State.User;
136 |         }
137 |         
138 |         public AliceResponseBase<TUserState, TSessionState> ToAuthorizationResponse()
139 |         {
140 |             Response = null;
141 |             StartAccountLinking = new AliceEmpty();
142 |             return this;
143 |         }
144 | 
145 |         public AliceResponseBase<TUserState, TSessionState> ToPong()
146 |         {
147 |             Response = new Response
148 |             {
149 |                 Text = "pong"
150 |             };
151 |             return this;
152 |         }
153 | 
154 |         public AliceResponseBase<TUserState, TSessionState> AppendEvent(string name, params string[] data)
155 |         {
156 |             if (data.Length % 2 != 0)
157 |                 throw new ArgumentException("Data length is not even");
158 | 
159 |             var dataDict = new Dictionary<string, string>();
160 |             for (var i = 0; i < data.Length - 1; i += 2)
161 |             {
162 |                 dataDict.Add(data[i], data[i + 1]);
163 |             }
164 |             
165 |             Analytics.Events.Add(new AliceEvent
166 |             {
167 |                 Name = name,
168 |                 Value = dataDict
169 |             });
170 | 
171 |             return this;
172 |         }
173 |     }
174 | }


--------------------------------------------------------------------------------
/AliceHook/Models/Abstract/AliceRequestBase.cs:
--------------------------------------------------------------------------------
  1 | using System.Collections.Generic;
  2 | using System.Linq;
  3 | 
  4 | namespace AliceHook.Models.Abstract
  5 | {
  6 |     public class AliceEmpty
  7 |     {
  8 |     }
  9 |     
 10 |     public class Interfaces
 11 |     {
 12 |         public AliceEmpty Screen { get; set; }
 13 |         public AliceEmpty Payments { get; set; }
 14 |         public AliceEmpty AccountLinking { get; set; }
 15 |     }
 16 | 
 17 |     public class Meta
 18 |     {
 19 |         public string Locale { get; set; }
 20 |         public string Timezone { get; set; }
 21 |         public string ClientId { get; set; }
 22 |         public Interfaces Interfaces { get; set; }
 23 |     }
 24 | 
 25 |     public class Markup
 26 |     {
 27 |         public bool DangerousContext { get; set; }
 28 |     }
 29 | 
 30 |     public class Intent
 31 |     {
 32 |         public Dictionary<string, IntentSlot> Slots { get; set; }
 33 |     }
 34 | 
 35 |     public class IntentSlot
 36 |     {
 37 |         public string Type { get; set; }
 38 |         public object Value { get; set; }
 39 |     }
 40 | 
 41 |     public class TokensRange
 42 |     {
 43 |         public int Start { get; set; }
 44 |         public int End { get; set; }
 45 |     }
 46 | 
 47 |     public class Entity
 48 |     {
 49 |         public TokensRange Tokens { get; set; }
 50 |         public string Type { get; set; }
 51 |         public object Value { get; set; }
 52 |     }
 53 | 
 54 |     public class Nlu
 55 |     {
 56 |         public List<string> Tokens { get; set; }
 57 |         public List<Entity> Entities { get; set; }
 58 |         public Dictionary<string, Intent> Intents { get; set; }
 59 |     }
 60 | 
 61 |     public class Request
 62 |     {
 63 |         public string Command { get; set; }
 64 |         public string OriginalUtterance { get; set; }
 65 |         public string Type { get; set; }
 66 |         public Markup Markup { get; set; }
 67 |         public Dictionary<string, string> Payload { get; set; }
 68 |         public Nlu Nlu { get; set; }
 69 |     }
 70 | 
 71 |     public class User
 72 |     {
 73 |         public string UserId { get; set; }
 74 |     }
 75 | 
 76 |     public class Device
 77 |     {
 78 |         public string DeviceId { get; set; }
 79 |     }
 80 | 
 81 |     public class Session
 82 |     {
 83 |         public bool New { get; set; }
 84 |         public int MessageId { get; set; }
 85 |         public string SessionId { get; set; }
 86 |         public string SkillId { get; set; }
 87 |         public string UserId { get; set; }
 88 |         public User User { get; set; }
 89 |         public Device Device { get; set; }
 90 |     }
 91 | 
 92 |     public class State<TUserState, TSessionState> where TUserState : new() where TSessionState : new()
 93 |     {
 94 |         public TUserState User { get; set; } = new TUserState();
 95 |         public TSessionState Session { get; set; } = new TSessionState();
 96 |     }
 97 | 
 98 |     public class AliceRequestBase<TUserState, TSessionState> where TUserState : new() where TSessionState : new()
 99 |     {
100 |         public Meta Meta { get; set; }
101 |         public AliceEmpty AccountLinkingCompleteEvent { get; set; }
102 |         public Request Request { get; set; }
103 |         public Session Session { get; set; }
104 |         public string Version { get; set; }
105 |         public State<TUserState, TSessionState> State { get; set; } = new State<TUserState, TSessionState>();
106 | 
107 |         public bool HasScreen()
108 |         {
109 |             return Meta?.Interfaces?.Screen != null;
110 |         }
111 |         
112 |         public bool IsAccountLinking()
113 |         {
114 |             return AccountLinkingCompleteEvent != null;
115 |         }
116 | 
117 |         public bool IsPing()
118 |         {
119 |             if (Request == null)
120 |             {
121 |                 return false;
122 |             }
123 | 
124 |             return Request.Command.ToLower() == "ping";
125 |         }
126 | 
127 |         public bool IsAnonymous()
128 |         {
129 |             return Session.User == null;
130 |         }
131 |         
132 |         public bool IsEnter()
133 |         {
134 |             return Request != null && Request.Command.IsNullOrEmpty();
135 |         }
136 | 
137 |         public Intent GetIntent(string name)
138 |         {
139 |             if (Request?.Nlu?.Intents == null)
140 |             {
141 |                 return null;
142 |             }
143 |             
144 |             if (!Request.Nlu.Intents.ContainsKey(name))
145 |             {
146 |                 return null;
147 |             }
148 | 
149 |             return Request.Nlu.Intents[name];
150 |         }
151 |         
152 |         public bool HasIntent(string name, bool withSlots = false)
153 |         {
154 |             return withSlots ? GetIntent(name)?.Slots != null : GetIntent(name) != null;
155 |         }
156 | 
157 |         public bool HasOneOfIntents(params string[] names)
158 |         {
159 |             return names.Any(x=>GetIntent(x)!= null);
160 |         }
161 | 
162 |         public bool HasSlot(string intentName, string slotName)
163 |         {
164 |             return !string.IsNullOrEmpty(GetSlot(intentName, slotName));
165 |         }
166 | 
167 |         public bool HasOneOfSlots(string intentName, params string[] slotNames)
168 |         {
169 |             return slotNames.Any(s => HasSlot(intentName, s));
170 |         }
171 | 
172 |         public bool HasAllSlots(string intentName, params string[] slotNames)
173 |         {
174 |             return slotNames.All(s => HasSlot(intentName, s));
175 |         }
176 | 
177 |         public string GetSlot(string intentName, string slotName)
178 |         {
179 |             Intent intent = GetIntent(intentName);
180 |             if (intent?.Slots == null || !intent.Slots.ContainsKey(slotName))
181 |             {
182 |                 return null;
183 |             }
184 | 
185 |             return intent.Slots[slotName].Value.ToString();
186 |         }
187 |     }
188 | }


--------------------------------------------------------------------------------
/AliceHook/Models/Phrase.cs:
--------------------------------------------------------------------------------
  1 | using System.Linq;
  2 | using System.Text.RegularExpressions;
  3 | using AliceHook.Models.Abstract;
  4 | 
  5 | namespace AliceHook.Models
  6 | {
  7 |     public class Phrase
  8 |     {
  9 |         private static readonly Regex Pattern = new Regex("\\[[a-z\\+]{1,10}\\|?[^\\[\\]]*\\]");
 10 |         private static readonly Regex HasScreenPattern = new Regex("\\[hasScreen\\|([^\\|]*)\\|([^\\|]*)\\]");
 11 | 
 12 |         public string Text { get; private set; }
 13 |         public string[] Buttons { get; private set; }
 14 |         public string[] Images { get; private set; }
 15 | 
 16 |         private Phrase() { }
 17 | 
 18 |         public Phrase(string text, string[] buttons = null, string[] images = null)
 19 |         {
 20 |             Text = text;
 21 |             Buttons = buttons;
 22 |             Images = images;
 23 |         }
 24 | 
 25 |         public AliceResponse Generate(AliceRequest request, UserState newUserState = null, SessionState newSessionState = null)
 26 |         {
 27 |             var (text, tts) = GetTextTtsPair(request.HasScreen());
 28 |             var response = new AliceResponse(request, newSessionState, newUserState)
 29 |             {
 30 |                 Response =
 31 |                 {
 32 |                     Text = text,
 33 |                     Tts = tts,
 34 |                     Buttons = Buttons?.Select(b =>
 35 |                     {
 36 |                         var bData = b.Split("!");
 37 |                         return bData.Length == 1 ? new Button(b) : new Button(bData[0]) {Url = bData[1], Hide = false};
 38 |                     }).ToList()
 39 |                 }
 40 |             };
 41 | 
 42 |             if (Images != null && Images.Length > 0)
 43 |             {
 44 |                 var description = text
 45 |                     .Replace("\\n", " ")
 46 |                     .Replace("  ", " ")
 47 |                     .SafeSubstring(256);
 48 |                 
 49 |                 if (Images.Length == 1)
 50 |                 {
 51 |                     var imgData = Images[0].Split("!");
 52 |                     response.Response.Card = imgData.Length > 1 
 53 |                         ? new SingleCard(imgData[0], new Button(imgData[1])) {Description = description}
 54 |                         : new SingleCard(imgData[0]) {Description = description};
 55 |                 }
 56 |                 else
 57 |                 {
 58 |                     response.Response.Card = new GalleryCard(Images.Select(i =>
 59 |                     {
 60 |                         var iData = i.Split("!");
 61 |                         return iData.Length > 1
 62 |                             ? new GalleryItem(iData[0], iData[1])
 63 |                             : new GalleryItem(i);
 64 |                     }));
 65 |                 }
 66 |             }
 67 | 
 68 |             return response;
 69 |         }
 70 | 
 71 |         public (string text, string tts) GetTextTtsPair(bool hasScreen)
 72 |         {
 73 |             var t = Text;
 74 |             var text = "";
 75 |             var tts = "";
 76 |             
 77 |             var match = Pattern.Match(t);
 78 | 			
 79 | 			// check if no found
 80 |             if (!match.Success)
 81 |             {
 82 |                 return (Text, Text.Replace("\\n", " sil <[100]> ").Replace("\n", " sil <[100]> "));
 83 |             }
 84 |             
 85 |             // if found
 86 |             while (match.Success)
 87 |             {
 88 |                 // remove beginning of string
 89 |                 if (match.Index > 0)
 90 |                 {
 91 |                     var before = t.Substring(0, match.Index);
 92 |                     text += before;
 93 |                     tts += before;
 94 |                 }
 95 | 
 96 |                 // remove match from string
 97 |                 t = t.Substring(match.Index + match.Length);
 98 |                 
 99 |                 // process match
100 |                 var pars = match.Value.Substring(1, match.Value.Length - 2).Split("|");
101 |                 var type = pars[0];
102 | 
103 |                 switch (type)
104 |                 {
105 |                     case "+": // accent
106 |                         tts += "+";
107 |                         break;
108 |                     case "p": // pause
109 |                         var delay = pars.Length > 1 ? int.Parse(pars[1]) : 0;
110 |                         if (delay > 0)
111 |                         {
112 |                             tts += $" sil <[{delay}]> ";
113 |                         }
114 |                         else
115 |                         {
116 |                             tts += " - ";
117 |                         }
118 |                         break;
119 |                     case "audio": // audio resource
120 |                         tts += $"<speaker audio=\"{pars[1]}\">";
121 |                         break;
122 |                     case "screen": // only on screen
123 |                         text += pars[1];
124 |                         break;
125 |                     case "voice": // only in voice
126 |                         tts += pars[1];
127 |                         break;
128 |                     case "hasScreen":
129 |                         if (hasScreen)
130 |                         {
131 |                             text += pars[1];
132 |                             tts += pars[1];
133 |                         }
134 |                         else
135 |                         {
136 |                             text += pars[2];
137 |                             tts += pars[2];
138 |                         }
139 |                         break;
140 |                 }
141 |                 
142 |                 // find pattern again
143 |                 match = Pattern.Match(t);
144 |             }
145 | 
146 |             text += t;
147 |             tts += t;
148 |             
149 |             // additional match hasScreen because of nesting
150 |             text = HasScreenPattern.Replace(text, hasScreen ? "$1" : "$2");
151 |             tts = HasScreenPattern.Replace(tts, hasScreen ? "$1" : "$2");
152 |             
153 |             // replace \n by small pauses
154 |             tts = tts.Replace("\\n", " sil <[100]> ").Replace("\n", " sil <[100]> ");
155 |             
156 |             return (text, tts);
157 |         }
158 |     }
159 | }


--------------------------------------------------------------------------------