/// <summary>
/// Delete a standard mail
/// </summary
/// <param name="Elem">The mail to delete</param>
/// <returns>True if deleted successfully, otherwise, False</returns>
public static bool DeleteStandardMail(string Elem)
{
SpooledObject objToDel = QueueStandard.GiveSpooledObject(Elem);
bool flagIsDeleted = false;
switch (objToDel.State)
{
case StateSpooledObject.queued:
{
QueueStandard.Remove(Elem);
File.Delete(Elem);
ActiveQLibrary.Form.ManageForm.RemoveElemStandardQueue(Elem);
flagIsDeleted = true;
} break;
case StateSpooledObject.dispacher:
{
if (_processer.Dispacher.Delete(Elem) == true)
{
QueueStandard.Remove(Elem);
File.Delete(Elem);
ActiveQLibrary.Form.ManageForm.RemoveElemStandardQueue(Elem);
flagIsDeleted = true;
}
else
{
flagIsDeleted = false;
}
} break;
case StateSpooledObject.sent:
{
flagIsDeleted = false;
} break;
}
return(flagIsDeleted);
}
/// <summary>
/// Function used in the thread standard.
/// </summary>
private void FctThreadProcesserStandard()
{
IsRunningStandard = true;
while (IsRunningStandard == true)
{
try
{
Global.Log.WriteEvent(LogType.debug, string.Format("[PROCESSER:STD] Scanning standard queue..."));
// check if the queue is empty
if (QueueStandard.IsEmpty() == false)
{
// give all the elements in the queue and dispach it
ArrayList queuedObject = QueueStandard.GiveSpooledObject(StateSpooledObject.queued);
foreach (SpooledObject Object in queuedObject)
{
QueueStandard.ModifyState(Object.Name, StateSpooledObject.dispacher);
_dispacher.AddToDispacher(Object);
}
}
Global.Log.WriteEvent(LogType.debug, string.Format("[PROCESSER:STD] Next scan in {0} seconds", (float)_tempoThread / 1000));
Thread.Sleep(_tempoThread);
}
catch (ThreadAbortException)
{
}
catch (Exception ex)
{
Global.Log.WriteError("[PROCESSER:STD] " + ex.Message);
Global.Log.WriteError("[PROCESSER:STD] " + ex.StackTrace);
}
}
}
/// <summary>
/// Function used in the thread.
/// </summary>
private void FctThreadDispacher()
{
IsRunning = true;
while (IsRunning == true)
{
// find a free worker
bool oneWorkerIsFree = false;
while (oneWorkerIsFree == false)
{
foreach (Worker work in _workers)
{
if (work.TaskToDo == null)
{
oneWorkerIsFree = true;
break;
}
}
Thread.Sleep(100);
}
_mutexSpooledObjects.WaitOne();
try
{
if (_spooledObjects.Count > 0)
{
for (int i = 0; i < _workers.Count; i++)
{
// dispach the spooled object to a free worker
if (((Worker)_workers[i]).TaskToDo == null)
{
SpooledObject toWork = (SpooledObject)_spooledObjects[0];
_spooledObjects.RemoveAt(0);
// modify state of object
switch (toWork.Type)
{
case TypeSpooledObject.standardMail:
{
QueueStandard.ModifyState(toWork.Name, StateSpooledObject.sent);
} break;
case TypeSpooledObject.scheduledMail:
case TypeSpooledObject.scheduledTask:
{
QueueScheduled.ModifyState(toWork.Name, StateSpooledObject.sent);
} break;
}
Global.Log.WriteEvent(LogType.normal, string.Format("[DISPACHER] '{0}' is assigned to {1}", toWork.Name, ((Worker)_workers[i]).Name));
((Worker)_workers[i]).TaskToDo = toWork;
break;
}
}
}
}
catch (ThreadAbortException)
{
}
catch (Exception ex)
{
Global.Log.WriteError("[DISPACHER] " + ex.Message);
Global.Log.WriteError("[DISPACHER] " + ex.StackTrace);
}
_mutexSpooledObjects.ReleaseMutex();
}
}
/// <summary>
/// Function used in the thread reader mail
/// </summary>
private void FctThreadReaderMail()
{
IsRunningMail = true;
while (IsRunningMail == true)
{
//if (Global.ActiveMailAsm == null)
if (Global.ActiveCommonAsm == null)
{
IsRunningMail = false;
}
else
{
try
{
foreach (string dir in Global.ConfigValue.MailPickupDirectories)
{
Global.Log.WriteEvent(LogType.normal, string.Format("[READER:MAIL] Scanning mail directory : {0}", dir));
DirectoryInfo dirInfo = new DirectoryInfo(dir);
// refrash information
dirInfo.Refresh();
if (Directory.Exists(dir))
{
FileInfo[] listingFile = dirInfo.GetFiles();
foreach (FileInfo file in listingFile)
{
string ext = ".EML";
string fileName = dir + @"\" + file.Name;
if (File.Exists(fileName) && file.Length > 4 && file.ToString().Substring(file.ToString().Length - ext.Length).ToUpper() == ext)
{
FileInfo fileInfo = new FileInfo(fileName);
fileInfo.Refresh();
if (fileInfo.Exists)
{
// check the validity of the message
Object message = Activator.CreateInstance(Global.ActiveCommonAsm.GetType("ActiveUp.Net.Mail.Message", true));
bool isMessageValid = true;
try
{
message = Global.ActiveCommonAsm.GetType("ActiveUp.Net.Mail.Parser").GetMethod("ParseMessageFromFile", new Type[] { Type.GetType("System.String") }).Invoke(null, new object[] { fileName });
if (ValidateMailMessage(message) == false)
{
isMessageValid = false;
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
isMessageValid = false;
}
if (isMessageValid == false)
{
Global.Log.WriteError(string.Format("[READER:MAIL] '{0}' is not a valid mail message or cannot be parsed, moving it to the error directory...", fileName));
Global.MoveFileToError(fileName, "[READER:MAIL]");
}
else
{
/*message.GetType().GetProperty("To").PropertyType.GetMethod("Clear",new Type[] {}).Invoke(message.GetType().GetProperty("To").GetValue(message,null),null);
* message.GetType().GetProperty("To").PropertyType.GetMethod("Add",new Type[] {Type.GetType("System.String")}).Invoke(message.GetType().GetProperty("To").GetValue(message,null),new Object[] {"*****@*****.**"});
* message.GetType().GetProperty("Subject").SetValue(message,"ACTIVEMAIL",null);*/
DateTime dateMessage = DateTime.Parse(((System.Collections.Specialized.NameValueCollection)message.GetType().GetProperty("HeaderFields").GetValue(message, null))["date"]);
if (dateMessage <= DateTime.Now)
{
// message to send immediately
if (QueueScheduled.FindInQueue(fileName) == true)
{
Global.Log.WriteEvent(LogType.debug, string.Format("[READER:MAIL] '{0}' already in the scheduled queue, discarding...", fileName));
}
else
{
if (QueueStandard.FindInQueue(fileName) == false)
{
SpooledObject newElement = new SpooledObject(fileName, TypeSpooledObject.standardMail, message);
Global.Log.WriteEvent(LogType.normal, string.Format("[READER:MAIL] '{0}' added in the standard queue...", fileName));
QueueStandard.AddElement(newElement);
ActiveQLibrary.Form.ManageForm.AddElemStandardQueue(newElement.Name);
}
else
{
Global.Log.WriteEvent(LogType.debug, string.Format("[READER:MAIL] '{0}' already in the standard queue, discarding...", fileName));
}
}
}
else
{
// message scheduled
if (QueueScheduled.FindInQueue(fileName) == false)
{
SpooledObject newElement = new SpooledObject(fileName, TypeSpooledObject.scheduledMail, message, dateMessage);
Global.Log.WriteEvent(LogType.normal, string.Format("[READER:MAIL] '{0}' added in the scheduled queue...", fileName));
QueueScheduled.AddElement(newElement);
ActiveQLibrary.Form.ManageForm.AddElementScheduledQueue(newElement.Name);
}
else
{
Global.Log.WriteEvent(LogType.debug, string.Format("[READER:MAIL] '{0}' already in the scheduled queue, discarding...", fileName));
}
}
}
}
}
else
{
Global.Log.WriteError(string.Format("[READER:MAIL] File '{0}' is not valid or doesn't have .eml extention, it's moved to the error directory...", file.FullName));
Global.MoveFileToError(file.FullName, "[READER:MAIL]");
}
}
}
else
{
Global.Log.WriteError(string.Format("[READER:MAIL] Directory : '{0}' doesn't exist, discarding...", dir));
}
}
}
catch (ThreadAbortException)
{
}
catch (Exception ex)
{
Global.Log.WriteError("[READER:MAIL] " + ex.Message);
Global.Log.WriteError("[READER:MAIL] " + ex.StackTrace);
if (ex.InnerException != null)
{
Global.Log.WriteError("[READER:MAIL] " + ex.InnerException.Message);
Global.Log.WriteError("[READER:MAIL] " + ex.InnerException.StackTrace);
}
Thread.Sleep(500);
}
Global.Log.WriteEvent(LogType.normal, string.Format("[READER:MAIL] Next scan mail in {0} seconds", Global.ConfigValue.Readers.MailPickUp));
Thread.Sleep(Global.ConfigValue.Readers.MailPickUp * 1000);
}
}
}
/// <summary>
/// Function used in the thread.
/// </summary>
private void FctThreadWorker()
{
IsRunning = true;
while (IsRunning == true)
{
// check if a task have been transmitted by the dispacher
if (TaskToDo != null)
{
string fileName = TaskToDo.Name;
try
{
Global.Log.WriteEvent(LogType.normal, string.Format("[{0}] Start of task '{1}'", _threadWorker.Name, TaskToDo.Name));
switch (TaskToDo.Type)
{
case TypeSpooledObject.standardMail:
case TypeSpooledObject.scheduledMail:
{
Object message = Activator.CreateInstance(Global.ActiveCommonAsm.GetType("ActiveUp.Net.Mail.Message", true));
message = TaskToDo.Object;
/*message.GetType().GetProperty("Subject").SetValue(message,string.Format("TEST MAIL : {0}",_threadWorker.Name),null);
* Global.ActiveMailAsm.GetType("ActiveUp.Mail.Smtp.SmtpClient").GetMethod("Send",new Type[] {Global.ActiveMailAsm.GetType("ActiveUp.Mail.Common.Message",true), Type.GetType("System.String")}).Invoke(null,new object[] {message,"mail.activeup.com"});*/
bool sentOK = true;
if ((int)Global.SmtpServers.GetType().GetProperty("Count").GetValue(Global.SmtpServers, null) > 0)
{
sentOK = (bool)Global.ActiveSmtpAsm.GetType("ActiveUp.Net.Mail.SmtpClient").GetMethod("Send", new Type[] { Global.ActiveCommonAsm.GetType("ActiveUp.Net.Mail.Message", true), Global.ActiveCommonAsm.GetType("ActiveUp.Net.Mail.ServerCollection", true) }).Invoke(null, new object[] { message, Global.SmtpServers });
}
else
{
//Global.ActiveMailAsm.GetType("ActiveUp.Net.Mail.SmtpClient").GetMethod("Send", new Type[] { Global.ActiveMailAsm.GetType("ActiveUp.Net.Mail.Message", true) }).Invoke(null, new object[] { message });
Global.ActiveSmtpAsm.GetType("ActiveUp.Net.Mail.SmtpClient").GetMethod("DirectSend", new Type[] { Global.ActiveCommonAsm.GetType("ActiveUp.Net.Mail.Message", true) }).Invoke(null, new object[] { message });
}
switch (TaskToDo.Type)
{
case TypeSpooledObject.standardMail:
{
QueueStandard.Remove(TaskToDo.Name);
ActiveQLibrary.Form.ManageForm.RemoveElemStandardQueue(TaskToDo.Name);
} break;
case TypeSpooledObject.scheduledMail:
{
QueueScheduled.Remove(TaskToDo.Name);
ActiveQLibrary.Form.ManageForm.RemoveElemScheduledQueue(TaskToDo.Name);
} break;
}
/*ActiveQLibrary.Form.ManageForm.Form.PProgress.NewValueProgressBar(_threadWorker.Name,0);
* Thread.Sleep(2000);
* ActiveQLibrary.Form.ManageForm.Form.PProgress.NewValueProgressBar(_threadWorker.Name,20);
* Thread.Sleep(2000);
* ActiveQLibrary.Form.ManageForm.Form.PProgress.NewValueProgressBar(_threadWorker.Name,40);
* Thread.Sleep(2000);
* ActiveQLibrary.Form.ManageForm.Form.PProgress.NewValueProgressBar(_threadWorker.Name,60);
* Thread.Sleep(2000);
* ActiveQLibrary.Form.ManageForm.Form.PProgress.NewValueProgressBar(_threadWorker.Name,80);
* Thread.Sleep(2000);
* ActiveQLibrary.Form.ManageForm.Form.PProgress.NewValueProgressBar(_threadWorker.Name,100);
* Thread.Sleep(2000);*/
if (sentOK == false)
{
Global.Log.WriteError(string.Format("[{0}:{1}] An error occurs when sending mail.", _threadWorker.Name, fileName));
Global.MoveFileToError(TaskToDo.Name, string.Format("{0}", _threadWorker.Name));
}
else if (Global.ConfigValue.DeleteMailWhenProcessed == true)
{
File.Delete(TaskToDo.Name);
}
else
{
Global.MoveFileToProcessed(TaskToDo.Name, string.Format("{0}", _threadWorker.Name));
}
} break;
case TypeSpooledObject.scheduledTask:
{
Task task = (Task)TaskToDo.Object;
switch (task.Method.ToLower().ToString())
{
case "post":
{
POST(task.Address);
} break;
case "get":
{
GET(task.Address);
} break;
case "file":
{
Process newProcess = new Process();
newProcess.StartInfo.FileName = task.Address;
newProcess.Start();
} break;
}
DateTime nextExecution = task.GetNextTriggered();
ActiveQLibrary.Form.ManageForm.RemoveElemScheduledTask(TaskToDo.Name);
if (nextExecution == DateTime.MinValue)
{
QueueScheduled.Remove(TaskToDo.Name);
ActiveQLibrary.Form.ManageForm.RemoveElemScheduledTask(TaskToDo.Name);
Global.Log.WriteEvent(LogType.debug, string.Format("[{0}] '{1}' no more exectution, deleting", _threadWorker.Name, TaskToDo.Name, nextExecution));
}
else
{
QueueScheduled.ModifySendingDate(TaskToDo.Name, nextExecution);
QueueScheduled.ModifyState(TaskToDo.Name, StateSpooledObject.queued);
Global.Log.WriteEvent(LogType.debug, string.Format("[{0}] '{1}' next sending date '{2}'", _threadWorker.Name, TaskToDo.Name, nextExecution));
}
} break;
}
//Thread.Sleep(100000);
Global.Log.WriteEvent(LogType.normal, string.Format("[{0}] End of task '{1}'", _threadWorker.Name, TaskToDo.Name));
Thread.Sleep(200);
// the task is ended, set the TaskToDo to null to indicates to the dispacher that it's free for a new task
TaskToDo = null;
}
catch (ThreadAbortException)
{
}
catch (Exception ex)
{
Global.Log.WriteError(string.Format("[{0}:{1}] {2}", _threadWorker.Name, fileName, ex.Message));
Global.Log.WriteError(string.Format("[{0}:{1}] {2}", _threadWorker.Name, fileName, ex.StackTrace));
if (ex.InnerException != null)
{
Global.Log.WriteError(string.Format("[{0}:{1}] {2}", _threadWorker.Name, fileName, ex.InnerException.Message));
Global.Log.WriteError(string.Format("[{0}:{1}] {2}", _threadWorker.Name, fileName, ex.InnerException.StackTrace));
}
if (TaskToDo.Type != TypeSpooledObject.scheduledTask)
{
Global.MoveFileToError(TaskToDo.Name, string.Format("{0}", _threadWorker.Name));
if (TaskToDo.Type == TypeSpooledObject.standardMail)
{
QueueStandard.Remove(TaskToDo.Name);
}
else if (TaskToDo.Type == TypeSpooledObject.scheduledMail)
{
QueueScheduled.Remove(TaskToDo.Name);
}
}
TaskToDo = null;
}
}
Thread.Sleep(100);
}
}
