/// <summary>
/// <para>
/// Archives the <paramref name="fileName"/> using a date and sequence style numbering. Archives will be stamped
/// with the prior period (Year, Month, Day) datetime. The most recent archive has the highest number (in
/// combination with the date).
/// </para>
/// <para>
/// When the number of archive files exceed <see cref="P:MaxArchiveFiles"/> the obsolete archives are deleted.
/// </para>
/// </summary>
/// <param name="fileName">File name to be archived.</param>
/// <param name="pattern">File name template which contains the numeric pattern to be replaced.</param>
/// <param name="logEvent">Log event that the <see cref="FileTarget"/> instance is currently processing.</param>
private void ArchiveByDateAndSequence(string fileName, string pattern, LogEventInfo logEvent)
{
string baseNamePattern = Path.GetFileName(pattern);
if (string.IsNullOrEmpty(baseNamePattern))
{
return;
}
FileNameTemplate fileTemplate = new FileNameTemplate(baseNamePattern);
string fileNameMask = fileTemplate.ReplacePattern("*");
string dateFormat = GetArchiveDateFormatString(this.ArchiveDateFormat);
string dirName = Path.GetDirectoryName(Path.GetFullPath(pattern));
if (string.IsNullOrEmpty(dirName))
{
return;
}
int minSequenceLength = fileTemplate.EndAt - fileTemplate.BeginAt - 2;
int nextSequenceNumber;
DateTime archiveDate = GetArchiveDate(fileName, logEvent);
List<string> archiveFileNames;
if (Directory.Exists(dirName))
{
List<DateAndSequenceArchive> archives = FindDateAndSequenceArchives(dirName, fileName, fileNameMask, minSequenceLength, dateFormat, fileTemplate)
.ToList();
// Find out the next sequence number among existing archives having the same date part as the current date.
int? lastSequenceNumber = archives
.Where(a => a.HasSameFormattedDate(archiveDate))
.Max(a => (int?)a.Sequence);
nextSequenceNumber = (int)(lastSequenceNumber != null ? lastSequenceNumber + 1 : 0);
archiveFileNames = archives
.OrderBy(a => a.Date)
.ThenBy(a => a.Sequence)
.Select(a => a.FileName)
.ToList();
}
else
{
Directory.CreateDirectory(dirName);
nextSequenceNumber = 0;
archiveFileNames = new List<string>();
}
string paddedSequence = nextSequenceNumber.ToString().PadLeft(minSequenceLength, '0');
string archiveFileNameWithoutPath = fileNameMask.Replace("*",
string.Format("{0}.{1}", archiveDate.ToString(dateFormat), paddedSequence));
string archiveFileName = Path.Combine(dirName, archiveFileNameWithoutPath);
RollArchiveForward(fileName, archiveFileName, allowCompress: true);
archiveFileNames.Add(archiveFileName);
EnsureArchiveCount(archiveFileNames);
}
protected override DateAndSequenceArchive GenerateArchiveFileInfo(FileInfo archiveFile, FileNameTemplate fileTemplate)
{
//Get the archive file name or empty string if it's null
string archiveFileNameWithoutPath = Path.GetFileName(archiveFile.FullName) ?? string.Empty;
if (!TryParseDateAndSequence(archiveFileNameWithoutPath, _archiveDateFormat, fileTemplate, out var date, out var sequence))
{
return(null);
}
date = DateTime.SpecifyKind(date, NLog.Time.TimeSource.Current.Time.Kind);
return(new DateAndSequenceArchive(archiveFile.FullName, date, _archiveDateFormat, sequence));
}
/// <summary>
/// Archives the <paramref name="fileName"/> using a sequence style numbering. The most recent archive has the
/// highest number. When the number of archive files exceed <see cref="P:MaxArchiveFiles"/> the obsolete
/// archives are deleted.
/// </summary>
/// <param name="fileName">File name to be archived.</param>
/// <param name="pattern">File name template which contains the numeric pattern to be replaced.</param>
private void ArchiveBySequence(string fileName, string pattern)
{
FileNameTemplate fileTemplate = new FileNameTemplate(Path.GetFileName(pattern));
int trailerLength = fileTemplate.Template.Length - fileTemplate.EndAt;
string fileNameMask = fileTemplate.ReplacePattern("*");
string dirName = Path.GetDirectoryName(Path.GetFullPath(pattern));
int nextNumber = -1;
int minNumber = -1;
var number2Name = new Dictionary<int, string>();
try
{
#if SILVERLIGHT && !WINDOWS_PHONE
foreach (string s in Directory.EnumerateFiles(dirName, fileNameMask))
#else
foreach (string s in Directory.GetFiles(dirName, fileNameMask))
#endif
{
string baseName = Path.GetFileName(s);
string number = baseName.Substring(fileTemplate.BeginAt, baseName.Length - trailerLength - fileTemplate.BeginAt);
int num;
try
{
num = Convert.ToInt32(number, CultureInfo.InvariantCulture);
}
catch (FormatException)
{
continue;
}
nextNumber = Math.Max(nextNumber, num);
minNumber = minNumber != -1 ? Math.Min(minNumber, num) : num;
number2Name[num] = s;
}
nextNumber++;
}
catch (DirectoryNotFoundException)
{
Directory.CreateDirectory(dirName);
nextNumber = 0;
}
if (minNumber != -1 && ShouldDeleteOldArchives())
{
int minNumberToKeep = nextNumber - this.MaxArchiveFiles + 1;
for (int i = minNumber; i < minNumberToKeep; ++i)
{
string s;
if (number2Name.TryGetValue(i, out s))
{
InternalLogger.Info("Deleting old archive {0}", s);
File.Delete(s);
}
}
}
string newFileName = ReplaceNumberPattern(pattern, nextNumber);
RollArchiveForward(fileName, newFileName, allowCompress: true);
}
protected override DateAndSequenceArchive GenerateArchiveFileInfo(FileInfo archiveFile, FileNameTemplate fileTemplate)
{
string baseName = Path.GetFileName(archiveFile.FullName) ?? "";
int trailerLength = fileTemplate.Template.Length - fileTemplate.EndAt;
string number = baseName.Substring(fileTemplate.BeginAt, baseName.Length - trailerLength - fileTemplate.BeginAt);
int num;
try
{
num = Convert.ToInt32(number, CultureInfo.InvariantCulture);
}
catch (FormatException)
{
return(null);
}
return(new DateAndSequenceArchive(archiveFile.FullName, DateTime.MinValue, string.Empty, num));
}
/// <summary>
/// Parse filename with date and sequence pattern
/// </summary>
/// <param name="archiveFileNameWithoutPath"></param>
/// <param name="dateFormat">dateformat for archive</param>
/// <param name="fileTemplate"></param>
/// <param name="date">the found pattern. When failed, then default</param>
/// <param name="sequence">the found pattern. When failed, then default</param>
/// <returns></returns>
private static bool TryParseDateAndSequence(string archiveFileNameWithoutPath, string dateFormat, FileNameTemplate fileTemplate, out DateTime date, out int sequence)
{
int trailerLength = fileTemplate.Template.Length - fileTemplate.EndAt;
int dateAndSequenceIndex = fileTemplate.BeginAt;
int dateAndSequenceLength = archiveFileNameWithoutPath.Length - trailerLength - dateAndSequenceIndex;
if (dateAndSequenceLength < 0)
{
date = default(DateTime);
sequence = 0;
return(false);
}
string dateAndSequence = archiveFileNameWithoutPath.Substring(dateAndSequenceIndex, dateAndSequenceLength);
int sequenceIndex = dateAndSequence.LastIndexOf('.') + 1;
string sequencePart = dateAndSequence.Substring(sequenceIndex);
if (!int.TryParse(sequencePart, NumberStyles.None, CultureInfo.CurrentCulture, out sequence))
{
date = default(DateTime);
return(false);
}
var dateAndSequenceLength2 = dateAndSequence.Length - sequencePart.Length - 1;
if (dateAndSequenceLength2 < 0)
{
date = default(DateTime);
return(false);
}
string datePart = dateAndSequence.Substring(0, dateAndSequenceLength2);
if (!DateTime.TryParseExact(datePart, dateFormat, CultureInfo.CurrentCulture, DateTimeStyles.None,
out date))
{
return(false);
}
InternalLogger.Trace("FileTarget: parsed date '{0}' from file-template '{1}'", datePart, fileTemplate?.Template);
return(true);
}
public override bool Equals(object o)
{
if (!(o is ConversionProfile))
{
return(false);
}
var v = o as ConversionProfile;
if (!AttachmentPage.Equals(v.AttachmentPage))
{
return(false);
}
if (!AutoSave.Equals(v.AutoSave))
{
return(false);
}
if (!BackgroundPage.Equals(v.BackgroundPage))
{
return(false);
}
if (!CoverPage.Equals(v.CoverPage))
{
return(false);
}
if (!EmailClient.Equals(v.EmailClient))
{
return(false);
}
if (!EmailSmtp.Equals(v.EmailSmtp))
{
return(false);
}
if (!Ftp.Equals(v.Ftp))
{
return(false);
}
if (!Ghostscript.Equals(v.Ghostscript))
{
return(false);
}
if (!JpegSettings.Equals(v.JpegSettings))
{
return(false);
}
if (!PdfSettings.Equals(v.PdfSettings))
{
return(false);
}
if (!PngSettings.Equals(v.PngSettings))
{
return(false);
}
if (!Printing.Equals(v.Printing))
{
return(false);
}
if (!Properties.Equals(v.Properties))
{
return(false);
}
if (!SaveDialog.Equals(v.SaveDialog))
{
return(false);
}
if (!Scripting.Equals(v.Scripting))
{
return(false);
}
if (!Stamping.Equals(v.Stamping))
{
return(false);
}
if (!TiffSettings.Equals(v.TiffSettings))
{
return(false);
}
if (!AuthorTemplate.Equals(v.AuthorTemplate))
{
return(false);
}
if (!FileNameTemplate.Equals(v.FileNameTemplate))
{
return(false);
}
if (!Guid.Equals(v.Guid))
{
return(false);
}
if (!Name.Equals(v.Name))
{
return(false);
}
if (!OpenViewer.Equals(v.OpenViewer))
{
return(false);
}
if (!OutputFormat.Equals(v.OutputFormat))
{
return(false);
}
if (!ShowProgress.Equals(v.ShowProgress))
{
return(false);
}
if (!SkipPrintDialog.Equals(v.SkipPrintDialog))
{
return(false);
}
if (!TitleTemplate.Equals(v.TitleTemplate))
{
return(false);
}
return(true);
}
protected override DateAndSequenceArchive GenerateArchiveFileInfo(FileInfo archiveFile, FileNameTemplate fileTemplate)
{
if (fileTemplate?.EndAt > 0)
{
string filename = archiveFile.Name;
int templatePos = 0;
for (int i = 0; i < filename.Length; ++i)
{
char fileNameChar = filename[i];
if (templatePos >= fileTemplate.Template.Length)
{
if (char.IsLetter(fileNameChar))
{
return(null); // reached end of template, but still letters
}
break;
}
char templateChar;
if (templatePos < fileTemplate.EndAt && i >= fileTemplate.BeginAt)
{
// Inside wildcard, skip validation of non-letters
if (char.IsLetter(fileNameChar))
{
templatePos = fileTemplate.EndAt;
do
{
if (templatePos >= fileTemplate.Template.Length)
{
return(null); // reached end of template, but still letters
}
templateChar = fileTemplate.Template[templatePos];
++templatePos;
} while (!char.IsLetter(templateChar));
}
else
{
continue;
}
}
else
{
templateChar = fileTemplate.Template[templatePos];
++templatePos;
}
if (fileNameChar == templateChar || char.ToLowerInvariant(fileNameChar) == char.ToLowerInvariant(templateChar))
{
continue;
}
if (templateChar == '*' && !char.IsLetter(fileNameChar))
{
break; // Reached archive-seq-no, lets call it a day
}
return(null); // filename is not matching file-template
}
}
int sequenceNumber = ExtractArchiveNumberFromFileName(archiveFile.FullName);
var creationTimeUtc = archiveFile.LookupValidFileCreationTimeUtc();
var creationTime = creationTimeUtc > DateTime.MinValue ? NLog.Time.TimeSource.Current.FromSystemTime(creationTimeUtc) : DateTime.MinValue;
return(new DateAndSequenceArchive(archiveFile.FullName, creationTime, _archiveDateFormat, sequenceNumber > 0 ? sequenceNumber : 0));
}
protected override DateAndSequenceArchive GenerateArchiveFileInfo(FileInfo archiveFile, FileNameTemplate fileTemplate)
{
string archiveFileName = Path.GetFileName(archiveFile.FullName) ?? "";
string fileNameMask = fileTemplate.ReplacePattern("*");
int lastIndexOfStar = fileNameMask.LastIndexOf('*');
if (lastIndexOfStar + _archiveDateFormat.Length <= archiveFileName.Length)
{
string datePart = archiveFileName.Substring(lastIndexOfStar, _archiveDateFormat.Length);
DateTime fileDate;
if (DateTime.TryParseExact(datePart, _archiveDateFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out fileDate))
{
fileDate = DateTime.SpecifyKind(fileDate, NLog.Time.TimeSource.Current.Time.Kind);
return(new DateAndSequenceArchive(archiveFile.FullName, fileDate, _archiveDateFormat, -1));
}
}
return(null);
}
protected override DateAndSequenceArchive GenerateArchiveFileInfo(FileInfo archiveFile, FileNameTemplate fileTemplate)
{
//Get the archive file name or empty string if it's null
string archiveFileNameWithoutPath = Path.GetFileName(archiveFile.FullName) ?? "";
DateTime date;
int sequence;
if (
!TryParseDateAndSequence(archiveFileNameWithoutPath, _archiveDateFormat, fileTemplate, out date,
out sequence))
{
return(null);
}
return(new DateAndSequenceArchive(archiveFile.FullName, date, _archiveDateFormat, sequence));
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("[AttachmentPage]");
sb.AppendLine(AttachmentPage.ToString());
sb.AppendLine("[AutoSave]");
sb.AppendLine(AutoSave.ToString());
sb.AppendLine("[BackgroundPage]");
sb.AppendLine(BackgroundPage.ToString());
sb.AppendLine("[CoverPage]");
sb.AppendLine(CoverPage.ToString());
sb.AppendLine("[DropboxSettings]");
sb.AppendLine(DropboxSettings.ToString());
sb.AppendLine("[EmailClientSettings]");
sb.AppendLine(EmailClientSettings.ToString());
sb.AppendLine("[EmailSmtpSettings]");
sb.AppendLine(EmailSmtpSettings.ToString());
sb.AppendLine("[Ftp]");
sb.AppendLine(Ftp.ToString());
sb.AppendLine("[Ghostscript]");
sb.AppendLine(Ghostscript.ToString());
sb.AppendLine("[HttpSettings]");
sb.AppendLine(HttpSettings.ToString());
sb.AppendLine("[JpegSettings]");
sb.AppendLine(JpegSettings.ToString());
sb.AppendLine("[PdfSettings]");
sb.AppendLine(PdfSettings.ToString());
sb.AppendLine("[PngSettings]");
sb.AppendLine(PngSettings.ToString());
sb.AppendLine("[Printing]");
sb.AppendLine(Printing.ToString());
sb.AppendLine("[Properties]");
sb.AppendLine(Properties.ToString());
sb.AppendLine("[Scripting]");
sb.AppendLine(Scripting.ToString());
sb.AppendLine("[Stamping]");
sb.AppendLine(Stamping.ToString());
sb.AppendLine("[TextSettings]");
sb.AppendLine(TextSettings.ToString());
sb.AppendLine("[TiffSettings]");
sb.AppendLine(TiffSettings.ToString());
sb.AppendLine("[UserTokens]");
sb.AppendLine(UserTokens.ToString());
sb.AppendLine("AuthorTemplate=" + AuthorTemplate.ToString());
sb.AppendLine("FileNameTemplate=" + FileNameTemplate.ToString());
sb.AppendLine("Guid=" + Guid.ToString());
sb.AppendLine("KeywordTemplate=" + KeywordTemplate.ToString());
sb.AppendLine("Name=" + Name.ToString());
sb.AppendLine("OpenViewer=" + OpenViewer.ToString());
sb.AppendLine("OpenWithPdfArchitect=" + OpenWithPdfArchitect.ToString());
sb.AppendLine("OutputFormat=" + OutputFormat.ToString());
sb.AppendLine("ShowAllNotifications=" + ShowAllNotifications.ToString());
sb.AppendLine("ShowOnlyErrorNotifications=" + ShowOnlyErrorNotifications.ToString());
sb.AppendLine("ShowProgress=" + ShowProgress.ToString());
sb.AppendLine("ShowQuickActions=" + ShowQuickActions.ToString());
sb.AppendLine("SkipPrintDialog=" + SkipPrintDialog.ToString());
sb.AppendLine("SubjectTemplate=" + SubjectTemplate.ToString());
sb.AppendLine("TargetDirectory=" + TargetDirectory.ToString());
sb.AppendLine("TitleTemplate=" + TitleTemplate.ToString());
return(sb.ToString());
}
protected override DateAndSequenceArchive GenerateArchiveFileInfo(FileInfo archiveFile, FileNameTemplate fileTemplate)
{
int sequenceNumber = ExtractArchiveNumberFromFileName(archiveFile.FullName);
var creationTimeUtc = FileCharacteristicsHelper.ValidateFileCreationTime(archiveFile, (f) => f.GetCreationTimeUtc(), (f) => f.GetLastWriteTimeUtc()).Value;
return(new DateAndSequenceArchive(archiveFile.FullName, creationTimeUtc, string.Empty, sequenceNumber > 0 ? sequenceNumber : 0));
}
public override bool Equals(object o)
{
if (!(o is ConversionProfile))
{
return(false);
}
ConversionProfile v = o as ConversionProfile;
if (!AttachmentPage.Equals(v.AttachmentPage))
{
return(false);
}
if (!AutoSave.Equals(v.AutoSave))
{
return(false);
}
if (!BackgroundPage.Equals(v.BackgroundPage))
{
return(false);
}
if (!CoverPage.Equals(v.CoverPage))
{
return(false);
}
if (!DropboxSettings.Equals(v.DropboxSettings))
{
return(false);
}
if (!EmailClientSettings.Equals(v.EmailClientSettings))
{
return(false);
}
if (!EmailSmtpSettings.Equals(v.EmailSmtpSettings))
{
return(false);
}
if (!Ftp.Equals(v.Ftp))
{
return(false);
}
if (!Ghostscript.Equals(v.Ghostscript))
{
return(false);
}
if (!HttpSettings.Equals(v.HttpSettings))
{
return(false);
}
if (!JpegSettings.Equals(v.JpegSettings))
{
return(false);
}
if (!PdfSettings.Equals(v.PdfSettings))
{
return(false);
}
if (!PngSettings.Equals(v.PngSettings))
{
return(false);
}
if (!Printing.Equals(v.Printing))
{
return(false);
}
if (!Properties.Equals(v.Properties))
{
return(false);
}
if (!Scripting.Equals(v.Scripting))
{
return(false);
}
if (!Stamping.Equals(v.Stamping))
{
return(false);
}
if (!TextSettings.Equals(v.TextSettings))
{
return(false);
}
if (!TiffSettings.Equals(v.TiffSettings))
{
return(false);
}
if (!UserTokens.Equals(v.UserTokens))
{
return(false);
}
if (!AuthorTemplate.Equals(v.AuthorTemplate))
{
return(false);
}
if (!FileNameTemplate.Equals(v.FileNameTemplate))
{
return(false);
}
if (!Guid.Equals(v.Guid))
{
return(false);
}
if (!KeywordTemplate.Equals(v.KeywordTemplate))
{
return(false);
}
if (!Name.Equals(v.Name))
{
return(false);
}
if (!OpenViewer.Equals(v.OpenViewer))
{
return(false);
}
if (!OpenWithPdfArchitect.Equals(v.OpenWithPdfArchitect))
{
return(false);
}
if (!OutputFormat.Equals(v.OutputFormat))
{
return(false);
}
if (!ShowAllNotifications.Equals(v.ShowAllNotifications))
{
return(false);
}
if (!ShowOnlyErrorNotifications.Equals(v.ShowOnlyErrorNotifications))
{
return(false);
}
if (!ShowProgress.Equals(v.ShowProgress))
{
return(false);
}
if (!ShowQuickActions.Equals(v.ShowQuickActions))
{
return(false);
}
if (!SkipPrintDialog.Equals(v.SkipPrintDialog))
{
return(false);
}
if (!SubjectTemplate.Equals(v.SubjectTemplate))
{
return(false);
}
if (!TargetDirectory.Equals(v.TargetDirectory))
{
return(false);
}
if (!TitleTemplate.Equals(v.TitleTemplate))
{
return(false);
}
return(true);
}
protected abstract DateAndSequenceArchive GenerateArchiveFileInfo(FileInfo archiveFile, FileNameTemplate fileTemplate);
async Task OnExecuteAsync()
{
OutputPath = Path.GetFullPath(OutputPath);
if (File.Exists(OutputPath))
{
throw new Exception("O caminho onde os arquivos aleatórios serão gravados precisa ser um diretório");
}
if (string.IsNullOrWhiteSpace(FileNameTemplate))
{
throw new Exception("Você precisa informar um template válido para nome do arquivo");
}
FileNameTemplate = FileNameTemplate.Replace("{n}", "{0}");
if (!Directory.Exists(OutputPath))
{
Directory.CreateDirectory(OutputPath);
}
if (FileCount < 1)
{
throw new Exception("Você precisa informar pelo menos 1 arquivo para gerar");
}
if (string.IsNullOrWhiteSpace(MinFileSize))
{
throw new Exception("Você precisa informar o parâmetro --min-file-size");
}
if (string.IsNullOrWhiteSpace(MaxFileSize))
{
throw new Exception("Você precisa informar o parâmetro --max-file-size");
}
var minFileSize = ParseHumanSize(MinFileSize);
var maxFileSize = ParseHumanSize(MaxFileSize);
if (minFileSize < 1)
{
throw new Exception("O tamanho mínimo do arquivo aleatório precisa ser de pelo menos 1 byte");
}
if (maxFileSize < minFileSize)
{
throw new Exception("O tamanho máximo do arquivo aleatório precisa ser pelo menos o mesmo tamanho mínimo");
}
var currentFile = 1;
var fileCountCharactersSize = FileCount.ToString().Length;
var rnd = new Random();
while (currentFile <= FileCount)
{
var fileNumber = (currentFile++).ToString().PadLeft(fileCountCharactersSize, '0');
var fileName = string.Format(FileNameTemplate, fileNumber);
var filePath = Path.Combine(OutputPath, fileName);
var fileSize = rnd.Next(minFileSize, maxFileSize);
Console.WriteLine("Gerando arquivo {0} com {1}...", fileName, FormatHumanSize(fileSize));
var fileBytes = new Byte[fileSize];
rnd.NextBytes(fileBytes);
using (var stream = new FileStream(filePath, FileMode.Create))
await stream.WriteAsync(fileBytes, 0, fileSize);
}
}
/// <summary>
/// Searches a given directory for archives that comply with the current archive pattern.
/// </summary>
/// <returns>An enumeration of archive infos, ordered by their file creation date.</returns>
private IEnumerable<DateAndSequenceArchive> FindDateAndSequenceArchives(string dirName, string logFileName,
string fileNameMask,
int minSequenceLength, string dateFormat, FileNameTemplate fileTemplate)
{
var directoryInfo = new DirectoryInfo(dirName);
int archiveFileNameMinLength = fileNameMask.Length + minSequenceLength;
var archiveFileNames = GetFiles(directoryInfo, fileNameMask)
.Where(n => n.Name.Length >= archiveFileNameMinLength)
.OrderBy(n => n.CreationTime)
.Select(n => n.FullName);
foreach (string archiveFileName in archiveFileNames)
{
//Get the archive file name or empty string if it's null
string archiveFileNameWithoutPath = Path.GetFileName(archiveFileName) ?? "";
DateTime date;
int sequence;
if (
!TryParseDateAndSequence(archiveFileNameWithoutPath, dateFormat, fileTemplate, out date,
out sequence))
{
continue;
}
//It's possible that the log file itself has a name that will match the archive file mask.
if (string.IsNullOrEmpty(archiveFileNameWithoutPath) ||
archiveFileNameWithoutPath.Equals(Path.GetFileName(logFileName)))
{
continue;
}
yield return new DateAndSequenceArchive(archiveFileName, date, dateFormat, sequence);
}
}
protected override DateAndSequenceArchive GenerateArchiveFileInfo(FileInfo archiveFile, FileNameTemplate fileTemplate)
{
if (fileTemplate?.EndAt > 0)
{
string filename = archiveFile.Name;
int templatePos = 0;
for (int i = 0; i < filename.Length; ++i)
{
char fileNameChar = filename[i];
if (templatePos >= fileTemplate.Template.Length)
{
if (char.IsLetter(fileNameChar))
{
return(null); // reached end of template, but still letters
}
break;
}
char templateChar;
if (templatePos < fileTemplate.EndAt && i >= fileTemplate.BeginAt)
{
// Inside wildcard, skip validation of non-letters
if (char.IsLetter(fileNameChar))
{
templatePos = fileTemplate.EndAt;
do
{
if (templatePos >= fileTemplate.Template.Length)
{
return(null); // reached end of template, but still letters
}
templateChar = fileTemplate.Template[templatePos];
++templatePos;
} while (!char.IsLetter(templateChar));
}
else
{
continue;
}
}
else
{
templateChar = fileTemplate.Template[templatePos];
++templatePos;
}
if (fileNameChar == templateChar || char.ToLowerInvariant(fileNameChar) == char.ToLowerInvariant(templateChar))
{
continue;
}
if (templateChar == '*' && !char.IsLetter(fileNameChar))
{
break; // Reached archive-seq-no, lets call it a day
}
return(null); // filename is not matching file-template
}
}
int sequenceNumber = ExtractArchiveNumberFromFileName(archiveFile.FullName);
InternalLogger.Trace("FileTarget: extracted sequenceNumber: {0} from file '{1}'", sequenceNumber, archiveFile.FullName);
var creationTimeUtc = FileCharacteristicsHelper.ValidateFileCreationTime(archiveFile, (f) => f.GetCreationTimeUtc(), (f) => f.GetLastWriteTimeUtc()).Value;
return(new DateAndSequenceArchive(archiveFile.FullName, creationTimeUtc, string.Empty, sequenceNumber > 0 ? sequenceNumber : 0));
}
private static bool TryParseDateAndSequence(string archiveFileNameWithoutPath, string dateFormat, FileNameTemplate fileTemplate, out DateTime date, out int sequence)
{
int trailerLength = fileTemplate.Template.Length - fileTemplate.EndAt;
int dateAndSequenceIndex = fileTemplate.BeginAt;
int dateAndSequenceLength = archiveFileNameWithoutPath.Length - trailerLength - dateAndSequenceIndex;
string dateAndSequence = archiveFileNameWithoutPath.Substring(dateAndSequenceIndex, dateAndSequenceLength);
int sequenceIndex = dateAndSequence.LastIndexOf('.') + 1;
string sequencePart = dateAndSequence.Substring(sequenceIndex);
if (!Int32.TryParse(sequencePart, NumberStyles.None, CultureInfo.CurrentCulture, out sequence))
{
date = default(DateTime);
return false;
}
string datePart = dateAndSequence.Substring(0, dateAndSequence.Length - sequencePart.Length - 1);
if (!DateTime.TryParseExact(datePart, dateFormat, CultureInfo.CurrentCulture, DateTimeStyles.None,
out date))
{
return false;
}
return true;
}
protected override DateAndSequenceArchive GenerateArchiveFileInfo(FileInfo archiveFile, FileNameTemplate fileTemplate)
{
string baseName = Path.GetFileName(archiveFile.FullName) ?? "";
int trailerLength = fileTemplate.Template.Length - fileTemplate.EndAt;
string number = baseName.Substring(fileTemplate.BeginAt, baseName.Length - trailerLength - fileTemplate.BeginAt);
int num;
try
{
num = Convert.ToInt32(number, CultureInfo.InvariantCulture);
}
catch (FormatException)
{
return(null);
}
var creationTimeUtc = archiveFile.LookupValidFileCreationTimeUtc();
var creationTime = creationTimeUtc > DateTime.MinValue ? NLog.Time.TimeSource.Current.FromSystemTime(creationTimeUtc) : DateTime.MinValue;
return(new DateAndSequenceArchive(archiveFile.FullName, creationTime, string.Empty, num));
}
