public FileProcessingModel DataMaskingFileProcessing(DataSet dsConfigSource, string FileNameWithPath, string MetaFileNameWithPath, FileProcessingModel model)
{
try
{
if (model.FileExtensionType == Enums.FileExtnType.PrintImageSD)
{
PrintImageSD_FileProcessing(dsConfigSource, FileNameWithPath, MetaFileNameWithPath, model);
}
}
catch (Exception Ex)
{
model = null;
throw Ex;
}
return(model);
}
private void PrintImageSD_FileProcessing(DataSet Dsconfigurations, string FileNameWithPath, string MetaFileNameWithPath, FileProcessingModel model)
{
bool isFileValid = true;
string ReordType = string.Empty, FileExtensionTargets = string.Empty;
(string workflowGroup, string productNum, string subType) = GetXmlNodesValue(MetaFileNameWithPath);
DataTable GetDataTable = new DataTable();
GetDataTable.Clear();
GetDataTable = GetConsolidatedConfiguration(Dsconfigurations);
if (model.FileExtension.ToString().ToUpper() == Enums.FileExtn.TXT.ToString())
{
FileExtensionTargets = Enums.FileExtn.TXT.ToString();
ReordType = (GetDataTable.AsEnumerable().Where(p => p.Field <string>("FileExtensionTargets") == Enums.FileExtn.TXT.ToString()
).Select(p => p.Field <string>("RecordType"))).FirstOrDefault();
}
StringBuilder sbText = new StringBuilder();
string countValue = GetDelimiterCount(FileNameWithPath);
string[] countVal = countValue.Split(' ');
int[] printImageIdentifierPosition = new int[Convert.ToInt32(countVal[0])];
int[] specialCharacterArray = new int[Convert.ToInt32(countVal[1])];
List <ClientDataPageWise> clientDataList = new List <ClientDataPageWise>();
recordRepeatlist.Clear();
using (StreamReader file = new StreamReader(new FileStream(FileNameWithPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite), Encoding.Default))
{
List <string> fileRows = new List <string>();
int counter = 0;
string ln;
dicMaskedVariable.Clear();
int indexval = 0;
int specialcharacterIndexVal = 0;
int linesCount = 0;
//Getting the Index of Mail_to_Address and special character
while ((ln = file.ReadLine()) != null)
{
fileRows.Add(ln.TrimEnd());
int linenumber = GetIndexValue(printImageIdentifier, ln);
counter++;
if (linenumber != -1)
{
printImageIdentifierPosition[indexval] = counter;
indexval++;
}
int specialCharacterLineNumber = GetIndexValue(printImageSDRecDelimiter, ln);
if (specialCharacterLineNumber != -1)
{
specialCharacterArray[specialcharacterIndexVal] = counter;
specialcharacterIndexVal++;
}
linesCount++;
}
//splliting the page client wise
if (linesCount != 0 && indexval != 0 && printImageIdentifierPosition.Length != 0)
{
List <List <string> > clientRecord = new List <List <string> >();
string[] clientArray = new string[printImageIdentifierPosition.Length + 1];
int ther = 0;
for (int count = 0; count <= printImageIdentifierPosition.Length + 1; count++)
{
if (count == (int)Enums.RecordType.Initial)
{
clientRecord.Add(fileRows.GetRange(count + 1, printImageIdentifierPosition[0] - 14));
}
else if (count == printImageIdentifierPosition.Length)
{
int loc = ((specialCharacterArray[specialCharacterArray.Length - 1]) - (printImageIdentifierPosition[count - 1] - 14));
clientRecord.Add(fileRows.GetRange(printImageIdentifierPosition[count - 1] - 14, loc - 1));
}
else if (count == printImageIdentifierPosition.Length + 1)
{
int loc = ((linesCount) - (specialCharacterArray[specialCharacterArray.Length - 1]));
clientRecord.Add(fileRows.GetRange(specialCharacterArray[specialCharacterArray.Length - 1], loc));
}
else
{
int loc = ((printImageIdentifierPosition[count] - 14) - (printImageIdentifierPosition[count - 1] - 14));
clientRecord.Add(fileRows.GetRange(printImageIdentifierPosition[count - 1] - 14, loc));
}
ther += clientRecord[count].Count;
}
int clientRecordCount = 0;
int clientcount = 0;
foreach (List <string> clientRec in clientRecord)
{
ClientDataPageWise ObjClientDataPageWise = new ClientDataPageWise();
string outPut = string.Join(Environment.NewLine, clientRec.ToArray());
string[] pages = outPut.Split(Convert.ToChar(printImageSDRecDelimiter));
int count = 0;
for (int i = 0; i < pages.Length; i++)
{
if ((clientcount == 0 && i == 0))
{
pages[i] = printImageSDRecDelimiter + "\r" + pages[i];
}
else if (clientcount == clientRecord.Count - 1)
{
pages[i] = printImageSDRecDelimiter + "\r\n" + pages[i];
}
else if (pages[i].Trim() != "")
{
pages[i] = printImageSDRecDelimiter + pages[i];//.Replace("�", "");
}
if (pages[i].Trim() != "")
{
ObjClientDataPageWise.Pages.Add(pages[i]);
}
count++;
clientRecordCount++;
}
clientcount++;
clientDataList.Add(ObjClientDataPageWise);
}
}
else
{
isFileValid = false;
}
bool isDescreptionPages = false;
int customerRecordNo = 1;
int isAccountValid = 0;
if (isFileValid)
{
foreach (var page in clientDataList)
{
if (!isFileValid)
{
break;
}
if (customerRecordNo == (int)Enums.RecordType.First)
{
isDescreptionPages = true;
}
else
{
isDescreptionPages = false;
}
customerRecordNo++;
int customerPageCount = 1;
foreach (var row in page.Pages)
{
int totalPageLines = CountLinesInFile(row.ToString());
StringBuilder maskedLine = new StringBuilder();
var tempread = new StringReader(row);
if (isDescreptionPages)
{
sbText.AppendLine(row.ToString().TrimEnd());
}
else
{
for (int currentRowofPage = 1; currentRowofPage <= totalPageLines; currentRowofPage++)
{
string unMaskedLine = tempread.ReadLine();
maskedLine = GeneratePrintImageSDMaskedData(unMaskedLine, Dsconfigurations, MetaFileNameWithPath, customerPageCount, Convert.ToString(currentRowofPage), ref isAccountValid);
sbText.AppendLine(maskedLine.ToString().TrimEnd());
}
}
customerPageCount++;
}
}
file.Close();
}
if (customerRecordNo - 3 == isAccountValid)
{
isFileValid = false;
}
}
// Full Scanning the document for repeated string
StringBuilder sbFinal = new StringBuilder();
sbFinal.Clear();
if (isFileValid)
{
int linesss = sbText.Length;
String[] arrFinal = sbText.ToString().TrimEnd().Split('\n');
bool isDescrptionPageExists = true;
foreach (string finalRow in arrFinal)
{
if (!isDescrptionPageExists)
{
StringBuilder scanLine = new StringBuilder(finalRow);
List <string> dicPreMasked = recordRepeatlist.OrderByDescending(s => s.Length).ToList();
Parallel.ForEach(dicPreMasked, record =>
{
string[] repeatString = record.Split(new[] { ' ', ' ' }, StringSplitOptions.RemoveEmptyEntries);
string[] lineCheck = finalRow.Trim('\r').Split(new Char[] { ' ', '-' });
StringBuilder stringMatched = new StringBuilder();
List <string> repeatLintMatch = new List <string>();
foreach (string dictionay in repeatString)
{
if (finalRow.Contains(dictionay))
{
foreach (string currentScanWord in lineCheck)
{
if (currentScanWord == dictionay)
{
repeatLintMatch.Add(dictionay);
}
}
}
else
{
break;
}
}
foreach (string value in repeatLintMatch)
{
stringMatched.Append(value + ' ');
}
string finalMatch = stringMatched.ToString().TrimEnd().TrimStart();
string originalArray = ConvertStringArrayToString(repeatString).TrimEnd();
if (finalMatch.Length == originalArray.Length)
{
string finalMaskedString = GetMaskedFieldValue(originalArray);
string[] maskedarray = finalMaskedString.Split(' ');
Dictionary <string, string> unMaskedAndMaskedDict = new Dictionary <string, string>();
for (int unm = 0; unm < repeatString.Length; unm++)
{
unMaskedAndMaskedDict.Add(repeatString[unm], maskedarray[unm]);
}
foreach (string final in finalMatch.Split(' '))
{
scanLine.Replace(final, unMaskedAndMaskedDict[final]);
}
}
else if (finalMatch.Length > originalArray.Length)
{
scanLine.Replace(originalArray, GetMaskedFieldValue(originalArray));
}
});
sbFinal.AppendLine(scanLine.ToString().TrimEnd());
}
else
{
if (finalRow.Contains(printImageIdentifier))
{
isDescrptionPageExists = false;
}
sbFinal.AppendLine(finalRow.TrimEnd());
}
}
}
else
{
sbFinal = null;
}
if (!isFileValid)
{
sbFinal = null;
}
using (MemoryStream fileStream = new MemoryStream())
{
fileStream.Write(Encoding.Default.GetBytes(sbFinal.ToString()), 0, Encoding.Default.GetBytes(sbFinal.ToString()).Length);
model.OutputDataFileBytes = fileStream.ToArray();
}
using (MemoryStream metaStream = new MemoryStream())
{
metaStream.Write(Encoding.Default.GetBytes(sbFinal.ToString()), 0, Encoding.Default.GetBytes(sbFinal.ToString()).Length);
model.OutputMetaDataFileBytes = metaStream.ToArray();
}
model.HasOutputErrors = (model.OutputDataFileBytes == null || model.OutputMetaDataFileBytes == null ? true : false);
model.HasOutputFileDetails = (model.OutputDataFileBytes == null || model.OutputMetaDataFileBytes == null ? false : true);
}
private bool CheckAndCreateMaskedFile(string _FileName, string _MetaFileName)
{
bool _return = false;
Logger.Trace("STARTED: CheckAndCreateMaskedFile Method.");
try
{
FileProcessingModel _fileProcessingModel = null;
bool IsProcessed = false;
try
{
FileExtn _fileExt = new FileExtn();
FileExtnType _fileExtTyp = new FileExtnType();
if (_FileName.ToUpper().Trim().Contains(Nbs_East))
{
_fileExt = FileExtn.TXT;
}
else
{
_fileExt = (FileExtn)Enum.Parse(typeof(FileExtn), FileIOService.GetFileExtension(_FileName).Split('.')[1].ToUpper());
}
if (_fileExt.ToString().ToUpper() == Convert.ToString(FileExtn.TXT))
{
_fileExtTyp = (FileExtnType)GetFileExtensionAndTypeDictionary()
.FirstOrDefault(x => x.Key == Convert.ToString(_fileExt)).Value.Key;
}
_fileProcessingModel = new FileProcessingModel
{
InputFileName = FileIOService.GetFileName(_FileName),
InputFileNameExtension = FileIOService.GetFileExtension(_FileName),
InputFileStream = FileIOService.GetFileStream(_FileName),
InputMetadataFileName = FileIOService.GetFileName(_MetaFileName),
InputMetadataFileNameExtension = FileIOService.GetFileExtension(_MetaFileName),
InputMetaDataFileStream = FileIOService.GetFileStream(_MetaFileName),
FileExtensionType = _fileExtTyp,
FileExtension = _fileExt
};
IsProcessed = true;
Logger.Trace(string.Format("STARTED: Processing of file: {0}", _FileName));
}
catch (Exception e) { IsProcessed = false; }
if (IsProcessed)
{
//DataMasking *****Started****
Logger.Trace("STARTED: DataMasking Process");
DataSet dsMaskingSource = new DataSet();
dsMaskingSource.Clear();
dsMaskingSource = FileIOService.GetMaskingSourceDataSet();
FileProcessingModel model = DataMaskingService.DataMaskingFileProcessing(dsMaskingSource, _FileName, _MetaFileName, _fileProcessingModel);
_fileProcessingModel.HasOutputFileDetails = (model == null ? false : model.HasOutputFileDetails);
_fileProcessingModel.HasOutputErrors = (model == null ? true : model.HasOutputErrors);
Logger.Trace("ENDED: DataMasking Process");
//DataMasking *****Ended****
if (!_fileProcessingModel.HasOutputErrors && _fileProcessingModel.HasOutputFileDetails)
{
_fileProcessingModel.OutputFileName = "Masked_" + _fileProcessingModel.InputFileName;
_fileProcessingModel.OutputFileNameExtension = _fileProcessingModel.InputFileNameExtension;
_fileProcessingModel.OutputMetadataFileName = "Masked_" + _fileProcessingModel.InputMetadataFileName;
_fileProcessingModel.OutputMetadataFileNameExtension = _fileProcessingModel.InputMetadataFileNameExtension;
string outputFileName = ConfigHelper.Model.OutputFilePathLocation_Local + Path.DirectorySeparatorChar + _fileProcessingModel.OutputFileName + _fileProcessingModel.OutputFileNameExtension;
string outputMetadataFileName = ConfigHelper.Model.OutputFilePathLocation_Local + Path.DirectorySeparatorChar + _fileProcessingModel.OutputMetadataFileName + _fileProcessingModel.OutputMetadataFileNameExtension;
bool retOutputFile = FileIOService.CreateFileFromFileStream(outputFileName, _fileProcessingModel.OutputDataFileBytes);
bool retOutputMetaFile = FileIOService.CopyFile(_MetaFileName, outputMetadataFileName);
Logger.Trace(string.Format("ENDED: Processing of file: {0}", _FileName));
if (retOutputFile && retOutputMetaFile)
{
_ = RemoveInputFiles(_FileName, _MetaFileName);
Logger.Trace(string.Format("SUCCESS: Output file generated successfully - {0}", outputFileName));
_return = true;
}
else
{
Logger.Trace("DISCARDED: Output Error");
_return = false;
_ = MoveFilesToOutputDiscarded(_FileName, _MetaFileName);
}
}
else
{
Logger.Trace("DISCARDED: Output Error");
_return = false;
_ = MoveFilesToOutputDiscarded(_FileName, _MetaFileName);
}
}
else
{
Logger.Trace("DISCARDED: INPUT Error");
_return = false;
_ = MoveFilesToInputDiscarded(_FileName, _MetaFileName);
}
}
catch (Exception ex)
{
_return = false;
Logger.Error(ex, "CheckAndCreateMaskedFile");
Logger.Trace("DISCARDED: Output Error");
_ = MoveFilesToOutputDiscarded(_FileName, _MetaFileName);
}
Logger.Trace("ENDED: CheckAndCreateMaskedFile Method");
return(_return);
}
