private void ComboBox1_TextChanged(object sender, EventArgs e)
{
string Name = comboBox1.Text;
CDO cdo = CDOHelper.CDO;
Dictionary <string, PluginSettings> plugins = cdo.CommunitySettings.Plugins;
bool flag = plugins.ContainsKey(Name);
PluginSettings settings = flag ? plugins[Name] : null;
chkAllAccess.Checked = flag ? settings.Permissions.Everyone : false;
chkSuperAdminRun.Checked = flag ? settings.Permissions.SuperAdminRun : false;
chkTestEnvRun.Checked = flag ? settings.Permissions.TestEnvironmentRun : false;
for (int i = 0; i < cbPersonas.Items.Count; i++)
{
if (flag)
{
cbPersonas.SetItemChecked(i, settings.Permissions.Personas.Contains(cbPersonas.Items[i]));
}
else
{
cbPersonas.SetItemChecked(i, false);
}
}
UserIdsAccessToPlugin = GetUsersWithAccessToPlugin(settings, flag);
// reset user search
enabledOnlyBox.Checked = false;
searchUserBox.Text = string.Empty;
LoadUserIds(EncompassUserIds);
}
public CDOSmtpMessage(CDO.Message message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
m_message = message;
}
public PluginManagement_Form()
{
InitializeComponent();
CDO cdo = CDOHelper.CDO;
chkSide.Checked = cdo.CommunitySettings.SideMenuOpenByDefault.Contains("True");
txtTest.Text = cdo.CommunitySettings.TestServer;
flwPlugins.Controls.Add(new AccessControl());
}
///<summary>
/// Returns first repetition of CDO (Cumulative Dosage) - creates it if necessary
///</summary>
public CDO GetCDO() {
CDO ret = null;
try {
ret = (CDO)this.GetStructure("CDO");
} catch(HL7Exception e) {
HapiLogFactory.GetHapiLog(GetType()).Error("Unexpected error accessing data - this is probably a bug in the source code generator.", e);
throw new System.Exception("An unexpected error ocurred",e);
}
return ret;
}
private void btnSave_Click(object sender, System.EventArgs e)
{
CDO cdo = CDOHelper.CDO;
cdo.CommunitySettings.SideMenuOpenByDefault = chkSide.Checked ? "True" : "False";
cdo.CommunitySettings.TestServer = txtTest.Text;
CDOHelper.UpdateCDO(cdo);
CDOHelper.UploadCDO();
MessageBox.Show($" Saved");
}
private void btnSave_Click(object sender, EventArgs e)
{
string Name = comboBox1.Text;
CDO cdo = CDOHelper.CDO;
Dictionary <string, PluginSettings> plugins = cdo.CommunitySettings.Plugins;
bool flag = plugins.ContainsKey(Name);
PluginSettings settings = flag ? plugins[Name] : new PluginSettings();
settings.Permissions.SuperAdminRun = chkSuperAdminRun.Checked;
settings.Permissions.TestEnvironmentRun = chkTestEnvRun.Checked;
settings.Permissions.Everyone = chkAllAccess.Checked;
settings.Permissions.Personas = cbPersonas.CheckedItems.OfType <string>().ToList();
settings.Permissions.UserIDs = UserIdsAccessToPlugin.Distinct().ToList();
if (!flag)
{
cdo.CommunitySettings.Plugins.Add(Name, settings);
}
CDOHelper.UpdateCDO(cdo);
CDOHelper.UploadCDO();
MessageBox.Show($"{settings.PluginName} Saved");
}
public void OnArrival(CDO.Message Msg, ref CdoEventStatus EventStatus)
{
MessageBox.Show(Msg.Subject, "Message arrived!", MessageBoxButtons.OK, MessageBoxIcon.Information);
EventStatus = CdoEventStatus.cdoRunNextSink;
}
///<summary>
///Removes the given CDO
///</summary>
public void RemoveCDO(CDO toRemove)
{
this.RemoveStructure("CDO", toRemove);
}
CDO.Message RunEndToEndTest(CDO.Message message)
{
m_agent.ProcessMessage(message);
message = this.LoadMessage(message);
base.VerifyOutgoingMessage(message);
m_agent.ProcessMessage(message);
message = this.LoadMessage(message);
if (m_agent.Settings.InternalMessage.EnableRelay)
{
base.VerifyIncomingMessage(message);
}
else
{
base.VerifyOutgoingMessage(message);
}
return message;
}
static void TestMdnsInProcessedStatus(CDO.Message message, bool timelyAndReliable)
{
var queryMdn = BuildMdnQueryFromMdn(message);
queryMdn.Status = MdnStatus.Processed;
var mdnManager = CreateConfigStore().Mdns;
var mdn = mdnManager.Get(queryMdn.MdnIdentifier);
Assert.NotNull(mdn);
Assert.Equal("processed", mdn.Status, StringComparer.OrdinalIgnoreCase);
Assert.Equal(timelyAndReliable, mdn.NotifyDispatched);
}
void RunMdnInBoundProcessingTest(CDO.Message message)
{
VerifyOutgoingMessage(message); //Encryted Message
m_agent.ProcessMessage(message); //Decrypts Message
VerifyMdnIncomingMessage(message); //Mdn looped back
}
void RunMdnOutBoundProcessingTest(CDO.Message message)
{
VerifyMdnIncomingMessage(message); //Plain Text
m_agent.ProcessMessage(message); //Encrypts
VerifyOutgoingMessage(message); //Mdn looped back
}
public static void UpdateCDO(CDO CDO)
{
File = CDO;
}
protected static Mdn BuildMdnQueryFromMdn(CDO.Message message)
{
var messageEnvelope = new CDOSmtpMessage(message).GetEnvelope();
Assert.True(messageEnvelope.Message.IsMDN());
var notification = MDNParser.Parse(messageEnvelope.Message);
var originalMessageId = notification.OriginalMessageID;
string originalSender = messageEnvelope.Recipients[0].Address;
string originalRecipient = messageEnvelope.Sender.Address;
return new Mdn(originalMessageId, originalRecipient, originalSender);
}
//
// A CDO Message could be arriving via the SMTP server, or could have been constructed manually
// The one created by SMTP has envelope information
// Returns false if no envelope info is available. We have to look within message headers in that case
//
bool ExtractEnvelopeFields(CDO.Message message, ref DirectAddressCollection recipientAddresses, ref DirectAddress senderAddress)
{
if (!this.HasEnvelope)
{
//
// No envelope
//
return false;
}
recipientAddresses = null;
senderAddress = null;
string sender = message.GetEnvelopeSender();
if (string.IsNullOrEmpty(sender))
{
throw new SmtpAgentException(SmtpAgentError.NoSenderInEnvelope);
}
//
// In SMTP Server, the MAIL TO (sender) in the envelope can be empty if the message is from the server postmaster
// The actual postmaster address is found in the message itself
//
if (Health.Direct.SmtpAgent.Extensions.IsSenderLocalPostmaster(sender))
{
return false;
}
string recipients = message.GetEnvelopeRecipients();
if (string.IsNullOrEmpty(recipients))
{
throw new SmtpAgentException(SmtpAgentError.NoRecipientsInEnvelope);
}
recipientAddresses = DirectAddressCollection.ParseSmtpServerEnvelope(recipients);
senderAddress = new DirectAddress(sender);
return true;
}
internal void VerifyIncomingMessage(CDO.Message message)
{
ContentType contentType = new ContentType(message.GetContentType());
Assert.False(SMIMEStandard.IsContentEncrypted(contentType));
}
MessageEnvelope CreateEnvelope(CDO.Message message)
{
DirectAddressCollection recipientAddresses = null;
DirectAddress senderAddress = null;
MessageEnvelope envelope;
string messageText = message.GetMessageText();
if (this.ExtractEnvelopeFields(message, ref recipientAddresses, ref senderAddress))
{
envelope = new MessageEnvelope(messageText, recipientAddresses, senderAddress);
}
else
{
envelope = new MessageEnvelope(messageText);
}
return envelope;
}
private void AddAttachement(CDO.Message m, Attachment attachment, bool allowUnicode)
{
// set message
var s = new ADODB.Stream();
s.Charset = "UTF-8";
s.Open();
s.Type = ADODB.StreamTypeEnum.adTypeBinary;
int bytesRead;
var buffer = new byte[0x4400];
using (var acs = attachment.ContentStream)
while ((bytesRead = acs.Read(buffer, 0, 0x4400)) > 0)
if (bytesRead == 0x4400)
s.Write(buffer);
else
{
Array.Resize(ref buffer, bytesRead);
s.Write(buffer);
break;
}
s.Flush();
s.Position = 0;
//
var p = m.Attachments.Add();
p.ContentMediaType = attachment.ContentType.ToString();
p.ContentTransferEncoding = "base64";
var ds = p.GetDecodedContentStream();
s.CopyTo(ds);
ds.Flush();
}
public void ProcessCDOMessage(CDO.Message message)
{
try
{
this.Agent.ProcessMessage(message);
}
catch (Exception ex)
{
Logger.Fatal("While ProcessCDOMessage", ex);
//
// Paranoia of last resort. A malconfigured or malfunctioning agent should NEVER let ANY messages through
//
try
{
message.AbortMessage();
}
catch (Exception ex2)
{
Logger.Fatal("While aborting message", ex2);
}
throw;
}
}
internal CDO.Message LoadMessage(CDO.Message source)
{
return this.LoadMessage(source.GetMessageText());
}
CDO.Message RunEndToEndTest(CDO.Message message)
{
m_agent.ProcessMessage(message);
message = LoadMessage(message);
VerifyOutgoingMessage(message);
m_agent.ProcessMessage(message);
message = LoadMessage(message);
if (m_agent.Settings.InternalMessage.EnableRelay)
{
var smtpMessage = new CDOSmtpMessage(message).GetEnvelope();
VerifyIncomingMessage(message);
}
else
{
VerifyOutgoingMessage(message);
}
return message;
}
internal void VerifyOutgoingMessage(CDO.Message message)
{
Assert.True(string.IsNullOrEmpty(message.Subject));
ContentType contentType = new ContentType(message.GetContentType());
Assert.True(SMIMEStandard.IsContentEncrypted(contentType));
}
private static CDO DownloadCDO()
{
File = JsonConvert.DeserializeObject <CDO>(Encoding.UTF8.GetString(EncompassApplication.Session.DataExchange.GetCustomDataObject(Name).Data));
return(File);
}
internal void VerifyDSNIncomingMessage(CDO.Message message)
{
var envelope = new CDOSmtpMessage(message).GetEnvelope();
Assert.True(envelope.Message.IsDSN());
}
//---------------------------------------------------
//
// Message Processing
//
//---------------------------------------------------
public void ProcessMessage(CDO.Message message)
{
try
{
this.ProcessMessage(new CDOSmtpMessage(message));
}
catch
{
// Paranoia
message.AbortMessage();
throw;
}
}
protected static Mdn BuildQueryFromDSN(CDO.Message message)
{
var messageEnvelope = new CDOSmtpMessage(message).GetEnvelope();
Assert.True(messageEnvelope.Message.IsDSN());
var mimeMessage = messageEnvelope.Message;
var messageId = mimeMessage.IDValue;
string sender = messageEnvelope.Sender.Address;
string recipient = messageEnvelope.Recipients[0].Address;
return new Mdn(messageId, recipient, sender);
}
//
// Processing message like smtp gateway would
//
CDO.Message RunEndToEndTest(CDO.Message message, SmtpAgent agent)
{
agent.ProcessMessage(message);
message = LoadMessage(message);
VerifyOutgoingMessage(message);
agent.ProcessMessage(message);
message = LoadMessage(message);
if (agent.Settings.InternalMessage.EnableRelay)
{
VerifyIncomingMessage(message);
}
else
{
VerifyOutgoingMessage(message);
}
return message;
}
