private bool ProcessInstruction(OutputInstruction instruction) { var result = false; var itemCount = instruction.Format == OutputFormat.Delete ? instruction.Deletions.Count : instruction.Updates.Count; var startTime = DateTime.Now; _logger.DebugFormat("Starting to process an instruction with type of {0} containing {1} entries.", instruction.Format, itemCount); if (instruction.Format == OutputFormat.Delete) { result = ProcessDeletionInstruction(instruction); } else { result = ProcessUpdateInstruction(instruction); } if (instruction.FileCount == 1) { _logger.InfoFormat("Completed processing of the {1} instruction with file count of {2}. Elapsed time is {0}.", (DateTime.Now - startTime).ToString(@"dd\.hh\:mm\:ss"), instruction.Format, instruction.FileCount); } else { _logger.DebugFormat("Completed processing of the {1} instruction with file count of {2}. Elapsed time is {0}.", (DateTime.Now - startTime).ToString(@"dd\.hh\:mm\:ss"), instruction.Format, instruction.FileCount); } return(result); }
private void ProcessAvailableInstruction(FileInfo fileInfo) { _logger.DebugFormat("Picked {0} as the file to process", fileInfo.FullName); try { OutputInstruction instruction = null; using (var reader = File.OpenText(fileInfo.FullName)) { using (var jsonStreamer = new JsonTextReader(reader)) { JsonSerializer serializer = new JsonSerializer(); instruction = serializer.Deserialize <OutputInstruction>(jsonStreamer); } } if (ProcessInstruction(instruction)) { RemoveFile(fileInfo); } } catch (Exception exception) { _hasError = true; _logger.ErrorFormat("Error occurred while processing {0}.", fileInfo.FullName + " - " + exception.Message + " - " + exception.StackTrace); } }
private void OutputBatch(OutputFormat batchOutput, IEnumerable <BaseExportData> batchData, int batchCounter, string identifier, string catalogName = null) { var data = batchData.ToList(); var message = string.Format("Starting batch {0} {1} for identifier {2} containing {3} records.", batchOutput.ToString(), batchCounter, identifier, data.Count); if (batchCounter == 1) { _logger.InfoFormat(message); } else { _logger.DebugFormat(message); } var instruction = new OutputInstruction { Format = batchOutput, CatalogName = catalogName, Count = batchCounter, OutputLocation = identifier, OutputName = string.Format("{0}_{1}", batchOutput.ToString(), batchCounter), Data = data }; RecordOutput(instruction); _logger.DebugFormat("Completed batch {0}.", batchOutput.ToString()); }
public override FileInfo FileWrite(OutputInstruction instruction) { if (instruction == null || instruction.Data == null || !instruction.Data.Any()) { return(null); } var filePath = GeneratorHelper.GetFilePath(instruction.OutputName, instruction.OutputLocation, _fileNameFormat); XmlWriter xmlWriter = null; GZipStream gZipStream = null; if (_isGzip) { gZipStream = new GZipStream(FileCreate(filePath + ".gz"), CompressionMode.Compress); xmlWriter = FileWriterCreate(gZipStream); } else { xmlWriter = FileWriterCreate(filePath); } var serializer = GetSerializer(instruction.Data.First().GetType(), string.Empty); using (xmlWriter) { serializer.Serialize(xmlWriter, instruction.Data); } if (gZipStream != null) { gZipStream.Close(); } return(new FileInfo(filePath)); }
public void RecordOutput(OutputInstruction instruction) { var file = WriteOutputInstructionFile(instruction); if (file != null) { _files.Add(file); } }
private bool ProcessUpdateInstruction(OutputInstruction instruction) { if (!_googleRequestProcessor.SendUpdateBatch(instruction.Updates)) { _logger.Info("Error sending update batch to Google. Moving on to next."); _hasError = true; return(false); } return(true); }
private bool ProcessDeletionInstruction(OutputInstruction instruction) { if (!_googleRequestProcessor.SendDeletionBatch(instruction.Deletions)) { _logger.Info("Error sending deletion batch to Google. Moving on to next."); _hasError = true; return(false); } return(true); }
private bool SendToDestination(OutputInstruction instruction) { if (!_destinationProcessor.Process(instruction)) { _logger.Info("Error sending data to destination. Moving on to next."); _hasError = true; return(false); } return(true); }
/// <summary> /// Reads a json file and converts it to output instruction. /// </summary> /// <param name="fileInfo">File info.</param> /// <returns>Output instruction.</returns> public override OutputInstruction FileRead(FileInfo fileInfo) { OutputInstruction instruction = null; using (var reader = File.OpenText(fileInfo.FullName)) { using (var jsonStreamer = new JsonTextReader(reader)) { JsonSerializer serializer = new JsonSerializer(); instruction = serializer.Deserialize <OutputInstruction>(jsonStreamer); } } return(instruction); }
protected override void ProcessAvailableInstruction(FileInfo fileInfo) { _logger.DebugFormat("Picked {0} as the file to process", fileInfo.FullName); try { OutputInstruction instruction = _fileProcessor.FileRead(fileInfo); if (ProcessInstruction(instruction)) { _fileProcessor.FileRemove(fileInfo); } } catch (Exception exception) { _hasError = true; _logger.ErrorFormat("Error occurred while processing {0}.", fileInfo.FullName + " - " + exception.Message + " - " + exception.StackTrace); } }
/// <summary> /// Writes a json file with given <paramref name="instruction"/>. /// </summary> /// <param name="instruction">Instruction with content.</param> /// <returns>File info.</returns> public override FileInfo FileWrite(OutputInstruction instruction) { var filePath = Path.Combine(instruction.OutputLocation, instruction.OutputName + ".json"); using (var stream = new FileStream(filePath, FileMode.Create)) { using (StreamWriter writer = new StreamWriter(stream)) { using (JsonWriter jsonWriter = new JsonTextWriter(writer)) { var serializer = new JsonSerializer(); serializer.Serialize(jsonWriter, instruction); } } } return(new FileInfo(filePath)); }
private void OutputBatch(OutputFormat batchOutput, IEnumerable <BaseExportData> batchData, int batchCounter, string identifier, string catalogName = null) { var data = batchData.ToList(); LogStartBatch(batchOutput, batchCounter, identifier, data.Count); var instruction = new OutputInstruction { Format = batchOutput, CatalogName = catalogName, Count = batchCounter, OutputLocation = OutputFolderPath, OutputName = batchOutput.ToString() + identifier + batchCounter, Data = data }; _outputInstructionProcessor.RecordOutput(instruction); Log.DebugFormat("Completed batch {0}{1}{2}.", batchOutput.ToString(), identifier, batchCounter); }
public Instruction GiveConcreteInstruction(Opcode instruction) { Instruction concreteInstruction = null; int opCode = instruction.GetOpCode(); switch (opCode) { case (int)Opcodes.Addition: concreteInstruction = new AdditionInstruction(instruction.GetFirstParameterMode(), instruction.GetSecondParameterMode()); break; case (int)Opcodes.Multiplication: concreteInstruction = new MultiplyInstruction(instruction.GetFirstParameterMode(), instruction.GetSecondParameterMode()); break; case (int)Opcodes.Input: concreteInstruction = new InputInstruction(program.Inputs[program.CurrentInputPointer++], instruction.GetFirstParameterMode()); break; case (int)Opcodes.Output: concreteInstruction = new OutputInstruction(instruction.GetFirstParameterMode()); break; case (int)Opcodes.JumpIfTrue: concreteInstruction = new JumpIfTrueInstruction(instruction.GetFirstParameterMode(), instruction.GetSecondParameterMode()); break; case (int)Opcodes.JumpIfFalse: concreteInstruction = new JumpIfFalseInstruction(instruction.GetFirstParameterMode(), instruction.GetSecondParameterMode()); break; case (int)Opcodes.LessThan: concreteInstruction = new LessThanInstruction(instruction.GetFirstParameterMode(), instruction.GetSecondParameterMode(), instruction.GetThirdParameterMode()); break; case (int)Opcodes.Equals: concreteInstruction = new EqualsInstruction(instruction.GetFirstParameterMode(), instruction.GetSecondParameterMode(), instruction.GetThirdParameterMode()); break; } return(concreteInstruction); }
private void SendUpdateBatch(IList <GooglePlaProductData> productDatas, int fileCount, string identifier) { if (fileCount == 1) { Log.InfoFormat("Starting to write batch update file {0} for identifier {1} containing {2} products.", fileCount, identifier, productDatas.Count); } else { Log.DebugFormat("Starting to write batch update file {0} for identifier {1} containing {2} products.", fileCount, identifier, productDatas.Count); } var fileContent = new OutputInstruction { Format = OutputFormat.Update, Updates = productDatas, FileCount = fileCount }; _outputInstructionProcessor.RecordOutputInstruction(fileContent, identifier, "update" + fileCount); Log.Debug("Completed writing batch update file."); }
private void SendDeletionBatch(IList <string> deletedProductIds, int fileCount, string identifier) { if (fileCount == 1) { Log.InfoFormat("Starting to write batch delete file {0} for identifier {1} containing {2} products.", fileCount, identifier, deletedProductIds.Count); } else { Log.DebugFormat("Starting to write batch delete file {0} for identifier {1} containing {2} products.", fileCount, identifier, deletedProductIds.Count); } var fileContent = new OutputInstruction { Format = OutputFormat.Delete, Deletions = deletedProductIds, FileCount = fileCount }; _outputInstructionProcessor.RecordOutputInstruction(fileContent, identifier, "delete" + fileCount); Log.Debug("Completed writing batch delete file."); }
private FileInfo WriteOutputInstructionFile(OutputInstruction instruction) { if (instruction == null) { throw new ArgumentException("Null instruction was provided.", "instruction"); } if (string.IsNullOrWhiteSpace(instruction.OutputLocation)) { throw new ArgumentException("An invalid output location was provided.", "OutputLocation"); } if (string.IsNullOrWhiteSpace(instruction.OutputName)) { throw new ArgumentException("An invalid output name was provided.", "OutputName"); } instruction.OutputLocation = Path.Combine(OutputFolderPath, instruction.OutputLocation); EnsureFolderExists(instruction.OutputLocation); return(_fileProcessor.FileWrite(instruction)); }
private bool ProcessInstruction(OutputInstruction instruction) { var result = false; var itemCount = GetItemCount(instruction); var startTime = DateTime.Now; _logger.DebugFormat("Starting to process an instruction with type of {0} containing {1} entries of catalog {2}.", instruction.Format, itemCount, instruction.CatalogName); result = SendToDestination(instruction); var message = string.Format("Completed processing of the {1} instruction with file count of {2}. Elapsed time is {0}.", (DateTime.Now - startTime).ToString(@"dd\.hh\:mm\:ss"), instruction.Format, instruction.Count); if (instruction.Count == 1) { _logger.InfoFormat(message); } else { _logger.DebugFormat(message); } return(result); }
private static FileInfo WriteOutputInstructionFile(OutputInstruction content, string folderName, string fileName) { if (content == null) { throw new ArgumentException("Null content was provided.", "content"); } if (string.IsNullOrWhiteSpace(folderName)) { throw new ArgumentException("An invalid folder name was provided.", "folderName"); } if (string.IsNullOrWhiteSpace(fileName)) { throw new ArgumentException("An invalid file name was provided.", "fileName"); } var folder = Path.Combine(OutputFolderPath, folderName); EnsureFolderExists(folder); var filePath = Path.Combine(folder, fileName + ".json"); using (var stream = new FileStream(filePath, FileMode.Create)) { using (StreamWriter writer = new StreamWriter(stream)) { using (JsonWriter jsonWriter = new JsonTextWriter(writer)) { var serializer = new JsonSerializer(); serializer.Serialize(jsonWriter, content); } } } return(new FileInfo(filePath)); }
public void RecordOutputInstruction(OutputInstruction content, string folderName, string fileName) { var file = WriteOutputInstructionFile(content, folderName, fileName); _files.Add(file); }
protected static int GetItemCount(OutputInstruction instruction) { return(instruction.Data.Count); }
public abstract FileInfo FileWrite(OutputInstruction instruction);