protected void Page_Load(object sender, EventArgs e)
{
// Check read permission
ContactHelper.AuthorizedReadContact(CMSContext.CurrentSiteID, true);
string siteName = CMSContext.CurrentSiteName;
// Get bounce limit
mBounceLimit = SettingsKeyProvider.GetIntValue(siteName + ".CMSBouncedEmailsLimit");
// Get info if bounced e-mail tracking is available
mBounceInfoAvailable = SettingsKeyProvider.GetBoolValue(siteName + ".CMSMonitorBouncedEmails") &&
NewsletterProvider.OnlineMarketingEnabled(siteName);
CurrentMaster.HeaderActions.HelpTopicName = "subscribercontacts_tab";
CurrentMaster.HeaderActions.HelpName = "helpTopic";
// Check if parent object exist
Subscriber sb = SubscriberProvider.GetSubscriber(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;
}
/// <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
Subscriber subscriberObj = SubscriberProvider.GetSubscriber(subscriberId);
if (subscriberObj != null)
{
// Check the email changes
if ((subscriberObj.SubscriberEmail.ToLower() != mail.ToLower()) && (SubscriberProvider.EmailExists(mail)))
{
// Show error message if the email address is already used by another subscriber
formCustomFields.BasicForm.StopProcessing = true;
lblError.Visible = true;
lblError.Text = GetString("Subscriber_Edit.EmailAlreadyExists");
}
}
else
{
formCustomFields.BasicForm.StopProcessing = true;
lblError.Visible = true;
lblError.Text = GetString("Subscriber_Edit.SubscriberDoesNotExists");
}
}
}
/// <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 (!SubscriberProvider.EmailExists(email))
{
// Create new subscriber info and set values
Subscriber subscriberObj = new Subscriber();
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 (SubscriberProvider.LicenseVersionCheck(URLHelper.GetCurrentDomain(), FeatureEnum.Subscribers, VersionActionEnum.Insert))
{
// Save subscriber to DB
SubscriberProvider.SetSubscriber(subscriberObj);
// Redirect to edit page
URLHelper.Redirect("Subscriber_Frameset.aspx?subscriberid=" + Convert.ToString(subscriberObj.SubscriberID) + "&saved=1");
}
else
{
lblError.Visible = true;
lblError.Text = GetString("LicenseVersionCheck.Subscribers");
}
}
else
{
lblError.Visible = true;
lblError.Text = GetString("Subscriber_Edit.EmailAlreadyExists");
}
}
else
{
lblError.Visible = true;
lblError.Text = errorMessage;
}
}
/// <summary>
/// Handles multiple selector actions.
/// </summary>
protected void btnOk_Clicked(object sender, EventArgs e)
{
// Check permissions
CheckAuthorization();
if (drpActions.SelectedValue != "SELECT")
{
// Go through all selected items
ArrayList list = UniGridSubscribers.SelectedItems;
if (list.Count > 0)
{
SubscriberNewsletterInfo sni = null;
foreach (object subscriberId in list)
{
sni = SubscriberNewsletterInfoProvider.GetSubscriberNewsletterInfo(ValidationHelper.GetInteger(subscriberId, 0), newsletterId);
if (sni != null)
{
switch (drpActions.SelectedValue)
{
// Remove subscription
case "REMOVE":
SubscriberProvider.Unsubscribe(sni, chkSendConfirmation.Checked);
break;
// Approve subscription
case "APPROVE":
if (!sni.SubscriptionApproved)
{
sni.SubscriptionApproved = true;
sni.SubscriptionApprovedWhen = DateTime.Now;
SubscriberNewsletterInfoProvider.SetSubscriberNewsletterInfo(sni);
}
break;
// Reject subscription
case "REJECT":
if (sni.SubscriptionApproved)
{
sni.SubscriptionApproved = false;
sni.SubscriptionApprovedWhen = DateTime.MinValue;
SubscriberNewsletterInfoProvider.SetSubscriberNewsletterInfo(sni);
}
break;
}
}
}
}
else
{
ltlScript.Text += ScriptHelper.GetAlertScript(GetString("general.noitems"));
}
}
UniGridSubscribers.ResetSelection();
UniGridSubscribers.ReloadData();
}
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
Subscriber subscriberObj = SubscriberProvider.GetSubscriber(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;
}
// Get first, last names and type for breadcrumbs
currentSubscriber = string.Format("{0} ({1})", string.Concat(subscriberObj.SubscriberFirstName, " ", subscriberObj.SubscriberLastName), type.ToLower());
}
}
// 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;
CurrentMaster.Title.HelpTopicName = "general_tab2";
CurrentMaster.Title.HelpName = "helpTopic";
// Initialize tabs
InitalizeMenu(subscriberObj);
}
/// <summary>
/// Handles the UniGrid's OnAction event.
/// </summary>
/// <param name="actionName">Name of item (button) that threw event</param>
/// <param name="actionArgument">ID (value of Primary key) of corresponding data row</param>
protected void UniGridSubscribers_OnAction(string actionName, object actionArgument)
{
// Check 'manage subscribers' permission
CheckAuthorization();
int subscriberId = ValidationHelper.GetInteger(actionArgument, 0);
switch (actionName.ToLower())
{
// Unsubscribe selected subscriber
case "remove":
SubscriberProvider.Unsubscribe(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;
// Block selected subscriber
case "block":
SubscriberProvider.BlockSubscriber(subscriberId);
break;
// Un-block selected subscriber
case "unblock":
SubscriberProvider.UnblockSubscriber(subscriberId);
break;
}
}
/// <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;
Newsletter newsletter = 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)
{
newsletter = NewsletterProvider.GetNewsletter(newsletterId);
// Subscribe role
if (isRoleORContactGroup)
{
SubscriberProvider.Subscribe(subscriberId, newsletterId, DateTime.Now, chkSendConfirmation.Checked, false);
}
// Subscribe users and subscribers
else
{
SubscriberProvider.Subscribe(subscriberId, newsletterId, DateTime.Now, chkSendConfirmation.Checked, chkRequireOptIn.Checked);
}
}
}
}
selectNewsletter.Value = null;
unigridNewsletters.ReloadData();
pnlUpdate.Update();
}
/// <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(Subscriber subscriber, Newsletter news, SubscriberNewsletterInfo subscription, string siteName)
{
// Get global e-mail template with unsubscription request
EmailTemplateInfo et = CMS.EmailEngine.EmailTemplateProvider.GetEmailTemplate("newsletter.unsubscriptionrequest", siteName);
if (et != null)
{
// Get subscriber member
SortedDictionary <int, Subscriber> subscribers = SubscriberProvider.GetSubscribers(subscriber, 1, 0);
foreach (KeyValuePair <int, Subscriber> item in subscribers)
{
// Get 1st subscriber's member
Subscriber 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>
/// 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
ArrayList newsletterIds = new ArrayList();
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 = SubscriberProvider.ExportSubscribersFromSite(newsletterIds, CMSContext.CurrentSiteID, true, ValidationHelper.GetInteger(rblExportList.SelectedValue, 0));
}
// No subscribers exported
if (string.IsNullOrEmpty(subscribers))
{
lblInfo.Text = GetString("Subscriber_Export.noSubscribersExported");
lblInfo.Visible = true;
txtExportSub.Enabled = false;
}
else
{
lblInfo.Text = GetString("Subscriber_Export.subscribersExported");
lblInfo.Visible = true;
txtExportSub.Enabled = true;
}
txtExportSub.Text = subscribers;
}
protected void Page_Load(object sender, EventArgs e)
{
subscriberId = QueryHelper.GetInteger("subscriberid", 0);
// Get subscriber by its ID and check its existence
Subscriber subscriberObj = SubscriberProvider.GetSubscriber(subscriberId);
EditedObject = subscriberObj;
// Check if it is role or contact group subscriber
isRoleORContactGroup = (subscriberObj.SubscriberRelatedID > 0) && (subscriberObj.SubscriberType != null) &&
(subscriberObj.SubscriberType.Equals(SiteObjectType.ROLE, StringComparison.InvariantCultureIgnoreCase) ||
subscriberObj.SubscriberType.Equals(PredefinedObjectType.CONTACTGROUP, StringComparison.InvariantCultureIgnoreCase));
// Initialize page controls
CurrentMaster.DisplayActionsPanel = true;
CurrentMaster.DisplayControlsPanel = true;
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.ImageDialog.CssClass = "NewItemImage";
selectNewsletter.LinkDialog.CssClass = "NewItemLink";
selectNewsletter.ShowSiteFilter = false;
selectNewsletter.ResourcePrefix = "newsletterselect";
selectNewsletter.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("general.approve"), "APPROVE"));
drpActions.Items.Add(new ListItem(GetString("general.reject"), "REJECT"));
drpActions.Items.Add(new ListItem(GetString("general.remove"), "REMOVE"));
}
}
/// <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
Subscriber subscriberObj = SubscriberProvider.GetSubscriber(subscriberId);
EditedObject = subscriberObj;
subscriberObj.SubscriberFullName = (subscriberObj.SubscriberFirstName + " " + subscriberObj.SubscriberLastName).Trim();
SubscriberProvider.SetSubscriber(subscriberObj);
lblInfo.Visible = true;
lblInfo.Text = GetString("General.ChangesSaved");
// Refresh header with display name
ScriptHelper.RefreshTabHeader(Page, null);
}
}
/// <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.ToLower())
{
// Unsubscribe selected subscriber
case "remove":
SubscriberProvider.Unsubscribe(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>
/// Subscriber control items changed event.
/// </summary>
protected void SubscriberSelector_OnItemsSelected(object sender, EventArgs e)
{
// Check permissions
CheckAuthorization();
int subscriberID = 0;
string[] newItems = null;
Subscriber sb = null;
// Get new items from selector
string newValues = ValidationHelper.GetString(selectSubscriber.Value, null);
newItems = newValues.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (newItems != null)
{
// Add all new items to site
foreach (string item in newItems)
{
subscriberID = ValidationHelper.GetInteger(item, 0);
// Get subscriber
sb = SubscriberProvider.GetSubscriber(subscriberID);
// If subscriber exists and is not subscribed, subscribe him
if ((sb != null) && (!SubscriberProvider.IsSubscribed(sb.SubscriberID, newsletterId)))
{
try
{
SubscriberProvider.Subscribe(sb.SubscriberID, newsletterId, DateTime.Now, chkSendConfirmation.Checked, chkRequireOptIn.Checked);
}
catch
{
}
}
}
}
selectSubscriber.Value = null;
UniGridSubscribers.ReloadData();
pnlUpdate.Update();
}
protected void Page_Load(object sender, EventArgs e)
{
// Initialize dataform
formCustomFields.OnAfterValidate += formCustomFields_OnAfterValidate;
formCustomFields.OnAfterSave += formCustomFields_OnAfterSave;
formCustomFields.OnBeforeValidate += formCustomFields_OnBeforeValidate;
// Get subscriber ID from querystring
subscriberId = QueryHelper.GetInteger("subscriberid", 0);
if (subscriberId > 0)
{
if (!RequestHelper.IsPostBack())
{
// Get subscriber info and check its existence
Subscriber subscriberObj = SubscriberProvider.GetSubscriber(subscriberId);
EditedObject = subscriberObj;
// Fill editing form only if subscriber is of standard type
if (DataHelper.IsEmpty(subscriberObj.SubscriberType) && subscriberObj.SubscriberRelatedID == 0)
{
formCustomFields.ItemID = subscriberObj.SubscriberID;
// Show that the subscriber was created or updated successfully
if (QueryHelper.GetBoolean("saved", false))
{
lblInfo.Visible = true;
lblInfo.Text = GetString("General.ChangesSaved");
}
}
else
{
formCustomFields.Visible = false;
}
}
}
else
{
formCustomFields.Visible = false;
}
}
private void LoadSelection(bool force)
{
currentValues = string.Empty;
Subscriber sb = SubscriberProvider.GetSubscriber(email, siteId);
if (sb != null)
{
// Get selected newsletters
DataSet ds = SubscriberNewsletterInfoProvider.GetSubscriberNewsletters(sb.SubscriberID, null, -1, "NewsletterID");
if (!DataHelper.DataSourceIsEmpty(ds))
{
currentValues = TextHelper.Join(";", SqlHelperClass.GetStringValues(ds.Tables[0], "NewsletterID"));
}
if (!RequestHelper.IsPostBack() || force)
{
// Load selected newsletters
usNewsletters.Value = currentValues;
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
string siteName = CMSContext.CurrentSiteName;
// Get bounce limit
mBounceLimit = SettingsKeyProvider.GetIntValue(siteName + ".CMSBouncedEmailsLimit");
// Get info if bounced e-mail tracking is available
mBounceInfoAvailable = SettingsKeyProvider.GetBoolValue(siteName + ".CMSMonitorBouncedEmails") &&
NewsletterProvider.OnlineMarketingEnabled(siteName);
CurrentMaster.HeaderActions.HelpTopicName = "subscriberusers_tab";
CurrentMaster.HeaderActions.HelpName = "helpTopic";
// Check if parent object exist
Subscriber sb = SubscriberProvider.GetSubscriber(QueryHelper.GetInteger("subscriberid", 0));
EditedObject = sb;
// Initialize unigrid
UniGrid.OnAction += uniGrid_OnAction;
UniGrid.OnExternalDataBound += uniGrid_OnExternalDataBound;
UniGrid.WhereCondition = "((RoleID = " + QueryHelper.GetInteger("roleid", 0) + ") AND (SiteID = " + CMSContext.CurrentSiteID + "))";
}
private void usNewsletters_OnSelectionChanged(object sender, EventArgs e)
{
if (RaiseOnCheckPermissions("ManageSubscribers", this))
{
if (this.StopProcessing)
{
return;
}
}
// Get specified user if used instead of current user
UserInfo ui = null;
if (this.UserID > 0)
{
ui = UserInfoProvider.GetUserInfo(this.UserID);
}
else
{
ui = CMSContext.CurrentUser;
}
// Get specified site ID instead of current site ID
int siteId = 0;
if (this.SiteID > 0)
{
siteId = this.SiteID;
}
else
{
siteId = CMSContext.CurrentSiteID;
}
if ((sb == null) && (ui != null))
{
// Create new subsciber (bind to existing user account)
if ((!ui.IsPublic()) && (ValidationHelper.IsEmail(ui.Email) || ValidationHelper.IsEmail(ui.UserName)))
{
sb = new Subscriber();
if (ui != null)
{
if (!string.IsNullOrEmpty(ui.FirstName) && !string.IsNullOrEmpty(ui.LastName))
{
sb.SubscriberFirstName = ui.FirstName;
sb.SubscriberLastName = ui.LastName;
}
else
{
sb.SubscriberFirstName = ui.FullName;
}
// Full name consists of "user " and user full name
sb.SubscriberFullName = "User '" + ui.FullName + "'";
}
sb.SubscriberSiteID = siteId;
sb.SubscriberType = SiteObjectType.USER;
sb.SubscriberRelatedID = ui.UserID;
// Save subscriber to DB
SubscriberProvider.SetSubscriber(sb);
}
}
if (sb == null)
{
return;
}
// Remove old items
int newsletterId = 0;
string newValues = ValidationHelper.GetString(usNewsletters.Value, null);
string items = DataHelper.GetNewItemsInList(newValues, currentValues);
if (!String.IsNullOrEmpty(items))
{
string[] newItems = items.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (newItems != null)
{
foreach (string item in newItems)
{
newsletterId = ValidationHelper.GetInteger(item, 0);
// If subscriber is subscribed, unsubscribe him
if (SubscriberProvider.IsSubscribed(sb.SubscriberID, newsletterId))
{
SubscriberProvider.Unsubscribe(sb.SubscriberID, newsletterId, SendConfirmationEmail);
// Log activity
LogActivity(ui, newsletterId, false, siteId);
}
}
}
}
// Add new items
items = DataHelper.GetNewItemsInList(currentValues, newValues);
if (!String.IsNullOrEmpty(items))
{
string[] newItems = items.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (newItems != null)
{
foreach (string item in newItems)
{
newsletterId = ValidationHelper.GetInteger(item, 0);
// If subscriber is not subscribed, subscribe him
if (!SubscriberProvider.IsSubscribed(sb.SubscriberID, newsletterId))
{
try
{
SubscriberProvider.Subscribe(sb.SubscriberID, newsletterId, DateTime.Now, SendConfirmationEmail);
// Log activity
LogActivity(ui, newsletterId, true, siteId);
}
catch { }
}
}
}
}
// Display information about successful (un)subscription
this.lblInfoMsg.Visible = true;
}
/// <summary>
/// Load data.
/// </summary>
public void LoadData()
{
if (this.StopProcessing)
{
// Hide control
this.Visible = false;
}
else
{
this.SetContext();
// Get specified user if used instead of current user
UserInfo ui = null;
if (this.UserID > 0)
{
ui = UserInfoProvider.GetUserInfo(this.UserID);
}
else
{
ui = CMSContext.CurrentUser;
}
// Get specified site ID instead of current site ID
int siteId = 0;
if (this.SiteID > 0)
{
siteId = this.SiteID;
}
else
{
siteId = CMSContext.CurrentSiteID;
}
usNewsletters.WhereCondition = "NewsletterSiteID = " + siteId;
usNewsletters.ButtonRemoveSelected.CssClass = "XLongButton";
usNewsletters.ButtonAddItems.CssClass = "XLongButton";
usNewsletters.OnSelectionChanged += new EventHandler(usNewsletters_OnSelectionChanged);
usNewsletters.IsLiveSite = this.IsLiveSite;
this.userIsIdentified = (ui != null) && (!ui.IsPublic()) && (ValidationHelper.IsEmail(ui.Email) || ValidationHelper.IsEmail(ui.UserName));
if (this.userIsIdentified)
{
usNewsletters.Visible = true;
// Try to get subsriber info with specified e-mail
sb = SubscriberProvider.GetSubscriber(ui.Email, siteId);
if (sb == null)
{
// Try to get subscriber info according to user info
sb = SubscriberProvider.GetSubscriber(SiteObjectType.USER, ui.UserID, siteId);
}
// Get user e-mail address
if (sb != null)
{
subscriberEmail = sb.SubscriberEmail;
// Get selected newsletters
DataSet ds = SubscriberNewsletterInfoProvider.GetSubscriberNewsletters(sb.SubscriberID, null, -1, "NewsletterID");
if (!DataHelper.DataSourceIsEmpty(ds))
{
currentValues = TextHelper.Join(";", SqlHelperClass.GetStringValues(ds.Tables[0], "NewsletterID"));
}
// Load selected newsletters
if (!string.IsNullOrEmpty(currentValues))
{
usNewsletters.Value = currentValues;
}
}
// Try to get email address from user data
if (string.IsNullOrEmpty(subscriberEmail))
{
if (ValidationHelper.IsEmail(ui.Email))
{
subscriberEmail = ui.Email;
}
else if (ValidationHelper.IsEmail(ui.UserName))
{
subscriberEmail = ui.UserName;
}
}
}
else
{
usNewsletters.Visible = false;
lblInfo.Visible = true;
if ((this.UserID > 0) && (CMSContext.CurrentUser.UserID == this.UserID))
{
lblInfo.Text = GetString("MySubscriptions.CannotIdentify");
}
else
{
lblInfo.Text = GetString("MySubscriptions.CannotIdentifyUser");
}
}
this.ReleaseContext();
}
}
/// <summary>
/// Contact group items selected event handler.
/// </summary>
protected void selector_OnItemsSelected(object sender, EventArgs e)
{
// Check permissions
CheckAuthorization();
if (cgSelector == null)
{
return;
}
int groupID = 0;
string[] newItems = null;
Subscriber sb = null;
int siteId = CMSContext.CurrentSiteID;
string cgType = "om.contactgroup";
// Get new items from selector
string newValues = ValidationHelper.GetString(cgSelector.Value, null);
// Get added items
newItems = newValues.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (newItems != null)
{
foreach (string item in newItems)
{
groupID = ValidationHelper.GetInteger(item, 0);
// Get subscriber
sb = SubscriberProvider.GetSubscriber(cgType, groupID, siteId);
if (sb == null)
{
// Get contact group display name
string cgName = ModuleCommands.OnlineMarketingGetContactGroupName(groupID);
if (string.IsNullOrEmpty(cgName))
{
break;
}
// Check limited number of subscribers
if (!SubscriberProvider.LicenseVersionCheck(URLHelper.GetCurrentDomain(), FeatureEnum.Subscribers, VersionActionEnum.Insert))
{
lblError.Text = GetString("licenselimitations.subscribers.errormultiple");
lblError.Visible = true;
break;
}
// Create new subscriber of contact group type
sb = new Subscriber();
sb.SubscriberFirstName = cgName;
// Full name consists of "contact group " and display name
sb.SubscriberFullName = string.Concat("Contact group '", cgName, "'");
sb.SubscriberSiteID = siteId;
sb.SubscriberType = cgType;
sb.SubscriberRelatedID = groupID;
SubscriberProvider.SetSubscriber(sb);
}
// If subscriber exists and is not subscribed, subscribe him
if ((sb != null) && (!SubscriberProvider.IsSubscribed(sb.SubscriberID, newsletterId)))
{
try
{
SubscriberProvider.Subscribe(sb.SubscriberID, newsletterId, DateTime.Now, chkSendConfirmation.Checked, false);
}
catch
{
}
}
}
}
cgSelector.Value = null;
UniGridSubscribers.ReloadData();
pnlUpdate.Update();
}
protected void Page_Load(object sender, EventArgs e)
{
Guid subscriberGuid = QueryHelper.GetGuid("subscriberguid", Guid.Empty);
int newsletterIssueId = QueryHelper.GetInteger("issueid", 0);
// Get newsletter issue
Issue issue = IssueProvider.GetIssue(newsletterIssueId);
if (issue == null)
{
return;
}
// Get subscriber
Subscriber subscriber = SubscriberProvider.GetSubscriber(subscriberGuid, CMSContext.CurrentSiteID);
// Get the newsletter
Newsletter news = NewsletterProvider.GetNewsletter(issue.IssueNewsletterID);
if (news == null)
{
return;
}
// Get site default culture
string culture = CultureHelper.GetDefaultCulture(CMSContext.CurrentSiteName);
// Ensure preview in default site culture
// Keep old culture
System.Globalization.CultureInfo oldUICulture = Thread.CurrentThread.CurrentUICulture;
// Set current culture
Thread.CurrentThread.CurrentUICulture = new System.Globalization.CultureInfo(culture);
string htmlPage = String.Empty;
try
{
if (subscriber != null)
{
// Get subscriber's member (different for user or role subscribers)
SortedDictionary <int, Subscriber> subscribers = SubscriberProvider.GetSubscribers(subscriber, 1, 0);
foreach (KeyValuePair <int, Subscriber> item in subscribers)
{
// Get 1st subscriber's member
Subscriber sb = item.Value;
htmlPage = IssueProvider.GetEmailBody(issue, news, null, sb, true, CMSContext.CurrentSiteName, null, null, null);
}
}
if (string.IsNullOrEmpty(htmlPage))
{
htmlPage = IssueProvider.GetEmailBody(issue, news, null, null, true, CMSContext.CurrentSiteName, null, null, null);
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
// Set back to old culture
Thread.CurrentThread.CurrentUICulture = oldUICulture;
}
Response.Clear();
Response.Write(htmlPage);
RequestHelper.EndResponse();
}
protected void btnSubmit_Click(object sender, EventArgs e)
{
// Check email format
string email = txtEmail.Text.Trim();
string result = new Validator().IsEmail(email, GetString("unsubscribe.invalidemailformat")).Result;
if (String.IsNullOrEmpty(result))
{
bool requestSent = false;
int siteId = 0;
if (CMSContext.CurrentSite != null)
{
siteId = CMSContext.CurrentSiteID;
}
// Try to get all subscriber infos with given e-mail
DataSet ds = SubscriberProvider.GetSubscribersFromView(email, siteId);
if (!DataHelper.DataSourceIsEmpty(ds))
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
Subscriber sb = new Subscriber(dr);
if ((sb != null) && ((sb.SubscriberType == null) || (sb.SubscriberRelatedID > 0) && (sb.SubscriberType == SiteObjectType.USER)))
{
// Get newsletter information
Newsletter news = NewsletterProvider.GetNewsletter(this.NewsletterName, siteId);
if (news != null)
{
// Get subscription info
SubscriberNewsletterInfo sni = SubscriberNewsletterInfoProvider.GetSubscriberNewsletterInfo(sb.SubscriberID, news.NewsletterID);
// Send e-mail to subscribed user only
if (sni != null)
{
SendUnsubscriptionRequest(sb, news, sni, CMSContext.CurrentSiteName);
requestSent = true; // At least one request was sent
}
}
}
}
}
// Unsubscription failed if none confirmation e-mail was sent
if (!requestSent)
{
// Use default error message if none is specified
if (String.IsNullOrEmpty(this.ErrorText))
{
result = GetString("unsubscribe.notsubscribed");
}
else
{
result = this.ErrorText;
}
}
}
// Display error message if set
if (!string.IsNullOrEmpty(result))
{
lblError.Text = result;
lblError.Visible = true;
}
else
{
// Display unsubscription confirmation
lblInfo.Visible = true;
if (String.IsNullOrEmpty(this.ResultText))
{
// Use default message if none was specified
lblInfo.Text = GetString("unsubscribe.confirmtext");
}
else
{
lblInfo.Text = this.ResultText;
}
lblError.Visible = false;
txtEmail.Visible = false;
btnSubmit.Visible = false;
}
}
protected void Page_Load(object sender, EventArgs e)
{
// If StopProcessing flag is set, do nothing
if (StopProcessing)
{
Visible = false;
return;
}
string subscriptionHash = QueryHelper.GetString("subscriptionhash", string.Empty);
string requestTime = QueryHelper.GetString("datetime", string.Empty);
DateTime datetime = DateTimeHelper.ZERO_TIME;
// Get date and time
if (!string.IsNullOrEmpty(requestTime))
{
try
{
datetime = DateTime.ParseExact(requestTime, SecurityHelper.EMAIL_CONFIRMATION_DATETIME_FORMAT, null);
}
catch
{
lblInfo.Text = ResHelper.GetString("newsletter.approval_failed");
return;
}
}
if (string.IsNullOrEmpty(subscriptionHash))
{
this.Visible = false;
return;
}
// Try to approve subscription
SubscriberProvider.ApprovalResult result = SubscriberProvider.ApproveSubscription(subscriptionHash, false, CMSContext.CurrentSiteName, datetime);
switch (result)
{
// Approving subscription was successful
case SubscriberProvider.ApprovalResult.Success:
if (!String.IsNullOrEmpty(this.SuccessfulApprovalText))
{
lblInfo.Text = this.SuccessfulApprovalText;
}
else
{
lblInfo.Text = ResHelper.GetString("newsletter.successful_approval");
}
// Log newsletter subscription activity
if ((CMSContext.ViewMode == ViewModeEnum.LiveSite))
{
SubscriberNewsletterInfo sni = SubscriberNewsletterInfoProvider.GetSubscriberNewsletterInfo(subscriptionHash);
if (sni != null)
{
// Load subscriber info and make sure activity modul is enabled
Subscriber sb = SubscriberProvider.GetSubscriber(sni.SubscriberID);
if ((sb != null) && ActivitySettingsHelper.ActivitiesEnabledAndModuleLoaded(sb.SubscriberSiteID))
{
int siteId = sb.SubscriberSiteID;
Newsletter news = NewsletterProvider.GetNewsletter(sni.NewsletterID);
if (news.NewsletterLogActivity && ActivitySettingsHelper.NewsletterSubscribeEnabled(siteId))
{
// Under what contacs this subscriber belogs to?
int contactId = ActivityTrackingHelper.GetContactID(sb);
if (contactId > 0)
{
ModuleCommands.OnlineMarketingUpdateContactFromExternalData(sb, contactId);
ModuleCommands.OnlineMarketingCreateRelation(sb.SubscriberID, MembershipType.NEWSLETTER_SUBSCRIBER, contactId);
var data = new ActivityData()
{
ContactID = contactId,
SiteID = sb.SubscriberSiteID,
Type = PredefinedActivityType.NEWSLETTER_SUBSCRIBING,
TitleData = news.NewsletterName,
ItemID = news.NewsletterID,
URL = URLHelper.CurrentRelativePath,
Campaign = CMSContext.Campaign
};
ActivityLogProvider.LogActivity(data);
}
}
}
}
}
break;
// Subscription was already approved
case SubscriberProvider.ApprovalResult.Failed:
if (!String.IsNullOrEmpty(this.UnsuccessfulApprovalText))
{
lblInfo.Text = this.UnsuccessfulApprovalText;
}
else
{
lblInfo.Text = ResHelper.GetString("newsletter.approval_failed");
}
break;
case SubscriberProvider.ApprovalResult.TimeExceeded:
if (!String.IsNullOrEmpty(this.UnsuccessfulApprovalText))
{
lblInfo.Text = this.UnsuccessfulApprovalText;
}
else
{
lblInfo.Text = ResHelper.GetString("newsletter.approval_timeexceeded");
}
break;
// Subscription not found
default:
case SubscriberProvider.ApprovalResult.NotFound:
if (!String.IsNullOrEmpty(this.UnsuccessfulApprovalText))
{
lblInfo.Text = this.UnsuccessfulApprovalText;
}
else
{
lblInfo.Text = ResHelper.GetString("newsletter.approval_invalid");
}
break;
}
}
/// <summary>
/// Handles multiple selector actions.
/// </summary>
protected void btnOk_Clicked(object sender, EventArgs e)
{
// Check permissions
if (!CMSContext.CurrentUser.IsAuthorizedPerResource("cms.newsletter", "ManageSubscribers"))
{
RedirectToCMSDeskAccessDenied("cms.newsletter", "ManageSubscribers");
}
// Return if no action was selected
if (drpActions.SelectedValue.Equals("SELECT", StringComparison.InvariantCultureIgnoreCase))
{
return;
}
// Get selected items
ArrayList list = unigridNewsletters.SelectedItems;
if (list.Count == 0)
{
ltlScript.Text += ScriptHelper.GetAlertScript(GetString("general.noitems"));
return;
}
int newsletterId;
SubscriberNewsletterInfo subscriptionInfo;
foreach (object id in list)
{
newsletterId = ValidationHelper.GetInteger(id, 0);
switch (drpActions.SelectedValue)
{
// Remove subscription
case "REMOVE":
SubscriberProvider.Unsubscribe(subscriberId, newsletterId, chkSendConfirmation.Checked);
break;
// Approve subscription
case "APPROVE":
subscriptionInfo = SubscriberNewsletterInfoProvider.GetSubscriberNewsletterInfo(subscriberId, newsletterId);
if ((subscriptionInfo != null) && (!subscriptionInfo.SubscriptionApproved))
{
subscriptionInfo.SubscriptionApproved = true;
subscriptionInfo.SubscriptionApprovedWhen = DateTime.Now;
SubscriberNewsletterInfoProvider.SetSubscriberNewsletterInfo(subscriptionInfo);
}
break;
// Reject subscription
case "REJECT":
subscriptionInfo = SubscriberNewsletterInfoProvider.GetSubscriberNewsletterInfo(subscriberId, newsletterId);
if ((subscriptionInfo != null) && (subscriptionInfo.SubscriptionApproved))
{
subscriptionInfo.SubscriptionApproved = false;
subscriptionInfo.SubscriptionApprovedWhen = DateTime.MinValue;
SubscriberNewsletterInfoProvider.SetSubscriberNewsletterInfo(subscriptionInfo);
}
break;
}
}
unigridNewsletters.ResetSelection();
unigridNewsletters.ReloadData();
}
protected void Page_Load(object sender, EventArgs e)
{
// Get data from query string
Guid subscriberGuid = QueryHelper.GetGuid("subscriberguid", Guid.Empty);
Guid newsletterGuid = QueryHelper.GetGuid("newsletterguid", Guid.Empty);
string subscriptionHash = QueryHelper.GetString("subscriptionhash", string.Empty);
Guid issueGuid = QueryHelper.GetGuid("issueGuid", Guid.Empty);
int issueID = QueryHelper.GetInteger("issueid", 0);
int contactId = QueryHelper.GetInteger("contactid", 0);
bool unsubscribed = false;
string requestTime = QueryHelper.GetString("datetime", string.Empty);
DateTime datetime = DateTimeHelper.ZERO_TIME;
// Get date and time
if (!string.IsNullOrEmpty(requestTime))
{
try
{
datetime = DateTime.ParseExact(requestTime, SecurityHelper.EMAIL_CONFIRMATION_DATETIME_FORMAT, null);
}
catch
{
ShowError(GetString("newsletter.unsubscribefailed"));
return;
}
}
// Get site ID
int siteId = 0;
if (CMSContext.CurrentSite != null)
{
siteId = CMSContext.CurrentSiteID;
}
if ((subscriberGuid != Guid.Empty) && (newsletterGuid != Guid.Empty) && (siteId != 0))
{
Subscriber subscriber = SubscriberProvider.GetSubscriber(subscriberGuid, siteId);
if (subscriber == null)
{
ShowError(GetString("Unsubscribe.SubscriberDoesNotExist"));
return;
}
// Show error message if subscriber type is 'Role'
if (!string.IsNullOrEmpty(subscriber.SubscriberType) && subscriber.SubscriberType.Equals(SiteObjectType.ROLE, StringComparison.InvariantCultureIgnoreCase))
{
ShowError(GetString("Unsubscribe.CannotUnsubscribeRole"));
return;
}
Newsletter newsletter = NewsletterProvider.GetNewsletter(newsletterGuid, siteId);
if (newsletter == null)
{
ShowError(GetString("Unsubscribe.NewsletterDoesNotExist"));
return;
}
// Check if subscriber with given GUID is subscribed to specified newsletter
if (SubscriberProvider.IsSubscribed(subscriber.SubscriberID, newsletter.NewsletterID))
{
bool isSubscribed = true;
if (string.IsNullOrEmpty(subscriber.SubscriberType) || !subscriber.SubscriberType.Equals(PredefinedObjectType.CONTACTGROUP, StringComparison.InvariantCultureIgnoreCase))
{
// Unsubscribe action
SubscriberProvider.Unsubscribe(subscriber.SubscriberID, newsletter.NewsletterID);
}
else
{
// Check if the contact group member has unsubscription activity for the specified newsletter
isSubscribed = (contactId > 0) && !ModuleCommands.OnlineMarketingIsContactUnsubscribed(contactId, newsletter.NewsletterID, siteId);
}
if (isSubscribed)
{
// Log newsletter unsubscription activity
LogActivity(subscriber, 0, newsletter.NewsletterID, issueID, issueGuid, siteId, contactId);
// Display confirmation
ShowInformation(GetString("Unsubscribe.Unsubscribed"));
unsubscribed = true;
}
else
{
// Contact group member is already unsubscribed
ShowError(GetString("Unsubscribe.NotSubscribed"));
}
}
else
{
ShowError(GetString("Unsubscribe.NotSubscribed"));
}
}
// Check if subscription approval hash is supplied
else if (!string.IsNullOrEmpty(subscriptionHash))
{
SubscriberNewsletterInfo sni = SubscriberNewsletterInfoProvider.GetSubscriberNewsletterInfo(subscriptionHash);
// Check if hash is valid
if (sni != null)
{
SubscriberProvider.ApprovalResult result = SubscriberProvider.Unsubscribe(subscriptionHash, true, CMSContext.CurrentSiteName, datetime);
switch (result)
{
// Approving subscription was successful
case SubscriberProvider.ApprovalResult.Success:
bool isSubscribed = true;
// Get subscriber
Subscriber subscriber = SubscriberProvider.GetSubscriber(sni.SubscriberID);
if ((subscriber != null) && !string.IsNullOrEmpty(subscriber.SubscriberType) && subscriber.SubscriberType.Equals(PredefinedObjectType.CONTACTGROUP, StringComparison.InvariantCultureIgnoreCase))
{
// Check if the contact group member has unsubscription activity for the specified newsletter
isSubscribed = (contactId > 0) && !ModuleCommands.OnlineMarketingIsContactUnsubscribed(contactId, sni.NewsletterID, siteId);
}
if (isSubscribed)
{
// Log newsletter unsubscription activity
LogActivity(null, sni.SubscriberID, sni.NewsletterID, issueID, issueGuid, siteId, contactId);
// Display confirmation
ShowInformation(GetString("Unsubscribe.Unsubscribed"));
unsubscribed = true;
}
else
{
// Contact group member is already unsubscribed
ShowError(GetString("Unsubscribe.NotSubscribed"));
}
break;
// Subscription was already approved
case SubscriberProvider.ApprovalResult.Failed:
ShowError(GetString("newsletter.unsubscribefailed"));
break;
case SubscriberProvider.ApprovalResult.TimeExceeded:
ShowError(GetString("newsletter.approval_timeexceeded"));
break;
// Subscription not found
default:
case SubscriberProvider.ApprovalResult.NotFound:
ShowError(GetString("Unsubscribe.NotSubscribed"));
break;
}
}
else
{
ShowError(GetString("Unsubscribe.NotSubscribed"));
}
}
else
{
if (subscriberGuid == Guid.Empty)
{
ShowError(GetString("Unsubscribe.SubscriberDoesNotExist"));
}
if (newsletterGuid == Guid.Empty)
{
ShowError(GetString("Unsubscribe.NewsletterDoesNotExist"));
}
}
// Increase unsubscribed count
if (unsubscribed)
{
// If Issue ID was provided
if (issueID > 0)
{
IssueProvider.Unsubscribe(issueID);
return;
}
// Otherwise try using the Issue GUID
if (issueGuid != Guid.Empty)
{
Issue issue = IssueProvider.GetIssue(issueGuid, siteId);
if (issue == null)
{
return;
}
IssueProvider.Unsubscribe(issue.IssueID);
}
}
}
/// <summary>
/// Un-block contact.
/// </summary>
private void Unblock(object actionArgument)
{
CheckAuthorization();
SubscriberProvider.UnblockContact(ValidationHelper.GetInteger(actionArgument, 0));
}
/// <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="siteId">Site ID</param>
/// <param name="issueId">Issue ID</param>
/// <param name="issueGuid">Issue GUID</param>
/// <param name="contactId">Contact ID is present if the mail is sent to a contact group</param>
private void LogActivity(Subscriber sb, int subscriberId, int newsletterId, int siteId, int issueId, Guid issueGuid, int contactId)
{
// Check if activities logging is enabled
if ((newsletterId <= 0) || (CMSContext.ViewMode != ViewModeEnum.LiveSite) || !ActivitySettingsHelper.ActivitiesEnabledAndModuleLoaded(siteId) ||
!ActivitySettingsHelper.NewsletterSubscribeEnabled(siteId))
{
return;
}
// Load subscriber info object according to its ID if not given
if (sb == null)
{
if (subscriberId <= 0)
{
return;
}
sb = SubscriberProvider.GetSubscriber(subscriberId);
}
if (sb == null)
{
return;
}
Newsletter news = NewsletterProvider.GetNewsletter(newsletterId);
if ((news != null) && news.NewsletterLogActivity)
{
bool isFromContactGroup = (contactId > 0);
// Try to retrieve contact IDs for particular subscriber from membership relations
if (!isFromContactGroup)
{
contactId = ActivityTrackingHelper.GetContactID(sb);
}
if (contactId > 0)
{
// Load additional info (issue id)
if ((issueId <= 0) && (issueGuid != Guid.Empty))
{
Issue issue = IssueProvider.GetIssue(issueGuid, siteId);
if (issue != null)
{
issueId = issue.IssueID;
}
}
var data = new ActivityData()
{
ContactID = contactId,
SiteID = sb.SubscriberSiteID,
Type = PredefinedActivityType.NEWSLETTER_UNSUBSCRIBING,
TitleData = news.NewsletterName,
ItemID = newsletterId,
URL = URLHelper.CurrentRelativePath,
ItemDetailID = issueId,
Value = (isFromContactGroup ? "contactgroup(" + sb.SubscriberRelatedID + ")" : null)
};
ActivityLogProvider.LogActivity(data);
}
}
}
/// <summary>
/// Initializes the control properties.
/// </summary>
protected void SetupControl()
{
if (StopProcessing)
{
// Do nothing
}
else
{
int siteId = 0;
// Get current id
if (CMSContext.CurrentSite != null)
{
siteId = CMSContext.CurrentSiteID;
}
// Get subscriber and newsletter guid from query string
Guid subscriberGuid = QueryHelper.GetGuid("subscriberguid", Guid.Empty);
Guid newsletterGuid = QueryHelper.GetGuid("newsletterguid", Guid.Empty);
string subscriptionHash = QueryHelper.GetString("subscriptionhash", string.Empty);
int issueId = QueryHelper.GetInteger("issueid", 0);
Guid issueGuid = QueryHelper.GetGuid("issueguid", Guid.Empty);
int contactId = QueryHelper.GetInteger("contactid", 0);
string requestTime = QueryHelper.GetString("datetime", string.Empty);
DateTime datetime = DateTimeHelper.ZERO_TIME;
// Get date and time
if (!string.IsNullOrEmpty(requestTime))
{
try
{
datetime = DateTime.ParseExact(requestTime, SecurityHelper.EMAIL_CONFIRMATION_DATETIME_FORMAT, null);
}
catch
{
lblError.Visible = true;
lblError.Text = GetString("newsletter.unsubscribefailed");
return;
}
}
// Check whether both guid exists
if ((subscriberGuid != Guid.Empty) && (newsletterGuid != Guid.Empty))
{
Subscriber subscriber = SubscriberProvider.GetSubscriber(subscriberGuid, siteId);
if (subscriber == null)
{
lblError.Visible = true;
lblError.Text = GetString("Unsubscribe.SubscriberDoesNotExist");
return;
}
// Show error message if subscriber type is 'Role'
if (!string.IsNullOrEmpty(subscriber.SubscriberType) && subscriber.SubscriberType.Equals(SiteObjectType.ROLE, StringComparison.InvariantCultureIgnoreCase))
{
lblError.Visible = true;
lblError.Text = GetString("Unsubscriber.CannotUnsubscribeRole");
return;
}
Newsletter newsletter = NewsletterProvider.GetNewsletter(newsletterGuid, siteId);
if (newsletter == null)
{
lblError.Visible = true;
lblError.Text = GetString("Unsubscribe.NewsletterDoesNotExist");
return;
}
// Check whether subscription is valid
if (SubscriberProvider.IsSubscribed(subscriber.SubscriberID, newsletter.NewsletterID))
{
bool isSubscribed = true;
if (string.IsNullOrEmpty(subscriber.SubscriberType) || !subscriber.SubscriberType.Equals(PredefinedObjectType.CONTACTGROUP, StringComparison.InvariantCultureIgnoreCase))
{
// Unsubscribe action
SubscriberProvider.Unsubscribe(subscriber.SubscriberID, newsletter.NewsletterID, SendConfirmationEmail);
}
else
{
// Check if the contact group member has unsubscription activity for the specified newsletter
isSubscribed = (contactId > 0) && !ModuleCommands.OnlineMarketingIsContactUnsubscribed(contactId, newsletter.NewsletterID, siteId);
}
if (isSubscribed)
{
// Log newsletter unsubscription activity
LogActivity(subscriber, subscriber.SubscriberID, newsletter.NewsletterID, subscriber.SubscriberSiteID, issueId, issueGuid, contactId);
// Display confirmation
DisplayConfirmation();
}
else
{
// Contact group member is already unsubscribed
lblError.Visible = true;
lblError.Text = GetString("Unsubscribe.NotSubscribed");
}
}
else
{
lblError.Visible = true;
lblError.Text = GetString("Unsubscribe.NotSubscribed");
}
}
// Check if subscriptionGUID is supplied
else if (!string.IsNullOrEmpty(subscriptionHash))
{
// Check if given subscription exists
SubscriberNewsletterInfo sni = SubscriberNewsletterInfoProvider.GetSubscriberNewsletterInfo(subscriptionHash);
if (sni != null)
{
SubscriberProvider.ApprovalResult result = SubscriberProvider.Unsubscribe(subscriptionHash, true, CMSContext.CurrentSiteName, datetime);
switch (result)
{
// Approving subscription was successful
case SubscriberProvider.ApprovalResult.Success:
bool isSubscribed = true;
// Get subscriber
Subscriber subscriber = SubscriberProvider.GetSubscriber(sni.SubscriberID);
if ((subscriber != null) && !string.IsNullOrEmpty(subscriber.SubscriberType) && subscriber.SubscriberType.Equals(PredefinedObjectType.CONTACTGROUP, StringComparison.InvariantCultureIgnoreCase))
{
// Check if the contact group member has unsubscription activity for the specified newsletter
isSubscribed = (contactId > 0) && !ModuleCommands.OnlineMarketingIsContactUnsubscribed(contactId, sni.NewsletterID, siteId);
}
if (isSubscribed)
{
// Log newsletter unsubscription activity
LogActivity(subscriber, subscriber.SubscriberID, sni.NewsletterID, siteId, issueId, issueGuid, contactId);
// Display confirmation
DisplayConfirmation();
}
else
{
// Contact group member is already unsubscribed
lblError.Visible = true;
lblError.Text = GetString("Unsubscribe.NotSubscribed");
}
break;
// Subscription was already approved
case SubscriberProvider.ApprovalResult.Failed:
lblError.Visible = true;
lblError.Text = GetString("newsletter.unsubscribefailed");
break;
case SubscriberProvider.ApprovalResult.TimeExceeded:
lblError.Visible = true;
lblError.Text = GetString("newsletter.approval_timeexceeded");
break;
// Subscription not found
default:
case SubscriberProvider.ApprovalResult.NotFound:
lblError.Visible = true;
lblError.Text = GetString("Unsubscribe.NotSubscribed");
break;
}
}
else
{
lblError.Visible = true;
lblError.Text = GetString("Unsubscribe.NotSubscribed");
}
}
else
{
Visible = false;
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
InitGUI();
// Get issue ID from query string
int newsletterIssueId = QueryHelper.GetInteger("issueid", 0);
// Get Issue object
Issue issue = IssueProvider.GetIssue(newsletterIssueId);
if (issue == null)
{
lblError.Visible = true;
lblError.Text = GetString("Newsletter_Issue_New_Preview.NoIssue");
return;
}
// Get specific number of subscribers subscribed to the newsletter
string where = "SubscriberID IN (SELECT SubscriberID FROM Newsletter_SubscriberNewsletter WHERE NewsletterID=" + issue.IssueNewsletterID + " AND (SubscriptionApproved = 1 OR SubscriptionApproved IS NULL))";
DataSet subscribers = SubscriberProvider.GetSubscribers(where, null, MAX_PREVIEW_SUBSCRIBERS, null);
string script;
if (!DataHelper.DataSourceIsEmpty(subscribers))
{
// Limit max subscribers count to number of rows
int maxCount = subscribers.Tables[0].Rows.Count;
// Generate javascript based on subscribers
script = string.Format(@"newsletterIssueId ={0};
var guid = new Array({1});
var email = new Array({1});
var subject = new Array({1});
var subscribers = new Array(guid, email);",
newsletterIssueId,
maxCount);
// Ensure correct subject culture
string siteName = CMSContext.CurrentSiteName;
string culture = CultureHelper.GetDefaultCulture(siteName);
// Get newsletter object
Newsletter news = NewsletterProvider.GetNewsletter(issue.IssueNewsletterID);
// Get subject base
string subjectBase = GetString("general.subject") + ResHelper.Colon;
Subscriber subscriber = null;
Subscriber sb = null;
SortedDictionary <int, Subscriber> subMembers = null;
string infoLine = null;
string subject = null;
IssueHelper ih = new IssueHelper();
for (int i = 0; i < maxCount; i++)
{
// Get subscriber
subscriber = new Subscriber(subscribers.Tables[0].Rows[i]);
if (subscriber != null)
{
// Insert subscriber GUID
script = string.Format("{0} guid[{1}] = '{2}'; \n ", script, i, subscriber.SubscriberGUID);
// Get subscriber's member (different for user, role or contact group subscribers)
subMembers = SubscriberProvider.GetSubscribers(subscriber, 1, 0);
foreach (KeyValuePair <int, Subscriber> item in subMembers)
{
// Get 1st subscriber's member
sb = item.Value;
if (sb != null)
{
// Create information line
infoLine = ScriptHelper.GetString(sb.SubscriberEmail, false);
// Add info about subscriber type
if (sb.SubscriberType == SiteObjectType.USER)
{
infoLine = string.Format("{0} ({1})", infoLine, GetString("objecttype.cms_user").ToLower());
}
else if (sb.SubscriberType == SiteObjectType.ROLE)
{
infoLine = string.Format("{0} ({1})", infoLine, GetString("objecttype.cms_role").ToLower());
}
else if (sb.SubscriberType == PredefinedObjectType.CONTACTGROUP)
{
infoLine = string.Format("{0} ({1})", infoLine, GetString("objecttype.om_contactgroup").ToLower());
}
script = string.Format("{0} email[{1}] = '{2}'; \n ", script, i, infoLine);
// Resolve dynamic field macros ({%FirstName%}, {%LastName%}, {%Email%})
if (ih.LoadDynamicFields(sb, news, null, issue, true, siteName, null, null, null))
{
subject = ih.ResolveDynamicFieldMacros(issue.IssueSubject);
}
// Create resolved subject
subject = HTMLHelper.HTMLEncode(string.Format("{0} {1}", subjectBase, subject));
script = string.Format("{0}subject[{1}] = {2}; \n ", script, i, ScriptHelper.GetString(subject));
}
}
}
}
}
else
{
// No subscribers? => hide 'prev' and 'next' link buttons
pnlLinkButtons.Visible = false;
// Generate void javascript
script = string.Format(@"newsletterIssueId ={0};
var guid = new Array(1);
var email = new Array(1);
var subscribers = new Array(guid, email);
guid[1] = 0;
email[1] = 0;",
newsletterIssueId);
}
ltlScript.Text = ScriptHelper.GetScript(script);
if (!RequestHelper.IsPostBack())
{
ScriptHelper.RegisterStartupScript(this, typeof(string), "LoadPreview" + ClientID, ScriptHelper.GetScript("pageLoad();"));
}
}
/// <summary>
/// Delete selected subscriber.
/// </summary>
private void Delete(object actionArgument)
{
CheckAuthorization();
SubscriberProvider.DeleteSubscriber(ValidationHelper.GetInteger(actionArgument, 0));
}
private void usNewsletters_OnSelectionChanged(object sender, EventArgs e)
{
// Check 'EcommerceModify' permission
if (!CMSContext.CurrentUser.IsAuthorizedPerResource("CMS.Ecommerce", "EcommerceModify"))
{
// Check 'ModifyCustomers' permission if don't have general ecommerce modify permission
if (!CMSContext.CurrentUser.IsAuthorizedPerResource("CMS.Ecommerce", "ModifyCustomers"))
{
CMSPage.RedirectToCMSDeskAccessDenied("CMS.Ecommerce", "EcommerceModify OR ModifyCustomers");
}
}
// Check if a customer has a valid email
if ((email != null) && (email.Trim() != string.Empty) && (ValidationHelper.IsEmail(email)))
{
// Check whether subcriber already exist
Subscriber sb = SubscriberProvider.GetSubscriber(email, siteId);
if (sb == null)
{
// Create new subscriber
sb = new Subscriber();
sb.SubscriberEmail = email;
sb.SubscriberFirstName = firstName;
sb.SubscriberLastName = lastName;
sb.SubscriberFullName = (firstName + " " + lastName).Trim();
sb.SubscriberSiteID = siteId;
sb.SubscriberGUID = Guid.NewGuid();
SubscriberProvider.SetSubscriber(sb);
}
// Remove old items
string newValues = ValidationHelper.GetString(usNewsletters.Value, null);
string items = DataHelper.GetNewItemsInList(newValues, currentValues);
if (!String.IsNullOrEmpty(items))
{
string[] newItems = items.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (newItems != null)
{
foreach (string item in newItems)
{
int newsletterId = ValidationHelper.GetInteger(item, 0);
// If subscriber is subscribed, unsubscribe him
if (SubscriberProvider.IsSubscribed(sb.SubscriberID, newsletterId))
{
SubscriberProvider.Unsubscribe(sb.SubscriberID, newsletterId);
}
}
}
}
// Add new items
items = DataHelper.GetNewItemsInList(currentValues, newValues);
if (!String.IsNullOrEmpty(items))
{
string[] newItems = items.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (newItems != null)
{
foreach (string item in newItems)
{
int newsletterId = ValidationHelper.GetInteger(item, 0);
// If subscriber is not subscribed, subscribe him
if (!SubscriberProvider.IsSubscribed(sb.SubscriberID, newsletterId))
{
SubscriberProvider.Subscribe(sb.SubscriberID, newsletterId, DateTime.Now);
}
}
}
}
// Display information about successful (un)subscription
lblInfo.Visible = true;
lblInfo.Text = GetString("General.ChangesSaved");
}
}
