public KataBankOcr(IFileUtilities fileUtilies, IRawCharacterReader rawCharacterReader,
IChecksumCalculator checksumCalculator)
{
_fileUtilities = fileUtilies;
_rawCharacterReader = rawCharacterReader;
_checksumCalculator = checksumCalculator;
}
public T EndCalculateChecksum <T>()
{
IChecksumCalculator c = checksumCalculator;
checksumCalculator = null;
return(((IChecksumCalculator <T>)c).ChecksumValue);
}
public StorageRepository(IFileStorageOrganizer storageOrganizer, IFileStorage fileStorage, ISongTagger songTagger, IChecksumCalculator checksumCalculator)
{
this.storageOrganizer = storageOrganizer ?? throw new ArgumentNullException(nameof(storageOrganizer));
this.fileStorage = fileStorage ?? throw new ArgumentNullException(nameof(fileStorage));
this.songTagger = songTagger ?? throw new ArgumentNullException(nameof(songTagger));
this.checksumCalculator = checksumCalculator ?? throw new ArgumentNullException(nameof(checksumCalculator));
}
public void Setup()
{
_fileName = "someFile";
_stubChecksumCalculator = MockRepository.GenerateStub<IChecksumCalculator>();
_stubUIThreadMarshaller = MockRepository.GenerateStub<IUIThreadMarshaller>();
_listBuilderServiceService = new ListBuilderService(_stubChecksumCalculator, _stubUIThreadMarshaller);
_stubChecksumCalculator.Stub(sumCalculator => sumCalculator.GetHashFromFile(_fileName)).IgnoreArguments().Return("someHash");
}
public static Packet GeneratePacket(List <Frame> frames, ChecksumType checksumType, int checksumLength)
{
IChecksumCalculator calculator = ChecksumCalculatorFactory.Create(checksumType);
string framesData = string.Join("", frames.Select(f => f.GetFrame()));
string checksum = calculator.Calculate(framesData, checksumLength);
return(new Packet(frames, checksum));
}
public static Frame GenerateFrame(int length, ChecksumType checksumType, int checksumLength)
{
string data = GenerateBytes(length);
IChecksumCalculator calculator = ChecksumCalculatorFactory.Create(checksumType);
string checksum = calculator.Calculate(data, checksumLength);
return(new Frame(data, checksum));
}
public ListBuilderService(IChecksumCalculator checksumCalculator, IUIThreadMarshaller uiThreadMarshaller)
{
_hashList = new Dictionary<string, string>();
_duplicateFilesList = new Dictionary<string, string>();
_duplicatedFileNamesDictionary = new Dictionary<string, IList<string>>();
_latestProcessedFiles = new Dictionary<string, IList<string>>();
_checksumCalculator = checksumCalculator;
_uiThreadMarshaller = uiThreadMarshaller;
}
public Code128Interpreter(IMapping mapping = null, Encoding encoding = null,
IChecksumCalculator checksumCalculator = null)
{
if (encoding != null && !encoding.IsSingleByte)
{
throw new ArgumentException("Encoding must be single byte");
}
_mapping = mapping ?? new DefaultMapping();
_encoding = encoding ?? Encoding.Default;
_checksumCalculator = checksumCalculator ?? new Mod103ChecksumCalculator();
}
private static async Task <Int32> HandleCreateAsync(Arguments arguments, CancellationToken token)
{
List <Output> outputs = new List <Output>();
Program.ExpandWildcards(arguments);
foreach (String file in arguments.Files)
{
using (FileStream stream = File.OpenRead(file))
{
if (!arguments.IsSparse)
{
outputs.Add(new Output("File", file));
}
foreach (Method method in arguments.Methods)
{
using (IChecksumCalculator calculator = ChecksumCalculatorFactory.Create(method))
{
String checksum = await calculator.CalculateAsync(stream, token);
if (token.IsCancellationRequested)
{
return(ExitCodeHelper.Canceled);
}
if (arguments.IsSparse)
{
outputs.Add(new Output(method.Format(checksum, file)));
}
else
{
outputs.Add(new Output("Method", method.ToDisplay()));
outputs.Add(new Output("Result", checksum));
}
}
stream.Position = 0;
}
}
}
if (token.IsCancellationRequested)
{
return(ExitCodeHelper.Canceled);
}
outputs.Print();
return(ExitCodeHelper.Success);
}
public FtpManager(IChecksumCalculator checksumCalculator, ChecksumDataStorage checksumDataStorage, IFtpClientProvider ftpClientProvider, IClassLogger logger)
{
var ftpExecutor = new FtpCommandExecutor(ftpClientProvider, logger);
_ftpContentGetter = new FtpContentGetter(ftpExecutor);
_ftpDirectoryCreator = new FtpDirectoryCreator(ftpExecutor);
_ftpDirectoryRemover = new FtpDirectoryRemover(ftpExecutor, _ftpContentGetter, _ftpFileRemover, logger);
_ftpFileUploader = new FtpFileUploader(checksumCalculator, ftpExecutor, checksumDataStorage);
_ftpDirectoryUploader = new FtpDirectoryUploader(_ftpDirectoryCreator, _ftpFileUploader, logger);
_ftpExistenceChecker = new FtpExistenceChecker(ftpExecutor);
_ftpFileRemover = new FtpFileRemover(ftpExecutor);
_ftpTextReader = new FtpTextReader(ftpExecutor);
_ftpTextUploader = new FtpTextUploader(_ftpFileUploader);
}
private async Task <String> HandleCreateAsync(String fullpath, Method method, CancellationToken token)
{
using (FileStream stream = File.OpenRead(fullpath))
{
using (IChecksumCalculator calculator = ChecksumCalculatorFactory.Create(method))
{
if (token.IsCancellationRequested)
{
return(String.Empty);
}
return(await calculator.CalculateAsync(stream, token));
}
}
}
public Controller(string input, IScanner ns, IChecksumCalculator cc)
{
if (input == string.Empty)
throw new ArgumentNullException("input");
this.input = input;
if (ns == null)
throw new ArgumentNullException("NumberScanner");
numberScanner = ns;
if (cc == null)
throw new ArgumentNullException("ChecksumCalculator");
checksumCalculator = cc;
log = new List<string>();
}
public EncodedCode128(IMapping mapping,
IEnumerable <Symbol> symbols,
string encodedContent,
IChecksumCalculator calculator)
{
var symbolList = symbols.ToList();
Symbols = symbolList;
Data = Symbols.SelectMany(c => c.Values).ToList();
EncodedContent = encodedContent;
if (calculator != null)
{
var checkSum = calculator.CalculateChecksum(Data);
var checkSumSymbol = new Symbol(SpecialCodes.CheckSum, mapping.GetPattern(checkSum), checkSum);
symbolList.Add(checkSumSymbol);
symbolList.Add(mapping.StopSymbol);
}
FullData = Symbols.SelectMany(c => c.Values).ToList();
}
public LocalChecksumProvider(IChecksumCalculator checksumCalculator) => _checksumCalculator = checksumCalculator;
/// <summary>
/// Begins calculating byte checksum for all decrypted bytes read from the stream
/// </summary>
/// <param name="checksumCalculator">The checksum calculator to use</param>
public override void BeginCalculateChecksum(IChecksumCalculator checksumCalculator)
{
writer.BeginCalculateChecksum(checksumCalculator);
}
public void BeginCalculateChecksum(IChecksumCalculator checksumCalculator) => CurrentChecksumCalculator = checksumCalculator;
protected PacketBuilder(IChecksumCalculator calculator)
{
_calculator = calculator;
}
private static async Task <Int32> HandleVerifyAsync(Arguments arguments, CancellationToken token)
{
List <Output> outputs = new List <Output>();
Method method = arguments.Methods[0];
using (FileStream stream = File.OpenRead(arguments.File))
{
if (!arguments.IsSparse)
{
outputs.Add(new Output("File", arguments.File));
outputs.Add(new Output("Hash", arguments.Hash));
outputs.Add(new Output("Method", method.ToDisplay()));
}
using (IChecksumCalculator calculator = ChecksumCalculatorFactory.Create(method))
{
String checksum = await calculator.CalculateAsync(stream, token);
if (token.IsCancellationRequested)
{
return(ExitCodeHelper.Canceled);
}
if (arguments.Hash.Equals(checksum, StringComparison.OrdinalIgnoreCase))
{
if (arguments.IsSparse)
{
outputs.Add(new Output("CONFIRMED", ConsoleColor.Green));
}
else
{
outputs.Add(new Output("Result", "CONFIRMED", ConsoleColor.Green));
}
if (token.IsCancellationRequested)
{
return(ExitCodeHelper.Canceled);
}
outputs.Print();
return(ExitCodeHelper.Success);
}
else
{
if (arguments.IsSparse)
{
outputs.Add(new Output("UNCONFIRMED", ConsoleColor.Red));
}
else
{
outputs.Add(new Output("Result", "UNCONFIRMED", ConsoleColor.Red));
outputs.Add(new Output("Detect", checksum, ConsoleColor.Red));
}
if (token.IsCancellationRequested)
{
return(ExitCodeHelper.Canceled);
}
outputs.Print();
return(ExitCodeHelper.Failure);
}
}
}
}
/// <summary>
/// Validate the subject for the given expected checksum.
/// The checksum is calculated and then compared to the expected one.
/// </summary>
/// <param name="calculator">The algorithm</param>
/// <param name="subject">the text to check</param>
/// <param name="expectedChecksum">the checksum that is expected</param>
/// <returns>Is the expected checksum found</returns>
public static bool Validate(this IChecksumCalculator calculator, string subject, int expectedChecksum)
{
var actualChecksum = calculator.Calculate(subject);
return(actualChecksum == expectedChecksum);
}
public void Create_ValidMethodInvalidAlgorithm_ResultAsExpected(Method method, String algorithm, Type expected)
{
IChecksumCalculator actual = ChecksumCalculatorFactory.Create(method, algorithm);
Assert.That(actual, Is.InstanceOf(expected));
}
internal LineHashCalculator(IChecksumCalculator checksumCalculator)
{
this.checksumCalculator = checksumCalculator;
}
/// <summary>
/// Validate the given string having the last digit to be the check digit
/// </summary>
/// <param name="calculator">the algorithm</param>
/// <param name="includingChecksumAsFinalDigit">the full number to validate including the last digit that is the expected checksum</param>
/// <returns>Is the given number valid</returns>
public static bool Validate(this IChecksumCalculator calculator, string includingChecksumAsFinalDigit)
{
int indexOfCheckDigit = includingChecksumAsFinalDigit.Length - 1;
return(calculator.Validate(includingChecksumAsFinalDigit.Substring(0, indexOfCheckDigit), includingChecksumAsFinalDigit.Substring(indexOfCheckDigit)));
}
public KataBankOcr()
{
_fileUtilities = new FileUtilities();
_rawCharacterReader = new RawCharacterReader();
_checksumCalculator = new ChecksumCalculator();
}
internal /* for testing */ SecondaryLocationHashUpdater(IChecksumCalculator checksumCalculator)
{
this.checksumCalculator = checksumCalculator;
}
public void Create_ValidMethod_ResultAsExpected(Method method, Type expected)
{
IChecksumCalculator actual = ChecksumCalculatorFactory.Create(method);
Assert.That(actual, Is.InstanceOf(expected));
}
public NormalChecksumValidator(IChecksumCalculator calculator)
{
_calculator = calculator;
}
internal IssueSpanCalculator(IChecksumCalculator checksumCalculator)
{
this.checksumCalculator = checksumCalculator;
}
public void BeginCalculateChecksum(IChecksumCalculator checksumCalculator)
{
this.checksumCalculator = checksumCalculator;
}
public FtpFileUploader(IChecksumCalculator checksumCalculator, IFtpCommandExecutor ftpCommandExecutor, ChecksumDataStorage checksumDataStorage) => (_checksumCalculator, _checksumDataStorage, _ftpExecutor) = (checksumCalculator, checksumDataStorage, ftpCommandExecutor);
public EncodedCode128Factory(bool appendStopCode = true, IChecksumCalculator checksumCalculator = null)
{
AppendStopCode = appendStopCode;
ChecksumCalculator = checksumCalculator;
}
/// <summary>
/// Validate the subject for the given expected checksum.
/// The checksum is calculated and then compared to the expected one.
/// </summary>
/// <param name="calculator">The algorithm</param>
/// <param name="subject">the text to check</param>
/// <param name="expectedChecksum">the checksum that is expected</param>
/// <returns>Is the expected checksum found</returns>
public static bool Validate(this IChecksumCalculator calculator, string subject, string expectedChecksum)
{
return(calculator.Validate(subject, int.Parse(expectedChecksum, CultureInfo.InvariantCulture)));
}
