//Priimami parametrai - vektorius
//Grąžinamas rezultatas - vektorius ir vėliava (flag), ar vektorius buvo pakeistas
//
//Funkcija paklausia vartotojo, ar jis norės pakeisti vektoriuje klaidas. Jei vartotojas nori,
//tuomet klaidos pakeičiamos ir grąžinamas pakeistas vektorius su vėliava, kad vektorius buvo keistas.
//Jei vartotojas nenori, grąžinamas paduotas vektorius ir vėliava, kad vektorius nekeistas.
public static Queue <int> ChangeErrors(Queue <int> vector, out bool changed)
{
Console.WriteLine("Do you want to change made errors?" + Environment.NewLine +
"1 - Yes" + Environment.NewLine +
"2 - No");
var input = Console.ReadLine();
var choice = int.Parse(input);
if (choice == 2)
{
changed = false;
return(vector);
}
else
{
changed = true;
Console.Write("Enter at what positions bits should be changed (separate by semicolon)" + Environment.NewLine +
"Example to change bits at 1, 5 and 6th positions: 1;5;6" + Environment.NewLine);
input = Console.ReadLine();
var errorPositionStringList = input.Split(';');
var errorPositionList = errorPositionStringList.Select(positionString => int.Parse(positionString)).ToList();
var vectorAsList = ErrorController.ChangeErrors(vector.ToList(), errorPositionList);
var changedVector = ConvertingHelper.ConvertListToQueue(vectorAsList);
return(changedVector);
}
}
public TimeTableService(IDocumentStoreRepository dsr, TimeService timeService, ConvertingHelper convertingHelper, StopTimesService stopTimesService, DownloadHelper downloadHelper)
{
_documentStoreRepository = dsr;
_timeService = timeService;
_convertingHelper = convertingHelper;
_stopTimesService = stopTimesService;
_downloadHelper = downloadHelper;
}
public async Task <Unit> Handle(FileExportQuery request, CancellationToken cancellationToken)
{
var storageInfo = await _storageRepository.GetStorageInfo();
SerializableStorageInfo serializableStorageInfo = ConvertingHelper.GetSerializableStorageInfo(storageInfo);
await _fileRepository.ExportFile(serializableStorageInfo, request.DestinationPath, request.Format);
return(Unit.Value);
}
static async Task Main(string[] args)
{
var logger = _container.GetService <ILogger <Program> >();
var consolePrinter = _container.GetService <IConsolePrinter>();
var controller = _container.GetService <IController>();
var mediator = _container.GetService <IMediator>();
var consoleFlagParser = new ConsoleFlagParser();
var consoleCommandParser = new ConsoleCommandParser(consoleFlagParser);
try
{
await mediator.Send(new InitializeStorageCommand());
var argsFlags = consoleFlagParser.Parse(args);
var credentials = GetCredentials(argsFlags);
var isAuthQuery = new IsAuthenticatedQuery(credentials.Login, credentials.Password);
if (!(await mediator.Send(isAuthQuery)))
{
throw new ArgumentException("Incorrect login or password");
}
consolePrinter.PrintAuthenticationSuccessful();
var command = new StorageCommand();
while (command.CommandType != StorageCommands.Exit)
{
try
{
command = GetCommand(consoleCommandParser, consolePrinter);
await controller.ExecuteConsoleCommand(command);
}
catch (AggregateException agEx)
{
foreach (var innerEx in agEx.InnerExceptions)
{
string logMessage = ConvertingHelper.GetLogMessage(innerEx.Message, innerEx.StackTrace);
logger.LogError(logMessage);
consolePrinter.PrintErrorMessage(innerEx.Message);
}
}
catch (Exception ex)
{
string logMessage = ConvertingHelper.GetLogMessage(ex.Message, ex.StackTrace);
logger.LogError(logMessage);
consolePrinter.PrintErrorMessage(ex.Message);
}
}
}
catch (Exception ex)
{
string logMessage = ConvertingHelper.GetLogMessage(ex.Message, ex.StackTrace);
logger.LogError(logMessage);
consolePrinter.PrintErrorMessage(ex.Message);
Environment.Exit(-1);
}
}
//Nieko nepriima
//Grąžinamas rezultatas - vektorius
//
//Funkcija paprašo vartotojo įvesti vektorių ir grąžina jį kaip bitų eilę
public static Queue <int> InputVector()
{
Console.WriteLine("Input the vector (made of 0s and 1s) to encode and press enter:" + Environment.NewLine +
"Example: 1010");
var input = Console.ReadLine();
var charBitArray = input.ToCharArray();
var vector = ConvertingHelper.ConvertListToQueue(charBitArray);
return(vector);
}
//Nieko nepriima
//Grąžinamas rezultatas - vektorius
//
//Funkcija paprašo vartotojo įvesti paveiksliuko pavadinimą, nuskaito paveiksliuką kaip baitus
//paverčia juos į vektorių (bitų eilę) ir grąžina
public static Queue <int> ReadImageFile()
{
Console.WriteLine("Only .jpg files are supported." + Environment.NewLine +
"Enter name of the image file (with extension):");
var fileName = Console.ReadLine();
var bytes = FileController.ReadFileBytes(fileName);
var queue = ConvertingHelper.ConvertBytesToIntQueue(bytes);
return(queue);
}
private async Task ExecuteConsoleCommandGetUserInfo(Options options)
{
var getUserQuery = new GetUserInfoQuery(options);
var userInfoResponceModel = await _mediator.Send(getUserQuery);
var userInfoViewModel = new UserInfoViewModel
{
CreationDate = ConvertingHelper.GetDateString(userInfoResponceModel.CreationDate),
Login = userInfoResponceModel.Login,
UsedStorage = ConvertingHelper.GetSizeString(userInfoResponceModel.UsedStorage)
};
_consolePrinter.PrintUserInformation(userInfoViewModel);
}
//Nieko nepriima
//Grąžinamas rezultatas - vektorius
//
//Funkcija paprašo vartotojo įvesti tekstą, jį paverčia į bitų eilę ir grąžina
public static Queue <int> InputText()
{
Console.WriteLine("Input the text to encode and press enter.");
var input = Console.ReadLine();
var sb = new StringBuilder();
foreach (var c in input)
{
sb.Append(Convert.ToString(c, 2).PadLeft(8, '0'));
}
var bitCharArray = sb.ToString().ToCharArray();
var preparedVector = ConvertingHelper.ConvertListToQueue(bitCharArray);
return(preparedVector);
}
//Priimami parametrai - vektorius, paveiksliuko pavadinimas
//Nieko negrąžina
//
//Funkcija bando išsaugoti vektorių kaip paveiksliuką ir informuoja vartotoją apie tai, ar saugojimas pavyko.
//Jei saugojimas pavyko, nurodo vartotojui, kokiu vardu galima rasti išsaugotą paveiksliuko failą.
//Jei nepavyko, informuoja apie tai.
public static void SaveImage(Queue <int> vector, string imageName)
{
var byteArray = ConvertingHelper.ConvertIntQueueToByteArray(vector);
Console.WriteLine();
try
{
FileController.SaveImageFile(byteArray, imageName);
Console.WriteLine("Successfully saved." + Environment.NewLine +
"Image can be found at project folder with the name '" + imageName + ".jpg'");
}
catch (Exception)
{
Console.WriteLine("Saving failed.");
}
}
private async Task ExecuteConsoleCommandFileUpload(Options options)
{
var fileUploadCommand = new FileUploadCommand(options);
var storageFile = await _mediator.Send(fileUploadCommand);
FileUploadViewModel uploadViewModel = new FileUploadViewModel
{
FilePath = fileUploadCommand.FilePath,
FileName = Path.GetFileName(fileUploadCommand.FilePath),
FileSize = ConvertingHelper.GetSizeString(storageFile.Size),
Extension = storageFile.Extension
};
LogInformationMessage($"File \"{fileUploadCommand.FilePath}\" has been uploaded");
_consolePrinter.PrintFileUploadedSuccessful(uploadViewModel);
}
private async Task ExecuteConsoleCommandDirectoryInfo(Options options)
{
var getDirectoryInfoQuery = new GetDirectoryInfoQuery(options);
var directoryInfo = await _mediator.Send(getDirectoryInfoQuery);
var directoryInfoViewModel = new DirectoryInfoViewModel()
{
CreationDate = ConvertingHelper.GetDateString(directoryInfo.CreationDate),
ModificationDate = ConvertingHelper.GetDateString(directoryInfo.ModificationDate),
Login = directoryInfo.Login,
Name = directoryInfo.Name,
Path = directoryInfo.Path,
Size = ConvertingHelper.GetSizeString(directoryInfo.Size)
};
_consolePrinter.PrintDirectoryInfo(directoryInfoViewModel);
}
private async Task ExecuteConsoleCommandFileInfo(Options options)
{
var fileInfoQuery = new GetFileInfoQuery(options);
var fileInfoResponseModel = await _mediator.Send(fileInfoQuery);
FileInfoViewModel fileInfoViewModel = new FileInfoViewModel
{
FileName = fileInfoResponseModel.FileName,
Extension = fileInfoResponseModel.Extension,
CreationDate = ConvertingHelper.GetDateString(fileInfoResponseModel.CreationDate),
FileSize = ConvertingHelper.GetSizeString(fileInfoResponseModel.FileSize),
DownloadsNumber = fileInfoResponseModel.DownloadsNumber,
Login = fileInfoResponseModel.Login
};
_consolePrinter.PrintFileInfo(fileInfoViewModel);
}
//Priimami parametrai - kanalas, užkoduotojas ir dekoduotojas
//Nieko negrąžina
//
//Funkcija, vykdanti teksto scenarijų. Perskaito vartotojo įvestą klaidos tikimybę, tekstą, paverčia jį į vektorių ir
// 1) užkoduoją jį, siunčia kanalu, dekoduoja ir atvaizduoja ekrane
// 2) siunčia kanalu ir atvaizduoja ekrane
private static void TextScenario(Channel channel, Encoder encoder, Decoder decoder)
{
var errorChance = InputOutputController.InputErrorChance();
var inputVector = InputOutputController.InputText();
var copyOfInputVector = ConvertingHelper.CopyVector(inputVector);
var encodedVector = encoder.Encode(inputVector);
var receivedEncodedVector = channel.SendThroughChannel(encodedVector, errorChance);
var decodedVector = decoder.Decode(receivedEncodedVector);
var decodedText = ConvertingHelper.ConvertVectorToText(decodedVector);
InputOutputController.PrintText("Decoded text: ", decodedText);
var receivedInputVector = channel.SendThroughChannel(copyOfInputVector, errorChance);
var plainText = ConvertingHelper.ConvertVectorToText(receivedInputVector);
InputOutputController.PrintText("Plain text, received after sending from channel: ", plainText);
}
static void ConfigureServices(IDocumentStoreRepository documentStoreRepository, IPublicTransportRepository publicTransportRepository)
{
var converter = new Converter();
var filterHelper = new FilterHelper();
var helperTimeService = new TimeService();
var convertingHelper = new ConvertingHelper(converter, filterHelper, documentStoreRepository);
var stopTimesService = new StopTimesService(documentStoreRepository, publicTransportRepository);
var downloadHelper = new DownloadHelper(documentStoreRepository, helperTimeService, publicTransportRepository);
var timeTableService = new TimeTableService(documentStoreRepository, helperTimeService, convertingHelper, stopTimesService, downloadHelper);
var polandPublicHoliday = new PolandPublicHoliday();
var dateChecker = new DateChecker(polandPublicHoliday);
var stopTimesFetcher = new StopTimesFetcher(dateChecker, documentStoreRepository);
var minuteTimeTableBuilder = new MinuteTimeTableBuilder(stopTimesFetcher);
var minuteTimeTableService = new MinuteTimeTableService(minuteTimeTableBuilder, documentStoreRepository);
UpdateTimeTableService.Init(timeTableService, minuteTimeTableService);
}
//Priimami parametrai - kanalas, užkoduotojas ir dekoduotojas
//Nieko negrąžina
//
//Funkcija, vykdanti paveiksliuko scenarijų. Nuskaito klaidos tikimybę, paverčia nurodytą paveiksliuką į bitus,
//pasilieka techninę informaciją ir
//1) likusius bitus užkoduoja, siunčia kanalu, dekoduoja, prideda techninę informaciją ir bando atvaizduoti faile
//2) likusius bitus siunčia kanalu, prideda techninę informaciją ir bando atvaizduoti file
private static void ImageScenario(Channel channel, Encoder encoder, Decoder decoder)
{
var errorChance = InputOutputController.InputErrorChance();
var vector = InputOutputController.ReadImageFile();
vector = channel.SendJPGTechnicalDataSafely(vector);
var copyOfInputVector = ConvertingHelper.CopyVector(vector);
var encodedVector = encoder.Encode(vector);
var receivedEncodedVector = channel.SendThroughChannel(encodedVector, errorChance);
var decodedVector = decoder.Decode(receivedEncodedVector);
decodedVector = channel.AddJPGTechnicalData(decodedVector);
InputOutputController.SaveImage(decodedVector, "decodedImage");
var receivedInputVector = channel.SendThroughChannel(copyOfInputVector, errorChance);
receivedInputVector = channel.AddJPGTechnicalData(receivedInputVector);
InputOutputController.SaveImage(receivedInputVector, "notEncodedImage");
}
/// <summary>
/// Prepares simulated input data as string
/// </summary>
protected virtual string PrepareSimulatedData()
{
StringBuilder inputData = new StringBuilder();
StringBuilder tempLine = new StringBuilder();
Receivers.ToList().ForEach(r => inputData.Append(r.Location).Append(PublicFields.PositionSeparator));
inputData = inputData.Trim(PublicFields.PositionSeparator);
inputData.Append('\n');
var times = ConvertingHelper.ConvertPointsToPropagationTimes(Receivers, Points);
foreach (var timeLine in times)
{
tempLine.Clear();
foreach (var time in timeLine)
{
tempLine.Append(time.ToString("0.00000000", CultureInfo.InvariantCulture)).Append(PublicFields.PositionSeparator);
}
tempLine = tempLine.Trim(PublicFields.PositionSeparator);
tempLine.Append('\n');
inputData.Append(tempLine);
}
return(inputData.ToString());
}
private void LogInformationMessage(string message)
{
string logMessage = ConvertingHelper.GetLogMessage(message, string.Empty);
_logger.LogInformation(logMessage);
}
