public override void Handle(SendMeasurementsCommand command)
{
var measurements =
Repository.Where(
new CommonSpecification <MeterMeasurement>(
x => command.MeterMeasurementIdentifiers.Contains(x.Id)))
.ToList();
var isAllMeasurementsInOneMonth = CheckIsAllMeasurementsInOneMonth(measurements);
if (!isAllMeasurementsInOneMonth)
{
throw new Exception("Selected measurements isn't for one month");
}
var mappedMeasurements =
measurements.Select(x => $"{x.MeasurementType.Name}: {x.Measurement}");
var date = measurements.FirstOrDefault().Date.ToString("MMMM yyyy", CultureInfo.GetCultureInfo("ru-RU"));
var messageModel =
new MeasurementMailModel(date, string.Join("\n", mappedMeasurements));
MailProcessor.Send(new SendMeasurementsMail(command.Recipient, date, messageModel));
foreach (var measurement in measurements)
{
measurement.IsSent = true;
}
}
public void TestConstructorEngineCannotBeNull()
{
var ns = new Mock <Microsoft.Office.Interop.Outlook._NameSpace>();
var en = new Mock <IEngine>();
var mp = new MailProcessor(en.Object, ns.Object);
Assert.Throws <ArgumentNullException>(() => new UnProcessedFolders("Title", mp, null));
}
protected void AutoCheckMailForAccount(Account acct)
{
if (acct != null)
{
try
{
DbStorage dbs = DbStorageCreator.CreateDatabaseStorage(acct);
MailProcessor mp = new MailProcessor(dbs);
WebmailResourceManager _resMan = (new WebmailResourceManagerCreator()).CreateResourceManager();
try
{
mp.MessageDownloaded += new DownloadedMessageHandler(mp_MessageDownloaded);
mp.Connect();
FolderCollection fc1 = dbs.GetFolders();
FolderCollection fc2 = new FolderCollection();
foreach (Folder fld in fc1)
{
if (fld.Type == FolderType.Inbox)
{
fc2.Add(fld);
}
}
Dictionary <long, string> updatedFolders = mp.Synchronize(fc2);
string strFolders = "";
foreach (KeyValuePair <long, string> kvp in updatedFolders)
{
strFolders += "{id: " + kvp.Key.ToString() + ", fullName: '" + kvp.Value + "'}, ";
}
Response.Write(@"<script type=""text/javascript"">parent.SetUpdatedFolders([" + strFolders.TrimEnd(new char[2] {
',', ' '
}) + "], false);</script>");
}
finally
{
mp.MessageDownloaded -= new DownloadedMessageHandler(mp_MessageDownloaded);
mp.Disconnect();
}
}
catch (WebMailException ex)
{
Log.WriteException(ex);
errorDesc = Utils.EncodeJsSaveString(ex.Message);
if (Type == 1 || Type == 2)
{
Session.Add(Constants.sessionErrorText, errorDesc);
}
}
}
}
public void TestMailMessage([FromBody] TestMailMessageRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var isValidEmail = Validate.Email(request.Recipient);
if (!isValidEmail)
{
throw new ArgumentException($"Passed \"{request.Recipient}\" isn't recognized as email.");
}
MailProcessor.Send(new TestMailMessage(request.Recipient));
}
public InteropSchedaDocHandler(InteropCreazioneDocRequest request)
{
try
{
_template = ProfilazioneDocumenti.getTemplateById(request.StatusTemplate.IdTemplate);
logger.Debug("template " + _template.DESCRIZIONE + " trovato");
OggettoCustom oc = _template.ELENCO_OGGETTI.Cast <OggettoCustom>().Single(e => request.StatusTemplate.StatusTemplateFieldName.Equals(e.DESCRIZIONE));
logger.Debug("Oggetto custom trovato " + oc.DESCRIZIONE);
oc.VALORE_DATABASE = request.StatusTemplate.StatusNotProcessedValue;
_processor = new MailProcessor(request.FiltriMail);
}
catch (Exception e)
{
logger.Debug("Errore nella costruzione del template: " + e.Message);
}
}
/// <summary>
/// Create the mail processor.
/// </summary>
private void CreateMailProcessor()
{
if (null == TheEngine)
{
throw new ArgumentNullException(nameof(TheEngine));
}
if (null == _explorers)
{
throw new ArgumentNullException(nameof(_explorers));
}
// then create the mail processor
TheMailProcessor = new MailProcessor(TheEngine, _explorers.Application.Session);
// the mail processor
_customUI.SetMailProcessor(TheMailProcessor);
}
protected void CheckMailForAccount(Account acct)
{
if (acct != null)
{
try
{
DbStorage dbs = DbStorageCreator.CreateDatabaseStorage(acct);
MailProcessor mp = new MailProcessor(dbs);
WebmailResourceManager _resMan = (new WebmailResourceManagerCreator()).CreateResourceManager();
try
{
mp.MessageDownloaded += new DownloadedMessageHandler(mp_MessageDownloaded);
Response.Write(@"<script type=""text/javascript"">parent.SetStateTextHandler(""" + _resMan.GetString("LoggingToServer") + @""");</script>");
mp.Connect();
Response.Write(@"<script type=""text/javascript"">parent.SetStateTextHandler(""" + _resMan.GetString("GettingMsgsNum") + @""");</script>");
Dictionary <long, string> updatedFolders = mp.Synchronize(dbs.GetFolders());
if (Type == 0)
{
string strFolders = "";
foreach (KeyValuePair <long, string> kvp in updatedFolders)
{
strFolders += "{id: " + kvp.Key.ToString() + ", fullName: '" + kvp.Value + "'}, ";
}
Response.Write(@"<script type=""text/javascript"">parent.SetUpdatedFolders([" + strFolders.TrimEnd(new char[2] {
',', ' '
}) + "]);</script>");
}
}
finally
{
mp.MessageDownloaded -= new DownloadedMessageHandler(mp_MessageDownloaded);
Response.Write(@"<script type=""text/javascript"">parent.SetStateTextHandler(""" + _resMan.GetString("LoggingOffFromServer") + @""");</script>");
mp.Disconnect();
}
}
catch (WebMailException ex)
{
Log.WriteException(ex);
errorDesc = Utils.EncodeJsSaveString(ex.Message);
if (Type == 1)
{
Session.Add(Constants.sessionErrorText, errorDesc);
}
}
}
}
internal static System.Xml.XmlAttribute CreateInboxSyncAttr(XmlElement webmailNode, Account acct)
{
XmlAttribute inboxSyncTypeAttr = webmailNode.OwnerDocument.CreateAttribute("inbox_sync_type");
FolderSyncType inboxSyncType = FolderSyncType.NewHeadersOnly;
MailProcessor mp = new MailProcessor(DbStorageCreator.CreateDatabaseStorage(acct));
try
{
mp.Connect();
Folder fld = mp.GetFolder(FolderType.Inbox);
if (fld != null)
{
inboxSyncType = fld.SyncType;
}
}
finally
{
mp.Disconnect();
}
inboxSyncTypeAttr.Value = ((short)inboxSyncType).ToString(CultureInfo.InvariantCulture);
return(inboxSyncTypeAttr);
}
public static void Run(
[QueueTrigger(queueName: Fn.Qs.IncomingMail, Connection = Fn.ConnectionKeyName)] CloudQueueMessage message,
[Queue(queueName: Fn.Qs.OutgoingMail, Connection = Fn.ConnectionKeyName)] ICollector <string> outputQueue,
[Queue(queueName: Fn.Qs.ErrorNotification, Connection = Fn.ConnectionKeyName)] ICollector <string> errorQueue,
ILogger log)
{
var storageConfig = Fn.StorageConfig.Load();
var storageAccount = CloudStorageAccount.Parse(storageConfig.ConnectionString);
var blobClient = storageAccount.CreateCloudBlobClient();
var incomingContainer = blobClient.GetContainerReference(storageConfig.IncomingMailContainerName);
var outgoingContainer = blobClient.GetContainerReference(storageConfig.OutgoingMailContainerName);
var settingsContainer = blobClient.GetContainerReference(storageConfig.SettingsContainerName);
var errorContainer = blobClient.GetContainerReference(storageConfig.ErrorMailContainerName);
var originalEmail = EmailStorage.LoadEmailFromStorage(message.AsString, incomingContainer);
var telemetry = new TelemetryClient(new TelemetryConfiguration(Fn.InstrumentationKey()));
var settingsStore = new SettingsStore(new CloudStore(settingsContainer));
var reply = MailProcessor.ProcessEmail(
originalEmail,
Fn.EmailConfig.Load().FromEmailAddress,
settingsStore,
telemetry);
if (!reply.WasSuccessful)
{
var erroredFile = EmailStorage.SaveEmailToStorage(originalEmail, errorContainer);
errorQueue.Add(erroredFile);
log.LogInformation($"enqueueing error - {erroredFile}");
log.LogError("Error processing email, ", reply.Exception);
}
EmailStorage.DeleteEmailFromStorage(message.AsString, incomingContainer);
var filename = EmailStorage.SaveEmailToStorage(reply.Value, outgoingContainer);
outputQueue.Add(filename);
log.LogInformation($"extracted data, enqueueing reply - {reply.Value.To} - {filename}");
}
/// <summary>
/// 寄送郵件
/// </summary>
/// <param name="_MailServer">郵件主機位置</param>
/// <param name="_MailServerPort">郵件主機服務Port</param>
/// <param name="_MailSender">寄件者</param>
/// <param name="_MailReceivers">收件者清單</param>
/// <returns></returns>
/// <remarks></remarks>
public string SendEmail(string _MailServer, int _MailServerPort, string _MailSender, List<string> _MailReceivers, string _Subject, string _Body)
{
string SendResult = null;
MailProcessor MailP = new MailProcessor();
string MailServer = _MailServer;
int MailServerPort = _MailServerPort;
string MailSender = _MailSender;
List<string> MailReceivers = _MailReceivers;
string MailSubject = _Subject;
string SendBody = _Body;
List<System.Net.Mail.Attachment> MailA = new List<System.Net.Mail.Attachment>();
List<string> MailCC = new List<string>();
MailP.setMailProcossor(MailSender, MailReceivers, MailCC, MailSubject, SendBody, MailA, MailServer, MailServerPort, false, true,
MailPriority.High.ToString(), 65001);
SendResult = MailP.Send();
return SendResult;
}
public ReaderController(IBooksReopository BookRepository, IOrderProcessor OrderProcessor, MailProcessor MailProcessor)
{
this.Bookrepository = BookRepository;
this.OrderProcessor = OrderProcessor;
this.MailProcessor = MailProcessor;
}
public static void Proccess(PXGraph graph, EMailAccount account, SMEmail email)
{
var obj = new MailProcessor(graph, account, email);
obj.Proccess();
}
protected void Page_Load(object sender, EventArgs e)
{
acct = Session[Constants.sessionAccount] as Account;
if (acct == null)
{
Response.Redirect("default.aspx", true);
}
string userAgent; //Client browser
string temp_filename = Request.QueryString["temp_filename"];
if (temp_filename != null)
{
try
{
byte[] buffer = new byte[0];
object tempFolder = Utils.GetTempFolderName(Session);
if (tempFolder != null)
{
//Response.Write(tempFolder.ToString() + "<br>");
//Response.Write(temp_filename);
//Response.End();
string safe_temp_file_name = Path.GetFileName(temp_filename);
string fullPath = Path.Combine(tempFolder.ToString(), safe_temp_file_name);
if (File.Exists(fullPath))
{
using (FileStream fs = File.OpenRead(fullPath))
{
buffer = new byte[fs.Length];
fs.Read(buffer, 0, buffer.Length);
}
}
}
else
{
return;
}
string filename = Request.QueryString["filename"] ?? temp_filename;
string download = Request.QueryString["download"];
//*************************************************************
//IE with cyrillic file names
//*************************************************************
string encodedFilename;
userAgent = Request.UserAgent;
if (userAgent.IndexOf("MSIE") > -1)
{
encodedFilename = Server.UrlPathEncode(filename);
}
else
{
encodedFilename = filename;
}
//**************************************************************
if (download != null)
{
Response.Clear();
if (string.Compare(download, "1", true, CultureInfo.InvariantCulture) == 0)
{
Response.AddHeader("Content-Disposition", @"attachment; filename=""" + encodedFilename + @"""");
Response.AddHeader("Accept-Ranges", "bytes");
Response.AddHeader("Content-Length", buffer.Length.ToString(CultureInfo.InvariantCulture));
Response.AddHeader("Content-Transfer-Encoding", "binary");
Response.ContentType = "application/octet-stream";
}
else
{
string ext = Path.GetExtension(filename);
if (!string.IsNullOrEmpty(ext))
{
ext = ext.Substring(1, ext.Length - 1); // remove first dot
}
Response.ContentType = Utils.GetAttachmentMimeTypeFromFileExtension(ext);
}
}
Response.BinaryWrite(buffer);
Response.Flush();
}
catch (Exception ex)
{
Log.WriteException(ex);
}
}
else
{
if (Request.QueryString["partID"] != null)
{
byte[] buffer = new byte[0];
try
{
string uid = HttpUtility.UrlDecode(Request.QueryString["uid"]);
string full_folder_name = Request.QueryString["full_folder_name"];
string partID = Request.QueryString["partID"];
string filename = Request.QueryString["filename"];
string download = Request.QueryString["download"];
string temp_file = Request.QueryString["tmp_filename"];
string temp_folder = Utils.GetTempFolderName(Session);
//*************************************************************
//IE with cyrillic file names
//*************************************************************
string encodedFilename;
userAgent = Request.UserAgent;
if (userAgent.IndexOf("MSIE") > -1)
{
encodedFilename = Server.UrlPathEncode(filename);
}
else
{
encodedFilename = filename;
}
//**************************************************************
if (!string.IsNullOrEmpty(temp_file) && File.Exists(Path.Combine(temp_folder, temp_file)))
{
using (FileStream fs = File.OpenRead(Path.Combine(temp_folder, temp_file)))
{
buffer = new byte[fs.Length];
fs.Read(buffer, 0, buffer.Length);
}
}
else
{
MailProcessor mp = new MailProcessor(DbStorageCreator.CreateDatabaseStorage(Session[Constants.sessionAccount] as Account));
try
{
mp.Connect();
Folder fld = mp.GetFolder(full_folder_name);
if (fld != null)
{
buffer = mp.GetAttachmentPart(uid, fld, partID);
}
}
finally
{
mp.Disconnect();
}
string tmp_filename = Utils.CreateTempFilePath(temp_folder, filename, true);
File.WriteAllBytes(tmp_filename, buffer);
}
if (download != null)
{
Response.Clear();
if (string.Compare(download, "1", true, CultureInfo.InvariantCulture) == 0)
{
Response.AddHeader("Content-Disposition", @"attachment; filename=""" + encodedFilename + @"""");
Response.AddHeader("Accept-Ranges", "bytes");
Response.AddHeader("Content-Length", buffer.Length.ToString(CultureInfo.InvariantCulture));
Response.AddHeader("Content-Transfer-Encoding", "binary");
Response.ContentType = "application/octet-stream";
}
else
{
string ext = Path.GetExtension(filename);
if (!string.IsNullOrEmpty(ext))
{
ext = ext.Substring(1, ext.Length - 1); // remove first dot
}
Response.ContentType = Utils.GetAttachmentMimeTypeFromFileExtension(ext);
}
}
Response.BinaryWrite(buffer);
Response.Flush();
}
catch (Exception ex)
{
Log.WriteException(ex);
}
}
else if ((Request.QueryString["id_msg"] != null) &&
(Request.QueryString["uid"] != null) &&
(Request.QueryString["id_folder"] != null) &&
(Request.QueryString["folder_path"] != null))
{
try
{
int id_msg = int.Parse(Request.QueryString["id_msg"], CultureInfo.InvariantCulture);
long id_folder = long.Parse(Request.QueryString["id_folder"], CultureInfo.InvariantCulture);
WebMailMessage msg = null;
MailProcessor mp = new MailProcessor(DbStorageCreator.CreateDatabaseStorage(Session[Constants.sessionAccount] as Account));
try
{
mp.Connect();
Folder fld = mp.GetFolder(id_folder);
if (fld != null)
{
msg = mp.GetMessage((fld.SyncType != FolderSyncType.DirectMode) ? (object)id_msg : HttpUtility.UrlDecode(Request.QueryString["uid"]), fld);
}
}
finally
{
mp.Disconnect();
}
if (msg.MailBeeMessage != null)
{
string subj = msg.MailBeeMessage.Subject;
//«\», «/», «?», «|», «*», «<», «>», «:»
string safeSubject = string.Empty;
for (int i = 0; i < subj.Length; i++)
{
if (subj[i] == '\\' || subj[i] == '|' || subj[i] == '/' ||
subj[i] == '?' || subj[i] == '*' || subj[i] == '<' ||
subj[i] == '>' || subj[i] == ':')
{
continue;
}
safeSubject += subj[i];
}
safeSubject = safeSubject.TrimStart();
if (safeSubject.Length > 30)
{
safeSubject = safeSubject.Substring(0, 30).TrimEnd();
}
safeSubject = safeSubject.TrimEnd(new char[2] {
'.', ' '
});
if (safeSubject.Length == 0)
{
safeSubject = "message";
}
string encodedMsgFilename;
userAgent = Request.UserAgent;
if (userAgent.IndexOf("MSIE") > -1)
{
encodedMsgFilename = Server.UrlPathEncode(safeSubject);
Response.AddHeader("Expires", "0");
Response.AddHeader("Cache-Control", "must-revalidate, post-check=0, pre-check=0");
Response.AddHeader("Pragma", "public");
}
else
{
encodedMsgFilename = safeSubject;
}
//**************************************************************
byte[] buffer = msg.MailBeeMessage.GetMessageRawData();
//**************************************************************
Response.Clear();
Response.ContentType = "application/octet-stream";
Response.AddHeader("Accept-Ranges", "bytes");
Response.AddHeader("Content-Length", buffer.Length.ToString(CultureInfo.InvariantCulture));
Response.AddHeader("Content-Disposition", string.Format(@"attachment; filename=""{0}.eml""", encodedMsgFilename));
Response.AddHeader("Content-Transfer-Encoding", "binary");
Response.BinaryWrite(buffer);
Response.Flush();
}
}
catch (Exception ex)
{
Log.WriteException(ex);
}
}
}
}
public static void Proccess(PXGraph graph, EMailAccount account, PX.Objects.CR.EPActivity email)
{
var obj = new MailProcessor(graph, account, email);
obj.Proccess();
}
/// <summary>
/// Rebuild all the magnets rules for each email addresses.
/// </summary>
private void RebuildRulesCombos()
{
// remove everything
comboMagnetAndRules.Items.Clear();
// and set the folder values.
var items = new List <ComboboxRuleItem>();
// keep track of the emails and/or domains
var itemsAlreadyAdded = new List <string>();
// the 'from' rules.
var address = MailProcessor.GetSmtpMailAddressForSender(_mailItem, _logger);
if (address != null)
{
// add them to the combo.
items.Add(new ComboboxRuleItem {
Text = $"From address: '{address.Address}'", Type = RuleTypes.FromEmail, MagnetText = address.Address.ToLower()
});
items.Add(new ComboboxRuleItem {
Text = $"From host: '@{address.Host}'", Type = RuleTypes.FromEmailHost, MagnetText = address.Host.ToLower()
});
// add those 2 to the list of 'done' items.
itemsAlreadyAdded.Add(address.Address.ToLower());
itemsAlreadyAdded.Add(address.Host.ToLower());
}
// the 'to' rules.
var toAddresses = MailProcessor.GetSmtpMailAddressForRecipients(_mailItem, _logger);
foreach (var toAddress in toAddresses)
{
// check if this address already exists.
var lowerCaseToAddress = toAddress.Address.ToLower();
if (!itemsAlreadyAdded.Select(c => c == lowerCaseToAddress).Any())
{
items.Add(new ComboboxRuleItem {
Text = $"To host: '{toAddress.Address}'", Type = RuleTypes.ToEmail, MagnetText = lowerCaseToAddress
});
itemsAlreadyAdded.Add(lowerCaseToAddress);
}
// check if this host already exists.
var lowerCaseToAddressHost = toAddress.Address.ToLower();
if (!itemsAlreadyAdded.Select(c => c == lowerCaseToAddressHost).Any())
{
items.Add(new ComboboxRuleItem {
Text = $"To host: '@{toAddress.Host}'", Type = RuleTypes.ToEmailHost, MagnetText = lowerCaseToAddressHost
});
itemsAlreadyAdded.Add(toAddress.Host.ToLower());
}
}
// the data source.
comboMagnetAndRules.DataSource = items;
// select the first item
comboMagnetAndRules.SelectedIndex = 0;
// do we have any folders?
if (_categories.Count == 0)
{
// there is nothing to select here, nothing much we can do really.
// so we select the first item, (the 'n/a' one)
comboMagnetAndRules.Enabled = false;
}
}
