455 lines
16 KiB
C#
455 lines
16 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text.RegularExpressions;
|
|
using Swarmops.Basic.Types;
|
|
using Swarmops.Basic.Types.Communications;
|
|
using Swarmops.Common;
|
|
using Swarmops.Common.Enums;
|
|
using Swarmops.Common.Interfaces;
|
|
using Swarmops.Database;
|
|
using Swarmops.Logic.Media;
|
|
using Swarmops.Logic.Structure;
|
|
using Swarmops.Logic.Swarm;
|
|
|
|
namespace Swarmops.Logic.Communications
|
|
{
|
|
public class OutboundMail : BasicOutboundMail
|
|
{
|
|
#region Creation and Construction
|
|
|
|
// =============================
|
|
// CREATION AND CONSTRUCTION
|
|
// =============================
|
|
|
|
|
|
/// <summary>
|
|
/// Private constructor from basic object
|
|
/// </summary>
|
|
private OutboundMail (BasicOutboundMail basic)
|
|
: base (basic)
|
|
{
|
|
// remember titel for templated mail, it is the name of the template.
|
|
if (MailType > 0)
|
|
this.templateName = basic.Title;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creation from basic object - internal to PirateWeb.Logic
|
|
/// </summary>
|
|
internal static OutboundMail FromBasic (BasicOutboundMail basic)
|
|
{
|
|
if (basic == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return new OutboundMail (basic);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Retrieves the OutboundMail with a certain Identity
|
|
/// </summary>
|
|
/// <param name="outboundMailId">The Identity of the OutboundMail</param>
|
|
/// <returns>An OutboundMail from the database</returns>
|
|
public static OutboundMail FromIdentity (int outboundMailId)
|
|
{
|
|
return FromBasic (SwarmDb.GetDatabaseForReading().GetOutboundMail (outboundMailId));
|
|
}
|
|
|
|
|
|
public static OutboundMail Create (Person author, string title,
|
|
string body, int mailPriority, int mailType,
|
|
Organization organization, Geography geography)
|
|
{
|
|
return Create (author, title, body, mailPriority, mailType, organization,
|
|
geography, DateTime.Now);
|
|
}
|
|
|
|
public static OutboundMail Create (Person author, string title,
|
|
string body, int mailPriority, int mailType,
|
|
Organization organization, Geography geography, DateTime releaseDateTime)
|
|
{
|
|
return
|
|
FromIdentity (SwarmDb.GetDatabaseForWriting()
|
|
.CreateOutboundMail (MailAuthorType.Person, author.Identity, title,
|
|
body, mailPriority, mailType,
|
|
geography.Identity, organization.Identity,
|
|
releaseDateTime));
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Creates an unusable OutboundMail. Used for rendering previews - ONLY.
|
|
/// (this version, with the ignored priority param is for backward compability)
|
|
/// </summary>
|
|
public static OutboundMail CreateFake (Person author, string title, string body, int ignoredPriority,
|
|
int mailType,
|
|
Organization organization, Geography geography)
|
|
{
|
|
return CreateFake (author, title, body, mailType, organization, geography);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Creates an unusable OutboundMail. Used for rendering previews - ONLY.
|
|
/// </summary>
|
|
public static OutboundMail CreateFake (Person author, string title,
|
|
string body, int mailType,
|
|
Organization organization, Geography geography)
|
|
{
|
|
return FromBasic (new BasicOutboundMail (0, MailAuthorType.Person, author.PersonId, title,
|
|
body, 99, mailType, organization.Identity,
|
|
geography.Identity, DateTime.Now,
|
|
DateTime.Now, false, false, false, Constants.DateTimeLow,
|
|
Constants.DateTimeLow, Constants.DateTimeLow, 0, 0, 0));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates an OutboundMail with a "functional" author.
|
|
/// </summary>
|
|
public static OutboundMail CreateFunctional (MailAuthorType authorType, string title,
|
|
string body, int mailPriority, int mailType,
|
|
int organizationId, int geographyId, DateTime releaseDateTime)
|
|
{
|
|
int mailID = SwarmDb.GetDatabaseForWriting().CreateOutboundMail (authorType, 0, title,
|
|
body, mailPriority, mailType, geographyId,
|
|
organizationId, releaseDateTime);
|
|
|
|
//Constructing instead of reading back from DB, saves time but..., Don't know if it is a good idea./JL
|
|
return FromBasic (new BasicOutboundMail (mailID, authorType, 0, title,
|
|
body, mailPriority, mailType, organizationId,
|
|
geographyId, DateTime.Now,
|
|
releaseDateTime));
|
|
}
|
|
|
|
public List<OutboundMail> GetDuplicates (DateTime afterTime, int recipientId)
|
|
{
|
|
List<OutboundMail> retList = new List<OutboundMail>();
|
|
BasicOutboundMail[] mails
|
|
= SwarmDb.GetDatabaseForReading().GetDuplicateOutboundMail (AuthorType, AuthorPersonId, Title,
|
|
Body, MailPriority, MailType, GeographyId, OrganizationId, afterTime, recipientId);
|
|
foreach (BasicOutboundMail mail in mails)
|
|
{
|
|
retList.Add (FromBasic (mail));
|
|
}
|
|
|
|
return retList;
|
|
;
|
|
}
|
|
|
|
public static OutboundMail GetFirstUnresolved()
|
|
{
|
|
BasicOutboundMail[] mails = SwarmDb.GetDatabaseForReading().GetTopUnresolvedOutboundMail (1);
|
|
|
|
if (mails.Length > 0)
|
|
{
|
|
return FromBasic (mails[0]);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public static OutboundMail GetFirstUnprocessed()
|
|
{
|
|
BasicOutboundMail[] mails = SwarmDb.GetDatabaseForReading().GetTopUnprocessedOutboundMail (1);
|
|
|
|
if (mails.Length > 0)
|
|
{
|
|
return FromBasic (mails[0]);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Properties and Accessors
|
|
|
|
public new DateTime StartProcessDateTime
|
|
{
|
|
get { return base.StartProcessDateTime; }
|
|
set
|
|
{
|
|
SwarmDb.GetDatabaseForWriting().SetOutboundMailStartProcess (Identity);
|
|
base.StartProcessDateTime = DateTime.Now;
|
|
}
|
|
}
|
|
|
|
public Person Author
|
|
{
|
|
get
|
|
{
|
|
if (AuthorType != MailAuthorType.Person)
|
|
{
|
|
throw new InvalidOperationException (
|
|
"OutboundMail.Author is not a valid property when OutboundMail.AuthorType isn't MailAuthorType.Person.");
|
|
}
|
|
|
|
if (this.author == null)
|
|
{
|
|
this.author = Person.FromIdentity (AuthorPersonId);
|
|
}
|
|
|
|
return this.author;
|
|
}
|
|
}
|
|
|
|
public Organization Organization
|
|
{
|
|
get
|
|
{
|
|
if (this.organization == null)
|
|
{
|
|
this.organization = Organization.FromIdentity (OrganizationId);
|
|
}
|
|
|
|
return this.organization;
|
|
}
|
|
}
|
|
|
|
public Geography Geography
|
|
{
|
|
get
|
|
{
|
|
if (this.geography == null)
|
|
{
|
|
this.geography = Geography.FromIdentity (GeographyId);
|
|
}
|
|
|
|
return this.geography;
|
|
}
|
|
}
|
|
|
|
public string TemplateName
|
|
{
|
|
get { return this.templateName; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Recipient access and manipulation
|
|
|
|
public OutboundMailRecipients GetNextRecipientBatch (int batchSize)
|
|
{
|
|
return
|
|
OutboundMailRecipients.FromArray (
|
|
SwarmDb.GetDatabaseForReading().GetTopOutboundMailRecipients (Identity, batchSize), this);
|
|
}
|
|
|
|
public void AddRecipient (Person person, bool asOfficer)
|
|
{
|
|
AddRecipient (person.Identity, asOfficer);
|
|
}
|
|
|
|
public void AddRecipient (Reporter person)
|
|
{
|
|
AddReporterRecipient (person.Identity);
|
|
}
|
|
|
|
public void AddRecipients (int[] personIds, bool asOfficers)
|
|
{
|
|
foreach (int personId in personIds)
|
|
{
|
|
AddRecipient (personId, asOfficers);
|
|
}
|
|
}
|
|
|
|
public void AddReporterRecipients (int[] personIds)
|
|
{
|
|
foreach (int personId in personIds)
|
|
{
|
|
AddReporterRecipient (personId);
|
|
}
|
|
}
|
|
|
|
public void AddRecipient (int personId, bool asOfficer)
|
|
{
|
|
SwarmDb.GetDatabaseForWriting()
|
|
.CreateOutboundMailRecipient (Identity, personId, asOfficer,
|
|
(int) OutboundMailRecipient.RecipientType.Person);
|
|
}
|
|
|
|
private void AddReporterRecipient (int identity)
|
|
{
|
|
SwarmDb.GetDatabaseForWriting()
|
|
.CreateOutboundMailRecipient (Identity, identity, false,
|
|
(int) OutboundMailRecipient.RecipientType.Reporter);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Status changers
|
|
|
|
public void SetReadyForPickup()
|
|
{
|
|
SwarmDb.GetDatabaseForWriting().SetOutboundMailReadyForPickup (Identity);
|
|
base.ReadyForPickup = true;
|
|
}
|
|
|
|
public void SetResolved()
|
|
{
|
|
SwarmDb.GetDatabaseForWriting().SetOutboundMailResolved (Identity);
|
|
base.Resolved = true;
|
|
}
|
|
|
|
public void SetProcessed()
|
|
{
|
|
SwarmDb.GetDatabaseForWriting().SetOutboundMailProcessed (Identity);
|
|
base.Processed = true;
|
|
}
|
|
|
|
public void SetRecipientCount (int recipientCount)
|
|
{
|
|
SwarmDb.GetDatabaseForWriting().SetOutboundMailRecipientCount (Identity, recipientCount);
|
|
base.RecipientCount = recipientCount;
|
|
}
|
|
|
|
public void IncrementSuccesses()
|
|
{
|
|
SwarmDb.GetDatabaseForWriting().IncrementOutboundMailSuccesses (Identity);
|
|
base.RecipientsSuccess++;
|
|
}
|
|
|
|
public void IncrementFailures()
|
|
{
|
|
SwarmDb.GetDatabaseForWriting().IncrementOutboundMailFailures (Identity);
|
|
base.RecipientsFail++;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Methods and Manipulation
|
|
|
|
/// <summary>
|
|
/// Renders the mail for a specific recipient, in text.
|
|
/// </summary>
|
|
/// <param name="person">The person to render for.</param>
|
|
/// <returns>Text with proper replacements done</returns>
|
|
public string RenderText (IEmailPerson recipient, string culture)
|
|
{
|
|
// First, check if there is a mail template AT ALL. If not, return the raw text.
|
|
if (MailType == (int) TypedMailTemplate.TemplateType.None)
|
|
{
|
|
return Body;
|
|
}
|
|
|
|
// (If there is a template, the body contains the serialized placeholder values)
|
|
return Render (recipient, culture, true).PlainText;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Renders the mail for a specific recipient, in HTML.
|
|
/// </summary>
|
|
/// <param name="recipient">The person to render for.</param>
|
|
/// <returns>HTML with proper replacements done</returns>
|
|
public string RenderHtml (IEmailPerson recipient, string culture)
|
|
{
|
|
// First, check if there is a mail template AT ALL. If not, return the raw text,
|
|
// within <PRE></PRE> if not already html
|
|
|
|
if (MailType == (int) TypedMailTemplate.TemplateType.None)
|
|
{
|
|
Regex reHtmlType = new Regex (@"(</[a-z1-4]+>)", RegexOptions.IgnoreCase);
|
|
|
|
if (reHtmlType.IsMatch (Body))
|
|
return Body;
|
|
return "<PRE>" + Body + "</PRE>";
|
|
}
|
|
|
|
// (If there is a template, the body contains the serialized placeholder values)
|
|
return Render (recipient, culture, false).Html;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Renders the mail for a specific recipient
|
|
/// </summary>
|
|
/// <param name="recipient">The person to render for.</param>
|
|
/// <param name="recipient">The culture to render for.</param>
|
|
/// <param name="renderText">True if "Plain" template should be used (if available)</param>
|
|
/// <returns>MailTemplate with proper replacements done</returns>
|
|
public MailTemplate Render (IEmailPerson recipient, string culture, bool renderText)
|
|
{
|
|
lock (lockTemplates)
|
|
{
|
|
//Locking is needed since this is used in a multithreading scenario and the template is cached for efficiency
|
|
|
|
TypedMailTemplate template = PrepareTemplate (culture, renderText);
|
|
// Setup template and load serialized replacements
|
|
template.FillIndividualPlaceholders (recipient); // Add recipient data
|
|
template.InsertAllPlaceHoldersToTemplate(); // Make all replacements
|
|
Title = template.Template.TemplateTitleText; // Get the resulting title
|
|
template.Template.TemplateBody = template.Template.TemplateBody; // Force it to save Html
|
|
return new MailTemplate (template.Template);
|
|
}
|
|
}
|
|
|
|
private TypedMailTemplate PrepareTemplate (string culture, bool renderText)
|
|
{
|
|
TypedMailTemplate template = null;
|
|
if (renderText)
|
|
{
|
|
if (this.templatePlain == null)
|
|
{
|
|
this.templatePlain =
|
|
TypedMailTemplate.FromName (TypedMailTemplate.GetNameFromMailType (MailType) + "Plain");
|
|
this.templatePlain.Initialize (culture.Substring (3), Organization.Identity, this,
|
|
(renderText ? "Plain" : ""));
|
|
this.templatePlain.PreparePlaceholders();
|
|
}
|
|
else
|
|
{
|
|
//reuse the template, just reset the html to the saved version before replacements
|
|
this.templatePlain.Template.ResetContent();
|
|
}
|
|
template = this.templatePlain;
|
|
}
|
|
else
|
|
{
|
|
if (this.templateHtml == null)
|
|
{
|
|
this.templateHtml = TypedMailTemplate.FromName (TypedMailTemplate.GetNameFromMailType (MailType));
|
|
this.templateHtml.Initialize (culture.Substring (3), Organization.Identity, this,
|
|
(renderText ? "Plain" : ""));
|
|
this.templateHtml.PreparePlaceholders();
|
|
}
|
|
else
|
|
{
|
|
//reuse the template, just reset the html to the saved version before replacements
|
|
this.templateHtml.Template.ResetContent();
|
|
}
|
|
template = this.templateHtml;
|
|
}
|
|
|
|
return template;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Dish and Dishonesty
|
|
|
|
// Long live Black Adder.
|
|
|
|
#endregion
|
|
|
|
public static readonly int PriorityHighest = 10;
|
|
public static readonly int PriorityHigh = 30;
|
|
public static readonly int PriorityNormal = 50;
|
|
public static readonly int PriorityLow = 70;
|
|
public static readonly int PriorityLowest = 90;
|
|
private static readonly object lockTemplates = new object();
|
|
private readonly string templateName = "";
|
|
|
|
private Person author;
|
|
private Geography geography;
|
|
private Organization organization;
|
|
|
|
//If used in a multithreaded scenario, the cached templates need to be locked while rendering.
|
|
private TypedMailTemplate templateHtml; //Cached template to use for plain rendering
|
|
private TypedMailTemplate templatePlain; //Cached template to use for html rendering
|
|
|
|
|
|
// keeps track of the Title of the outbound mail as it were when loaded from DB
|
|
}
|
|
} |