Files

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
}
}