public void InputEmptyStringNegative()
{
string str = "";
Transliteration transliteration = new Transliteration();
Assert.ThrowsException <StringException>(() => transliteration.CheckString(str));
}
private async Task <Player> CreatePlayer(string userName, string email)
{
var latinName = Transliteration.CyrillicToLatin(userName, Language.Russian);
var newName = latinName.Replace(" ", string.Empty);
var user = await _userManager.FindByNameAsync(newName);
if (user == null)
{
var player = new Player
{
UserName = newName,
Balance = 1000,
Email = email
};
var createdUser = await _userManager.CreateAsync(player);
if (!createdUser.Succeeded)
{
throw new CustomServiceException("The user was not registered");
}
return(player);
}
else
{
if (string.IsNullOrEmpty(user.Email))
{
user.Email = email;
await _userManager.UpdateAsync(user);
}
return(user);
}
}
public void InputNextRussianInvalidCharactersNegative()
{
string str = "��אןכ�";
Transliteration transliteration = new Transliteration();
Assert.ThrowsException <StringException>(() => transliteration.CheckString(str));
}
public async Task ExecuteAsync(Message message, TelegramBotClient botClient, Update update)
{
var chatId = message.Chat.Id;
var messageId = message.MessageId;
var usefulMessage = Transliteration.Front(message.Text.Remove(0, message.Text.IndexOf(' ') + 1)).ToLower();
var buttonMessage = message.Text.Remove(0, message.Text.IndexOf(' ') + 1);
var resultMessage = _parserService.GetOneMovieInfo(usefulMessage);
if (resultMessage == "Вы ввели неверное название фильма!")
{
await botClient.SendTextMessageAsync(chatId, resultMessage, replyToMessageId : messageId);
return;
}
await botClient.SendChatActionAsync(message.Chat.Id, ChatAction.Typing);
ReplyKeyboardMarkup ReplyKeyboard = new[]
{
new[] { $"Подробнее о фильме {buttonMessage}" },
new[] { "К началу" },
};
await botClient.SendTextMessageAsync(chatId, _parserService.GetOneMovieInfo(usefulMessage), replyToMessageId : messageId, replyMarkup : ReplyKeyboard);
}
public static string SaveImageResize(HttpPostedFileBase hpf, string Path, int NewSize, string Orientation)
{
ImageCodecInfo myImageCodecInfo = GetEncoderInfo("image/jpeg");
EncoderParameters myEncoderParameters = new EncoderParameters(1);
myEncoderParameters.Param[0] = new EncoderParameter(Encoder.Quality, 100L);
Bitmap _File = (Bitmap)Bitmap.FromStream(hpf.InputStream);
if (NewSize > 100)
{
_File = Imaging.Resize(_File, NewSize, Orientation);
}
if (!Directory.Exists(Path))
{
Directory.CreateDirectory(HttpContext.Current.Server.MapPath(Path));
}
string imageName = Transliteration.Translit(hpf.FileName.Substring(0, hpf.FileName.IndexOf("."))).Replace(" ", "_");
string extension = hpf.FileName.Substring(hpf.FileName.IndexOf("."));
string filePath = HttpContext.Current.Server.MapPath(Path + imageName + extension);
if (File.Exists(filePath))
{
File.Delete(filePath);
}
_File.Save(filePath, myImageCodecInfo, myEncoderParameters);
_File.Dispose();
return(Path + imageName + extension);
}
public void InputLatinAndRussianNegative()
{
string str = "Asdפ�גasd";
Transliteration transliteration = new Transliteration();
Assert.ThrowsException <StringException>(() => transliteration.CheckString(str));
}
/// <summary>
/// Заполнение базовой информации о пассажире, на основании данных из запроса
/// </summary>
/// <param name="passengerFromRequest"></param>
public void Fill(Traveller passengerFromRequest, bool latinRegistration = true)
{
Num = passengerFromRequest.Num;
Type = passengerFromRequest.Type;
IsContact = passengerFromRequest.IsContact;
LinkedTo = passengerFromRequest.LinkedTo;
PersonalInfo = passengerFromRequest.PersonalInfo;
DocumentInfo = passengerFromRequest.DocumentInfo;
VisaInfo = passengerFromRequest.VisaInfo;
ArrAddress = passengerFromRequest.ArrAddress;
ContactInfo = passengerFromRequest.ContactInfo;
if (latinRegistration)
{
if (DocumentInfo != null)
{
DocumentInfo.DocNum = Transliteration.UARUStoENG(passengerFromRequest.DocumentInfo.CleanDocNum).ToUpper();
}
if (VisaInfo != null)
{
VisaInfo.BirthCity = Transliteration.UARUStoENG(passengerFromRequest.VisaInfo.BirthCity).ToUpper();
VisaInfo.IssuePlace = Transliteration.UARUStoENG(passengerFromRequest.VisaInfo.IssuePlace).ToUpper();
}
if (ArrAddress != null)
{
ArrAddress.City = Transliteration.UARUStoENG(passengerFromRequest.ArrAddress.City).ToUpper();
ArrAddress.State = Transliteration.UARUStoENG(passengerFromRequest.ArrAddress.State).ToUpper();
ArrAddress.StreetAddress = Transliteration.UARUStoENG(passengerFromRequest.ArrAddress.StreetAddress).ToUpper();
}
}
}
public async Task <ActionResult> Edit(Category model)
{
if (ModelState.IsValid)
{
var selectCat = _context.Categorys.FirstOrDefault(a => a.Name == model.Name);
if (selectCat.Name != null && selectCat.Name != model.Name)
{
selectCat.Name = model.Name;
selectCat.Transliteration = Transliteration.Front(selectCat.Name);
_context.SaveChanges();
TempData["Flag"] = "Success";
}
else
{
TempData["Danger"] = "Danger";
}
}
else
{
TempData["Flag"] = "Fail";
}
return(RedirectToAction("Edit", new { id = model.Id }));
}
/// <summary>
/// Создание нового объекта из старого с учётом требований транслитерации
/// </summary>
/// <param name="old">Старая информация об агентстве</param>
/// <param name="latinRegistration">Необходимость транслитерации</param>
public AgencyInfo(AgencyInfo old, bool latinRegistration = true)
{
Address = old.Address;
if (latinRegistration)
{
Name = Transliteration.CyrillicToLatin(old.Name).ToUpper();
if (Address != null)
{
if (!string.IsNullOrEmpty(Address.City))
{
Address.City = Transliteration.CyrillicToLatin(Address.City).ToUpper();
}
if (!string.IsNullOrEmpty(Address.State))
{
Address.State = Transliteration.CyrillicToLatin(Address.State).ToUpper();
}
if (!string.IsNullOrEmpty(Address.StreetAddress))
{
Address.StreetAddress = Transliteration.CyrillicToLatin(Address.StreetAddress).ToUpper();
}
}
}
else
{
Name = old.Name;
}
}
/// <summary>
/// Заполнение общих с пассажиром из запроса полей
/// </summary>
/// <param name="basePass">Базовый класс для пассажиров</param>
public BookedTraveller(Traveller basePass)
{
ContactInfo = basePass.ContactInfo;
DocumentInfo = basePass.DocumentInfo;
IsContact = basePass.IsContact;
LinkedTo = basePass.LinkedTo;
PersonalInfo = basePass.PersonalInfo;
Type = basePass.Type;
ArrAddress = basePass.ArrAddress;
LoyaltyCards = basePass.LoyaltyCards;
Num = basePass.Num;
VisaInfo = basePass.VisaInfo;
if (DocumentInfo != null)
{
DocumentInfo.DocNum = Transliteration.UARUStoENG(basePass.DocumentInfo.CleanDocNum).ToUpper();
}
if (VisaInfo != null)
{
VisaInfo.BirthCity = Transliteration.UARUStoENG(basePass.VisaInfo.BirthCity).ToUpper();
VisaInfo.IssuePlace = Transliteration.UARUStoENG(basePass.VisaInfo.IssuePlace).ToUpper();
}
if (ArrAddress != null)
{
ArrAddress.City = Transliteration.UARUStoENG(basePass.ArrAddress.City).ToUpper();
ArrAddress.State = Transliteration.UARUStoENG(basePass.ArrAddress.State).ToUpper();
ArrAddress.StreetAddress = Transliteration.UARUStoENG(basePass.ArrAddress.StreetAddress).ToUpper();
}
}
public static string Translit(string login)
{
var latin = Transliteration.CyrillicToLatin(login);
var a = latin.Replace("`", "");
return(a);
}
public string CreateLogin(RegisterEmployeeViewModel model)
{
model.SecondName = Transliteration.Front(model.SecondName);
model.FirstName = Transliteration.Front(model.FirstName);
bool isUnique = false;
rnd = new Random();
string fName = "";
string sName = model.SecondName;
string login = "";
int i = 0;
while (!isUnique)
{
if (i >= model.FirstName.Length)
{
while (!isUnique)
{
string rand = rnd.Next(0, 999).ToString();
login = fName + sName + rand;
isUnique = IsUniqueAsync(login).Result;
return(login);
}
}
fName += model.FirstName[i];
i++;
fName = fName.ToLower();
login = fName + sName;
isUnique = IsUniqueAsync(login).Result;
}
return(login);
}
public async Task <OperationResult <ListResponse <SearchResult> > > GetCategories(OffsetLimitModel request, CancellationToken token)
{
if (!EnableRead)
{
return(null);
}
var results = Validate(request);
if (results.Any())
{
return(new OperationResult <ListResponse <SearchResult> >(new ValidationError(string.Join(Environment.NewLine, results.Select(i => i.ErrorMessage)))));
}
var parameters = new Dictionary <string, object>();
AddOffsetLimitParameters(parameters, request.Offset, request.Limit);
var endpoint = "categories/top";
var result = await Gateway.Get <ListResponse <SearchResult> >(GatewayVersion.V1, endpoint, parameters, token);
if (result.IsSuccess)
{
foreach (var category in result.Result.Results)
{
category.Name = Transliteration.ToRus(category.Name);
}
}
return(result);
}
public async Task <ActionResult> CreateNewSubCat(SubCategory model)
{
if (ModelState.IsValid)
{
var translit = Transliteration.Front(model.Name);
SubCategory sub = new SubCategory
{
Id = Guid.NewGuid(),
Name = model.Name,
Transliteration = translit
};
_context.SubCategory.Add(sub);
_context.SaveChanges();
ViewBag.Flag = "Success";
}
else
{
ViewBag.Flag = "Fail";
}
return(View("AddSubCategory"));
}
private void WindowAdded(object sender, GwmWindowEventArgs e)
{
if (e.Form is PwEntryForm form && form.EditModeEx == PwEditMode.AddNewEntry)
{
Transliteration currentTransliteration = Transliterations.Get(_host.CustomConfig.GetCurrentTransliterationName());
if (currentTransliteration == null)
{
return;
}
e.Form.Shown += delegate(object o, EventArgs args)
{
TextBox tbTitle = e.Form.Controls.Find("m_tbTitle", true).FirstOrDefault() as TextBox;
TextBox tbUserName = e.Form.Controls.Find("m_tbUserName", true).FirstOrDefault() as TextBox;
tbTitle.LostFocus += delegate(object s, EventArgs eventArgs)
{
string title = currentTransliteration.Front(tbTitle.Text.ToShortTitle());
string userName = tbUserName.Text;
if (string.IsNullOrEmpty(userName))
{
tbUserName.Text = title;
}
else if (userName.Contains('\\'))
{
string[] parts = userName.Split(new string[] { "\\" }, StringSplitOptions.RemoveEmptyEntries);
tbUserName.Text = $"{parts[0]}\\{title}";
}
};
};
}
}
private static void ShowRoles(SqlConnection connection)
{
SqlCommand selectRoles = connection.CreateCommand();
selectRoles.CommandText = "SELECT * FROM Roles ORDER BY id";
using (SqlDataReader reader =
selectRoles.ExecuteReader())
{
int fieldCount = reader.FieldCount;
for (int i = 0; i < fieldCount; i++)
{
Console.Write(reader.GetName(i) + " ");
}
Console.WriteLine();
while (reader.Read())
{
Console.WriteLine(reader.GetInt32(0) + " " + reader.GetString(1));
foreach (Char item in reader.GetString(1))
{
// Console.WriteLine(item + 0);
// Console.WriteLine((ushort)item);
if ((ushort)item >= 1000)
{
Console.WriteLine(Transliteration.CyrillicToLatin(reader.GetString(1), Language.Russian));
break;
}
}
}
}
}
public void InputNextInvalidStringNegative()
{
string str = "',.[]";
Transliteration transliteration = new Transliteration();
Assert.ThrowsException <StringException>(() => transliteration.CheckString(str));
}
public async Task <OperationResult <ListResponse <SearchResult> > > GetCategories(OffsetLimitModel request, CancellationToken token)
{
if (!EnableRead)
{
return(null);
}
var results = Validate(request);
if (results != null)
{
return(new OperationResult <ListResponse <SearchResult> >(results));
}
var parameters = new Dictionary <string, object>();
AddOffsetLimitParameters(parameters, request.Offset, request.Limit);
var endpoint = $"{BaseUrl}/{GatewayVersion.V1}/categories/top";
var result = await HttpClient.Get <ListResponse <SearchResult> >(endpoint, parameters, token);
if (result.IsSuccess)
{
foreach (var category in result.Result.Results)
{
category.Name = Transliteration.ToRus(category.Name);
}
}
return(result);
}
public void RoundTest(Language lang, string reference, string text)
{
var latin = Transliteration.CyrillicToLatin(text, lang);
var actual = Transliteration.LatinToCyrillic(latin, lang);
Assert.Equal(text, actual);
}
public static string TagToRu(this string text)
{
if (string.IsNullOrWhiteSpace(text))
{
return(text);
}
return(Transliteration.ToRus(text));
}
public static void Run()
{
var text = "Погребальные байки";
var transliterated = Transliteration.Front(text);
Console.WriteLine($"Original text: {text}");
Console.WriteLine($"Transliterated: {transliterated}");
}
public static string Transliterate(string str)
{
if (string.IsNullOrWhiteSpace(str))
{
return(str);
}
return(Transliteration.CyrillicToLatin(str));
}
protected override Dictionary <string, List <Dictionary <int, string> > > GatherValuesFromPage(Page page, Dictionary <string, int> columnNumbers)
{
Dictionary <string, List <Dictionary <int, string> > > result
= new Dictionary <string, List <Dictionary <int, string> > >();
string textName = page.ReadText(2);
string textDrive = page.ReadText(16);
if (textName.Length > 0)
{
Dictionary <int, string> dataCommon = new Dictionary <int, string>();
List <Dictionary <int, string> > dataAttributes = new List <Dictionary <int, string> >();
// заполняем массив данных для страницы Products
dataCommon.Add(1, productID.ToString());
dataCommon.Add(2, textName);
dataCommon.Add(13, textName);
dataCommon.Add(4, MAIN_CATEGORY);
dataCommon.Add(12, "1000");
dataCommon.Add(14, page.ReadText(8));
dataCommon.Add(16, "yes");
dataCommon.Add(17, page.ReadText(3));
if (textDrive.ToLower().Contains("прям"))
{
dataCommon.Add(3, DIRECT_DRIVE_CATEGORY);
}
else if (textDrive.ToLower().Contains("рем"))
{
dataCommon.Add(3, BELT_DRIVE_CATEGORY);
}
dataCommon.Add(22, GetRegValue(page.ReadText(23), @"\d+"));
dataCommon.Add(23, GetRegValue(page.ReadText(23), @"\D+"));
dataCommon.Add(24, GetRegValue(page.ReadText(20), @"\d+"));
dataCommon.Add(25, GetRegValue(page.ReadText(21), @"\d+"));
dataCommon.Add(26, GetRegValue(page.ReadText(22), @"\d+"));
dataCommon.Add(27, GetRegValue(page.ReadText(22), @"\D+"));
dataCommon.Add(28, "true");
dataCommon.Add(32, Transliteration.Front(textName).Replace(" ", "-"));
// заполнение страницы атрибутов
List <PropertyBase> properties = GetListOfAttributes();
foreach (PropertyBase prop in properties)
{
prop.ReadValue(page);
dataAttributes.Add(prop.MakeDictionary(productID));
}
result.Add(PRODUCTS_PAGE_NAME, new List <Dictionary <int, string> > {
dataCommon
});
result.Add(ATTRIBUTES_PAGE_NAME, dataAttributes);
productID++;
return(result);
}
return(null);
}
/// <summary>
/// Uses input text to generate a valid Permlink
/// </summary>
/// <param name="text">Any text (usually a Title)</param>
/// <returns>A formatted string with a postfix (used current date and time)</returns>
public static string TitleToPermlink(string text)
{
text = text.Trim();
text = text.ToLower();
text = WordDelimiters.Replace(text, "-");
text = Transliteration.ToEng(text);
text = PermlinkNotSupportedCharacters.Replace(text, string.Empty);
return($"{text}-{DateTime.UtcNow:yyyy-MM-dd-HH-mm-ss}");
}
public async Task ExecuteAsync(Message message, TelegramBotClient botClient, Update update)
{
var chatId = message.Chat.Id;
var messageId = message.MessageId;
var usefulMessage = Transliteration.Front(message.Text.Remove(0, message.Text.IndexOf(' ') + 1)).ToLower();
await botClient.SendTextMessageAsync(chatId, _parserService.GetDirectorInfo(usefulMessage), replyToMessageId : messageId);
}
public void InputRussian�onsonantsValidCharactersPositive()
{
string str = "��ר��תכת";
string expected = "PshZl";
Transliteration transliteration = new Transliteration();
string actual = transliteration.TranslateString(str);
Assert.AreEqual(expected, actual, "Does not converge");
}
public void InputRussianWithValidValuePositive()
{
string str = "ABVGdeyozhziyklmnOPRStufkhtschshschyeyuya";
string expected = "����הו¸זחטיךכלם����עףפץצקרשיו�";
Transliteration transliteration = new Transliteration();
string actual = transliteration.TranslateString(str);
Assert.AreEqual(expected, actual, "Does not converge");
}
public async Task UploadAsync(UserInfo currentUser, IFormFileCollection files)
{
if (currentUser == null)
{
throw new ArgumentNullException(nameof(currentUser));
}
if (files == null)
{
throw new ArgumentNullException(nameof(files));
}
_logger.LogDebug($"{currentUser} начал загрузку {files.Count} файлов");
Validate(files);
using (var context = _contextFactory.CreateContext())
{
foreach (var file in files)
{
var userFileName = Transliteration.Front(file.FileName);
var fileName = GetUniqueFileName();
var fileBasePath = Path.Combine(StoragePath, $"u{currentUser.Id}");
_logger.LogInformation($"Сохраняем файл в локальное хранилище (userFileName = \"{userFileName}\", fileName = \"{fileName}\", filePath = \"{fileBasePath}\")");
// здесь может быть запись файлов на SFTP сервер
// проверим локальную директорию
if (!Directory.Exists(fileBasePath))
{
Directory.CreateDirectory(fileBasePath);
}
// сохранение
using (var fileStream = File.Create(Path.Combine(fileBasePath, fileName)))
{
await file.CopyToAsync(fileStream);
}
_logger.LogInformation("Файл успешно сохранен в хранилище");
var entity = new FileEntity
{
UserFileName = userFileName,
StorageFilePath = fileBasePath,
StorageFileName = fileName,
UserId = currentUser.Id,
};
context.Files.Add(entity);
await context.SaveChangesAsync(); // сохраняем при каждой итерации, потому что файл уже на сервере
_logger.LogInformation($"Сохранили сущность в базу (id = {entity.Id})");
}
}
_logger.LogDebug("Все файлы успешно загружены");
}
public Weather()
{
var config = new MapperConfiguration(cfg => {
cfg.CreateMap <WeatherInfo, WeatherInfoJson>()
.ForMember(n => n.Id, m => m.MapFrom(c => c.Id))
.ForMember(n => n.Desc, m => m.MapFrom(c => Transliteration.Front(c.Description)));
});
_mapper = config.CreateMapper();
}
public void BroadcastMessageTest(string ip, int port, string send_message, string expected_message)
{
Client client = new Client(IPAddress.Parse(ip), port);
client.NewMassageEvent += delegate(TcpClient client, string message)
{
Assert.AreEqual(expected_message, Transliteration.Run(send_message));
};
server.BroadcastMessage(send_message);
}
