614 lines
30 KiB
C#
614 lines
30 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Globalization;
|
|
using System.Threading;
|
|
using System.Windows.Media.Imaging;
|
|
using Microsoft.Graph;
|
|
using Directory = System.IO.Directory;
|
|
using File = System.IO.File;
|
|
using FileSystemInfo = System.IO.FileSystemInfo;
|
|
|
|
namespace Image_Sorter
|
|
{
|
|
class Program
|
|
{
|
|
static void Main(string[] args)
|
|
{
|
|
Worker(args);
|
|
Console.ReadLine();
|
|
}
|
|
public const string MsaClientId = "";
|
|
//public const string MsaReturnUrl = "urn:ietf:wg:oauth:2.0:oob";
|
|
private static GraphServiceClient graphClient { get; set; }
|
|
|
|
|
|
// Threading synchronisation
|
|
static volatile SemaphoreSlim folderCreateMarshall = new(1);
|
|
// Store created folders in a lookup
|
|
static volatile Dictionary<string, DriveItem> CreatedFolderItems = new();
|
|
|
|
static readonly List<string> DNGTypes = new List<string> { "raw", "cr2", "dng" };
|
|
static readonly List<string> ImagePrefixes = new List<string> { "", "Screenshot_", "VID" };
|
|
static async void Worker(string[] args)
|
|
{
|
|
Console.WriteLine("Image Sorter {0} (C) 2021 Brychan Dempsey");
|
|
Console.WriteLine("Moves images from the source folder and arranges them by date (from metadata) in the destination folder");
|
|
string SourceDir = "";
|
|
string DestinationDir = "";
|
|
|
|
string OneDriveSourceDir = "";
|
|
string OneDriveDestinationDir = "";
|
|
|
|
DriveItem OneDriveSourceItem = null;
|
|
DriveItem OneDriveDestItem = null;
|
|
|
|
bool copyFiles = false;
|
|
if (args.Length > 0 && args[0].ToLower() == "\\s")
|
|
{
|
|
int sourceDirSpecified = Array.IndexOf(args, "\\d");
|
|
if (sourceDirSpecified != -1)
|
|
{
|
|
if (Directory.Exists(args[sourceDirSpecified + 1]))
|
|
{
|
|
SourceDir = args[sourceDirSpecified + 1];
|
|
}
|
|
}
|
|
int targetDirSpecified = Array.IndexOf(args, "\\t");
|
|
if (targetDirSpecified != -1)
|
|
{
|
|
if (Directory.Exists(args[targetDirSpecified + 1]))
|
|
{
|
|
DestinationDir = args[targetDirSpecified + 1];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DestinationDir = SourceDir;
|
|
}
|
|
|
|
if (args.Contains("\\c"))
|
|
{
|
|
copyFiles = true;
|
|
}
|
|
// Redirect all console writes
|
|
Console.SetOut(new StringWriter());
|
|
}
|
|
else if (args.Length > 0 && (args[0] == "\\?" || args[0].ToLower() == "\\h"))
|
|
{
|
|
Console.WriteLine("Image Sorter");
|
|
Console.WriteLine("Can be run in silent mode using the argument: \\s");
|
|
Console.WriteLine("Additional flags: \\d - Source Directory (Usage: \\s \\d <soruce directory>");
|
|
Console.WriteLine("\t\t\\t - Target Directory (Usage: \\s \\t <target directory>");
|
|
Console.WriteLine("\t\t\\c - Copy files if this flag is specified");
|
|
Console.WriteLine("Usage Example:");
|
|
Console.WriteLine("\\s \\d \"C:\\Camera Files\\Images\" \\t \"C:\\Camera Files\\Sorted\\\"");
|
|
Console.WriteLine("\nIf the destination directory is not specified, it will default to the source directory");
|
|
Console.ReadLine();
|
|
Environment.Exit(0);
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine("Enter the source directory:");
|
|
SourceDir = Console.ReadLine();
|
|
Console.WriteLine("Enter the destionation directory:");
|
|
DestinationDir = Console.ReadLine();
|
|
Console.WriteLine("Enter \'y\' to perform a copy instead of move");
|
|
string tRead = Console.ReadLine();
|
|
|
|
if (tRead.Trim().ToLower().Equals("y"))
|
|
{
|
|
copyFiles = true;
|
|
}
|
|
|
|
}
|
|
Console.WriteLine("Scanning the source directory...");
|
|
List<string> SourceFiles = GetFiles(SourceDir);
|
|
Console.WriteLine("Found {0} files", SourceFiles.Count);
|
|
string OneDriveLoc = "";
|
|
//Drive contextDrive = null;
|
|
if (SourceDir.ToLower().Contains("onedrive"))
|
|
{
|
|
OneDriveLoc = SourceDir[0..(SourceDir.ToLower().IndexOf("onedrive\\") + "onedrive\\".Length)];
|
|
}
|
|
|
|
bool OneDriveLogin = false;
|
|
if ((File.GetAttributes(SourceDir).HasFlag(FileAttributes.Offline) || SourceDir.Contains("OneDrive") || SourceFiles.Any((x) => File.GetAttributes(SourceDir + x).HasFlag(FileAttributes.Offline))) && DestinationDir.Contains(OneDriveLoc))
|
|
{
|
|
Console.WriteLine("Source and target folders seem to be inside a OneDrive folder.\nWould you like to sign-in to OneDrive and manage files online?");
|
|
string tRead = Console.ReadLine();
|
|
if (tRead.Trim().ToLower().Equals("y"))
|
|
{
|
|
// Do a OneDrive login
|
|
if (SourceDir.ToLower().Split("onedrive").Length > 2)
|
|
{
|
|
throw new ArgumentException("Cannot identify OneDrive source folder");
|
|
}
|
|
try
|
|
{
|
|
graphClient = AuthenticationHelper.GetAuthenticatedClient();
|
|
// The user isn't yet logged in - formulate a request:
|
|
User me = await graphClient.Me.Request().GetAsync();
|
|
//contextDrive = await graphClient.Drives.Request().GetAsync();
|
|
Console.WriteLine("Authentication of {0} successful. Welcome {1}.", AuthenticationHelper.UserAccount.Username, me.DisplayName);
|
|
OneDriveLogin = true;
|
|
OneDriveSourceDir = SourceDir.Replace(OneDriveLoc, "").Replace('\\', '/');
|
|
OneDriveDestinationDir = DestinationDir.Replace(OneDriveLoc, "").Replace('\\', '/');
|
|
if (!OneDriveSourceDir.StartsWith('/'))
|
|
{
|
|
OneDriveSourceDir = '/' + OneDriveSourceDir;
|
|
}
|
|
if (!OneDriveDestinationDir.StartsWith('/'))
|
|
{
|
|
OneDriveDestinationDir = '/' + OneDriveDestinationDir;
|
|
}
|
|
// Finally, evaluate the base source and destination folders
|
|
OneDriveDestItem = await graphClient.Drive.Root.ItemWithPath(OneDriveDestinationDir).Request().GetAsync();
|
|
OneDriveSourceItem = await graphClient.Drive.Root.ItemWithPath(OneDriveSourceDir).Request().GetAsync();
|
|
}
|
|
catch (ServiceException exception)
|
|
{
|
|
Console.WriteLine(exception);
|
|
}
|
|
|
|
}
|
|
}
|
|
// Check if the folder is a OneDrive folder
|
|
// Do Login if not already complete
|
|
|
|
int processedCount = 0;
|
|
object countLock = new();
|
|
|
|
object folderLock = new();
|
|
|
|
|
|
Task updateFilesTask = new(() =>
|
|
{
|
|
_ = Parallel.ForEach(SourceFiles, async (filepath) =>
|
|
{
|
|
uint fab = (uint)File.GetAttributes(SourceDir + filepath);
|
|
// It seems that FileAttributes.Offline is no longer used to store on-demand OneDrive file status.
|
|
// One undefined flag - 1048576 - is set
|
|
// As well as defined - 4194304 - FILE_ATTRIBUTE_RECALL_ON_DATA_ACCESS
|
|
// We will check initially for the presense of both
|
|
bool fileState = ((uint)fab & 1048576) == 1048576 && (fab & 4194304) == 4194304;
|
|
if (OneDriveLogin && fileState)
|
|
{
|
|
|
|
// File is online-only, process via OneDrive API
|
|
DriveItem file = null;
|
|
DriveItem newFolder = null;
|
|
DriveItem subFolder = null;
|
|
try
|
|
{
|
|
file = await graphClient.Drive.Root.ItemWithPath(OneDriveSourceDir + filepath.Replace('\\', '/')).Request().GetAsync();
|
|
}
|
|
catch (ServiceException ex)
|
|
{
|
|
Console.WriteLine(ex);
|
|
}
|
|
|
|
// Folder creation will cause a race condition (which modifies the base object),
|
|
// Need to intelligently handle this; threads that are simultaneously trying to create the same folder
|
|
// must wait; if the folder exists, we don't need to create it.
|
|
|
|
// Therefore, a semaphore must be used to determine the current state of access
|
|
|
|
// To handle this smartly, we create a boolean that suggests if the folder is being created (Marshalled by a semaphore)
|
|
// The first thread to reach it will set it to true, then check if it exists asynchronously
|
|
DateTime fileTime = DateTime.MinValue;
|
|
if (file.Photo.TakenDateTime != null)
|
|
{
|
|
DateTimeOffset dateTimeOffset = (DateTimeOffset)file.Photo.TakenDateTime;
|
|
fileTime = dateTimeOffset.LocalDateTime;
|
|
}
|
|
else
|
|
{
|
|
fileTime = file.FileSystemInfo.CreatedDateTime < file.FileSystemInfo.LastModifiedDateTime ? file.FileSystemInfo.CreatedDateTime.Value.LocalDateTime : file.FileSystemInfo.LastModifiedDateTime.Value.LocalDateTime;
|
|
}
|
|
|
|
|
|
if (fileTime != DateTime.MinValue)
|
|
{
|
|
// Get the destination folder. If
|
|
if (folderCreateMarshall.CurrentCount > 0 && CreatedFolderItems.ContainsKey(fileTime.Year.ToString()))
|
|
{
|
|
newFolder = CreatedFolderItems[fileTime.Year.ToString()];
|
|
}
|
|
else
|
|
{
|
|
// Create a folder object and wait
|
|
|
|
DriveItem tempNewFolder = new()
|
|
{
|
|
Name = fileTime.Year.ToString(),
|
|
Folder = new Folder(),
|
|
AdditionalData = new Dictionary<string, object>
|
|
{
|
|
{ "@microsoft.graph.conflictBehavior", "fail" }
|
|
}
|
|
};
|
|
// Wait for our turn to create the object
|
|
await folderCreateMarshall.WaitAsync();
|
|
try
|
|
{
|
|
// Check the folder wasn't surprise created
|
|
if (CreatedFolderItems.ContainsKey(fileTime.Year.ToString()))
|
|
{
|
|
newFolder = CreatedFolderItems[fileTime.Year.ToString()];
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine("Creating Folder");
|
|
// Folder doesn't exist or wasn't added; create and add
|
|
newFolder = await graphClient.Drive.Root.ItemWithPath(OneDriveDestinationDir)
|
|
.Children.Request().AddAsync(tempNewFolder);
|
|
CreatedFolderItems.Add(fileTime.Year.ToString(), newFolder);
|
|
}
|
|
|
|
}
|
|
catch (ServiceException ex)
|
|
{
|
|
// TODO: Handle the existing item
|
|
if (ex.StatusCode == System.Net.HttpStatusCode.Conflict)
|
|
{
|
|
try
|
|
{
|
|
newFolder = await graphClient.Drive.Root.ItemWithPath(OneDriveDestinationDir + "/" + fileTime.Year.ToString()).Request().GetAsync();
|
|
CreatedFolderItems.Add(fileTime.Year.ToString(), newFolder);
|
|
}
|
|
catch (ServiceException exNF)
|
|
{
|
|
Console.WriteLine(exNF);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine(ex);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine(ex);
|
|
}
|
|
finally
|
|
{
|
|
folderCreateMarshall.Release();
|
|
}
|
|
}
|
|
|
|
if (folderCreateMarshall.CurrentCount > 0 && CreatedFolderItems.ContainsKey(fileTime.Year.ToString() + "/" + CultureInfo.CurrentCulture.DateTimeFormat.GetMonthName(fileTime.Month)))
|
|
{
|
|
subFolder = CreatedFolderItems[fileTime.Year.ToString() + "/" + CultureInfo.CurrentCulture.DateTimeFormat.GetMonthName(fileTime.Month)];
|
|
}
|
|
else
|
|
{
|
|
// Create a folder and wait
|
|
DriveItem tempNewFolder = new()
|
|
{
|
|
Name = CultureInfo.CurrentCulture.DateTimeFormat.GetMonthName(fileTime.Month),
|
|
Folder = new Folder(),
|
|
AdditionalData = new Dictionary<string, object>
|
|
{
|
|
{ "@microsoft.graph.conflictBehavior", "fail" }
|
|
}
|
|
};
|
|
await folderCreateMarshall.WaitAsync();
|
|
try
|
|
{
|
|
// Check the folder wasn't surprise created
|
|
if (CreatedFolderItems.ContainsKey(fileTime.Year.ToString() + "/" + CultureInfo.CurrentCulture.DateTimeFormat.GetMonthName(fileTime.Month)))
|
|
{
|
|
subFolder = CreatedFolderItems[fileTime.Year.ToString() + "/" + CultureInfo.CurrentCulture.DateTimeFormat.GetMonthName(fileTime.Month)];
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine("Creating Subfolder");
|
|
// Folder doesn't exist or wasn't added; create and add
|
|
subFolder = await graphClient.Drive.Root.ItemWithPath(OneDriveDestinationDir + "/" + fileTime.Year.ToString())
|
|
.Children.Request().AddAsync(tempNewFolder);
|
|
CreatedFolderItems.Add(fileTime.Year.ToString() + "/" + CultureInfo.CurrentCulture.DateTimeFormat.GetMonthName(fileTime.Month), subFolder);
|
|
}
|
|
|
|
}
|
|
catch (ServiceException ex)
|
|
{
|
|
if (ex.StatusCode == System.Net.HttpStatusCode.Conflict)
|
|
{
|
|
try
|
|
{
|
|
subFolder = await graphClient.Drive.Root.ItemWithPath(OneDriveDestinationDir + "/" + fileTime.Year.ToString() + "/" + CultureInfo.CurrentCulture.DateTimeFormat.GetMonthName(fileTime.Month)).Request().GetAsync();
|
|
CreatedFolderItems.Add(fileTime.Year.ToString() + "/" + CultureInfo.CurrentCulture.DateTimeFormat.GetMonthName(fileTime.Month), subFolder);
|
|
}
|
|
catch (ServiceException exNF)
|
|
{
|
|
Console.WriteLine(exNF);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine(ex);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
folderCreateMarshall.Release();
|
|
}
|
|
}
|
|
// Finally, get the resulting files
|
|
ItemReference parentReference = new()
|
|
{
|
|
Id = subFolder.Id
|
|
};
|
|
try
|
|
{
|
|
// Fail-fast, copy item first
|
|
if (await graphClient.Me.Drive.Items[file.Id].Copy(null, parentReference).Request().PostAsync() != file && !copyFiles)
|
|
{
|
|
// Only if the returned file is not a duplicate, and we aren't copying, shall we remove the old file
|
|
await graphClient.Drive.Items[file.Id].Request().DeleteAsync();
|
|
}
|
|
}
|
|
catch (ServiceException ex)
|
|
{
|
|
Console.WriteLine(ex);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string fileDestination = "";
|
|
DateTime photoDate = new();
|
|
bool hasMetadata = true;
|
|
using (FileStream fs = new(SourceDir + filepath, FileMode.Open, FileAccess.Read, FileShare.Read))
|
|
{
|
|
// If the file is online-only, allow a large amount of time to download
|
|
if (fileState)
|
|
{
|
|
fs.ReadTimeout = (int)TimeSpan.FromMinutes(60).TotalMilliseconds; // Allow about 60 minutes for a download; should be enough for even large concurrent downloads
|
|
}
|
|
bool ruleMatch = false;
|
|
Dictionary<string, string> imgMetadata = GetMetaData(fs);
|
|
if (imgMetadata.ContainsKey("date"))
|
|
{
|
|
photoDate = DateTime.Parse(imgMetadata["date"]);
|
|
ruleMatch = true;
|
|
}
|
|
// If the file is a negative, it may have a conjugate image file
|
|
else if (DNGTypes.Contains(Path.GetExtension(filepath).TrimStart('.')))
|
|
{
|
|
List<string> matches = SourceFiles.FindAll((x) => Path.GetFileNameWithoutExtension(x).Equals(Path.GetFileNameWithoutExtension(SourceDir + filepath)) && !Path.GetExtension(x).Equals(Path.GetExtension(SourceDir + filepath)));
|
|
if (matches.Count == 1)
|
|
{
|
|
using (FileStream tfs = new(matches[0], FileMode.Open, FileAccess.Read, FileShare.Read))
|
|
{
|
|
imgMetadata = GetMetaData(tfs);
|
|
}
|
|
if (imgMetadata.ContainsKey("date"))
|
|
{
|
|
photoDate = DateTime.Parse(imgMetadata["date"]);
|
|
Console.WriteLine(" Conjugate file found - " + Path.GetFileName(SourceDir + filepath));
|
|
ruleMatch = true;
|
|
}
|
|
}
|
|
}
|
|
// Try parsing a date by the rules set in ImagePrefixes, using the first if found
|
|
else if (ImagePrefixes.Exists((x) => TryParseDate(Path.GetFileNameWithoutExtension(SourceDir + filepath).TrimStart(x.ToCharArray()), out photoDate)))
|
|
{
|
|
Console.WriteLine(" Date successfully parsed from file: {0} - Parsed Date: {1} ", Path.GetFileName(SourceDir + filepath), photoDate.ToString("dd-MM-yyyy"));
|
|
ruleMatch = true;
|
|
}
|
|
// Failsafe to avoid implausable dates (Greater than system year + 10, < 1990)
|
|
if (ruleMatch && (photoDate.Year > DateTime.Now.Year + 10 || photoDate.Year < 1990))
|
|
{
|
|
ruleMatch = false;
|
|
}
|
|
// Finally, resort to the least of the file creation time && file modified time
|
|
if (!ruleMatch)
|
|
{
|
|
FileSystemInfo fileInfo = new FileInfo(SourceDir + filepath);
|
|
photoDate = fileInfo.CreationTime < fileInfo.LastWriteTime ? fileInfo.CreationTime : fileInfo.LastWriteTime;
|
|
}
|
|
}
|
|
fileDestination = "\\" + photoDate.Year;
|
|
fileDestination += "\\" + CultureInfo.CurrentCulture.DateTimeFormat.GetMonthName(photoDate.Month);
|
|
Directory.CreateDirectory(DestinationDir + fileDestination + "\\");
|
|
fileDestination += "\\" + filepath[filepath.LastIndexOf('\\')..];
|
|
if (copyFiles)
|
|
{
|
|
try
|
|
{
|
|
File.Copy(SourceDir + filepath, DestinationDir + fileDestination);
|
|
filepath = DestinationDir + fileDestination;
|
|
}
|
|
catch
|
|
{
|
|
Console.WriteLine("Failed to copy {0}", Path.GetFileName(SourceDir + filepath));
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
File.Move(SourceDir + filepath, DestinationDir + fileDestination);
|
|
filepath = DestinationDir + fileDestination;
|
|
}
|
|
catch
|
|
{
|
|
Console.WriteLine("Failed to move {0}", Path.GetFileName(SourceDir + filepath));
|
|
}
|
|
|
|
}
|
|
}
|
|
lock (countLock)
|
|
{
|
|
processedCount++;
|
|
}
|
|
});
|
|
});
|
|
int lastProcessed = 0;
|
|
updateFilesTask.Start();
|
|
bool eval = false;
|
|
while (!eval)
|
|
{
|
|
lock (countLock)
|
|
{
|
|
if (processedCount != lastProcessed)
|
|
{
|
|
Console.WriteLine("{0}/{1} processed.", processedCount, SourceFiles.Count);
|
|
lastProcessed = processedCount;
|
|
}
|
|
if (processedCount == SourceFiles.Count)
|
|
eval = true;
|
|
}
|
|
Thread.Sleep(10);
|
|
}
|
|
Console.ReadLine();
|
|
}
|
|
|
|
static Dictionary<string, string> GetMetaData(FileStream fileStream)
|
|
{
|
|
|
|
Dictionary<string, string> Metadata = new Dictionary<string, string>();
|
|
try
|
|
{
|
|
BitmapSource srcimg = BitmapFrame.Create(fileStream);
|
|
BitmapMetadata md = (BitmapMetadata)srcimg.Metadata;
|
|
string date = md.DateTaken;
|
|
if (!string.IsNullOrEmpty(date))
|
|
{
|
|
Metadata.Add("date", date);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
Console.WriteLine("Couldn't get metadata - {0}", fileStream.Name);
|
|
}
|
|
return Metadata;
|
|
}
|
|
|
|
|
|
static List<string> GetFiles(string SourceDirectory)
|
|
{
|
|
// Get the files, remove the source
|
|
// This gives us a source list with relative pathing. This allows OneDrive files to be easily incorporated
|
|
List<string> foundFiles = Directory.GetFiles(SourceDirectory, "*", SearchOption.TopDirectoryOnly).Select((s) => s.Replace(SourceDirectory, "")).ToList();
|
|
foreach (var subDirectory in Directory.GetDirectories(SourceDirectory))
|
|
{
|
|
foundFiles.AddRange(GetFiles(subDirectory));
|
|
}
|
|
return foundFiles;
|
|
}
|
|
|
|
static bool TryParseDate(string input, out DateTime dt)
|
|
{
|
|
// Attempt a base conversion first
|
|
|
|
// As datetime's built-in converter does not seem to be able to handle more complex strings,
|
|
// convert the to a usable format before attempting to convert a datetime
|
|
//int pos = ImagePrefixes.FindIndex(0, (x) => input.StartsWith(x));
|
|
//input = input.Replace(ImagePrefixes[pos], ""); // Remove the prefix
|
|
if (DateTime.TryParse(input, out dt))
|
|
return true;
|
|
StringBuilder converted = new StringBuilder();
|
|
string modified = input;
|
|
DateTime result = new DateTime();
|
|
// if we are in the format "ddddsddsdd" we can try to parse that date
|
|
if (isMatch(input))
|
|
{
|
|
int year = Convert.ToInt32(input.Substring(0, 4));
|
|
int month = Convert.ToInt32(input.Substring(5, 2));
|
|
int day = Convert.ToInt32(input.Substring(8, 2));
|
|
try
|
|
{
|
|
result = new DateTime(year, month, day);
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
// Else try the straight digit parsing, so ensure we have 8 contiguous digits to parse.
|
|
else if (isMatch(input, "dddddddd"))
|
|
{
|
|
int year = Convert.ToInt32(input.Substring(0, 4));
|
|
int month = Convert.ToInt32(input.Substring(4, 2));
|
|
int day = Convert.ToInt32(input.Substring(6, 2));
|
|
try
|
|
{
|
|
result = new DateTime(year, month, day);
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
if (result.Year <= DateTime.Now.Year + 10 && result.Year >= 1980)
|
|
{
|
|
// Falls within an acceptable date range, so try use it as a date
|
|
dt = result;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private static bool isNumeric(char c1)
|
|
{
|
|
if (c1 >= 48 && c1 < 58)
|
|
{
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
|
|
private static bool isSymbol(char c1)
|
|
{
|
|
if ((c1 >= 32 && c1 < 48) || (c1 >= 58 && c1 < 65) || (c1 >= 91 && c1 < 97) || (c1 >= 123 && c1 < 127))
|
|
{
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if the provided string matches the format specified
|
|
/// d = digit
|
|
/// a = alphanumeric
|
|
/// s = symbol
|
|
/// * = any
|
|
/// </summary>
|
|
/// <param name="source"></param>
|
|
/// <param name="format"></param>
|
|
/// <returns></returns>
|
|
private static bool isMatch(string source, string format = "ddddsddsdd")
|
|
{
|
|
if (source.Length < format.Length) return false;
|
|
bool state = true;
|
|
for (int i = 0; i < format.Length; i++)
|
|
{
|
|
if (format[i] == 'd')
|
|
{
|
|
if (!isNumeric(source[i]))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else if (format[i] == 's')
|
|
{
|
|
if (!isSymbol(source[i]))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return state;
|
|
}
|
|
|
|
}
|
|
}
|