/// <summary>
/// UIForm's OnAfterValidate event handler.
/// </summary>
protected void EditForm_OnAfterValidate(object sender, EventArgs e)
{
SubscriberInfo subscriberObj = EditedObject as SubscriberInfo;
if (subscriberObj != null)
{
string emailNew = ValidationHelper.GetString(EditForm.GetFieldValue("SubscriberEmail"), String.Empty);
string emailCurrent = subscriberObj.SubscriberEmail;
// Check email
if (emailNew == string.Empty)
{
EditForm.StopProcessing = true;
ShowError(GetString("Subscriber_Edit.ErrorEmptyEmail"));
}
else if ((emailNew.ToLowerCSafe() != emailCurrent.ToLowerCSafe()) && (SubscriberInfoProvider.EmailExists(emailNew)))
{
EditForm.StopProcessing = true;
ShowError(GetString("Subscriber_Edit.EmailAlreadyExists"));
}
}
else
{
EditForm.StopProcessing = true;
ShowError(GetString("Subscriber_Edit.SubscriberDoesNotExists"));
}
}
protected void Page_Load(object sender, EventArgs e)
{
IssueInfo issue = EditedObject as IssueInfo;
if (issue == null)
{
RedirectToAccessDenied(GetString("general.invalidparameters"));
}
if (!issue.CheckPermissions(PermissionsEnum.Read, CurrentSiteName, CurrentUser))
{
RedirectToAccessDenied(issue.TypeInfo.ModuleName, "AuthorIssues");
}
Guid subscriberGuid = QueryHelper.GetGuid("subscriberguid", Guid.Empty);
SubscriberInfo subscriber = SubscriberInfoProvider.GetSubscriberInfo(subscriberGuid, SiteContext.CurrentSiteID);
using (var context = new CMSActionContext())
{
// Switch culture to the site culture, so the e-mail isn't rendered in the editor's culture
string culture = CultureHelper.GetDefaultCultureCode(SiteContext.CurrentSiteName);
context.Culture = CultureHelper.GetCultureInfo(culture);
string htmlPage = NewsletterHelper.GetPreviewHTML(issue, subscriber);
Response.Clear();
Response.Write(htmlPage);
}
RequestHelper.EndResponse();
}
/// <summary>
/// Gets and bulk updates subscribers. Called when the "Get and bulk update subscribers" button is pressed.
/// Expects the CreateSubscriber method to be run first.
/// </summary>
private bool GetAndBulkUpdateSubscribers()
{
// Prepare the parameters
string where = "SubscriberEmail LIKE N'[email protected]%'";
// Get the data
DataSet subscribers = SubscriberInfoProvider.GetSubscribers(where, null);
if (!DataHelper.DataSourceIsEmpty(subscribers))
{
// Loop through the individual items
foreach (DataRow subscriberDr in subscribers.Tables[0].Rows)
{
// Create object from DataRow
SubscriberInfo modifySubscriber = new SubscriberInfo(subscriberDr);
// Update the properties
modifySubscriber.SubscriberFullName = modifySubscriber.SubscriberFullName.ToUpper();
// Save the changes
SubscriberInfoProvider.SetSubscriberInfo(modifySubscriber);
}
return(true);
}
return(false);
}
/// <summary>
/// Uniselector item selected event handler.
/// </summary>
protected void UniSelector_OnItemsSelected(object sender, EventArgs e)
{
// Check permissions
if (!MembershipContext.AuthenticatedUser.IsAuthorizedPerResource("cms.newsletter", "ManageSubscribers"))
{
RedirectToAccessDenied("cms.newsletter", "ManageSubscribers");
}
// Get new items from selector
string newValues = ValidationHelper.GetString(selectNewsletter.Value, null);
string[] newItems = newValues.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
// Get all selected newsletters
foreach (string item in newItems)
{
int newsletterId = ValidationHelper.GetInteger(item, 0);
// Get subscription
SubscriberNewsletterInfo subscription = SubscriberNewsletterInfoProvider.GetSubscriberNewsletterInfo(mSubscriberId, newsletterId);
// If not already subscribed
if (subscription == null)
{
// Send confirmation only when subscriber is not Role or CG type and only when Double opt-in is enabled.
SubscriberInfoProvider.Subscribe(mSubscriberId, newsletterId, DateTime.Now, chkSendConfirmation.Checked, !mIsMultipleSubscriber && chkRequireOptIn.Checked);
}
}
selectNewsletter.Value = null;
unigridNewsletters.ReloadData();
pnlUpdate.Update();
}
protected void Page_Load(object sender, EventArgs e)
{
// Check read permission
ContactHelper.AuthorizedReadContact(CMSContext.CurrentSiteID, true);
string siteName = CMSContext.CurrentSiteName;
// Get bounce limit
mBounceLimit = NewsletterHelper.BouncedEmailsLimit(siteName);
// Get info if bounced e-mail tracking is available
mBounceInfoAvailable = NewsletterHelper.MonitorBouncedEmails(siteName);
// Check if parent object exist
SubscriberInfo sb = SubscriberInfoProvider.GetSubscriberInfo(QueryHelper.GetInteger("subscriberid", 0));
EditedObject = sb;
// Initialize unigrid
UniGrid.OnAction += uniGrid_OnAction;
UniGrid.OnExternalDataBound += uniGrid_OnExternalDataBound;
UniGrid.WhereCondition = "ContactID IN (SELECT ContactGroupMemberRelatedID FROM OM_ContactGroupMember WHERE ContactGroupMemberContactGroupID = "
+ QueryHelper.GetInteger("groupid", 0) + " AND ContactGroupMemberType = 0) AND ContactSiteID = " + CMSContext.CurrentSiteID
+ " AND ContactMergedWithContactID IS NULL";
UniGrid.ShowObjectMenu = false;
}
private SubscriberInfo CreateSubscriber(
string email,
string firstName,
string lastName,
string fullName,
ContactInfo contact)
{
var subscriberByEmail = SubscriberInfoProvider.GetSubscriberByEmail(email, _mSite.SiteID);
if (subscriberByEmail != null)
{
return(subscriberByEmail);
}
var subscriber = new SubscriberInfo
{
SubscriberEmail = email,
SubscriberFirstName = firstName,
SubscriberLastName = lastName,
SubscriberSiteID = _mSite.SiteID,
SubscriberFullName = fullName,
SubscriberRelatedID = contact.ContactID,
SubscriberType = "om.contact"
};
SubscriberInfoProvider.SetSubscriberInfo(subscriber);
return(subscriber);
}
protected void OnBeforeSave(object sender, EventArgs e)
{
// Check license
if (!SubscriberInfoProvider.LicenseVersionCheck(RequestContext.CurrentDomain, FeatureEnum.Subscribers, ObjectActionEnum.Insert))
{
NewForm.StopProcessing = true;
ShowError(GetString("LicenseVersionCheck.Subscribers"));
}
// Set SiteID
NewForm.Data.SetValue("SubscriberSiteID", SiteContext.CurrentSiteID);
string firstName = ValidationHelper.GetString(NewForm.GetFieldValue("SubscriberFirstName"), string.Empty);
string lastName = ValidationHelper.GetString(NewForm.GetFieldValue("SubscriberLastName"), string.Empty);
// Set full name
NewForm.Data.SetValue("SubscriberFullName", string.Concat(firstName, " ", lastName));
string email = ValidationHelper.GetString(NewForm.GetFieldValue("SubscriberEmail"), string.Empty);
// Check email
if (email == string.Empty)
{
NewForm.StopProcessing = true;
ShowError(GetString("Subscriber_Edit.ErrorEmptyEmail"));
}
else if (SubscriberInfoProvider.EmailExists(email))
{
NewForm.StopProcessing = true;
ShowError(GetString("Subscriber_Edit.EmailAlreadyExists"));
}
}
/// <summary>
/// Performs action on given subscriber.
/// </summary>
/// <param name="subscriberId">Id of subscriber</param>
/// <param name="actionName">Name of action</param>
private void DoSubscriberAction(int subscriberId, string actionName)
{
try
{
// Check manage subscribers permission
var subscriber = SubscriberInfoProvider.GetSubscriberInfo(subscriberId);
if (!subscriber.CheckPermissions(PermissionsEnum.Modify, SiteContext.CurrentSiteName, MembershipContext.AuthenticatedUser))
{
RedirectToAccessDenied(subscriber.TypeInfo.ModuleName, "ManageSubscribers");
}
switch (actionName.ToUpperInvariant())
{
// Subscribe
case SUBSCRIBE:
var subscription = SubscriberNewsletterInfoProvider.GetSubscriberNewsletterInfo(subscriberId, mNewsletter.NewsletterID);
if ((subscription == null) || subscription.SubscriptionEnabled)
{
return;
}
SubscriberInfoProvider.RenewSubscription(subscriberId, mNewsletter.NewsletterID, chkSendConfirmation.Checked);
SubscriberNewsletterInfoProvider.SetApprovalStatus(subscriberId, mNewsletter.NewsletterID, !chkRequireOptIn.Checked);
if (chkRequireOptIn.Checked)
{
IssueInfoProvider.SendDoubleOptInEmail(subscriberId, mNewsletter.NewsletterID);
}
break;
// Unsubscribe
case UNSUBSCRIBE:
SubscriberInfoProvider.Unsubscribe(subscriberId, mNewsletter.NewsletterID, chkSendConfirmation.Checked);
break;
// Remove subscription
case REMOVE:
SubscriberInfoProvider.DeleteSubscription(subscriberId, mNewsletter.NewsletterID, chkSendConfirmation.Checked);
break;
// Approve subscription
case APPROVE:
SubscriberNewsletterInfoProvider.ApproveSubscription(subscriberId, mNewsletter.NewsletterID);
break;
// Block selected subscriber
case BLOCK:
SubscriberInfoProvider.BlockSubscriber(subscriberId);
break;
// Un-block selected subscriber
case UNBLOCK:
SubscriberInfoProvider.UnblockSubscriber(subscriberId);
break;
}
}
catch (Exception e)
{
LogAndShowError("Newsletter subscriber", "NEWSLETTERS", e);
}
}
public void ConfirmSubscription_Hash_DateTime_SubscriptionIsConfirmed()
{
var email = "a-guid-" + Guid.NewGuid() + "@domain.com";
var dateTime = DateTime.Now;
var contact = GetContact(email);
mNewsletterSubscriptionService.Subscribe(contact, mNewsletter, mNewsletterSubscriptionSettings);
// Get the expected subscriber and binding to newsletter so that hash for their subscription confirmation can be faked
// (the newsletters API allows to retrieve current hash, but not the corresponding timestamp which is necessary to pass the validation).
var expectedSubscriber = SubscriberInfoProvider.GetSubscriberByEmail(email, mSite.SiteID);
var confirmationHash = SecurityHelper.GenerateConfirmationEmailHash(mNewsletter.NewsletterGUID + "|" + expectedSubscriber.SubscriberGUID, dateTime);
var expectedSubscriberNewsletter = SubscriberNewsletterInfoProvider.GetSubscriberNewsletterInfo(expectedSubscriber.SubscriberID, mNewsletter.NewsletterID);
expectedSubscriberNewsletter.SubscriptionApprovalHash = confirmationHash;
SubscriberNewsletterInfoProvider.SetSubscriberNewsletterInfo(expectedSubscriberNewsletter);
var approvalResult = mNewsletterSubscriptionService.ConfirmSubscription(expectedSubscriberNewsletter.SubscriptionApprovalHash, false, dateTime);
// Retrieve the subscriber-newsletter binding again so that approval state can be validated
expectedSubscriberNewsletter = SubscriberNewsletterInfoProvider.GetSubscriberNewsletterInfo(expectedSubscriber.SubscriberID, mNewsletter.NewsletterID);
Assert.AreEqual(ApprovalResult.Success, approvalResult, "Subscription confirmation was not successful.");
Assert.IsTrue(expectedSubscriberNewsletter.SubscriptionApproved, $"Subscription is not approved after confirmation.");
}
/// <summary>
/// DataForm's OnAfterValidate event handler.
/// </summary>
protected void formCustomFields_OnAfterValidate(object sender, EventArgs e)
{
// Get subscriber's email
FormEngineUserControl control = (FormEngineUserControl)formCustomFields.BasicForm.FieldControls["SubscriberEmail"];
if (control != null)
{
string mail = ValidationHelper.GetString(control.Value, String.Empty).Trim();
// Get original subscriber
SubscriberInfo subscriberObj = SubscriberInfoProvider.GetSubscriberInfo(subscriberId);
if (subscriberObj != null)
{
// Check the email changes
if ((subscriberObj.SubscriberEmail.ToLowerCSafe() != mail.ToLowerCSafe()) && (SubscriberInfoProvider.EmailExists(mail)))
{
// Show error message if the email address is already used by another subscriber
formCustomFields.BasicForm.StopProcessing = true;
ShowError(GetString("Subscriber_Edit.EmailAlreadyExists"));
}
}
else
{
formCustomFields.BasicForm.StopProcessing = true;
ShowError(GetString("Subscriber_Edit.SubscriberDoesNotExists"));
}
}
}
/// <summary>
/// Creates a subscriber object. If the subscriber with the given e-mail address already exists, returns the existing subscriber.
/// </summary>
/// <param name="email">Subscriber's e-mail address</param>
/// <returns>Returns new subscriber object. If the subscriber with the given email already exists, returns the existing subscriber.</returns>
private SubscriberInfo SaveSubscriber(string email)
{
// Gets information about subscriber based on email address and current site
SubscriberInfo subscriber = SubscriberInfoProvider.GetSubscriberInfo(email, SiteId);
if (subscriber == null)
{
// Creates new subscriber
subscriber = new SubscriberInfo
{
SubscriberEmail = email,
SubscriberSiteID = SiteId
};
// Checks subscriber license limitation
if (!SubscriberInfoProvider.LicenseVersionCheck(RequestContext.CurrentDomain, FeatureEnum.Subscribers, ObjectActionEnum.Insert))
{
CoreServices.EventLog.LogEvent("W", "Newsletters", "SaveSubscriber", "Subscriber could not be added due to license limitations.");
return(null);
}
// Saves subscriber info
SubscriberInfoProvider.SetSubscriberInfo(subscriber);
}
return(subscriber);
}
/// <summary>
/// Logs activity for unsubscribing.
/// </summary>
/// <param name="sb">Subscriber (optional - can be null if subscriber ID is used)</param>
/// <param name="subscriberId">Subscriber ID (optional - can be zero if subscriber object is used)</param>
/// <param name="newsletterId">Newsletter ID</param>
/// <param name="issueId">Issue ID</param>
/// <param name="contactId">Contact ID is present if the mail is sent to a contact or a contact group</param>
private void LogActivity(SubscriberInfo sb, int subscriberId, int newsletterId, int issueId, int contactId)
{
bool isFromContactGroup = !string.IsNullOrEmpty(sb.SubscriberType) && sb.SubscriberType.EqualsCSafe(PredefinedObjectType.CONTACTGROUP, true);
if (contactId <= 0)
{
contactId = ActivityTrackingHelper.GetContactID(sb);
}
if (sb == null)
{
sb = SubscriberInfoProvider.GetSubscriberInfo(subscriberId);
}
if (contactId > 0)
{
NewsletterInfo news = NewsletterInfoProvider.GetNewsletterInfo(newsletterId);
Activity activity = new ActivityNewsletterUnsubscribing(sb, news, CMSContext.ActivityEnvironmentVariables);
if (activity.Data != null)
{
activity.Data.ContactID = contactId;
activity.Data.ItemDetailID = issueId;
activity.Data.Value = isFromContactGroup ? "contactgroup(" + sb.SubscriberRelatedID + ")" : null;
activity.Log();
}
}
}
/// <summary>
/// Performs action on given subscriber.
/// </summary>
/// <param name="subscriberId">Id of subscriber</param>
/// <param name="actionName">Name of action</param>
private void DoSubscriberAction(int subscriberId, string actionName)
{
try
{
// Check manage subscribers permission
var subscriber = SubscriberInfoProvider.GetSubscriberInfo(subscriberId);
if (!subscriber.CheckPermissions(PermissionsEnum.Modify, SiteContext.CurrentSiteName, MembershipContext.AuthenticatedUser))
{
RedirectToAccessDenied(subscriber.TypeInfo.ModuleName, "ManageSubscribers");
}
switch (actionName.ToUpperInvariant())
{
// Remove subscription
case REMOVE:
mSubscriptionService.RemoveSubscription(subscriberId, mNewsletter.NewsletterID, false);
break;
// Approve subscription
case APPROVE:
SubscriberNewsletterInfoProvider.ApproveSubscription(subscriberId, mNewsletter.NewsletterID);
break;
}
}
catch (Exception exception)
{
LogAndShowError("Newsletter subscriber", "NEWSLETTERS", exception);
}
}
protected void Page_Load(object sender, EventArgs e)
{
string currentSubscriber = GetString("Subscriber_Edit.NewItemCaption");
// Get subscriber id from querystring
subscriberId = QueryHelper.GetInteger("subscriberid", 0);
// Get subscriber object
SubscriberInfo subscriberObj = SubscriberInfoProvider.GetSubscriberInfo(subscriberId);
if (subscriberObj != null)
{
if (!DataHelper.IsEmpty(subscriberObj.SubscriberEmail))
{
// Get e-mail for breadcrumbs
currentSubscriber = subscriberObj.SubscriberEmail;
}
else
{
string type = null;
switch (subscriberObj.SubscriberType)
{
case SiteObjectType.USER:
type = GetString("objecttype.cms_user");
break;
case SiteObjectType.ROLE:
type = GetString("objecttype.cms_role");
break;
case PredefinedObjectType.CONTACTGROUP:
type = GetString("objecttype.om_contactgroup");
break;
case PredefinedObjectType.CONTACT:
type = GetString("objecttype.om_contact");
break;
}
// Get first, last names and type for breadcrumbs
currentSubscriber = string.Format("{0} ({1})", string.Concat(subscriberObj.SubscriberFirstName, " ", subscriberObj.SubscriberLastName), type.ToLowerCSafe());
}
}
// Initializes page title
string[,] breadcrumbs = new string[2, 3];
breadcrumbs[0, 0] = GetString("Subscriber_Edit.ItemListLink");
breadcrumbs[0, 1] = "~/CMSModules/Newsletters/Tools/Subscribers/Subscriber_List.aspx";
breadcrumbs[0, 2] = "newslettersContent";
breadcrumbs[1, 0] = currentSubscriber;
CurrentMaster.Title.Breadcrumbs = breadcrumbs;
// Initialize tabs
InitalizeMenu(subscriberObj);
}
/// <summary>
/// Deletes subscriber. Called when the "Delete subscriber" button is pressed.
/// Expects the CreateSubscriber method to be run first.
/// </summary>
private bool DeleteSubscriber()
{
// Get the subscriber
SubscriberInfo deleteSubscriber = SubscriberInfoProvider.GetSubscriberInfo("*****@*****.**", SiteContext.CurrentSiteID);
// Delete the subscriber
SubscriberInfoProvider.DeleteSubscriberInfo(deleteSubscriber);
return(deleteSubscriber != null);
}
private SubscriberInfo GetSubscriber()
{
var sb = SubscriberInfoProvider.GetSubscriberInfo(email, siteId);
if (sb == null)
{
sb = SubscriberInfoProvider.GetSubscriberInfo(PredefinedObjectType.USER, customerUserId, siteId);
}
return(sb);
}
/// <summary>
/// Unigrid newsletters action handler.
/// </summary>
protected void unigridNewsletters_OnAction(string actionName, object actionArgument)
{
// Check 'configure' permission
if (!CMSContext.CurrentUser.IsAuthorizedPerResource("cms.newsletter", "ManageSubscribers"))
{
RedirectToCMSDeskAccessDenied("cms.newsletter", "ManageSubscribers");
}
int newsletterId = ValidationHelper.GetInteger(actionArgument, 0);
switch (actionName.ToLowerCSafe())
{
// Renew subscription
case "subscribe":
SubscriberInfoProvider.RenewSubscription(subscriberId, newsletterId, chkSendConfirmation.Checked);
break;
// Unsubscribe selected subscriber
case "unsubscribe":
SubscriberInfoProvider.Unsubscribe(subscriberId, newsletterId, chkSendConfirmation.Checked);
break;
// Unsubscribe selected subscriber
case "remove":
SubscriberInfoProvider.DeleteSubscription(subscriberId, newsletterId, chkSendConfirmation.Checked);
break;
// Approve selected subscription
case "approve":
{
SubscriberNewsletterInfo subscriptionInfo = SubscriberNewsletterInfoProvider.GetSubscriberNewsletterInfo(subscriberId, newsletterId);
if ((subscriptionInfo != null) && (!subscriptionInfo.SubscriptionApproved))
{
subscriptionInfo.SubscriptionApproved = true;
subscriptionInfo.SubscriptionApprovedWhen = DateTime.Now;
SubscriberNewsletterInfoProvider.SetSubscriberNewsletterInfo(subscriptionInfo);
}
}
break;
// Reject selected subscription
case "reject":
{
SubscriberNewsletterInfo subscriptionInfo = SubscriberNewsletterInfoProvider.GetSubscriberNewsletterInfo(subscriberId, newsletterId);
if ((subscriptionInfo != null) && (subscriptionInfo.SubscriptionApproved))
{
subscriptionInfo.SubscriptionApproved = false;
subscriptionInfo.SubscriptionApprovedWhen = DateTime.MinValue;
SubscriberNewsletterInfoProvider.SetSubscriberNewsletterInfo(subscriptionInfo);
}
}
break;
}
}
/// <summary>
/// Sets data to database.
/// </summary>
protected void btnOK_Click(object sender, EventArgs e)
{
// Check "Manage subscribers" permission
if (!CMSContext.CurrentUser.IsAuthorizedPerResource("cms.newsletter", "managesubscribers"))
{
RedirectToCMSDeskAccessDenied("cms.newsletter", "managesubscribers");
}
string email = txtSubscriberEmail.Text.Trim();
// Check entered values
string errorMessage = new Validator().NotEmpty(email, GetString("Subscriber_Edit.ErrorEmptyEmail"))
.IsEmail(email, GetString("NewsletterSubscription.ErrorInvalidEmail"))
.Result;
if (string.IsNullOrEmpty(errorMessage))
{
if (!SubscriberInfoProvider.EmailExists(email))
{
// Create new subscriber info and set values
SubscriberInfo subscriberObj = new SubscriberInfo();
subscriberObj.SubscriberID = 0;
subscriberObj.SubscriberLastName = txtSubscriberLastName.Text.Trim();
subscriberObj.SubscriberEmail = email;
subscriberObj.SubscriberFirstName = txtSubscriberFirstName.Text.Trim();
subscriberObj.SubscriberFullName = (subscriberObj.SubscriberFirstName + " " + subscriberObj.SubscriberLastName).Trim();
subscriberObj.SubscriberSiteID = CMSContext.CurrentSiteID;
subscriberObj.SubscriberGUID = Guid.NewGuid();
if (SubscriberInfoProvider.LicenseVersionCheck(URLHelper.GetCurrentDomain(), FeatureEnum.Subscribers, VersionActionEnum.Insert))
{
// Save subscriber to DB
SubscriberInfoProvider.SetSubscriberInfo(subscriberObj);
// Redirect to edit page
URLHelper.Redirect("Subscriber_Frameset.aspx?subscriberid=" + Convert.ToString(subscriberObj.SubscriberID) + "&saved=1");
}
else
{
ShowError(GetString("LicenseVersionCheck.Subscribers"));
}
}
else
{
ShowError(GetString("Subscriber_Edit.EmailAlreadyExists"));
}
}
else
{
ShowError(errorMessage);
}
}
public void Subscribe_Contact_ContactIsSubscribed()
{
var email = "a-guid-" + Guid.NewGuid() + "@domain.com";
var contact = GetContact(email);
var result = mNewsletterSubscriptionService.Subscribe(contact, mNewsletter, mNewsletterSubscriptionSettings);
var expectedSubscriber = SubscriberInfoProvider.GetSubscriberByEmail(email, mSite.SiteID);
CMSAssert.All(
() => Assert.IsTrue(result, "New subscription is expected."),
() => Assert.NotNull(expectedSubscriber, $"No subscriber for email '{email}' was created.")
);
}
public void ConfirmSubscription_SubscriptionIsNotConfirmedByDefault()
{
var email = "a-guid-" + Guid.NewGuid() + "@domain.com";
var contact = GetContact(email);
mNewsletterSubscriptionService.Subscribe(contact, mNewsletter, mNewsletterSubscriptionSettings);
var expectedSubscriber = SubscriberInfoProvider.GetSubscriberByEmail(email, mSite.SiteID);
var expectedSubscriberNewsletter = SubscriberNewsletterInfoProvider.GetSubscriberNewsletterInfo(expectedSubscriber.SubscriberID, mNewsletter.NewsletterID);
Assert.IsFalse(expectedSubscriberNewsletter.SubscriptionApproved, $"Subscription must not be approved when double opt-in is enabled.");
}
protected void btnSubmit_Click(object sender, EventArgs e)
{
string email = txtEmail.Text.Trim();
string result = new Validator().IsEmail(email, GetString("unsubscribe.invalidemailformat")).Result;
if (String.IsNullOrEmpty(result))
{
bool requestSent = false;
var site = SiteContext.CurrentSite;
var newsletter = NewsletterInfoProvider.GetNewsletterInfo(NewsletterName, site.SiteID);
if (newsletter != null)
{
var unsubscriptionProvider = Service <IUnsubscriptionProvider> .Entry();
if (!unsubscriptionProvider.IsUnsubscribedFromSingleNewsletter(email, newsletter.NewsletterID, newsletter.NewsletterSiteID))
{
var subscriber = SubscriberInfoProvider.GetSubscriberByEmail(email, site.SiteID);
if (subscriber != null)
{
SendUnsubscriptionRequest(subscriber, newsletter, site.SiteName);
requestSent = true;
}
}
}
// Unsubscription failed if none confirmation e-mail was sent
if (!requestSent)
{
// Use default error message if none is specified
result = String.IsNullOrEmpty(ErrorText) ? GetString("unsubscribe.notsubscribed") : ErrorText;
}
}
// Display error message if set
if (!string.IsNullOrEmpty(result))
{
lblError.Text = result;
lblError.Visible = true;
}
else
{
// Display unsubscription confirmation
lblInfo.Visible = true;
lblInfo.Text = String.IsNullOrEmpty(ResultText) ? GetString("unsubscribe.confirmtext") : ResultText;
lblError.Visible = false;
txtEmail.Visible = false;
btnSubmit.Visible = false;
}
}
/// <summary>
/// Creates and sends unsubscription e-mail.
/// </summary>
/// <param name="subscriber">Subscriber object</param>
/// <param name="news">Newsletter object</param>
/// <param name="subscription">Subscription object</param>
/// <param name="siteName">Site name</param>
protected void SendUnsubscriptionRequest(SubscriberInfo subscriber, NewsletterInfo news, SubscriberNewsletterInfo subscription, string siteName)
{
// Get global e-mail template with unsubscription request
EmailTemplateInfo et = EmailTemplateProvider.GetEmailTemplate("newsletter.unsubscriptionrequest", siteName);
if (et != null)
{
// Get subscriber member
SortedDictionary <int, SubscriberInfo> subscribers = SubscriberInfoProvider.GetSubscribers(subscriber, 1, 0);
foreach (KeyValuePair <int, SubscriberInfo> item in subscribers)
{
// Get 1st subscriber's member
SubscriberInfo sb = item.Value;
string body = et.TemplateText;
string plainBody = et.TemplatePlainText;
// Resolve newsletter macros (first name, last name etc.)
IssueHelper ih = new IssueHelper();
if (ih.LoadDynamicFields(sb, news, subscription, null, false, siteName, null, null, null))
{
body = ih.ResolveDynamicFieldMacros(body);
plainBody = ih.ResolveDynamicFieldMacros(plainBody);
}
// Create e-mail
EmailMessage msg = new EmailMessage();
msg.EmailFormat = EmailFormatEnum.Default;
msg.From = EmailHelper.GetSender(et, news.NewsletterSenderEmail);
msg.Recipients = sb.SubscriberEmail;
msg.BccRecipients = et.TemplateBcc;
msg.CcRecipients = et.TemplateCc;
msg.Subject = ResHelper.LocalizeString(et.TemplateSubject);
msg.Body = URLHelper.MakeLinksAbsolute(body);
msg.PlainTextBody = URLHelper.MakeLinksAbsolute(plainBody);
// Add attachments and send e-mail
MetaFileInfoProvider.ResolveMetaFileImages(msg, et.TemplateID, EmailObjectType.EMAILTEMPLATE, MetaFileInfoProvider.OBJECT_CATEGORY_TEMPLATE);
EmailSender.SendEmail(siteName, msg);
}
}
else
{
// Log missing template
EventLogProvider ev = new EventLogProvider();
ev.LogEvent(EventLogProvider.EVENT_TYPE_ERROR, DateTime.Now, "UnsubscriptionRequest", "Unsubscription request e-mail template is missing.");
}
}
/// <summary>
/// Performs action on given subscriber.
/// </summary>
/// <param name="subscriberId">Id of subscriber</param>
/// <param name="actionName">Name of action</param>
private void DoSubscriberAction(int subscriberId, string actionName)
{
try
{
// Check manage subscribers permission
var subscriber = SubscriberInfoProvider.GetSubscriberInfo(subscriberId);
if (!subscriber.CheckPermissions(PermissionsEnum.Modify, SiteContext.CurrentSiteName, MembershipContext.AuthenticatedUser))
{
RedirectToAccessDenied(subscriber.TypeInfo.ModuleName, "ManageSubscribers");
}
Func <bool> subscriberIsUserAndIsDisabled = () =>
{
var user = GetSubscriberUser(subscriber);
return((user != null) && !user.UserEnabled);
};
switch (actionName.ToUpperInvariant())
{
// Remove subscription
case REMOVE:
mSubscriptionService.RemoveSubscription(subscriberId, mNewsletter.NewsletterID, chkSendConfirmation.Checked);
break;
// Approve subscription
case APPROVE:
if (subscriberIsUserAndIsDisabled())
{
return;
}
SubscriberNewsletterInfoProvider.ApproveSubscription(subscriberId, mNewsletter.NewsletterID);
break;
// Block selected subscriber
case BLOCK:
SubscriberInfoProvider.BlockSubscriber(subscriberId);
break;
// Un-block selected subscriber
case UNBLOCK:
SubscriberInfoProvider.UnblockSubscriber(subscriberId);
break;
}
}
catch (Exception exception)
{
LogAndShowError("Newsletter subscriber", "NEWSLETTERS", exception);
}
}
/// <summary>
/// Subscribes subscriber to a newsletter. Called when the "Unsubscribe from newsletter" button is pressed.
/// Expects the CreateSubscriber method to be run first.
/// </summary>
private bool UnsubscribeFromNewsletter()
{
// Get the subscriber and newsletter
SubscriberInfo subscriber = SubscriberInfoProvider.GetSubscriberInfo("*****@*****.**", SiteContext.CurrentSiteID);
NewsletterInfo newsletter = NewsletterInfoProvider.GetNewsletterInfo("MyNewStaticNewsletter", SiteContext.CurrentSiteID);
if ((subscriber != null) && (newsletter != null))
{
// Unubscribe from 'My new static newsletter'
SubscriberInfoProvider.Unsubscribe(subscriber.SubscriberID, newsletter.NewsletterID);
return(true);
}
return(false);
}
/// <summary>
/// Subscribes subscriber to a newsletter. Called when the "Subscribe to newsletter" button is pressed.
/// Expects the CreateSubscriber method to be run first.
/// </summary>
private bool SubscribeToNewsletter()
{
// Get the subscriber and newsletter
SubscriberInfo subscriber = SubscriberInfoProvider.GetSubscriberInfo("*****@*****.**", CMSContext.CurrentSiteID);
NewsletterInfo newsletter = NewsletterInfoProvider.GetNewsletterInfo("MyNewStaticNewsletter", CMSContext.CurrentSiteID);
if ((subscriber != null) && (newsletter != null))
{
// Subscribe to 'My new static newsletter'
SubscriberInfoProvider.Subscribe(subscriber.SubscriberID, newsletter.NewsletterID, DateTime.Now);
return(true);
}
return(false);
}
/// <summary>
/// Uniselector item selected event handler.
/// </summary>
protected void UniSelector_OnItemsSelected(object sender, EventArgs e)
{
// Check permissions
if (!CMSContext.CurrentUser.IsAuthorizedPerResource("cms.newsletter", "ManageSubscribers"))
{
RedirectToCMSDeskAccessDenied("cms.newsletter", "ManageSubscribers");
}
// Get new items from selector
string newValues = ValidationHelper.GetString(selectNewsletter.Value, null);
string[] newItems = null;
SubscriberNewsletterInfo subscription = null;
int newsletterId = 0;
newItems = newValues.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (newItems != null)
{
// Get all selected newsletters
foreach (string item in newItems)
{
newsletterId = ValidationHelper.GetInteger(item, 0);
// Get subscription
subscription = SubscriberNewsletterInfoProvider.GetSubscriberNewsletterInfo(subscriberId, newsletterId);
// If not already subscribed
if (subscription == null)
{
// Subscribe role
if (isRoleORContactGroup)
{
SubscriberInfoProvider.Subscribe(subscriberId, newsletterId, DateTime.Now, chkSendConfirmation.Checked, false);
}
// Subscribe users and subscribers
else
{
SubscriberInfoProvider.Subscribe(subscriberId, newsletterId, DateTime.Now, chkSendConfirmation.Checked, chkRequireOptIn.Checked);
}
}
}
}
selectNewsletter.Value = null;
unigridNewsletters.ReloadData();
pnlUpdate.Update();
}
/// <summary>
/// Handles export button click.
/// </summary>
/// <param name="sender">Sender</param>
/// <param name="e">Event arguments</param>
protected void btnExport_Click(object sender, EventArgs e)
{
// Check "manage subscribers" permission
if (!CMSContext.CurrentUser.IsAuthorizedPerResource("cms.newsletter", "managesubscribers"))
{
RedirectToCMSDeskAccessDenied("cms.newsletter", "managesubscribers");
}
// Get selected newsletters
List <int> newsletterIds = new List <int>();
string values = ValidationHelper.GetString(usNewsletters.Value, null);
if (!String.IsNullOrEmpty(values))
{
string[] newItems = values.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (newItems != null)
{
foreach (string item in newItems)
{
newsletterIds.Add(ValidationHelper.GetInteger(item, 0));
}
}
}
// Export subscribers
string subscribers = null;
if (CMSContext.CurrentSite != null)
{
subscribers = SubscriberInfoProvider.ExportSubscribersFromSite(newsletterIds, CMSContext.CurrentSiteID, true, ValidationHelper.GetInteger(rblExportList.SelectedValue, 0));
}
// No subscribers exported
if (string.IsNullOrEmpty(subscribers))
{
ShowInformation(GetString("Subscriber_Export.noSubscribersExported"));
txtExportSub.Enabled = false;
}
else
{
ShowInformation(GetString("Subscriber_Export.subscribersExported"));
txtExportSub.Enabled = true;
}
txtExportSub.Text = subscribers;
}
/// <summary>
/// DataForm's OnAfterSave event handler.
/// </summary>
protected void formCustomFields_OnAfterSave(object sender, EventArgs e)
{
if (!formCustomFields.BasicForm.StopProcessing)
{
// Save with provider to log synchronization
SubscriberInfo subscriberObj = SubscriberInfoProvider.GetSubscriberInfo(subscriberId);
EditedObject = subscriberObj;
subscriberObj.SubscriberFullName = (subscriberObj.SubscriberFirstName + " " + subscriberObj.SubscriberLastName).Trim();
SubscriberInfoProvider.SetSubscriberInfo(subscriberObj);
ShowChangesSaved();
// Refresh header with display name
ScriptHelper.RefreshTabHeader(Page, null);
}
}
/// <summary>
/// Creates subscriber. Called when the "Create subscriber" button is pressed.
/// </summary>
private bool CreateSubscriber()
{
// Create new subscriber object
SubscriberInfo newSubscriber = new SubscriberInfo();
// Set the properties
newSubscriber.SubscriberFirstName = "Name";
newSubscriber.SubscriberLastName = "Surname";
newSubscriber.SubscriberFullName = "Name Surname";
newSubscriber.SubscriberEmail = "*****@*****.**";
newSubscriber.SubscriberSiteID = SiteContext.CurrentSiteID;
// Save the subscriber
SubscriberInfoProvider.SetSubscriberInfo(newSubscriber);
return(true);
}
protected void Page_Load(object sender, EventArgs e)
{
subscriberId = QueryHelper.GetInteger("subscriberid", 0);
// Get subscriber by its ID and check its existence
SubscriberInfo subscriberObj = SubscriberInfoProvider.GetSubscriberInfo(subscriberId);
EditedObject = subscriberObj;
// Check if it is role or contact group subscriber
isRoleORContactGroup = (subscriberObj.SubscriberRelatedID > 0) && (subscriberObj.SubscriberType != null) &&
(subscriberObj.SubscriberType.EqualsCSafe(SiteObjectType.ROLE, true) ||
subscriberObj.SubscriberType.EqualsCSafe(PredefinedObjectType.CONTACTGROUP, true));
// Initialize page controls
chkRequireOptIn.TextAlign = TextAlign.Right;
chkSendConfirmation.TextAlign = TextAlign.Right;
// Initialize uniselector for newsletters
selectNewsletter.UniSelector.SelectionMode = SelectionModeEnum.MultipleButton;
selectNewsletter.UniSelector.OnItemsSelected += new EventHandler(UniSelector_OnItemsSelected);
selectNewsletter.UniSelector.ReturnColumnName = "NewsletterID";
selectNewsletter.UniSelector.ButtonImage = GetImageUrl("Objects/Newsletter_Newsletter/add.png");
selectNewsletter.UniSelector.DialogLink.CssClass = "MenuItemEdit";
selectNewsletter.ShowSiteFilter = false;
selectNewsletter.ResourcePrefix = "newsletterselect";
selectNewsletter.UniSelector.DialogButton.CssClass = "LongButton";
selectNewsletter.IsLiveSite = false;
// Initialize unigrid
unigridNewsletters.WhereCondition = "SubscriberID = " + subscriberId.ToString();
unigridNewsletters.OnAction += new OnActionEventHandler(unigridNewsletters_OnAction);
unigridNewsletters.OnExternalDataBound += new OnExternalDataBoundEventHandler(unigridNewsletters_OnExternalDataBound);
// Initialize mass actions
if (drpActions.Items.Count == 0)
{
drpActions.Items.Add(new ListItem(GetString("general.selectaction"), SELECT));
drpActions.Items.Add(new ListItem(GetString("newsletter.unsubscribelink"), UNSUBSCRIBE));
drpActions.Items.Add(new ListItem(GetString("newsletter.renewsubscription"), SUBSCRIBE));
drpActions.Items.Add(new ListItem(GetString("newsletter.approvesubscription"), APPROVE));
drpActions.Items.Add(new ListItem(GetString("newsletter.rejectsubscription"), REJECT));
drpActions.Items.Add(new ListItem(GetString("newsletter.deletesubscription"), REMOVE));
}
}
