/// <summary>
/// create handler to specific client - read from the client command, use the controller to
/// execute it and write to the client the answer.
/// </summary>
/// <param name="client">specific tcpClient to handle</param>
public void HandleClient(TcpClient client)
{
using (NetworkStream stream = client.GetStream())
using (BinaryReader reader = new BinaryReader(stream))
using (BinaryWriter writer = new BinaryWriter(stream))
{
while (true)
{
string newcommand = reader.ReadString();
CommandRecievedEventArgs command = JsonConvert.DeserializeObject <CommandRecievedEventArgs>(newcommand);
if (command.CommandID == (int)CommandStateEnum.CLOSE_HANDLER)
{
CommandRecieved?.Invoke(this, command);
imageController.ExecuteCommand((int)command.CommandID, command.Args, out bool result, out MessageTypeEnum type);
}
else
{
string msg = imageController.ExecuteCommand((int)command.CommandID, null, out bool result, out MessageTypeEnum type);
m.WaitOne();
writer.Write(msg);
m.ReleaseMutex();
}
}
}
}
/// <summary>
/// Executes the commands using the controller.
/// </summary>
/// <param name="sender"> Sender. </param>
/// <param name="e"> Event. </param>
public void OnCommandRecieved(object sender, CommandRecievedEventArgs e)
{
bool result;
if (e.CommandID == (int)CommandEnum.NewFileCommand)
{
if (!e.RequestDirPath.Equals(m_path))
{
return;
}
m_logging.Log("going into addFile", MessageTypeEnum.INFO);
string r = m_controller.ExecuteCommand(e.CommandID, e.Args, out result);
if (!result)
{
m_logging.Log("Command failed.", MessageTypeEnum.FAIL);
return;
}
m_logging.Log("Command successful.", MessageTypeEnum.INFO);
}
else if (e.CommandID == (int)CommandEnum.CloseCommand)
{
m_logging.Log("Command close success", MessageTypeEnum.INFO);
EndHandler();
return;
}
}
/**
* when the directory is changing, send the pictures to the correct path.
*/
private void OnChanged(object sender, FileSystemEventArgs e)
{
string[] args = new string[1];
args[0] = e.FullPath;
string path = args[0];
bool result;
DateTime lastWriteTime = File.GetLastWriteTime(e.FullPath);
MessageTypeEnum typeMsg = new MessageTypeEnum();
if (lastWriteTime != lastRead)
{
string resultMsg = "could'nt find picture...";
//string fileEnding = Path.GetExtension(path);
if (isCorrectEnding(path))
{
resultMsg = controller.ExecuteCommand((int)CommandEnum.NewFileCommand, args, out result);
if (result)
{
typeMsg = MessageTypeEnum.INFO;
}
else
{
typeMsg = MessageTypeEnum.FAIL;
}
}
lastRead = lastWriteTime;
logging.Log(resultMsg, typeMsg);
}
}
/// <summary>
/// This function is being called whenever a new client is connected
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnNewClient(object sender, NewClientEventArgs e)
{
bool result;
string answer = _mController.ExecuteCommand((int)CommandEnum.GetConfigCommand, null, out result);
if (answer != "")
{
serverChannel.SendSpecificlly(e.Client, answer);
}
lock (thisLock)
{
// get the list of logs
List <MessageRecievedEventArgs> logMsgsReversed =
new List <MessageRecievedEventArgs>(LogService.Instance.LogMsgs);
// reverse the list
logMsgsReversed.Reverse();
// go over the list of logs ans send them to the specific client
foreach (MessageRecievedEventArgs msg in logMsgsReversed)
{
string[] info = { msg.Status.ToString(), msg.Message };
CommandMessage msgC = new CommandMessage((int)CommandEnum.LogCommand, info);
serverChannel.SendSpecificlly(e.Client, msgC.ToJson());
System.Threading.Thread.Sleep(100);
}
}
_mLogging.Log("New client is connected", MessageTypeEnum.INFO);
_mLogging.Log("Send config: " + answer, MessageTypeEnum.INFO);
}
/// <summary>
/// The event occur upon receiving a command.
/// </summary>
/// <param name="sender"></param> The command sender (invoker).
/// <param name="e"></param> The argumetns.
public void OnCommandRecieved(object sender, CommandReceivedEventArgs e)
{
string msg;
bool result = true;
if (e.CommandID == CommandEnum.CloseCommand)
{
if (e.RequestDirPath != dirPath)
{
return;
}
msg = "Directory " + dirPath + " is closing";
dirWatcher.EnableRaisingEvents = false;
DirectoryClose?.Invoke(this, new DirectoryCloseEventArgs(e.RequestDirPath, msg));
//logger.Log(msg, MessageTypeEnum.INFO);
}
else
{
if (!IsSubFile(e.RequestDirPath))
{
return;
}
msg = controller.ExecuteCommand(e.CommandID, e.Args, out result);
}
logger.Log(msg, GetMessageType(result));
}
//Called when a new file is added
private void OnCreated(object source, FileSystemEventArgs e)
{
List <string> extensions = new List <string>()
{
".jpg", ".png", ".gif", ".bmp", ".MOV"
};
string extension = Path.GetExtension(e.FullPath);
if (!extensions.Contains(extension))
{
return;
}
Logging.Log(e.Name + " was added to " + DirPath, MessageTypeEnum.INFO);
string[] args = { e.FullPath };
string info = Controller.ExecuteCommand(CommandEnum.NewFile, args, out bool result);
if (result)
{
Logging.Log(e.Name + " moved to " + DirPath, MessageTypeEnum.INFO);
}
else
{
Logging.Log(e.Name + " failed to move to " + DirPath + ": " + info, MessageTypeEnum.FAIL);
}
}
// handles commands from server
// no comands from server at this point of the ex
public void OnCommandRecieved(object sender, CommandRecievedEventArgs e)
{
bool flag;
// TODO: execute command
// figure out what to send to the execute comand
m_controller.ExecuteCommand(e.CommandID, e.Args, out flag);
}
/// <summary>
/// the method incharge to close the hanlers and the all service.
/// </summary>
public void onCloseService()
{
CloseService?.Invoke(this, null);
m_logging.Log("On stop", Logging.Modal.MessageTypeEnum.INFO);
bool res;
string s = m_controller.ExecuteCommand((int)CommandEnum.LastLogCommand, null, out res);
this.m_tcpServer.NotifyAll(s);
}
/// <summary>
/// Sends the settings and log.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="client">The client.</param>
private void SendSettingsAndLog(object sender, IClientHandler client)
{
bool success;
//genertate string (serialize to json of all settings from the appconfig)
string setting = m_controller.ExecuteCommand((int)CommandEnum.GetConfigCommand, null, out success);
client.SendCommand(setting);
string log = m_controller.ExecuteCommand((int)CommandEnum.LogCommand, null, out success);
client.SendCommand(log);
}
/// <summary>
///See if command is meant for its directory
///Close command of execute command.
///Param: object, CommandRecuevedEventArgs.
/// </summary>
public void OnCommandRecieved(object sender, CommandRecievedEventArgs e) //how to check if command is meant for its directory?
{
if (e.CommandID == (int)CommandEnum.CloseCommand && (e.RequestDirPath.Equals(m_path) || e.RequestDirPath.Equals("")))
{
CloseHandler(sender, e);
}
else
{
m_controller.ExecuteCommand(e.CommandID, e.Args, out bool result); // why object sender? its "*"
}
}
/// <summary>
/// Handles the client.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="stream">The stream.</param>
public void HandleClient(TcpClient client, NetworkStream stream)
{
m_logging.Log("start listening to new client...", Logging.Modal.MessageTypeEnum.INFO);
new Task(() =>
{
StreamReader reader = new StreamReader(stream);
StreamWriter writer = new StreamWriter(stream);
while (true)
{
try
{
bool res;
string commandLine = reader.ReadLine();
while (reader.Peek() > 0)
{
commandLine += reader.ReadLine();
}
if (commandLine != null)
{
CommandRecievedEventArgs command = JsonConvert.DeserializeObject <CommandRecievedEventArgs>(commandLine);
if (command.CommandID.Equals((int)CommandEnum.CloseGui))
{
string[] args = { JsonConvert.SerializeObject(client) };
CommandRecievedEventArgs closeCommand = new CommandRecievedEventArgs((int)CommandEnum.CloseGui, args, "");
m_controller.ExecuteCommand(closeCommand.CommandID, closeCommand.Args, out res);
m_logging.Log("Client disconnected", Logging.Modal.MessageTypeEnum.WARNING);
break;
}
string result = m_controller.ExecuteCommand(command.CommandID, command.Args, out res);
try
{
// Thread.Sleep(1000);
mtx.WaitOne();
writer.WriteLine(result);
writer.Flush();
mtx.ReleaseMutex();
} catch (Exception e)
{
m_logging.Log("Client disconnected", Logging.Modal.MessageTypeEnum.WARNING);
RemoveClient?.Invoke(client);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
return;
}
}
}).Start();
}
/// <summary>
/// sends App.config content and all existing logs to the client
/// </summary>
/// <param name="writer">a writer that writes to a client</param>
private void SendInitialInfo(BinaryWriter writer)
{
bool res1, res2;
string configs = m_controller.ExecuteCommand(
(int)CommandEnum.GetConfigCommand, null, out res1);
string logs = m_controller.ExecuteCommand(
(int)CommandEnum.GetLogCommand, null, out res2);
if (res1 && res2)
{
SendDataToClient(configs, writer);
SendDataToClient(logs, writer);
}
}
private void FileCreatedEvent(object sender, System.IO.FileSystemEventArgs e)
{
m_Logger.Log($"File created name: {e.Name} @ {m_Path}", MessageTypeEnum.INFO);
string[] extensions = { ".jpg", ".png", ".gif", ".bmp" };
var ext = (Path.GetExtension(e.FullPath) ?? string.Empty).ToLower();
if (extensions.Any(ext.Equals))
{
m_Logger.Log($"Image file extention detectet: {ext}, \nProcessing..", MessageTypeEnum.INFO);
bool commandResult = false;
string[] args = { e.FullPath, e.Name };
string resultInfo = m_Controller.ExecuteCommand(1, args, out commandResult);
if (false == commandResult)
{
m_Logger.Log($"Command #1 failed with error: {resultInfo}", MessageTypeEnum.FAIL);
}
else
{
m_Logger.Log($"Command 1 success - info: {resultInfo}", MessageTypeEnum.INFO);
}
}
else
{
m_Logger.Log($"Not watching {ext} files.", MessageTypeEnum.INFO);
}
}
/// <summary>
/// OnCommandRecieved function, once we recieved the command we will execute it.
/// </summary>
/// <param name="sender">Who sent the command</param>
/// <param name="e">Arguments of command - id, args</param>
public void OnCommandRecieved(object sender, CommandRecievedEventArgs e)
{
bool resultSuccesful;
string msg;
//When running with parameter * it means we want for all so we will do this specific command for this specific handler
if (e.Args[0].Equals("*"))
{
e.Args[0] = this.m_path;
}
//First we will excecute the command
msg = m_controller.ExecuteCommand(e.CommandID, e.Args, out resultSuccesful);
//Than we will write into the logger - we will use our boolean in order to know if succeeded or not
if (resultSuccesful)
{
m_logging.Log(msg, MessageTypeEnum.INFO);
}
//Did not succeed
else
{
m_logging.Log(msg, MessageTypeEnum.FAIL);
}
//Return the argument to * for the next handlers
e.Args[0] = "*";
}
/// <summary>
/// Invoking this function every time a new file is added to the watched folder
/// </summary>
/// <param name="sender">
/// The invoker
/// </param>
/// <param name="e">
/// Event arguments
/// </param>
private void OnCreated(object sender, FileSystemEventArgs e)
{
string[] path = { e.FullPath };
string[] filters = { ".jpg", ".png", ".gif", ".bmp" };
string extension = Path.GetExtension(e.FullPath);
// Checking if the new file is an image we should handle
foreach (string f in filters)
{
// If so we'll execute the new fille command and logg approptiatly
if (extension.Equals(f, StringComparison.InvariantCultureIgnoreCase) && File.Exists(path[0]))
{
Thread.Sleep(100);
string msg = m_controller.ExecuteCommand((int)CommandEnum.NewFileCommand, path, out bool result);
if (result)
{
m_logging.Log("file in new path:" + msg, MessageTypeEnum.INFO);
}
else
{
m_logging.Log("could not move new file. reason: " + msg, MessageTypeEnum.FAIL);
}
}
}
}
/// <summary>
/// The function executes a given command ussing the controller.
/// </summary>
/// <param name="CommandID">An command enum</param>
/// <param name="args">Arguments for the command</param>
private void ExecuteCommand(int CommandID, string[] args)
{
// the task
Task t = Task.Run(() =>
{
// update runnig tasks value
lock (tLock)
m_tasks++;
string commandName = Enum.GetName(typeof(CommandEnum), CommandID);
// update logger of new command
m_logging.Log("DirectoyHandler received a " + commandName,
MessageTypeEnum.INFO);
bool check;
// execute the command
string message = m_controller.ExecuteCommand(CommandID, args, out check);
// update logger with the result (success or failure)
if (check)
{
m_logging.Log("DirectoyHandler done with " + commandName,
MessageTypeEnum.INFO);
}
else
{
m_logging.Log(message, MessageTypeEnum.FAIL);
}
// update runnig tasks value
lock (tLock)
m_tasks--;
});
}
public void OnCommandRecieved(object sender, CommandRecievedEventArgs e)
{
Task task = new Task(() =>
{
bool success; // Indication if the Command Was Successful
// If The Command is directed to the given Path
if (e.RequestDirPath.Equals("*") || e.RequestDirPath.Equals(m_path))
{
// If The User Wishes to close the file
if (e.CommandID == (int)CommandEnum.CloseCommand)
{
if (m_dirWatcher != null)
{
m_dirWatcher.EnableRaisingEvents = false;
}
DirectoryClose?.Invoke(this, new DirectoryCloseEventArgs(m_path,
String.Format(MessageInfrastructure.INFO_CloseCommand, m_path)));
// Invoking the Server Close
}
// Logging the Command Being Recieved
m_logging.Log(String.Format(MessageInfrastructure.INFO_RecievedCommand, e.CommandID,
String.Join(",", e.Args)), Logging.Modal.MessageTypeEnum.INFO);
// Execute command
string result = m_controller.ExecuteCommand(e.CommandID, e.Args, out success);
MessageTypeEnum type = (success) ? MessageTypeEnum.INFO : MessageTypeEnum.FAIL;
m_logging.Log(String.Format(MessageInfrastructure.INFO_SuccessfulCommand, e.CommandID,
String.Join(",", e.Args), result), type);
}
});
task.Start();
}
/// <summary>
/// when file created
/// </summary>
/// <param name="source">event caller</param>
/// <param name="e">the created file</param>
public void OnChanged(object source, FileSystemEventArgs e)
{
// check if file is an image
// if it is, backup
logger.Log("New file detected in \"" + dirPath + "\"", MessageTypeEnum.L_INFO);
if (!filters.Contains(Path.GetExtension(e.FullPath)))
{
logger.Log("File \"" + Path.GetFileName(e.FullPath) + "\" isnt an image",
MessageTypeEnum.L_INFO);
return;
}
logger.Log("Backup \"" + Path.GetFileName(e.FullPath) + "\" is an image",
MessageTypeEnum.L_INFO);
ExitCode status = controller.ExecuteCommand(Command.BackupFile, new string[] { e.FullPath });
if (status != ExitCode.Success)
{
logger.Log("Failed to back up \"" + Path.GetFileName(e.FullPath) + "\" reson of failuer: " +
GetFailedReson(status), MessageTypeEnum.L_FAIL);
}
else
{
logger.Log("Successfully Backup \"" + Path.GetFileName(e.FullPath) + "\" and created thumbnail",
MessageTypeEnum.L_INFO);
}
}
/// <summary>
/// When a command comes- checks what kind it is: if closing- its closes the service,
/// otherwise its calls to ExecuteCommand and writes to the log sucsess\failure
/// </summary>
/// <param name="sender">the object called to the event</param>
/// <param name="e">the event args required for this event</param>
public void OnCommandRecieved(object sender, CommandRecievedEventArgs e)
{
bool result;
string message;
if (e.CommandID == (int)CommandEnum.CloseCommand)
{
if (e.RequestDirPath.Equals("*") || e.RequestDirPath.Equals(m_path))
{
m_dirWatcher.EnableRaisingEvents = false;
DirectoryCloseEventArgs dirCloseArgs = new DirectoryCloseEventArgs(m_path, "CLOSE");
DirectoryClose?.Invoke(this, dirCloseArgs);
}
return;
}
else
{
if (m_path == null || !e.RequestDirPath.Contains(m_path))
{
return;
}
message = m_controller.ExecuteCommand(e.CommandID, e.Args, out result);
}
// write to the log
if (result)
{
m_logging.Log(message, MessageTypeEnum.INFO);
}
else
{
m_logging.Log(message, MessageTypeEnum.FAIL);
}
}
/// <summary>
/// Called when [server data recieved].
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="Communication.Model.Event.DataReceivedEventArgs"/> instance containing the event data.</param>
private void OnServerDataRecieved(object sender, Communication.Model.Event.DataReceivedEventArgs <string> e)
{
CommandMessage cmdMsg = CommandMessage.FromJSON(e.Data);
IClientCommunicationChannel <string> receiver = (IClientCommunicationChannel <string>)sender;
string msg = null;
if (cmdMsg.CmdId == CommandEnum.CloseClientCommand)
{
receiver.Close();
}
else if (cmdMsg.CmdId == CommandEnum.CloseCommand)
{
m_imageServer.sendCommand(CommandEnum.CloseCommand, new string[] { }, cmdMsg.Args[0]);
ServerCommunication.Instance.Send(new CommandMessage(CommandEnum.CloseCommand, cmdMsg.Args).ToJSON());
}
else
{
bool result;
msg = m_controller.ExecuteCommand((int)cmdMsg.CmdId, cmdMsg.Args, out result);
}
if (msg != null)
{
receiver.Send(msg);
}
}
/************************************************************************
* The Input: a sender and an event.
* The Output: -.
* The Function operation: The function runs when a new file is being watched.
*************************************************************************/
private void OnCreated(object sender, FileSystemEventArgs e)
{
string[] path = { e.FullPath };
//Possible endings for images.
string[] filters = { ".jpg", ".png", ".gif", ".bmp" };
string extension = Path.GetExtension(e.FullPath);
bool result;
//Checking whether the new file is an image we should handle.
foreach (string f in filters)
{
// If it is we'll execute the new file command and logg accordingly.
if (extension.Equals(f, StringComparison.InvariantCultureIgnoreCase))
{
Thread.Sleep(100);
string msg = m_controller.ExecuteCommand((int)CommandEnum.NewFileCommand, path, out result);
if (result)
{
m_logging.Log("file in new path:" + msg, MessageTypeEnum.INFO);
}
else
{
m_logging.Log("Error in moving the new file. Reason: " + msg, MessageTypeEnum.FAIL);
}
}
}
}
/// <summary>
/// Handles the client.
/// </summary>
public void HandleClient()
{
new Task(() =>
{
try
{
while (true)
{
string commandLine = _reader.ReadString();
string[] parameters = commandLine.Split('|');
string retval = _imageController.ExecuteCommand(
(CommandEnum)Enum.Parse(typeof(CommandEnum), parameters[0]),
parameters.Skip(1).ToArray(), out EventLogEntryType _);
if (retval == null)
{
continue;
}
_writer.Write(parameters[0] + "|" + retval);
_writer.Flush();
}
}
catch (Exception)
{
GuiClientClosed?.Invoke(this, null);
_loggingService.Log("Client Closed", EventLogEntryType.Error);
}
}).Start();
}
/// <summary>
/// this method responsible on command recieved.
/// </summary>
/// <param name="sender">the object that send the event</param>
/// <param name="e">event args</param>
public void OnCommandRecieved(object sender, CommandRecievedEventArgs e)
{
m_logging.Log("On Command Recieved", MessageTypeEnum.INFO);
{
bool isSuccess;
if (e.CommandID == (int)CommandEnum.CloseCommand)
{
m_logging.Log("Close command execute in handler", MessageTypeEnum.INFO);
closeHandler();
return;
}
if (e.RequestDirPath.Equals(this.m_path))
{
string msg = m_controller.ExecuteCommand(e.CommandID, e.Args, out isSuccess);
if (isSuccess)
{
m_logging.Log(msg, MessageTypeEnum.INFO);
}
else
{
m_logging.Log("Error on execute command: " + msg, MessageTypeEnum.FAIL);
}
}
}
}
/// <summary>
/// c'tor
/// </summary>
/// <param name="m_controller"></param> to execute commands from its dictionary
/// <param name="m_logging"></param> to send logs
public ImageServer(IImageController m_controller, ILoggingService m_logging)
{
this._mController = m_controller;
this._mLogging = m_logging;
string[] directories = (ConfigurationManager.AppSettings.Get("Handler").Split(';'));
foreach (string dir in directories)
{
if (Directory.Exists(dir))
{
createHandler(dir);
}
else
{ // if dir is not exists
bool result;
string[] args = { dir };
m_controller.ExecuteCommand((int)CommandEnum.CloseCommand, args, out result);
m_logging.Log("Not such file or directory: " + dir, MessageTypeEnum.WARNING);
}
}
// get comunication details to connect the server
string ip = ConfigurationManager.AppSettings.Get("Ip");
int port = Int32.Parse(ConfigurationManager.AppSettings.Get("Port"));
serverChannel = new TcpServerChannel(port, ip);
serverChannel.NewHandler += OnNewClient; // for new client
ClientHandler.MessageRecived += GetMessageFromUser; // for msg from the user
serverChannel.Start();
}
/// <summary>
/// This method is called when command is received.
/// </summary>
/// <param name="sender">The command sender.</param>
/// <param name="e">The command's arguments.</param>
public void OnCommandRecieved(object sender, CommandRecievedEventArgs e) // The Event that will be activated upon new Command
{ //checking if our path is the one the server intended to handle the command
if (e.RequestDirPath.Equals(m_path) || e.RequestDirPath.Equals("*")) // Equals compares content
{
// if CloseCommand
if (e.CommandID == (int)CommandEnum.CloseCommand) // == better for numbers
{
m_dirWatcher.EnableRaisingEvents = false; // stop watching.
string exitMsg = "Stoped handling the directory in path: " + m_path;
DirectoryCloseEventArgs directoryCloseEventArgs = new DirectoryCloseEventArgs(m_path, exitMsg);
DirectoryClose?.Invoke(this, directoryCloseEventArgs);
}
else // if other command
{
bool success;
string msg = m_controller.ExecuteCommand(e.CommandID, e.Args, out success);
if (success)
{
m_logging.Log(msg, MessageTypeEnum.INFO);
}
else
{
m_logging.Log(msg, MessageTypeEnum.FAIL);
}
}
}
}
public void HandleClient(IClientWrapper client)
{
Task task = new Task(() => {
try
{
while (true)
{
string message = client.Read();
if (message == null)
{
client.Close();
break;
}
long length = message.Length;
CommandMessage cmd = CommandMessage.FromJSONString(message);
bool result;
string newMessage = m_controller.ExecuteCommand((int)cmd.Type, cmd.Args, out result);
if (result)
{
client.Write(newMessage);
}
}
} catch (IOException ex)
{
client.Close();
}
});
task.Start();
}
public void HandleClient(TcpClient client)
{
//create a task witch will listen to client command and execute them.
new Task(() =>
{
try
{
NetworkStream stream = client.GetStream();
BinaryReader reader = new BinaryReader(stream);
BinaryWriter writer = new BinaryWriter(stream);
string commandLine = "";
while (!commandLine.Equals("Close Client"))
{
//read first message from client.
commandLine = reader.ReadString();
if (commandLine.Equals("Close Client"))
{
break;
}
bool check;
string[] command = commandLine.Split(':');
//execute command
string result = m_controller.ExecuteCommand(Int32.Parse(command[0]), command, out check);
//send to client the result of the command
writer.Write(result);
}
//if client closed
client.Close();
} catch (Exception)
{
client.Close();
}
}).Start();
}
/// <summary>
/// Handles the <see cref="E:CommandRecieved" /> event.
/// A command from the server, for now - just "close" command
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">An EventArgs that contains the event data.</param>
public void OnCommandReceived(object sender, CommandReceivedEventArgs e)
{
bool result;
//check if command is meant for its directory,
//if yes – handle command (for now will just be to close handler)};
if (e.RequestDirPath.Equals(m_path) || e.RequestDirPath.Equals("*"))
{
//check if the command is close
if (e.CommandID == (int)CommandEnum.RemoveHandler)
{
//close
closeHandler();
}
else
{
// the string will return the new path if result = true,
//and will return the error message if the result = false
string resultOfCommand = m_controller.ExecuteCommand(
e.CommandID, e.Args, out result);
if (result == false)
{
m_logging.Log(resultOfCommand, MessageTypeEnum.FAIL);
}
else
{
m_logging.Log("copy image from " + m_path + " to "
+ resultOfCommand + " successes", MessageTypeEnum.INFO);
}
}
}
}
/*********************************************************************/
//check if command is meant for its directory, if yes – handle command(for now will just be to close handler)
public void OnCommandRecieved(object sender, CommandRecievedEventArgs e)
{
FileSystemEventArgs e2 = null;
if (watcher.Path.CompareTo(e.RequestDirPath) == 0)
{
if (e.CommandID == 1)
{
closeHandler(e.RequestDirPath);
m_logging.Log("closeHandler command recieved " + e.RequestDirPath, MessageTypeEnum.INFO);
}
else
{
bool result;
FileInfo file = new FileInfo(e2.FullPath);
//send command to controller to add a file
string[] args = { e2.FullPath, file.Name };
m_controller.ExecuteCommand(CommandEnum.NewFileCommand, args, out result);
if (result == true)
{
//notify logger on success
m_logging.Log("added file " + file.Name + " succesfully", MessageTypeEnum.INFO);
}
else //notify logger on failure
{
m_logging.Log("ERROR: faild to add " + file.Name + " file", MessageTypeEnum.INFO);
}
// Specify what is done when a file is changed, created, or deleted.
}
}
}
/// <summary>
/// Creating a thumbnail directory if missing and adding a thumbnail and its nessecery folders
/// </summary>
/// <param name="source"></param>
/// <param name="e"></param>
public void CreateThumbnail(object source, FileSystemEventArgs e)
{
string strFileExt = Path.GetExtension(e.FullPath);
m_logging.Log(strFileExt, MessageTypeEnum.INFO);
// filter file types ignoring folders
switch (strFileExt)
{
case @".jpg":
break;
case @".png":
break;
case @".bmp":
break;
case @".gif":
break;
default:
return;
}
m_logging.Log("started creating thumbnail", MessageTypeEnum.INFO);
bool result;
string [] args = new string[3];
args[0] = e.FullPath;
//creting a filestream in order to copy the file
FileStream fs = new FileStream(e.FullPath, FileMode.Open, FileAccess.Read);
try
{
//getting the time and date of the image
DateTime dt = GetDateTakenFromImage(fs);
m_logging.Log("date taken from image", MessageTypeEnum.INFO);
args[1] = dt.Year.ToString();
args[2] = dt.Month.ToString();
} catch (Exception exce)
{
// in case the image has no date
m_logging.Log("No Available Date", MessageTypeEnum.FAIL);
args[1] = "Default";
args[2] = "Default";
}
//closing the image
fs.Close();
fs.Dispose();
try
{
//execute the command
m_logging.Log(m_controller.ExecuteCommand(1, args, out result), MessageTypeEnum.INFO);
} catch (Exception errors)
{
//incase there was an error int adding the file
m_logging.Log(errors.ToString(), MessageTypeEnum.FAIL);
}
}