private async Task OnRegistrationSelected(IDialogContext context, IAwaitable <string> result)
{
try
{
string selected = await result;
string yes = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Registration_Yes}", Settings.SpecificLanguage);
string no = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Registration_No}", Settings.SpecificLanguage);
if (selected.ToLower().Contains(yes.ToLower()))
{
}
else if (selected.ToLower().Contains(no.ToLower()))
{
string advice = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Registration_AdviseNoIdentification}", Settings.SpecificLanguage);
await context.PostAsync(advice);
var registrationFormDialog = FormDialog.FromForm(this.BuildRegistrationForm, FormOptions.PromptFieldsWithValues);
await context.Forward(registrationFormDialog, AfterRegistrationAsync, context.Activity, CancellationToken.None);
}
}
catch (TooManyAttemptsException)
{
context.Wait(this.MessageReceivedAsync);
}
}
public static IEnumerable <Language> GetAllLanguage(string callBackUri = null, string rootUri = null)
{
if (string.IsNullOrWhiteSpace(rootUri))
{
rootUri = EwayFramework.Utils.UriHelper.Static.UriHelper.GetAbsoultUri("/Content/images/flag/");
}
LanguageConfig config = (LanguageConfig)HttpContext.Current.Cache.Get("LanguageConfig");
config.ChangeLangUri = EwayFramework.Utils.UriHelper.Static.UriHelper.GetAbsoultUri(config.ChangeLangUri);;
List <Language> list = new List <Language>();
list.Add(new Language()
{
Image = rootUri + "cn.png", LangName = "简体中文", LangTag = "Lang_CN", LangKey = "zh-CN", LangAddress = config.ChangeLangUri + "?lang=zh-CN&callBack=" + callBackUri ?? ""
});
list.Add(new Language()
{
Image = rootUri + "us.png", LangName = "英文", LangTag = "Lang_US", LangKey = "en-us", LangAddress = config.ChangeLangUri + "?lang=en-us&callBack=" + callBackUri ?? ""
});
list.Add(new Language()
{
Image = rootUri + "fr.png", LangName = "法语", LangTag = "Lang_FR", LangKey = "fr-fr", LangAddress = config.ChangeLangUri + "?lang=fr-fr&callBack=" + callBackUri ?? ""
});
foreach (var c in list)
{
c.LangName = TranslatorHelper.Translator(c.LangTag);
}
return(list);
}
private async Task OnSearchModeSelected(IDialogContext context, IAwaitable <string> result)
{
try
{
string selected = await result;
string photo = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Search_Photo}", Settings.SpecificLanguage);
string namelastname = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Search_NameLastname}", Settings.SpecificLanguage);
if (selected.ToLower().Contains(photo.ToLower()))
{
string waiting = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Search_WaitingForImage}", Settings.SpecificLanguage);
await context.PostAsync(waiting);
context.Wait(ImageReceivedAsync);
}
else if (selected.ToLower().Contains(namelastname.ToLower()))
{
var registrationFormDialog = FormDialog.FromForm(this.BuildSearchForm, FormOptions.PromptFieldsWithValues);
await context.Forward(registrationFormDialog, AfterSearchAsync, context.Activity, CancellationToken.None);
}
}
catch (TooManyAttemptsException)
{
context.Wait(this.MessageReceivedAsync);
}
}
public static void TestTranslatorHelper()
{
string filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Test.xml");
FileUtils fileUtils = new FileUtils();
string reqXml = fileUtils.ReadFileByFileStream(filePath);
var a = TranslatorHelper.AnalysicInputData <Person>(reqXml, "/bookstore/book/title");
}
private async Task ImageReceivedAsync(IDialogContext context, IAwaitable <IMessageActivity> result)
{
var inprogress = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Search_InProgress}", Settings.SpecificLanguage);
await context.PostAsync(inprogress);
var message = await result;
byte[] imageBytes = null;
if (message.Attachments.Count > 0)
{
using (var httpClient = new HttpClient())
{
imageBytes = await httpClient.GetByteArrayAsync(message.Attachments[0].ContentUrl);
}
}
Stream stream = new MemoryStream(imageBytes);
var pid = Guid.NewGuid().ToString();
var extension = "jpg";
var list = new List <Person>();
if (await StorageHelper.UploadPhoto(pid, stream, true))
{
list = await RestHelper.ImageVerification($"{pid}.{extension}");
}
else
{
var verification = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Search_VerificationError}", Settings.SpecificLanguage);
await context.PostAsync(verification);
TraceManager.SendTrace(context, "SearchDialog", "End");
context.Done("done");
}
if (!list.Any())
{
var noitems = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Search_NoItems}", Settings.SpecificLanguage);
await context.PostAsync(noitems);
TraceManager.SendTrace(context, "SearchDialog", "End");
context.Done("done");
}
else
{
var reply = context.MakeMessage();
reply.AttachmentLayout = AttachmentLayoutTypes.Carousel;
reply.Attachments = GetCardsAttachments(list);
await context.PostAsync(reply);
TraceManager.SendTrace(context, "SearchDialog", "End");
context.Done("done");
}
}
/// <summary>
/// Starts a session and returns user API method capabilities -- which features the given user can and cannot use.
/// http://www.sendspace.com/dev_method.html?method=auth.login
/// </summary>
/// <param name="token">Received on create token</param>
/// <param name="username">Registered user name</param>
/// <param name="password">Registered password</param>
/// <returns>Account informations including session key</returns>
public LoginInfo AuthLogin(string token, string username, string password)
{
Dictionary <string, string> args = new Dictionary <string, string>();
args.Add("method", "auth.login");
args.Add("token", token);
args.Add("user_name", username);
// lowercase(md5(token+lowercase(md5(password)))) - md5 values should always be lowercase.
string passwordHash = TranslatorHelper.TextToHash(password, HashType.MD5);
args.Add("tokened_password", TranslatorHelper.TextToHash(token + passwordHash, HashType.MD5));
string response = SendRequest(HttpMethod.POST, APIURL, args);
if (!string.IsNullOrEmpty(response))
{
ResponsePacket packet = ParseResponse(response);
if (!packet.Error)
{
LoginInfo loginInfo = new LoginInfo(packet.Result);
return(loginInfo);
}
}
return(null);
}
private IForm <RegistrationQuery> BuildRegistrationForm()
{
OnCompletionAsyncDelegate <RegistrationQuery> processRegistration = async(context, state) =>
{
string waiting = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Registration_WaitingForImage}", Settings.SpecificLanguage);
await context.PostAsync(waiting);
context.PrivateConversationData.SetValue(REGISTRATIONDATA, state);
};
RegistrationQueryAllText res = null;
Task.Run(BuildAsync).ContinueWith((b) => { res = b.Result; }).Wait();
return(new FormBuilder <RegistrationQuery>()
.Field(nameof(RegistrationQuery.Name), res.Name)
.Field(nameof(RegistrationQuery.Lastname), res.Lastname)
.Field(nameof(RegistrationQuery.Country), res.CountryText)
.Field(nameof(RegistrationQuery.LocationOfLost), res.LocationOfLost)
.Field(nameof(RegistrationQuery.DateOfLost), res.DateOfLost)
.Field(nameof(RegistrationQuery.ReportId), res.ReportId)
.Field(nameof(RegistrationQuery.ReportedBy), res.ReportedBy)
.Field(nameof(RegistrationQuery.Genre), res.GenreText)
.OnCompletion(processRegistration)
.Build());
}
private string GetUploadKey(string action, string tpid, string tpk)
{
Dictionary <string, string> args = new Dictionary <string, string>();
args.Add("action", action);
args.Add("tpid", tpid);
args.Add("sig", TranslatorHelper.TextToHash(action + tpid + tpk, HashType.MD5));
args.Add("responsetype", "XML");
string response = SendRequest(HttpMethod.GET, URLAPI, args);
if (!string.IsNullOrEmpty(response) && CheckResponse(response))
{
string upk = Helpers.GetXMLValue(response, "uploadkey");
if (string.IsNullOrEmpty(upk))
{
Errors.Add("Upload key is empty.");
}
return(upk);
}
Errors.Add("Unable to get upload key.");
return(null);
}
//------------------------------------------------------------------------------------------------------------------------------------------
public async Task <ActualResult> CreateAsync(CreateAccountDTO dto)
{
try
{
if (!await CheckEmailAsync(dto.Email))
{
var user = new User
{
Email = dto.Email,
UserName = dto.Email,
FirstName = dto.FirstName,
LastName = dto.LastName,
Patronymic = dto.Patronymic
};
var result = await _userManager.CreateAsync(user, dto.Password);
if (result.Succeeded)
{
return(await UpdateUserRoleAsync(user, TranslatorHelper.ConvertToEnglishLang(dto.Role)));
}
return(new ActualResult(Errors.DataBaseError));
}
return(new ActualResult(Errors.DuplicateEmail));
}
catch (Exception exception)
{
return(new ActualResult(DescriptionExceptionHelper.GetDescriptionError(exception)));
}
}
/// <summary>
/// 烟丝立库上传工单执行情况
/// </summary>
/// <returns></returns>
public void AdapterTransOutBillState(OutBill outBill, List <Storage> storages)
{
try
{
var requestHeaderXml = Translator.RequestHeaderXml("ESB_LYMES_WLPT_YSK_GDZXQK", "transSilkOutDetail", "立库工单执行情况");
var translaEnt = Translator.GetTransOutbillStateModel(outBill, storages);
var reqXml = TranslatorHelper.CreateResXml(translaEnt, requestHeaderXml);
//Logger.Debug("烟丝立库上传reqXml：" + reqXml);
//var resXml = WebServiceImport.ServiceInstance.transSilkOutDetail(reqXml);
//Logger.Debug("烟丝立库上传resXml：" + resXml);
//var xmlHeader = TranslatorHelper.AnalysisHeaderXml(resXml);
//if (!xmlHeader.StateCode.Contains("600"))
//{
// throw new Exception(xmlHeader.StateDesription);
//}
}
catch (Exception e)
{
//Logger.Error(e);
throw;
}
}
public static NameValueCollection CreateAuthenticationHeader(string username, string password)
{
string authorization = TranslatorHelper.TextToBase64(username + ":" + password);
NameValueCollection headers = new NameValueCollection();
headers["Authorization"] = "Basic " + authorization;
return(headers);
}
private string ParseSyntaxBase64(string syntax)
{
if (!string.IsNullOrEmpty(syntax))
{
return(TranslatorHelper.TextToBase64(syntax));
}
return(null);
}
private async Task TranslationReceivedAsync(IDialogContext context, IAwaitable <IMessageActivity> result)
{
var activity = await result;
Settings.SpecificLanguage = await TranslatorHelper.GetDesiredLanguageAsync(activity.Text);
TraceManager.SendTrace(context, "TranslateDialog", "End");
context.Done("done");
}
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default(CancellationToken))
{
if (turnContext.Activity.Type == ActivityTypes.Message)
{
UserProfile userProfile = await accessors.UserProfileAccesor.GetAsync(turnContext, () => new UserProfile());
if (string.IsNullOrEmpty(userProfile.Language))
{
userProfile.Language = TranslatorHelper.GetDesiredLanguage(turnContext.Activity.Text);
await accessors.UserProfileAccesor.SetAsync(turnContext, userProfile);
await accessors.UserState.SaveChangesAsync(turnContext);
var confirmedLanguageResponse = await TranslatorHelper.TranslateSentenceAsync("Está hecho, tu lenguaje está seleccionado", userProfile.Language);
await turnContext.SendActivityAsync(confirmedLanguageResponse);
}
else
{
if (turnContext.Activity.Text == "nuevo idioma")
{
await turnContext.SendActivityAsync("Solo dí la palabra mágica");
userProfile.Language = string.Empty;
await accessors.UserProfileAccesor.SetAsync(turnContext, userProfile);
await accessors.UserState.SaveChangesAsync(turnContext);
}
else
{
Attachment plAttachment = new Attachment()
{
ContentType = HeroCard.ContentType,
Content = await MoviesHelper.SearchMovieAsync(turnContext.Activity.Text, userProfile.Language),
};
var reply = turnContext.Activity.CreateReply();
reply.Attachments.Add(plAttachment);
await turnContext.SendActivityAsync(reply);
}
}
}
else if (turnContext.Activity.Type == ActivityTypes.ConversationUpdate)
{
if (turnContext.Activity.MembersAdded != null)
{
await SendWelcomeMessageAsync(turnContext, cancellationToken);
}
}
else
{
await turnContext.SendActivityAsync($"{turnContext.Activity.Type} event detected", cancellationToken : cancellationToken);
}
}
public override string Call(ShareXCustomUploaderSyntaxParser parser, string[] parameters)
{
string text = parameters[0];
if (!string.IsNullOrEmpty(text))
{
return(TranslatorHelper.TextToBase64(text));
}
return(null);
}
public static async Task <List <string> > CreateList()
{
string report = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.MenuReportSearch_Report}", Settings.SpecificLanguage);
string search = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.MenuReportSearch_Search}", Settings.SpecificLanguage);
List <string> list = new List <string>();
list.Add(report);
list.Add(search);
return(list);
}
public static async Task <List <string> > CreateList()
{
string yes = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Registration_Yes}", Settings.SpecificLanguage);
string no = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Registration_No}", Settings.SpecificLanguage);
List <string> list = new List <string>();
list.Add(yes);
list.Add(no);
return(list);
}
public static async Task <List <string> > CreateList()
{
string photo = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Search_Photo}", Settings.SpecificLanguage);
string namelastname = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Search_NameLastname}", Settings.SpecificLanguage);
List <string> list = new List <string>();
list.Add(photo);
list.Add(namelastname);
return(list);
}
private async Task <SearchQueryAllText> BuildAsync()
{
SearchQueryAllText result = new SearchQueryAllText();
result.Name = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Registration_Name}", Settings.SpecificLanguage);
result.Lastname = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Registration_Lastname}", Settings.SpecificLanguage);
result.CountryText = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Registration_Country}", Settings.SpecificLanguage);
return(result);
}
private async Task MessageReceivedAsync(IDialogContext context, IAwaitable <object> result)
{
string QuestionPrompt = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Search_Question}", Settings.SpecificLanguage);
string NotValid = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Search_NotValid}", Settings.SpecificLanguage);
string TooManyAttempts = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.TooManyAttempts}", Settings.SpecificLanguage);
PromptOptions <string> options = new PromptOptions <string>(QuestionPrompt, NotValid, TooManyAttempts, await Collections.Search.CreateList(), 1);
PromptDialog.Choice <string>(context, OnSearchModeSelected, options);
}
private async Task AfterTranslateAsync(IDialogContext context, IAwaitable <object> result)
{
string welcome = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Welcome}", Settings.SpecificLanguage);
await context.PostAsync(welcome);
string QuestionPrompt = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.MenuReportSearch}", Settings.SpecificLanguage);
string NotValid = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.MenuReportSearch_NotValid}", Settings.SpecificLanguage);
string TooManyAttempts = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.TooManyAttempts}", Settings.SpecificLanguage);
PromptOptions <string> options = new PromptOptions <string>(QuestionPrompt, NotValid, TooManyAttempts, await Collections.ReportSearch.CreateList(), 1);
PromptDialog.Choice <string>(context, OnMenuReportSearchSelected, options);
}
public async Task <ActualResult> UpdateRoleAsync(AccountDTO dto)
{
try
{
var user = await _userManager.FindByIdAsync(dto.HashId);
if (user != null)
{
return(await UpdateUserRoleAsync(user, TranslatorHelper.ConvertToEnglishLang(dto.Role)));
}
return(new ActualResult(Errors.UserNotFound));
}
catch (Exception exception)
{
return(new ActualResult(DescriptionExceptionHelper.GetDescriptionError(exception)));
}
}
private string HashCheckThread(string filePath, HashType hashType, IProgress <float> progress, CancellationToken ct)
{
using (FileStream stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (HashAlgorithm hash = GetHashType(hashType))
using (CryptoStream cs = new CryptoStream(stream, hash, CryptoStreamMode.Read))
{
long bytesRead, totalRead = 0;
byte[] buffer = new byte[8192];
Stopwatch timer = Stopwatch.StartNew();
while ((bytesRead = cs.Read(buffer, 0, buffer.Length)) > 0 && !ct.IsCancellationRequested)
{
totalRead += bytesRead;
if (timer.ElapsedMilliseconds > 200)
{
float percentage = (float)totalRead / stream.Length * 100;
progress.Report(percentage);
timer.Reset();
timer.Start();
}
}
if (ct.IsCancellationRequested)
{
progress.Report(0);
ct.ThrowIfCancellationRequested();
}
else
{
progress.Report(100);
string[] hex = TranslatorHelper.BytesToHexadecimal(hash.Hash);
return(string.Concat(hex));
}
}
return(null);
}
public override UploadResult Upload(Stream stream, string fileName)
{
UploadResult result = null;
string action = "getuploadkey", tpid = TinyPicID, tpk = TinyPicKey;
string upk = GetUploadKey(action, tpid, tpk);
if (!string.IsNullOrEmpty(upk))
{
Dictionary <string, string> arguments = new Dictionary <string, string>();
if (AccountType == AccountType.User && !string.IsNullOrEmpty(Shuk))
{
action = "userupload";
arguments.Add("shuk", Shuk);
}
else
{
action = "upload";
}
arguments.Add("action", action);
arguments.Add("tpid", tpid);
arguments.Add("sig", TranslatorHelper.TextToHash(action + tpid + tpk, HashType.MD5));
arguments.Add("responsetype", "XML");
arguments.Add("upk", upk);
arguments.Add("type", "image");
arguments.Add("tags", string.Empty);
result = UploadData(stream, URLAPI, fileName, "uploadfile", arguments);
if (result.IsSuccess && CheckResponse(result.Response))
{
result.URL = Helpers.GetXMLValue(result.Response, "fullsize");
result.ThumbnailURL = Helpers.GetXMLValue(result.Response, "thumbnail");
}
}
return(result);
}
private async Task <RegistrationQueryAllText> BuildAsync()
{
RegistrationQueryAllText result = new RegistrationQueryAllText();
result.Name = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Registration_Name}", Settings.SpecificLanguage);
result.Lastname = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Registration_Lastname}", Settings.SpecificLanguage);
result.CountryText = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Registration_Country}", Settings.SpecificLanguage);
result.LocationOfLost = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Registration_LocationOfLost}", Settings.SpecificLanguage);
result.DateOfLost = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Registration_DateOfLost}", Settings.SpecificLanguage);
result.ReportId = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Registration_ReportId}", Settings.SpecificLanguage);
result.ReportedBy = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Registration_ReportedBy}", Settings.SpecificLanguage);
result.GenreText = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Registration_Genre}", Settings.SpecificLanguage);
return(result);
}
private ActionResult GetItems(string storename, string type, string hash)
{
var response = new GetItemsResponse();
var suggestedFiles = new string[]
{
localizationPath + $"/{type}/{storename}.{Lang.ShortName}.{defaultExtension}",
localizationPath + $"/{type}/{storename}-{Lang.ShortName}.{defaultExtension}",
localizationPath + $"/{type}/{storename}.{defaultExtension}"
};
foreach (var file in suggestedFiles)
{
if (System.IO.File.Exists(file))
{
response.Data = TranslatorHelper.ReadLocalizationFile(file);
break;
}
}
if (response.Data == null)
{
response.Data = GetTranslatorItems(storename, hash);
}
var result = JsonConvert.SerializeObject(response.Data);
response.Hash = Locust.Cryptography.Cryptography.GetMD5(result);
if (!string.IsNullOrEmpty(hash) && string.Compare(hash, response.Hash, true) == 0)
{
response.Data = null;
response.Hash = "";
}
result = JsonConvert.SerializeObject(response);
return(Content(result, "text/plain"));
}
public string UserAuth(string email, string password)
{
string action = "userauth", tpid = TinyPicID, tpk = TinyPicKey;
Dictionary <string, string> args = new Dictionary <string, string>
{
{ "action", action },
{ "tpid", tpid },
{ "sig", TranslatorHelper.TextToHash(action + tpid + tpk, HashType.MD5) },
{ "email", email },
{ "pass", password }
};
string response = SendRequest(HttpMethod.POST, URLAPI, args);
if (!string.IsNullOrEmpty(response))
{
string result = Helpers.GetXMLValue(response, "shuk");
return(HttpUtility.HtmlEncode(result));
}
return(string.Empty);
}
private async Task AfterSearchAsync(IDialogContext context, IAwaitable <SearchQuery> result)
{
var state = await result;
MetadataVerification metadata = new MetadataVerification();
metadata.Name = state.Name;
metadata.Lastname = state.Lastname;
metadata.Country = state.Country.ToString();
var list = new List <Person>();
list = await RestHelper.MetadataVerification(metadata);
if (!list.Any())
{
var noitems = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.Search_NoItems}", Settings.SpecificLanguage);
await context.PostAsync(noitems);
TraceManager.SendTrace(context, "SearchDialog", "End");
context.Done("done");
}
else
{
var reply = context.MakeMessage();
reply.AttachmentLayout = AttachmentLayoutTypes.Carousel;
reply.Attachments = GetCardsAttachments(list);
await context.PostAsync(reply);
TraceManager.SendTrace(context, "SearchDialog", "End");
context.Done("done");
}
}
public async Task <ActualResult <AccountDTO> > GetAccountRoleAsync(string hashId)
{
try
{
var user = await _userManager.FindByIdAsync(hashId);
if (user != null)
{
var roles = await _userManager.GetRolesAsync(user);
var result = new AccountDTO {
HashId = hashId, Role = TranslatorHelper.ConvertToUkrainianLang(roles.FirstOrDefault())
};
return(new ActualResult <AccountDTO> {
Result = result
});
}
return(new ActualResult <AccountDTO>(Errors.UserNotFound));
}
catch (Exception exception)
{
return(new ActualResult <AccountDTO>(DescriptionExceptionHelper.GetDescriptionError(exception)));
}
}
private async Task OnMenuReportSearchSelected(IDialogContext context, IAwaitable <string> result)
{
try
{
string selected = await result;
string report = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.MenuReportSearch_Report}", Settings.SpecificLanguage);
string search = await TranslatorHelper.TranslateSentenceAsync($"{Resources.Resource.MenuReportSearch_Search}", Settings.SpecificLanguage);
if (selected.ToLower().Contains(report.ToLower()))
{
await context.Forward(new RegistrationDialog(), AfterRegistrationAsync, context.Activity, CancellationToken.None);
}
else if (selected.ToLower().Contains(search.ToLower()))
{
await context.Forward(new SearchDialog(), AfterSearchAsync, context.Activity, CancellationToken.None);
}
}
catch (TooManyAttemptsException)
{
context.Wait(this.MessageReceivedAsync);
}
}
