public static EmailMessage CreateMessage(SubscriberInfo info, string emailAddress, bool isSubscription, bool alreadyDone = false)
{
if (isSubscription)
{
return(new EmailMessage()// i dont care about null pointer here!
{
EmailAddress = info.EmailAddress,
Subject = "New Subscription",
Body = !alreadyDone
? $"Hello \"{info.FirstName} {info.LastName}\"\tYour subscription is done successfully.we added you to our mailing list."
: $"Hello \"{info.FirstName} {info.LastName}\"\tYou have been already added to our mailing list."
});
}
else
{
return(new EmailMessage()
{
EmailAddress = info.EmailAddress,
Subject = "UnSubscription",
Body = !alreadyDone
? $"dear:{info.FirstName} {info.LastName}\n\tIf your are determined to unsubscribe please confirm <here>"
: $"dear:{emailAddress}\n\tyou have not subscribed to our system, if you still receive from us please contact administrator."
});
}
}
private bool InvokeSubscriberHandler <T>(SubscriberInfo subscriber, T eventData, InvokeOption invokeOption)
{
if (subscriber.Delay > 0)
{
UnregisterDelay(subscriber);
}
var handler = subscriber.Handler.CreateAction <T>();
if (handler == null)
{
return(false);
}
switch (invokeOption)
{
case InvokeOption.UIThread:
SynchronizationContext.Post(state => handler(eventData), eventData);
break;
case InvokeOption.ThreadPool:
ThreadPool.QueueUserWorkItem(obj => handler(eventData));
break;
case InvokeOption.Blocking:
handler(eventData);
break;
}
return(true);
}
public static async Task <SubscriberInfo> AddSubscriber()
{
var credential = new RestCredentialInfo();
credential.ReadFromConfiguration();
var subscriberInfo = new SubscriberInfo
{
EmailAddress = "*****@*****.**",
Status = "subscribed"
};
var mergeFieldInfo = new MergeFieldInfo();
mergeFieldInfo.FirstName = "Kim";
mergeFieldInfo.LastName = "Jung";
subscriberInfo.MergeFields = new MergeFieldInfo
{
FirstName = "Kim",
LastName = "Jung"
};
var result = await Subscriber.Subscribe(
credential,
subscriberInfo,
"Site Registration"
);
return(result);
}
public static SubscriberInfo Parse(string data)
{
try
{
XmlDocument xml = new XmlDocument();
xml.LoadXml(data);
XmlElement root = xml.DocumentElement;
XmlElement nameNode = root["name"];
XmlElement authorNode = root["author"];
XmlElement versionNode = root["version"];
XmlElement descriptionNode = root["description"];
XmlElement packageUrlNode = root["packageurl"];
string name = nameNode.InnerText.Trim();
string author = authorNode.InnerText.Trim();
string version = versionNode.InnerText.Trim();
string description = descriptionNode.InnerText.Trim();
string packageUrl = packageUrlNode.InnerText.Trim();
SubscriberInfo info = new SubscriberInfo(name, author, version, description, packageUrl);
return(info);
}
catch
{
return(null);
}
}
public static Queue <SubscriberInfo> GetMailingListSubscribersWithEmailsByListOfMailingListIDs(List <int> mailingListIDs, int?existingMailoutId)
{
Queue <SubscriberInfo> objects = new Queue <SubscriberInfo>();
using (Entities entity = new Entities())
{
var mailingListSubscribersWithEmails = entity.Newsletter_GetMailingListSubscribersWithEmailsByListOfMailingListIDs(
string.Join(",", mailingListIDs.Select(id => id.ToString())),
existingMailoutId);
foreach (var mailingListSubscribersWithEmail in mailingListSubscribersWithEmails)
{
SubscriberInfo obj = new SubscriberInfo();
obj.Email = mailingListSubscribersWithEmail.Email;
obj.EntityID = mailingListSubscribersWithEmail.EntityID;
obj.Replacements = new Hashtable {
{ "[[EntityID]]", obj.EntityID.Value.ToString("D").ToLower() }
};
obj.SubscriberID = mailingListSubscribersWithEmail.SubscriberID;
obj.SubscriptionType = (SubscriptionType)mailingListSubscribersWithEmail.DefaultNewsletterFormatID;
objects.Enqueue(obj);
}
}
return(objects);
}
/// <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>
/// Subscribes e-mail address to specific newsletter.
/// If no subscriber with the given e-mail is found, the new one is created.
/// Action fails when:
/// <list type="bullet">
/// <item>
/// <description>Request is performed from banned IP address</description>
/// </item>
/// <item>
/// <description>Email is already subscribed to the newsletter</description>
/// </item>
/// <item>
/// <description>Newsletter with the given name does not exist</description>
/// </item>
/// <item>
/// <description>Current licence does not allow creating new subscribers</description>
/// </item>
/// </list>
/// errorMessage output parameter is filled with localized error description in all these cases.
/// No exception can be thrown.
/// </summary>
/// <param name="email">Subscriber's e-mail address</param>
/// <param name="newsletterName">Name of the newsletter</param>
/// <param name="errorMessage">Error message used when subscription failed</param>
/// <returns>Returns true if subscription was successful</returns>
public virtual bool Subscribe(string email, string newsletterName, out string errorMessage)
{
bool result = false;
// Creates new transaction for saving subscriber's information
using (var tr = new CMSTransactionScope())
{
// Saves subscriber into the database
SubscriberInfo subscriber = SaveSubscriber(email, out errorMessage);
if ((subscriber != null) && string.IsNullOrEmpty(errorMessage))
{
// Assignes subscriber into the newsletter
bool newsletterSubscribed = SaveNewsletter(newsletterName, subscriber, out errorMessage);
if (newsletterSubscribed && string.IsNullOrEmpty(errorMessage))
{
result = true;
}
}
// Saves changes
tr.Commit();
}
return(result);
}
private string GetPreviewScriptForCampaign(IssueInfo issue, NewsletterInfo newsletter, IssueHelper issueHelper)
{
string currentSiteName = SiteContext.CurrentSiteName;
var output = new StringBuilder();
var recipients = issue.GetRecipientsProvider()
.GetMarketableRecipients()
.TopN(MAX_PREVIEW_SUBSCRIBERS)
.ToList();
if (!recipients.Any())
{
return(InitializePreviewScriptForZeroSubscribers(issue, GetPreviewSubject(issue, newsletter, issueHelper, null, currentSiteName)));
}
output.AppendLine(InitializePreviewScript(issue, recipients.Count));
for (int index = 0; index < recipients.Count; index++)
{
var recipient = recipients[index];
var dummySubscriber = new SubscriberInfo
{
SubscriberFirstName = recipient.ContactFirstName,
SubscriberLastName = recipient.ContactLastName,
SubscriberEmail = recipient.ContactEmail
};
output.AppendFormat("guid[{0}] = '{1}';", index, recipient.ContactGUID);
output.AppendFormat("email[{0}] = '{1}';", index, recipient.ContactEmail);
output.AppendFormat("subject[{0}] = {1};", index, ScriptHelper.GetString(HTMLHelper.HTMLEncode(GetPreviewSubject(issue, newsletter, issueHelper, dummySubscriber, currentSiteName))));
}
return(output.ToString());
}
public void Send(SubscriberInfo subscriber, string statusNotif)
{
subscriber.Status = statusNotif;
Console.WriteLine($"Curier : character {subscriber.Id} got the notif");
Console.WriteLine();
Console.WriteLine(subscriber.ToString());
}
/// <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);
}
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>
/// 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"));
}
}
public void DefineSubscriberInfo(SubscriberInfo subscriberInfo)
{
ParkingManagementDAL parkingManagementDAL = new ParkingManagementDAL();
parkingManagementDAL.DefineSubscriberInfo(subscriberInfo);
parkingManagementDAL = null;
}
/// <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>
/// 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>
/// Valid checkbox list, Indicates whether the subscriber is already subscribed to the selected newsletter.
/// </summary>
/// <param name="sb">Subscriber</param>
private void ValidChoose(SubscriberInfo sb)
{
if (sb == null)
{
return;
}
bool wasWrong = true;
// Save selected items
for (int i = 0; i < chklNewsletters.Items.Count; i++)
{
ListItem item = chklNewsletters.Items[i];
if (item != null && item.Selected)
{
wasWrong = wasWrong & (!Save(item.Value, sb));
}
}
// Check subscription
if ((chklNewsletters.Items.Count > 0) && (!wasWrong))
{
lblInfo.Visible = true;
lblInfo.Text += SubscriptionConfirmationMessage;
// Hide subscription form after successful subscription
pnlSubscription.Visible = false;
}
}
/// <summary>
/// Logs activity for unsubscribing.
/// </summary>
/// <param name="subscriber">Subscriber</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 subscriber, int newsletterId, int issueId, int contactId)
{
if (subscriber == null)
{
throw new ArgumentNullException("subscriber");
}
if (contactId <= 0)
{
contactId = ActivityTrackingHelper.GetContactID(subscriber);
}
if (contactId > 0)
{
NewsletterInfo news = NewsletterInfoProvider.GetNewsletterInfo(newsletterId);
bool isFromContactGroup = subscriber.SubscriberType.EqualsCSafe(PredefinedObjectType.CONTACTGROUP, true);
bool isFromPersona = subscriber.SubscriberType.EqualsCSafe(PredefinedObjectType.PERSONA, true);
Activity activity = new ActivityNewsletterUnsubscribing(subscriber, news, AnalyticsContext.ActivityEnvironmentVariables);
if (activity.Data != null)
{
activity.Data.ContactID = contactId;
activity.Data.ItemDetailID = issueId;
if (isFromContactGroup)
{
activity.Data.Value = "contactgroup(" + subscriber.SubscriberRelatedID + ")";
}
else if (isFromPersona)
{
activity.Data.Value = "persona(" + subscriber.SubscriberRelatedID + ")";
}
activity.Log();
}
}
}
private void ConsumeMessage(SubscriberInfo subscriberInfo, IBrokeredMessage brokeredMessage)
{
try
{
var messageBody = brokeredMessage.GetBody <string>();
var message = JsonConvert.DeserializeObject <TMessage>(messageBody);
_logService.Debug("Consuming message id '{0}', topic/subscription '{1}', body '{2}'",
brokeredMessage.MessageId, subscriberInfo.SubscriptionPath, messageBody);
var state = subscriberInfo.Subscriber.Consume(message);
HandleMessageResult(subscriberInfo, state, brokeredMessage, messageBody);
_logService.Debug("Consumed message id '{0}', topic/subscription '{1}', body '{2}'",
brokeredMessage.MessageId, subscriberInfo.SubscriptionPath, messageBody);
}
catch (Exception e)
{
var deadLetterReason = string.Format(
"Unexpected exception consuming message id '{0}, topic/subscription '{1}': message will be dead-lettered",
brokeredMessage.MessageId, subscriberInfo.SubscriptionPath);
_logService.Error(deadLetterReason, e);
brokeredMessage.DeadLetter();
}
}
private void StartDownload(object obj)
{
SubscriberInfo info = (SubscriberInfo)obj;
this.wc.DownloadFileAsync(new Uri(info.PackageUrl), info.LocalZipFileLocation, info);
}
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);
}
public string partial_subscription(string txt_name, string txt_email)
{
var result = "";
SubscriberInfo SubscriberInfo = new SubscriberInfo();
SubscriberInfo.email = txt_email;
SubscriberInfo.name = txt_name;
SubscriberInfo.isActive = true;
try
{
db.SubscriberInfoes.Add(SubscriberInfo);
db.SaveChanges();
StreamReader sr = new StreamReader(System.Web.Hosting.HostingEnvironment.MapPath("~/Content/emailers/SubscriptionToClient.html"));
string HTML_Body = sr.ReadToEnd();
string final_Html_Body = HTML_Body.Replace("#name", txt_name);
sr.Close();
string To = txt_email;
string mail_Subject = "Thank you for subscribing PromoTalks.";
result = BaseUtil.sendEmailer(To, mail_Subject, final_Html_Body);
}
catch (Exception e)
{
return(e.Message.ToString());
}
return(result);
}
/// <summary>
/// Checks whether the current user has permissions to add the subscriber. If not, redirect to access denied page.
/// </summary>
/// <param name="subscriber">Subscriber to be checked</param>
private void CheckPermissionsForSubscriber(SubscriberInfo subscriber)
{
if (!subscriber.CheckPermissions(PermissionsEnum.Modify, CurrentSiteName, CurrentUser))
{
RedirectToAccessDenied(ModuleName.NEWSLETTER, "ManageSubscribers");
}
}
/// <summary>
/// </summary>
/// <param name="method"></param>
/// <param name="subscriber"></param>
/// <param name="field">Action 을 저장할 필드</param>
private void InjectSubscribe(MethodDefinition method, SubscriberInfo subscriber, FieldDefinition field)
{
WvPatterns.WrapMethod.Apply(
method,
(ilgen, cursor) => { },
(ilgen, cursor) => {
cursor.Emit(ilgen.Create(OpCodes.Ldstr, subscriber.key));
cursor.LdThis(ilgen);
var actionType = new GenericInstanceType(Net2Resolver.GetType(typeof(Action <>).Name));
actionType.GenericArguments.Add(module.ImportReference(typeof(IPubSubMessage)));
cursor.Emit(ilgen.CreateLdType(actionType));
cursor.LdThis(ilgen);
cursor.LdStr(ilgen, subscriber.method.Name);
cursor.Call(ilgen,
module.ImportReference(Net2Resolver.GetMethod(typeof(Delegate), nameof(Delegate.CreateDelegate), new Type[] {
typeof(Type), typeof(object), typeof(string)
})));
//cursor.Emit(ilgen.Create(OpCodes.Dup));
cursor.Emit(ilgen.Create(OpCodes.Stfld, field));
cursor.LdThis(ilgen);
cursor.Emit(ilgen.Create(OpCodes.Ldfld, field));
cursor.Emit(ilgen.Create(OpCodes.Castclass, module.ImportReference(typeof(Action <IPubSubMessage>))));
cursor.Emit(ilgen.Create(OpCodes.Call,
module.ImportReference(typeof(PubSub).GetMethod("Subscribe", new Type[] { typeof(string), typeof(Action <IPubSubMessage>) }))));
});
}
/// <summary>
/// Submit button handler.
/// </summary>
protected void btnSubmit_Click(object sender, EventArgs e)
{
if (PortalContext.IsDesignMode(PortalManager.ViewMode) || (HideOnCurrentPage) || (!IsVisible))
{
// Do not process
return;
}
// Check banned ip
if (!BannedIPInfoProvider.IsAllowed(SiteContext.CurrentSiteName, BanControlEnum.AllNonComplete))
{
lblError.Visible = true;
lblError.Text = GetString("General.BannedIP");
return;
}
if (IsValid())
{
// Ensure subscriber - get existing or create new one
SubscriberInfo subscriber = SaveSubscriber();
if (chooseMode)
{
ValidChoose(subscriber);
}
else
{
// Hide subscription form if subscription was successful
pnlSubscription.Visible = !Save(NewsletterName, subscriber);
}
}
}
private void btnSave_Click(object sender, EventArgs e)
{
try
{
SubscriberInfo subscriberInfo = new SubscriberInfo();
subscriberInfo.FirstName = txtFirstName.Text;
subscriberInfo.LastName = txtLastName.Text;
subscriberInfo.Address = txtAddress.Text;
subscriberInfo.District = txtDistrict.Text;
subscriberInfo.Province = txtProvince.Text;
subscriberInfo.PhoneNumber = txtPhoneNumber.Text;
subscriberInfo.RegistrationDate = DateTime.Now;
ParkingManagementBLL parkingManagementBLL = new ParkingManagementBLL();
parkingManagementBLL.DefineSubscriberInfo(subscriberInfo);
MessageBox.Show("Kayıt başarılı!");
ClearPanel();
}
catch (Exception ex)
{
Log.AddExceptionLog(ex);
MessageBox.Show("Kayıt eklenemedi!");
}
}
/// <summary>Subscribe w/o auto unsubscribe</summary>
public SubscriberInfo SubscribeRaw(Action callback)
{
var unit = new SubscriberInfo(callback, this);
subscribers.AddLast(unit);
return(unit);
}
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 void btnSubscriberShowInfo_Click(object sender, EventArgs e)
{
var sub = SubscriberHelper.GetSubscribers().Where(x => x.ToString().Equals(lbSubscribers.SelectedItem)).FirstOrDefault();
var form = new SubscriberInfo(sub);
form.ShowDialog();
}
public ActionResult DeleteConfirmed(int id)
{
SubscriberInfo subscriberInfo = db.SubscriberInfoes.Find(id);
db.SubscriberInfoes.Remove(subscriberInfo);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public CreateSubscriptionsUserControl()
{
InitializeComponent();
SubscriberInfo subscriberInfo = new SubscriberInfo();
subscriberInfo.GetSubscriberInfos(cmbBoxUsers);
}
/// <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);
}
}
/// <summary>
/// User control items changed event.
/// </summary>
protected void UserSelector_OnItemsSelected(object sender, EventArgs e)
{
// Check permissions
CheckAuthorization();
int siteId = SiteContext.CurrentSiteID;
// Get new items from selector
string newValues = ValidationHelper.GetString(selectUser.Value, null);
string[] newItems = newValues.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string item in newItems)
{
// Check limited number of subscribers
if (!SubscriberInfoProvider.LicenseVersionCheck(RequestContext.CurrentDomain, FeatureEnum.Subscribers, ObjectActionEnum.Insert))
{
ShowError(GetString("licenselimitations.subscribers.errormultiple"));
break;
}
int userID = ValidationHelper.GetInteger(item, 0);
// Get subscriber
SubscriberInfo subscriber = SubscriberInfoProvider.GetSubscriberInfo(UserInfo.OBJECT_TYPE, userID, siteId);
if (subscriber == null)
{
// Get user info
UserInfo ui = UserInfoProvider.GetUserInfo(userID);
if (ui == null)
{
continue;
}
// Create new subscriber of user type
subscriber = new SubscriberInfo();
subscriber.SubscriberFirstName = ui.FullName;
subscriber.SubscriberFullName = new SubscriberFullNameFormater().GetUserSubscriberName(ui.FullName);
subscriber.SubscriberSiteID = siteId;
subscriber.SubscriberType = UserInfo.OBJECT_TYPE;
subscriber.SubscriberRelatedID = userID;
CheckPermissionsForSubscriber(subscriber);
SubscriberInfoProvider.SetSubscriberInfo(subscriber);
}
if (!mSubscriptionService.IsSubscribed(subscriber.SubscriberID, mNewsletter.NewsletterID))
{
mSubscriptionService.Subscribe(subscriber.SubscriberID, mNewsletter.NewsletterID, new SubscribeSettings()
{
SendConfirmationEmail = chkSendConfirmation.Checked,
RequireOptIn = chkRequireOptIn.Checked,
RemoveAlsoUnsubscriptionFromAllNewsletters = false,
});
}
}
selectUser.Value = null;
UniGridSubscribers.ReloadData();
pnlUpdate.Update();
}
internal HTTPMessage _SubscribeEvent(out String SID, String CallbackURL, String Timeout)
{
SubscriberInfo sinfo = new SubscriberInfo();
sinfo.SID = GetNewSID();
sinfo.CallbackURL = CallbackURL;
sinfo.SEQ = 1;
int to = int.Parse(Timeout);
if (to == 0)
{
sinfo.Expires = -1;
}
else
{
sinfo.Expires = DateTime.Now.AddSeconds(to).Ticks;
}
SubscriberTable[sinfo.SID] = sinfo;
// Send an inital Event
//SSDP.ParseURL(CallbackURL,out WebIP, out WebPort, out Tag);
HTTPMessage Packet = new HTTPMessage();
Packet.Directive = "NOTIFY";
Packet.AddTag("Content-Type", "text/xml");
Packet.AddTag("NT", "upnp:event");
Packet.AddTag("NTS", "upnp:propchange");
Packet.AddTag("SID", sinfo.SID);
Packet.AddTag("SEQ", "0");
Packet.AddTag("CONNECTION", "close");
Packet.BodyBuffer = BuildEventXML();
SID = sinfo.SID;
SubscriptionAddedEvent.Fire(this); // Trigger event saying that a subscription was added
return (Packet);
}
/// <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>
/// Subscribes customer to newsletter. Called when the "Subscribe customer to newsletter" button is pressed.
/// Expects the CreateRegisteredCustomer method to be run first.
/// </summary>
private bool SubscribeCustomerToNewsletter()
{
// Prepare the parameters
string where = "CustomerLastName LIKE N'My New Registered%'";
CustomerInfo customer = null;
// Get the customer
DataSet customers = CustomerInfoProvider.GetCustomers(where, null);
if (!DataHelper.DataSourceIsEmpty(customers))
{
// Create object from DataRow
customer = new CustomerInfo(customers.Tables[0].Rows[0]);
}
// Get the newsletter
NewsletterInfo customerNewsletter = NewsletterInfoProvider.GetNewsletterInfo("CorporateNewsletter", CMSContext.CurrentSiteID);
if ((customer != null) && (customerNewsletter != null))
{
// Create the new subscription object
SubscriberNewsletterInfo subscription = new SubscriberNewsletterInfo();
SubscriberInfo customerExistedSubscriber = SubscriberInfoProvider.GetSubscriberInfo("*****@*****.**", CMSContext.CurrentSiteID);
// Check if customer is subscriber
if (customerExistedSubscriber != null)
{
// Subscribe existed customer subscriber to newsletter
subscription.SubscriberID = customerExistedSubscriber.SubscriberID;
}
else
{
// Create the new subscriber object
SubscriberInfo customerSubscriber = new SubscriberInfo();
// Set the properties
customerSubscriber.SubscriberEmail = customer.CustomerEmail;
customerSubscriber.SubscriberLastName = customer.CustomerLastName;
customerSubscriber.SubscriberSiteID = CMSContext.CurrentSiteID;
// Create the new subscriber
SubscriberInfoProvider.SetSubscriberInfo(customerSubscriber);
// Subscribe new customer subscriber to newsletter
subscription.SubscriberID = customerSubscriber.SubscriberID;
}
subscription.NewsletterID = customerNewsletter.NewsletterID;
subscription.SubscribedWhen = DateTime.Now;
// Save the data
SubscriberNewsletterInfoProvider.SetSubscriberNewsletterInfo(subscription);
return true;
}
return false;
}
/// <summary>
/// Saves the data.
/// </summary>
private bool Save(string newsletterName, SubscriberInfo subscriber)
{
bool toReturn = false;
int siteId = SiteContext.CurrentSiteID;
// Check if subscriber info object exists
if ((subscriber == null) || string.IsNullOrEmpty(newsletterName))
{
return false;
}
// Get newsletter info
NewsletterInfo newsletter = NewsletterInfoProvider.GetNewsletterInfo(newsletterName, siteId);
if (newsletter != null)
{
try
{
// Check if subscriber is not already subscribed
if (!mSubscriptionService.IsSubscribed(subscriber.SubscriberID, newsletter.NewsletterID))
{
toReturn = true;
mSubscriptionService.Subscribe(subscriber.SubscriberID, newsletter.NewsletterID, new SubscribeSettings()
{
SendConfirmationEmail = SendConfirmationEmail,
RequireOptIn = true,
RemoveAlsoUnsubscriptionFromAllNewsletters = true,
});
// Info message
if (!chooseMode)
{
lblInfo.Visible = true;
lblInfo.Text = GetString("NewsletterSubscription.Subscribed");
}
// Track successful subscription conversion
if (TrackConversionName != string.Empty)
{
string siteName = SiteContext.CurrentSiteName;
if (AnalyticsHelper.AnalyticsEnabled(siteName) && !AnalyticsHelper.IsIPExcluded(siteName, RequestContext.UserHostAddress))
{
// Log conversion
HitLogProvider.LogConversions(siteName, LocalizationContext.PreferredCultureCode, TrackConversionName, 0, ConversionValue);
}
}
// Log newsletter subscription activity if double opt-in is not required
if (!newsletter.NewsletterEnableOptIn)
{
Activity activity = new ActivityNewsletterSubscribing(subscriber, newsletter, AnalyticsContext.ActivityEnvironmentVariables);
activity.Log();
}
}
else
{
// Info message - subscriber is allready in site
if (!chooseMode)
{
lblInfo.Visible = true;
lblInfo.Text = GetString("NewsletterSubscription.SubscriberIsAlreadySubscribed");
}
else
{
lblInfo.Visible = true;
lblInfo.Text += GetString("NewsletterSubscription.SubscriberIsAlreadySubscribedXY") + " " + HTMLHelper.HTMLEncode(GetString(newsletter.NewsletterDisplayName)) + ".<br />";
}
}
}
catch (Exception ex)
{
lblError.Visible = true;
lblError.Text = ex.Message;
}
}
else
{
lblError.Visible = true;
lblError.Text = GetString("NewsletterSubscription.NewsletterDoesNotExist");
}
return toReturn;
}
/// <summary>
/// Contact group items selected event handler.
/// </summary>
protected void CGSelector_OnItemsSelected(object sender, EventArgs e)
{
// Check permissions
CheckAuthorization();
if (cgSelector == null)
{
return;
}
int siteId = SiteContext.CurrentSiteID;
// Get new items from selector
string newValues = ValidationHelper.GetString(cgSelector.Value, null);
// Get added items
string[] newItems = newValues.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string item in newItems)
{
// Check limited number of subscribers
if (!SubscriberInfoProvider.LicenseVersionCheck(RequestContext.CurrentDomain, FeatureEnum.Subscribers, ObjectActionEnum.Insert))
{
ShowError(GetString("licenselimitations.subscribers.errormultiple"));
break;
}
// Get group ID
int groupID = ValidationHelper.GetInteger(item, 0);
// Try to get subscriber
SubscriberInfo sb = SubscriberInfoProvider.GetSubscriberInfo(PredefinedObjectType.CONTACTGROUP, groupID, siteId);
if (sb == null)
{
// Get contact group display name
string cgName = ModuleCommands.OnlineMarketingGetContactGroupName(groupID);
if (string.IsNullOrEmpty(cgName))
{
continue;
}
// Create new subscriber of contact group type
sb = new SubscriberInfo();
sb.SubscriberFirstName = cgName;
// Full name consists of "contact group " and display name
sb.SubscriberFullName = new SubscriberFullNameFormater().GetContactGroupSubscriberName(cgName);
sb.SubscriberSiteID = siteId;
sb.SubscriberType = PredefinedObjectType.CONTACTGROUP;
sb.SubscriberRelatedID = groupID;
CheckPermissionsForSubscriber(sb);
SubscriberInfoProvider.SetSubscriberInfo(sb);
}
// If subscriber exists and is not subscribed, subscribe him
if (!SubscriberInfoProvider.IsSubscribed(sb.SubscriberID, mNewsletter.NewsletterID))
{
try
{
SubscriberInfoProvider.Subscribe(sb.SubscriberID, mNewsletter.NewsletterID, DateTime.Now, chkSendConfirmation.Checked, false);
}
catch (InvalidOperationException ex)
{
ShowError(ex.Message);
}
}
}
cgSelector.Value = null;
UniGridSubscribers.ReloadData();
pnlUpdate.Update();
}
/// <summary>
/// User control items changed event.
/// </summary>
protected void UserSelector_OnItemsSelected(object sender, EventArgs e)
{
// Check permissions
CheckAuthorization();
int siteId = SiteContext.CurrentSiteID;
// Get new items from selector
string newValues = ValidationHelper.GetString(selectUser.Value, null);
string[] newItems = newValues.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string item in newItems)
{
// Check limited number of subscribers
if (!SubscriberInfoProvider.LicenseVersionCheck(RequestContext.CurrentDomain, FeatureEnum.Subscribers, ObjectActionEnum.Insert))
{
ShowError(GetString("licenselimitations.subscribers.errormultiple"));
break;
}
int userID = ValidationHelper.GetInteger(item, 0);
// Get subscriber
SubscriberInfo sb = SubscriberInfoProvider.GetSubscriberInfo(UserInfo.OBJECT_TYPE, userID, siteId);
if (sb == null)
{
// Get user info
UserInfo ui = UserInfoProvider.GetUserInfo(userID);
if (ui == null)
{
continue;
}
// Create new subscriber of user type
sb = new SubscriberInfo();
sb.SubscriberFirstName = ui.FullName;
sb.SubscriberFullName = new SubscriberFullNameFormater().GetUserSubscriberName(ui.FullName);
sb.SubscriberSiteID = siteId;
sb.SubscriberType = UserInfo.OBJECT_TYPE;
sb.SubscriberRelatedID = userID;
CheckPermissionsForSubscriber(sb);
SubscriberInfoProvider.SetSubscriberInfo(sb);
}
// If subscriber exists and is not subscribed, subscribe him
if (!SubscriberInfoProvider.IsSubscribed(sb.SubscriberID, mNewsletter.NewsletterID))
{
try
{
SubscriberInfoProvider.Subscribe(sb.SubscriberID, mNewsletter.NewsletterID, DateTime.Now, chkSendConfirmation.Checked, chkRequireOptIn.Checked);
}
catch (InvalidOperationException ex)
{
ShowError(ex.Message);
}
}
}
selectUser.Value = null;
UniGridSubscribers.ReloadData();
pnlUpdate.Update();
}
/// <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 or a contact group</param>
private void LogActivity(SubscriberInfo sb, int subscriberId, int newsletterId, int siteId, int issueId, Guid issueGuid, int contactId)
{
// Load subscriber info object according to its ID if not given
if (sb == null)
{
sb = SubscriberInfoProvider.GetSubscriberInfo(subscriberId);
}
NewsletterInfo news = NewsletterInfoProvider.GetNewsletterInfo(newsletterId);
bool isFromContactGroup = !string.IsNullOrEmpty(sb.SubscriberType) && sb.SubscriberType.EqualsCSafe(PredefinedObjectType.CONTACTGROUP, true);
bool isFromPersona = !string.IsNullOrEmpty(sb.SubscriberType) && sb.SubscriberType.EqualsCSafe(PredefinedObjectType.PERSONA, true);
if (contactId <= 0)
{
contactId = ActivityTrackingHelper.GetContactID(sb);
}
if (contactId > 0)
{
// Load additional info (issue id)
if ((issueId <= 0) && (issueGuid != Guid.Empty))
{
IssueInfo issue = IssueInfoProvider.GetIssueInfo(issueGuid, siteId);
if (issue != null)
{
issueId = issue.IssueID;
}
}
Activity activity = new ActivityNewsletterUnsubscribing(sb, news, AnalyticsContext.ActivityEnvironmentVariables);
if (activity.Data != null)
{
activity.Data.ContactID = contactId;
activity.Data.ItemDetailID = issueId;
activity.Data.Value = isFromContactGroup
? "contactgroup(" + sb.SubscriberRelatedID + ")"
: isFromPersona
? "persona(" + sb.SubscriberRelatedID + ")"
: null;
activity.Log();
}
}
}
/// <summary>
/// Saves the data.
/// </summary>
private bool Save(string newsletterName, SubscriberInfo sb)
{
bool toReturn = false;
int siteId = CMSContext.CurrentSiteID;
// Check if sunscriber info object exists
if ((sb == null) || string.IsNullOrEmpty(newsletterName))
{
return false;
}
// Get nesletter info
NewsletterInfo news = NewsletterInfoProvider.GetNewsletterInfo(newsletterName, siteId);
if (news != null)
{
try
{
// Check if subscriber is not allready subscribed
if (!SubscriberInfoProvider.IsSubscribed(sb.SubscriberGUID, news.NewsletterGUID, siteId))
{
toReturn = true;
// Subscribe to the site
SubscriberInfoProvider.Subscribe(sb.SubscriberID, news.NewsletterID, DateTime.Now, SendConfirmationEmail);
// Info message
if (!chooseMode)
{
lblInfo.Visible = true;
lblInfo.Text = GetString("NewsletterSubscription.Subscribed");
}
// Track successful subscription conversion
if (TrackConversionName != string.Empty)
{
string siteName = CMSContext.CurrentSiteName;
if (AnalyticsHelper.AnalyticsEnabled(siteName) && AnalyticsHelper.TrackConversionsEnabled(siteName) && !AnalyticsHelper.IsIPExcluded(siteName, HTTPHelper.UserHostAddress))
{
// Log conversion
HitLogProvider.LogConversions(siteName, CMSContext.PreferredCultureCode, TrackConversionName, 0, ConversionValue);
}
}
// Log newsletter subscription activity if double opt-in is not required
if (!news.NewsletterEnableOptIn)
{
Activity activity = new ActivityNewsletterSubscribing(sb, news, CMSContext.ActivityEnvironmentVariables);
activity.Log();
}
}
else
{
// Info message - subscriber is allready in site
if (!chooseMode)
{
lblInfo.Visible = true;
lblInfo.Text = GetString("NewsletterSubscription.SubscriberIsAlreadySubscribed");
}
else
{
lblInfo.Visible = true;
lblInfo.Text += GetString("NewsletterSubscription.SubscriberIsAlreadySubscribedXY") + " " + HTMLHelper.HTMLEncode(news.NewsletterDisplayName) + ".<br />";
}
}
}
catch (Exception ex)
{
lblError.Visible = true;
lblError.Text = ex.Message;
}
}
else
{
lblError.Visible = true;
lblError.Text = GetString("NewsletterSubscription.NewsletterDoesNotExist");
}
return toReturn;
}
/// <summary>
/// Returns email for given subscriber.
/// When subscriber is <see cref="PredefinedObjectType.CONTACTGROUP"/> or <see cref="PredefinedObjectType.PERSONA"/>
/// also <see cref="contactID"/> must be specified otherwise email wouldn't be found.
/// </summary>
private static string GetSubscriberEmail(SubscriberInfo subscriber, int contactID = 0)
{
var subscriberEmailRetriever = Service<ISubscriberEmailRetriever>.Entry();
string subscriberEmail = null;
// Subscriber can be null for example when it was deleted.
if (subscriber != null)
{
subscriberEmail = subscriberEmailRetriever.GetSubscriberEmail(subscriber.SubscriberID);
}
// When email was not found, use contact ID to retrieve an email (subscriber is probably group type - role, cg, persona)
if (string.IsNullOrEmpty(subscriberEmail))
{
subscriberEmail = subscriberEmailRetriever.GetEmailForContact(contactID);
}
return subscriberEmail;
}
/// <summary>
/// Save subscriber.
/// </summary>
/// <returns>Subscriver info object</returns>
private SubscriberInfo SaveSubscriber()
{
// Check if a subscriber exists first
SubscriberInfo sb = null;
if (AllowUserSubscribers && (CMSContext.CurrentUser != null) && CMSContext.CurrentUser.IsAuthenticated())
{
sb = SubscriberInfoProvider.GetSubscriberInfo(SiteObjectType.USER, CMSContext.CurrentUser.UserID, CMSContext.CurrentSiteID);
}
else
{
sb = SubscriberInfoProvider.GetSubscriberInfo(txtEmail.Text, CMSContext.CurrentSiteID);
}
if ((sb == null) || ((chooseMode) && (sb != null)))
{
// Create subscriber
if (sb == null)
{
sb = new SubscriberInfo();
}
// Handle authenticated user
if (AllowUserSubscribers && (CMSContext.CurrentUser != null) && CMSContext.CurrentUser.IsAuthenticated())
{
// Get user info and copy first name, last name or full name to new subscriber
UserInfo ui = UserInfoProvider.GetUserInfo(CMSContext.CurrentUser.UserID);
if (ui != null)
{
if (!DataHelper.IsEmpty(ui.FirstName) && !DataHelper.IsEmpty(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 + "'";
}
else
{
return null;
}
sb.SubscriberType = PredefinedObjectType.USER;
sb.SubscriberRelatedID = CMSContext.CurrentUser.UserID;
}
// Work with non-authenticated user
else
{
sb.SubscriberEmail = txtEmail.Text.Trim();
// First name
if (DisplayFirstName)
{
sb.SubscriberFirstName = txtFirstName.Text;
}
else
{
sb.SubscriberFirstName = string.Empty;
}
// Last name
if (DisplayLastName)
{
sb.SubscriberLastName = txtLastName.Text;
}
else
{
sb.SubscriberLastName = string.Empty;
}
// Full name
sb.SubscriberFullName = (sb.SubscriberFirstName + " " + sb.SubscriberLastName).Trim();
}
// Set site ID
sb.SubscriberSiteID = CMSContext.CurrentSiteID;
// Check subscriber limits
if (!SubscriberInfoProvider.LicenseVersionCheck(URLHelper.GetCurrentDomain(), FeatureEnum.Subscribers, VersionActionEnum.Insert))
{
lblError.Visible = true;
lblError.Text = GetString("LicenseVersionCheck.Subscribers");
return null;
}
// Save subscriber info
SubscriberInfoProvider.SetSubscriberInfo(sb);
}
if (sb != null)
{
// Create membership between current contact and subscriber
ModuleCommands.OnlineMarketingCreateRelation(sb.SubscriberID, MembershipType.NEWSLETTER_SUBSCRIBER, ModuleCommands.OnlineMarketingGetCurrentContactID());
}
// Hide all
visibleLastName = false;
visibleFirstName = false;
visibleEmail = false;
pnlButtonSubmit.Visible = false;
pnlImageSubmit.Visible = false;
plcNwsList.Visible = false;
// Clear the form
txtEmail.Text = string.Empty;
txtFirstName.Text = string.Empty;
txtLastName.Text = string.Empty;
// Return subscriber info object
return sb;
}
/// <summary>
/// Contact items selected event handler.
/// </summary>
protected void ContactSelector_OnItemsSelected(object sender, EventArgs e)
{
// Check permissions
CheckAuthorization();
if (cSelector == null)
{
return;
}
int siteId = SiteContext.CurrentSiteID;
// Get new items from selector
string newValues = ValidationHelper.GetString(cSelector.Value, null);
// Get added items
string[] newItems = newValues.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string item in newItems)
{
// Check limited number of subscribers
if (!SubscriberInfoProvider.LicenseVersionCheck(RequestContext.CurrentDomain, FeatureEnum.Subscribers, ObjectActionEnum.Insert))
{
ShowError(GetString("licenselimitations.subscribers.errormultiple"));
break;
}
// Get contact ID
int contactID = ValidationHelper.GetInteger(item, 0);
// Try to get subscriber
SubscriberInfo sb = SubscriberInfoProvider.GetSubscriberInfo(PredefinedObjectType.CONTACT, contactID, siteId);
if (sb == null)
{
// Get contact's info
DataSet contactData = ModuleCommands.OnlineMarketingGetContactForNewsletters(contactID, "ContactFirstName,ContactMiddleName,ContactLastName,ContactEmail");
if (DataHelper.DataSourceIsEmpty(contactData))
{
continue;
}
string firstName = ValidationHelper.GetString(contactData.Tables[0].Rows[0]["ContactFirstName"], string.Empty);
string lastName = ValidationHelper.GetString(contactData.Tables[0].Rows[0]["ContactLastName"], string.Empty);
string middleName = ValidationHelper.GetString(contactData.Tables[0].Rows[0]["ContactMiddleName"], string.Empty);
string email = ValidationHelper.GetString(contactData.Tables[0].Rows[0]["ContactEmail"], string.Empty);
// Create new subscriber of contact type
sb = new SubscriberInfo();
sb.SubscriberFirstName = firstName;
sb.SubscriberLastName = lastName;
sb.SubscriberEmail = email;
sb.SubscriberFullName = new SubscriberFullNameFormater().GetContactSubscriberName(firstName, middleName, lastName);
sb.SubscriberSiteID = siteId;
sb.SubscriberType = PredefinedObjectType.CONTACT;
sb.SubscriberRelatedID = contactID;
CheckPermissionsForSubscriber(sb);
SubscriberInfoProvider.SetSubscriberInfo(sb);
}
// Subscribe the existing or created subscriber
if (!SubscriberInfoProvider.IsSubscribed(sb.SubscriberID, mNewsletter.NewsletterID))
{
try
{
SubscriberInfoProvider.Subscribe(sb.SubscriberID, mNewsletter.NewsletterID, DateTime.Now, chkSendConfirmation.Checked, chkRequireOptIn.Checked);
}
catch (InvalidOperationException ex)
{
ShowError(ex.Message);
}
}
}
cSelector.Value = null;
UniGridSubscribers.ReloadData();
pnlUpdate.Update();
}
private void usNewsletters_OnSelectionChanged(object sender, EventArgs e)
{
// Check 'EcommerceModify' permission
if (!MembershipContext.AuthenticatedUser.IsAuthorizedPerResource("CMS.Ecommerce", "EcommerceModify"))
{
// Check 'ModifyCustomers' permission if don't have general ecommerce modify permission
if (!MembershipContext.AuthenticatedUser.IsAuthorizedPerResource("CMS.Ecommerce", "ModifyCustomers"))
{
RedirectToAccessDenied("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 subscriber already exist
var sb = GetSubscriber();
if (sb == null)
{
// Create new subscriber
sb = new SubscriberInfo
{
SubscriberEmail = email,
SubscriberFirstName = firstName,
SubscriberLastName = lastName,
SubscriberFullName = (firstName + " " + lastName).Trim(),
SubscriberSiteID = siteId,
SubscriberGUID = Guid.NewGuid()
};
SubscriberInfoProvider.SetSubscriberInfo(sb);
}
var changed = false;
// 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[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string item in newItems)
{
int newsletterId = ValidationHelper.GetInteger(item, 0);
// If subscriber is subscribed, unsubscribe him
if (SubscriberInfoProvider.IsSubscribed(sb.SubscriberID, newsletterId))
{
SubscriberInfoProvider.Unsubscribe(sb.SubscriberID, newsletterId);
changed = true;
}
}
}
// Add new items
items = DataHelper.GetNewItemsInList(currentValues, newValues);
if (!String.IsNullOrEmpty(items))
{
string[] newItems = items.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string item in newItems)
{
int newsletterId = ValidationHelper.GetInteger(item, 0);
// If subscriber is not subscribed, subscribe him
if (!SubscriberInfoProvider.IsSubscribed(sb.SubscriberID, newsletterId))
{
SubscriberInfoProvider.Subscribe(sb.SubscriberID, newsletterId, DateTime.Now);
changed = true;
}
}
}
// Display information about successful (un)subscription if occurred
if (changed)
{
ShowChangesSaved();
}
}
}
/// <summary>
/// Persona items selected event handler.
/// </summary>
protected void PersonaSelector_OnItemsSelected(object sender, EventArgs e)
{
// Check permissions
CheckAuthorization();
if (personaSelector == null)
{
return;
}
int siteId = SiteContext.CurrentSiteID;
// Get new items from selector
string newValues = ValidationHelper.GetString(personaSelector.Value, null);
// Get added items
string[] newItems = newValues.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string item in newItems)
{
// Check limited number of subscribers
if (!SubscriberInfoProvider.LicenseVersionCheck(RequestContext.CurrentDomain, FeatureEnum.Personas, ObjectActionEnum.Insert))
{
ShowError(GetString("licenselimitations.subscribers.errormultiple"));
break;
}
// Get persona ID
int personaID = ValidationHelper.GetInteger(item, 0);
// Try to get subscriber
SubscriberInfo subscriber = SubscriberInfoProvider.GetSubscriberInfo(PredefinedObjectType.PERSONA, personaID, siteId);
if (subscriber == null)
{
// Get persona display name
var persona = BaseAbstractInfoProvider.GetInfoById(PredefinedObjectType.PERSONA, personaID);
string personaName = ValidationHelper.GetString(persona.GetValue("PersonaDisplayName"), string.Empty);
if (string.IsNullOrEmpty(personaName))
{
continue;
}
// Create new subscriber of persona type
subscriber = new SubscriberInfo();
subscriber.SubscriberFirstName = personaName;
// Full name consists of "persona" and display name
subscriber.SubscriberFullName = new SubscriberFullNameFormater().GetPersonaSubscriberName(personaName);
subscriber.SubscriberSiteID = siteId;
subscriber.SubscriberType = PredefinedObjectType.PERSONA;
subscriber.SubscriberRelatedID = personaID;
CheckPermissionsForSubscriber(subscriber);
SubscriberInfoProvider.SetSubscriberInfo(subscriber);
}
// If subscriber exists and is not subscribed, subscribe him
if (!SubscriberInfoProvider.IsSubscribed(subscriber.SubscriberID, mNewsletter.NewsletterID))
{
try
{
SubscriberInfoProvider.Subscribe(subscriber.SubscriberID, mNewsletter.NewsletterID, DateTime.Now, chkSendConfirmation.Checked, false);
}
catch (InvalidOperationException ex)
{
ShowError(ex.Message);
}
}
}
personaSelector.Value = null;
UniGridSubscribers.ReloadData();
pnlUpdate.Update();
}
/// <summary>
/// Initializes the control properties.
/// </summary>
protected void SetupControl()
{
if (StopProcessing)
{
formElem.StopProcessing = StopProcessing;
Visible = false;
}
else
{
isAuthenticated = (CurrentUser != null) && AuthenticationHelper.IsAuthenticated();
if (AllowUserSubscribers && isAuthenticated && (CurrentUser != null) && (!string.IsNullOrEmpty(CurrentUser.Email)))
{
// Hide form for authenticated user who has an email
formElem.StopProcessing = true;
formElem.Visible = false;
}
else
{
// Get alternative form info
AlternativeFormInfo afi = AlternativeFormInfoProvider.GetAlternativeFormInfo(AlternativeForm);
if (afi != null)
{
// Init subscriber object
SubscriberInfo sb = new SubscriberInfo();
if (AllowUserSubscribers && isAuthenticated)
{
// Prepare user subscriber object for authenticated user without an email
// Try to get existing user subscriber
sb = SubscriberInfoProvider.GetSubscriberInfo(UserInfo.OBJECT_TYPE, CurrentUser.UserID, SiteContext.CurrentSiteID);
if (sb == null)
{
// Prepare new user subscriber with pre-filled data
sb = new SubscriberInfo()
{
SubscriberFirstName = CurrentUser.FirstName,
SubscriberLastName = CurrentUser.LastName,
SubscriberFullName = (CurrentUser.FirstName + " " + CurrentUser.LastName).Trim(),
SubscriberType = UserInfo.OBJECT_TYPE,
SubscriberRelatedID = CurrentUser.UserID
};
}
}
// Init the form
formElem.AlternativeFormFullName = AlternativeForm;
formElem.Info = sb;
formElem.ClearAfterSave = false;
formElem.Visible = true;
formElem.ValidationErrorMessage = SubscriptionErrorMessage;
formElem.IsLiveSite = true;
// Reload form if not in PortalEngine environment and if post back
if ((StandAlone) && (RequestHelper.IsPostBack()))
{
formElem.ReloadData();
}
}
else
{
lblError.Text = String.Format(GetString("altform.formdoesntexists"), AlternativeForm);
lblError.Visible = true;
pnlSubscription.Visible = false;
}
}
// Display/hide captcha
plcCaptcha.Visible = DisplayCaptcha;
lblCaptcha.ResourceString = CaptchaText;
lblCaptcha.AssociatedControlClientID = scCaptcha.InputClientID;
// Init submit buttons
if ((UseImageButton) && (!String.IsNullOrEmpty(ImageButtonURL)))
{
pnlButtonSubmit.Visible = false;
pnlImageSubmit.Visible = true;
btnImageSubmit.ImageUrl = ImageButtonURL;
}
else
{
pnlButtonSubmit.Visible = true;
pnlImageSubmit.Visible = false;
btnSubmit.Text = ButtonText;
}
lblInfo.CssClass = "EditingFormInfoLabel";
lblError.CssClass = "EditingFormErrorLabel";
if (formElem != null)
{
// Set the live site context
formElem.ControlContext.ContextName = CMS.ExtendedControls.ControlContext.LIVE_SITE;
}
// Init newsletter selector
InitNewsletterSelector();
}
}
/// <summary>
/// Checks whether the current user has permissions to add the subscriber. If not, redirect to access denied page.
/// </summary>
/// <param name="subscriber">Subscriber to be checked</param>
private void CheckPermissionsForSubscriber(SubscriberInfo subscriber)
{
if (!subscriber.CheckPermissions(PermissionsEnum.Modify, CurrentSiteName, CurrentUser))
{
RedirectToAccessDenied(ModuleName.NEWSLETTER, "ManageSubscribers");
}
}
/// <summary>
/// Saves the data.
/// </summary>
/// <param name="newsletterName">Newsletter name</param>
/// <param name="sb">Subscriber</param>
private bool Save(string newsletterName, SubscriberInfo sb)
{
bool toReturn = false;
int siteId = SiteContext.CurrentSiteID;
// Check if sunscriber info object exists
if ((sb == null) || string.IsNullOrEmpty(newsletterName))
{
return false;
}
// Get nesletter info
NewsletterInfo news = NewsletterInfoProvider.GetNewsletterInfo(newsletterName, siteId);
if (news != null)
{
// Init webpart resolver
object[] data = new object[3];
data[0] = news;
data[1] = sb;
MacroResolver resolver = ContextResolver;
resolver.SetNamedSourceData("Newsletter", news);
resolver.SetNamedSourceData("Subscriber", sb);
if (AllowUserSubscribers && isAuthenticated)
{
data[2] = CurrentUser;
resolver.SetNamedSourceData("User", CurrentUser);
}
resolver.SetAnonymousSourceData(data);
try
{
// Check if subscriber is not allready subscribed
if (!SubscriberInfoProvider.IsSubscribed(sb.SubscriberGUID, news.NewsletterGUID, siteId))
{
toReturn = true;
// Subscribe to the site
SubscriberInfoProvider.Subscribe(sb.SubscriberID, news.NewsletterID, DateTime.Now, SendConfirmationEmail);
if (!chooseMode)
{
// Display message about successful subscription
lblInfo.Visible = true;
lblInfo.Text = SubscriptionConfirmationMessage;
}
// Track successful subscription conversion
if (!string.IsNullOrEmpty(TrackConversionName))
{
string siteName = SiteContext.CurrentSiteName;
if (AnalyticsHelper.AnalyticsEnabled(siteName) && AnalyticsHelper.TrackConversionsEnabled(siteName) && !AnalyticsHelper.IsIPExcluded(siteName, RequestContext.UserHostAddress))
{
// Log conversion
HitLogProvider.LogConversions(siteName, LocalizationContext.PreferredCultureCode, TrackConversionName, 0, ConversionValue);
}
}
// Log newsletter subscription activity if double opt-in is not required
if (!news.NewsletterEnableOptIn)
{
Activity activity = new ActivityNewsletterSubscribing(sb, news, AnalyticsContext.ActivityEnvironmentVariables);
activity.Log();
}
}
else
{
lblInfo.Visible = true;
string message = null;
if (string.IsNullOrEmpty(MessageForAlreadySubscribed))
{
if (!chooseMode)
{
message = GetString("NewsletterSubscription.SubscriberIsAlreadySubscribed");
}
else
{
message = string.Format("{0} {1}.<br />", GetString("NewsletterSubscription.SubscriberIsAlreadySubscribedXY"), HTMLHelper.HTMLEncode(ResHelper.LocalizeString(news.NewsletterDisplayName)));
}
}
else
{
message = MessageForAlreadySubscribed;
}
// Info message - subscriber is allready in site
if (!chooseMode)
{
lblInfo.Text = message;
}
else
{
lblInfo.Text += message;
}
}
}
catch (Exception ex)
{
lblError.Visible = true;
lblError.Text = ex.Message;
}
}
else
{
lblError.Visible = true;
lblError.Text = GetString("NewsletterSubscription.NewsletterDoesNotExist");
}
return toReturn;
}
/// <summary>
/// Checks whether the given subscriber is of type User. If so, returns proper User info; otherwise, null.
/// </summary>
/// <param name="subscriber">Subscriber info to be checked</param>
/// <returns>UserInfo related to the given subscriber or null</returns>
private UserInfo GetSubscriberUser(SubscriberInfo subscriber)
{
if (subscriber.SubscriberType == UserInfo.OBJECT_TYPE)
{
return UserInfoProvider.GetUserInfo(subscriber.SubscriberRelatedID);
}
return null;
}
/// <summary>
/// Save subscriber.
/// </summary>
/// <returns>Subscriber info object</returns>
private SubscriberInfo SaveSubscriber()
{
string emailValue = null;
int currentSiteId = SiteContext.CurrentSiteID;
// Check if a subscriber exists first
SubscriberInfo sb = null;
if (AllowUserSubscribers && isAuthenticated)
{
// Try to get user subscriber
sb = SubscriberInfoProvider.GetSubscriberInfo(UserInfo.OBJECT_TYPE, CurrentUser.UserID, currentSiteId);
}
else
{
EditingFormControl txtEmail = formElem.FieldEditingControls["SubscriberEmail"] as EditingFormControl;
if (txtEmail != null)
{
emailValue = ValidationHelper.GetString(txtEmail.Value, String.Empty);
}
if (!string.IsNullOrEmpty(emailValue))
{
// Try to get subscriber by email address
sb = SubscriberInfoProvider.GetSubscriberInfo(emailValue, currentSiteId);
}
}
if ((sb == null) || (chooseMode))
{
// Create subscriber
if (sb == null)
{
if (formElem.Visible)
{
int formSiteId = formElem.Data.GetValue("SubscriberSiteID").ToInteger(0);
if (formSiteId == 0)
{
// Specify SiteID for the new subscriber
formElem.Data.SetValue("SubscriberSiteID", currentSiteId);
}
// Save form with new subscriber data
if (!formElem.Save())
{
return null;
}
// Get subscriber info from form
sb = (SubscriberInfo)formElem.Info;
}
else
{
sb = new SubscriberInfo();
}
}
// Handle authenticated user
if (AllowUserSubscribers && isAuthenticated)
{
// Get user info and copy first name, last name or full name to new subscriber
// if these properties were not set
UserInfo ui = UserInfoProvider.GetUserInfo(CurrentUser.UserID);
var subscriberUserProvider = Service<ISubscriberUserProvider>.Entry();
subscriberUserProvider.UpdateSubscriberForUser(sb, ui, SiteContext.CurrentSiteID);
if (!string.IsNullOrEmpty(sb.SubscriberEmail) && string.IsNullOrEmpty(ui.Email))
{
// Update user email if it was not set
ui.Email = sb.SubscriberEmail;
UserInfoProvider.SetUserInfo(ui);
// Reset email for user subscriber
sb.SubscriberEmail = null;
}
}
// Work with non-authenticated user
else
{
if (string.IsNullOrEmpty(sb.SubscriberFullName))
{
// Fill full name if it was not set via the form
sb.SubscriberFullName = (sb.SubscriberFirstName + " " + sb.SubscriberLastName).Trim();
}
}
// Insert or update subscriber info
SubscriberInfoProvider.SetSubscriberInfo(sb);
// Check subscriber limits
if (!SubscriberInfoProvider.LicenseVersionCheck(RequestContext.CurrentDomain, FeatureEnum.Subscribers, ObjectActionEnum.Insert))
{
// Remove created subscriber and display error message
SubscriberInfoProvider.DeleteSubscriberInfo(sb);
lblError.Visible = true;
lblError.Text = GetString("LicenseVersionCheck.Subscribers");
return null;
}
}
if (sb != null)
{
// Create membership between current contact and subscriber
ModuleCommands.OnlineMarketingCreateRelation(sb.SubscriberID, MembershipType.NEWSLETTER_SUBSCRIBER, ModuleCommands.OnlineMarketingGetCurrentContactID());
}
// Return subscriber info object
return sb;
}
private static void LogNewsletterSubscriptionActivity(SubscriberInfo subscriber, NewsletterInfo newsletter)
{
// Under what contacts this subscriber belogs to?
int contactId = ActivityTrackingHelper.GetContactID(subscriber);
if (contactId <= 0)
{
return;
}
// Activity object is created for contact taken from ActivityContext.
// Set ID of contact opening this email into this context otherwise new contact could be created.
var activityContext = AnalyticsContext.ActivityEnvironmentVariables;
activityContext.ContactID = contactId;
var activity = new ActivityNewsletterSubscribing(subscriber, newsletter, activityContext);
activity.Log();
}
/// <summary>
/// Valid checkbox list, Indicates whether the subscriber is already subscribed to the selected newsletter.
/// </summary>
/// <param name="sb">Subscriber</param>
private void ValidChoose(SubscriberInfo sb)
{
if (sb == null)
{
return;
}
bool wasWrong = true;
// Save selected items
for (int i = 0; i < chklNewsletters.Items.Count; i++)
{
ListItem item = chklNewsletters.Items[i];
if (item != null && item.Selected)
{
wasWrong = wasWrong & (!Save(item.Value, sb));
}
}
// Check subscription
if ((chklNewsletters.Items.Count > 0) && (!wasWrong))
{
lblInfo.Visible = true;
lblInfo.Text += SubscriptionConfirmationMessage;
// Hide subscription form after successful subscription
pnlSubscription.Visible = false;
}
}
/// <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 = CMSContext.CurrentSiteID;
// Save the subscriber
SubscriberInfoProvider.SetSubscriberInfo(newSubscriber);
return true;
}
/// <summary>
/// Save subscriber.
/// </summary>
/// <returns>Subscriver info object</returns>
private SubscriberInfo SaveSubscriber()
{
string emailValue = null;
int siteId = CMSContext.CurrentSiteID;
// Check if a subscriber exists first
SubscriberInfo sb = null;
if (AllowUserSubscribers && isAuthenticated)
{
// Try to get user subscriber
sb = SubscriberInfoProvider.GetSubscriberInfo(SiteObjectType.USER, CurrentUser.UserID, siteId);
}
else
{
EditingFormControl txtEmail = formElem.BasicForm.FieldEditingControls["SubscriberEmail"] as EditingFormControl;
if (txtEmail != null)
{
emailValue = ValidationHelper.GetString(txtEmail.Value, String.Empty);
}
if (!string.IsNullOrEmpty(emailValue))
{
// Try to get subscriber by email address
sb = SubscriberInfoProvider.GetSubscriberInfo(emailValue, siteId);
}
}
if ((sb == null) || (chooseMode && (sb != null)))
{
// Create subscriber
if (sb == null)
{
if (formElem.Visible)
{
// Validate and save form with new subscriber data
if (!formElem.Save())
{
return null;
}
// Get subscriber info from form
sb = (SubscriberInfo)formElem.Info;
}
else
{
sb = new SubscriberInfo();
}
}
// Handle authenticated user
if (AllowUserSubscribers && isAuthenticated)
{
// Get user info and copy first name, last name or full name to new subscriber
// if these properties were not set
UserInfo ui = UserInfoProvider.GetUserInfo(CurrentUser.UserID);
if (ui != null)
{
if (!DataHelper.IsEmpty(ui.FirstName) && !DataHelper.IsEmpty(ui.LastName))
{
if (string.IsNullOrEmpty(sb.SubscriberFirstName))
{
sb.SubscriberFirstName = ui.FirstName;
}
if (string.IsNullOrEmpty(sb.SubscriberLastName))
{
sb.SubscriberLastName = ui.LastName;
}
}
else
{
if (string.IsNullOrEmpty(sb.SubscriberFirstName))
{
sb.SubscriberFirstName = ui.FullName;
}
}
// Full name consists of "user " and user full name
sb.SubscriberFullName = "User '" + ui.FullName + "'";
if (!string.IsNullOrEmpty(sb.SubscriberEmail) && string.IsNullOrEmpty(ui.Email))
{
// Update user email if it was not set
ui.Email = sb.SubscriberEmail;
UserInfoProvider.SetUserInfo(ui);
// Reset email for user subscriber
sb.SubscriberEmail = null;
}
}
else
{
return null;
}
sb.SubscriberType = PredefinedObjectType.USER;
sb.SubscriberRelatedID = ui.UserID;
}
// Work with non-authenticated user
else
{
if (string.IsNullOrEmpty(sb.SubscriberFullName))
{
// Fill full name if it was not set via the form
sb.SubscriberFullName = (sb.SubscriberFirstName + " " + sb.SubscriberLastName).Trim();
}
}
// Set site ID
sb.SubscriberSiteID = siteId;
// Check subscriber limits
if (!SubscriberInfoProvider.LicenseVersionCheck(URLHelper.GetCurrentDomain(), FeatureEnum.Subscribers, VersionActionEnum.Insert))
{
// Remove created subscriber and display error message
SubscriberInfoProvider.DeleteSubscriberInfo(sb);
lblError.Visible = true;
lblError.Text = GetString("LicenseVersionCheck.Subscribers");
return null;
}
// Update subscriber info
SubscriberInfoProvider.SetSubscriberInfo(sb);
}
if (sb != null)
{
// Create membership between current contact and subscriber
ModuleCommands.OnlineMarketingCreateRelation(sb.SubscriberID, MembershipType.NEWSLETTER_SUBSCRIBER, ModuleCommands.OnlineMarketingGetCurrentContactID());
}
// Return subscriber info object
return sb;
}
protected void Page_Load(object sender, EventArgs e)
{
// Get Issue object
IssueInfo issue = (IssueInfo)CMSContext.EditedObject;
if ((issue == null) || (issue.IssueSiteID != CMSContext.CurrentSiteID))
{
return;
}
// Get newsletter object
NewsletterInfo news = NewsletterInfoProvider.GetNewsletterInfo(issue.IssueNewsletterID);
string subject = null;
IssueHelper ih = new IssueHelper();
string siteName = CMSContext.CurrentSiteName;
InitGUI();
// 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) AND (SubscriptionEnabled=1 OR SubscriptionEnabled IS NULL))";
DataSet subscribers = SubscriberInfoProvider.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(
@"var currentSubscriberIndex = 0;
var newsletterIssueId ={0};
var guid = new Array({1});
var email = new Array({1});
var subject = new Array({1});
var subscribers = new Array(guid, email);", issue.IssueID, maxCount);
SubscriberInfo subscriber = null;
SubscriberInfo sbMember = null;
SortedDictionary<int, SubscriberInfo> subMembers = null;
string infoLine = null;
for (int i = 0; i < maxCount; i++)
{
// Get subscriber
subscriber = new SubscriberInfo(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 = SubscriberInfoProvider.GetSubscribers(subscriber, 1, 0, issue.IssueNewsletterID);
if ((subMembers != null) && (subMembers.Count > 0))
{
foreach (KeyValuePair<int, SubscriberInfo> item in subMembers)
{
// Get 1st subscriber's member
sbMember = item.Value;
if (sbMember != null)
{
// Create information line
infoLine = ScriptHelper.GetString(sbMember.SubscriberEmail, false);
// Add info about subscriber type
if (sbMember.SubscriberType.EqualsCSafe(SiteObjectType.USER, true))
{
infoLine = string.Format("{0} ({1})", infoLine, GetString("objecttype.cms_user").ToLowerCSafe());
}
else if (sbMember.SubscriberType.EqualsCSafe(SiteObjectType.ROLE, true))
{
infoLine = string.Format("{0} ({1})", infoLine, GetString("objecttype.cms_role").ToLowerCSafe());
}
else if (sbMember.SubscriberType.EqualsCSafe(PredefinedObjectType.CONTACTGROUP, true))
{
infoLine = string.Format("{0} ({1})", infoLine, GetString("objecttype.om_contactgroup").ToLowerCSafe());
}
else if (sbMember.SubscriberType.EqualsCSafe(PredefinedObjectType.CONTACT, true))
{
infoLine = string.Format("{0} ({1})", infoLine, GetString("objecttype.om_contact").ToLowerCSafe());
}
script = string.Format("{0}email[{1}] = '{2}'; \n ", script, i, infoLine);
// Resolve dynamic field macros ({%FirstName%}, {%LastName%}, {%Email%})
if (ih.LoadDynamicFields(sbMember, news, null, issue, true, siteName, null, null, null))
{
subject = ih.ResolveDynamicFieldMacros(issue.IssueSubject);
}
// Create resolved subject
script = string.Format("{0}subject[{1}] = {2}; \n ", script, i, ScriptHelper.GetString(HTMLHelper.HTMLEncode(subject)));
}
}
}
else
{
script = string.Format("{0}email[{1}] = '{2}'; \n ", script, i, "(N/A)");
// Resolve dynamic field macros (newsletter and issue)
if (ih.LoadDynamicFields(null, news, null, issue, true, siteName, null, null, null))
{
subject = ih.ResolveDynamicFieldMacros(issue.IssueSubject);
}
// Create resolved subject
script = string.Format("{0}subject[{1}] = {2}; \n ", script, i, ScriptHelper.GetString(HTMLHelper.HTMLEncode(subject)));
}
}
}
}
else
{
// Resolve dynamic field macros ({%FirstName%}, {%LastName%}, {%Email%}) in subject
if (ih.LoadDynamicFields(null, news, null, issue, true, siteName, null, null, null))
{
subject = ih.ResolveDynamicFieldMacros(issue.IssueSubject);
}
// Generate void javascript
script = string.Format(
@"var currentSubscriberIndex = 0;
var newsletterIssueId ={0};
var guid = new Array(1);
var email = new Array(1);
var subject = new Array(1);
subject[0] = '{1}';
var subscribers = new Array(guid, email);
guid[0] = 0;
email[0] = '(N/A)';", issue.IssueID, subject);
}
ScriptHelper.RegisterClientScriptBlock(this, typeof(string), "PreviewData", ScriptHelper.GetScript(script));
if (!RequestHelper.IsPostBack())
{
ScriptHelper.RegisterStartupScript(this, typeof(string), "LoadPreview" + ClientID, ScriptHelper.GetScript("pageLoad();"));
}
}
/// <summary>
/// Save subscriber.
/// </summary>
/// <returns>Subscriver info object</returns>
private SubscriberInfo SaveSubscriber()
{
// Check if a subscriber exists first
SubscriberInfo sb = null;
if (AllowUserSubscribers && (MembershipContext.AuthenticatedUser != null) && AuthenticationHelper.IsAuthenticated())
{
sb = SubscriberInfoProvider.GetSubscriberInfo(UserInfo.OBJECT_TYPE, MembershipContext.AuthenticatedUser.UserID, SiteContext.CurrentSiteID);
}
else
{
sb = SubscriberInfoProvider.GetSubscriberInfo(txtEmail.Text, SiteContext.CurrentSiteID);
}
if ((sb == null) || ((chooseMode) && (sb != null)))
{
// Create subscriber
if (sb == null)
{
sb = new SubscriberInfo();
}
// Handle authenticated user
if (AllowUserSubscribers && (MembershipContext.AuthenticatedUser != null) && AuthenticationHelper.IsAuthenticated())
{
UserInfo ui = UserInfoProvider.GetUserInfo(MembershipContext.AuthenticatedUser.UserID);
var subscriberUserProvider = Service<ISubscriberUserProvider>.Entry();
subscriberUserProvider.UpdateSubscriberForUser(sb, ui, SiteContext.CurrentSiteID);
}
// Work with non-authenticated user
else
{
sb.SubscriberEmail = txtEmail.Text.Trim();
// First name
if (DisplayFirstName)
{
sb.SubscriberFirstName = txtFirstName.Text;
}
else
{
sb.SubscriberFirstName = string.Empty;
}
// Last name
if (DisplayLastName)
{
sb.SubscriberLastName = txtLastName.Text;
}
else
{
sb.SubscriberLastName = string.Empty;
}
// Full name
sb.SubscriberFullName = (sb.SubscriberFirstName + " " + sb.SubscriberLastName).Trim();
// Set site ID
sb.SubscriberSiteID = SiteContext.CurrentSiteID;
}
// Check subscriber limits
if (!SubscriberInfoProvider.LicenseVersionCheck(RequestContext.CurrentDomain, FeatureEnum.Subscribers, ObjectActionEnum.Insert))
{
lblError.Visible = true;
lblError.Text = GetString("LicenseVersionCheck.Subscribers");
return null;
}
// Save subscriber info
SubscriberInfoProvider.SetSubscriberInfo(sb);
}
if (sb != null)
{
// Create membership between current contact and subscriber
ModuleCommands.OnlineMarketingCreateRelation(sb.SubscriberID, MembershipType.NEWSLETTER_SUBSCRIBER, ModuleCommands.OnlineMarketingGetCurrentContactID());
}
// Hide all
visibleLastName = false;
visibleFirstName = false;
visibleEmail = false;
pnlButtonSubmit.Visible = false;
pnlImageSubmit.Visible = false;
plcNwsList.Visible = false;
// Clear the form
txtEmail.Text = string.Empty;
txtFirstName.Text = string.Empty;
txtLastName.Text = string.Empty;
// Return subscriber info object
return sb;
}
public static SubscriberInfo Parse(string data)
{
try
{
XmlDocument xml = new XmlDocument();
xml.LoadXml(data);
XmlElement root = xml.DocumentElement;
XmlElement nameNode = root["name"];
XmlElement authorNode = root["author"];
XmlElement versionNode = root["version"];
XmlElement descriptionNode = root["description"];
XmlElement packageUrlNode = root["packageurl"];
string name = nameNode.InnerText.Trim();
string author = authorNode.InnerText.Trim();
string version = versionNode.InnerText.Trim();
string description = descriptionNode.InnerText.Trim();
string packageUrl = packageUrlNode.InnerText.Trim();
SubscriberInfo info = new SubscriberInfo(name, author, version, description, packageUrl);
return info;
}
catch
{
return null;
}
}
/// <summary>
/// Logs activity for unsubscribing.
/// </summary>
/// <param name="subscriber">Subscriber</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 subscriber, int newsletterId, int issueId, int contactId)
{
if (subscriber == null)
{
throw new ArgumentNullException("subscriber");
}
if (contactId <= 0)
{
contactId = ActivityTrackingHelper.GetContactID(subscriber);
}
if (contactId > 0)
{
NewsletterInfo news = NewsletterInfoProvider.GetNewsletterInfo(newsletterId);
bool isFromContactGroup = subscriber.SubscriberType.EqualsCSafe(PredefinedObjectType.CONTACTGROUP, true);
bool isFromPersona = subscriber.SubscriberType.EqualsCSafe(PredefinedObjectType.PERSONA, true);
Activity activity = new ActivityNewsletterUnsubscribing(subscriber, news, AnalyticsContext.ActivityEnvironmentVariables);
if (activity.Data != null)
{
activity.Data.ContactID = contactId;
activity.Data.ItemDetailID = issueId;
if (isFromContactGroup)
{
activity.Data.Value = "contactgroup(" + subscriber.SubscriberRelatedID + ")";
}
else if (isFromPersona)
{
activity.Data.Value = "persona(" + subscriber.SubscriberRelatedID + ")";
}
activity.Log();
}
}
}
/// <summary>
/// Subscribes customer to newsletter. Called when the "Subscribe customer to newsletter" button is pressed.
/// Expects the CreateRegisteredCustomer method to be run first.
/// </summary>
private bool SubscribeCustomerToNewsletter()
{
// Get the customer
CustomerInfo customer = CustomerInfoProvider.GetCustomers().WhereStartsWith("CustomerLastName", "My New Registered").FirstOrDefault();
// Get the newsletter
NewsletterInfo customerNewsletter = NewsletterInfoProvider.GetNewsletterInfo("CorporateNewsletter", SiteContext.CurrentSiteID);
if ((customer != null) && (customerNewsletter != null))
{
// Create the new subscription object
SubscriberNewsletterInfo subscription = new SubscriberNewsletterInfo();
SubscriberInfo customerExistedSubscriber = SubscriberInfoProvider.GetSubscriberInfo("*****@*****.**", SiteContext.CurrentSiteID);
// Check if customer is subscriber
if (customerExistedSubscriber != null)
{
// Subscribe existed customer subscriber to newsletter
subscription.SubscriberID = customerExistedSubscriber.SubscriberID;
}
else
{
// Create the new subscriber object
SubscriberInfo customerSubscriber = new SubscriberInfo();
// Set the properties
customerSubscriber.SubscriberEmail = customer.CustomerEmail;
customerSubscriber.SubscriberLastName = customer.CustomerLastName;
customerSubscriber.SubscriberSiteID = SiteContext.CurrentSiteID;
// Create the new subscriber
SubscriberInfoProvider.SetSubscriberInfo(customerSubscriber);
// Subscribe new customer subscriber to newsletter
subscription.SubscriberID = customerSubscriber.SubscriberID;
}
subscription.NewsletterID = customerNewsletter.NewsletterID;
subscription.SubscribedWhen = DateTime.Now;
// Save the data
SubscriberNewsletterInfoProvider.SetSubscriberNewsletterInfo(subscription);
return true;
}
return false;
}
private void usNewsletters_OnSelectionChanged(object sender, EventArgs e)
{
if (RaiseOnCheckPermissions("ManageSubscribers", this))
{
if (StopProcessing)
{
return;
}
}
// Get specified user if used instead of current user
UserInfo ui = null;
if (UserID > 0)
{
ui = UserInfoProvider.GetUserInfo(UserID);
}
else
{
ui = MembershipContext.AuthenticatedUser;
}
// Get specified site ID instead of current site ID
int siteId = 0;
if (SiteID > 0)
{
siteId = SiteID;
}
else
{
siteId = SiteContext.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 SubscriberInfo();
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 = new SubscriberFullNameFormater().GetUserSubscriberName(ui.FullName);
}
sb.SubscriberSiteID = siteId;
sb.SubscriberType = UserInfo.OBJECT_TYPE;
sb.SubscriberRelatedID = ui.UserID;
// Save subscriber to DB
SubscriberInfoProvider.SetSubscriberInfo(sb);
}
}
if (sb == null)
{
return;
}
// Create membership between current contact and subscriber
ModuleCommands.OnlineMarketingCreateRelation(sb.SubscriberID, MembershipType.NEWSLETTER_SUBSCRIBER, ModuleCommands.OnlineMarketingGetCurrentContactID());
// 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 (SubscriberInfoProvider.IsSubscribed(sb.SubscriberID, newsletterId))
{
SubscriberInfoProvider.Unsubscribe(sb.SubscriberID, newsletterId, SendConfirmationEmail);
// Log activity
LogActivity(ui, newsletterId, false);
}
}
}
}
// 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 (!SubscriberInfoProvider.IsSubscribed(sb.SubscriberID, newsletterId))
{
try
{
SubscriberInfoProvider.Subscribe(sb.SubscriberID, newsletterId, DateTime.Now, SendConfirmationEmail);
// Log activity
LogActivity(ui, newsletterId, true);
}
catch
{
}
}
}
}
}
// Display information about successful (un)subscription
ShowChangesSaved();
}
