/// <summary>
/// Sending the emails to users for campaign open/close
/// </summary>
/// <param name="campaignName"></param>
/// <param name="reciepientEmail"></param>
/// <param name="templateName"></param>
public static void CampaignEmail(string campaignName, string recipientEmail, string templateName, string programName = "")
{
try
{
TreeProvider tree = new TreeProvider(MembershipContext.AuthenticatedUser);
var email = EmailTemplateProvider.GetEmailTemplate(templateName, SiteContext.CurrentSite.SiteName);
EmailMessage msg = new EmailMessage();
if (email != null)
{
MacroResolver resolver = MacroResolver.GetInstance();
resolver.SetNamedSourceData("CampaignName", campaignName);
resolver.SetNamedSourceData("programName", programName);
msg.From = resolver.ResolveMacros(email.TemplateFrom);
msg.Recipients = recipientEmail;
msg.EmailFormat = EmailFormatEnum.Default;
msg.ReplyTo = resolver.ResolveMacros(email.TemplateReplyTo);
msg.Subject = resolver.ResolveMacros(email.TemplateSubject);
msg.Body = resolver.ResolveMacros(email.TemplateText);
EmailSender.SendEmail(SiteContext.CurrentSite.SiteName, msg, true);
}
}
catch (Exception ex)
{
EventLogProvider.LogException("ProductEmailNotifications", "CampaignEmail", ex, SiteContext.CurrentSite.SiteID, ex.Message);
}
}
public void SendFormEmail(BizFormItem item, int attachmentsCount)
{
if (item.BizFormInfo != null)
{
MacroResolver resolver = MacroContext.CurrentResolver.CreateChild();
resolver.SetAnonymousSourceData(item);
resolver.Settings.EncodeResolvedValues = true;
resolver.Culture = CultureHelper.GetPreferredCulture();
string body = DataHelper.GetNotEmpty(item.BizFormInfo.FormEmailTemplate, string.Empty);
body = resolver.ResolveMacros(body);
EmailMessage message = new EmailMessage();
message.From = item.BizFormInfo.FormSendFromEmail;
message.Recipients = resolver.ResolveMacros(item.BizFormInfo.FormSendToEmail);
message.Subject = resolver.ResolveMacros(item.BizFormInfo.FormEmailSubject);
message.Body = URLHelper.MakeLinksAbsolute(body);
message.EmailFormat = EmailFormatEnum.Html;
for (int i = 1; i <= attachmentsCount; i++)
{
Attachment attachment = GetAttachment(item.GetStringValue("File" + i, string.Empty));
if (attachment != null)
{
message.Attachments.Add(attachment);
}
}
EmailSender.SendEmail(message);
}
}
/// <summary>
/// Sending the emails based on datasource
/// </summary>
/// <param name="campaignName"></param>
/// <param name="reciepientEmail"></param>
/// <param name="templateName"></param>
public static void SendEmailNotification <T>(string templateName, string recipientEmail, IEnumerable <T> emailDataSource, string dataSourceName, Dictionary <string, object> macroData = null)
{
try
{
var email = DIContainer.Resolve <IKenticoMailProvider>().GetEmailTemplate(templateName, SiteContext.CurrentSiteID);
var itemTable = ConvertToDataTable(emailDataSource.ToList());
EmailMessage msg = new EmailMessage();
if (email != null)
{
MacroResolver resolver = MacroResolver.GetInstance();
resolver.SetNamedSourceData(dataSourceName, itemTable.Rows);
resolver.SetNamedSourceData(macroData);
msg.From = resolver.ResolveMacros(email.TemplateFrom);
msg.Recipients = recipientEmail;
msg.EmailFormat = EmailFormatEnum.Default;
msg.ReplyTo = resolver.ResolveMacros(email.TemplateReplyTo);
msg.Subject = resolver.ResolveMacros(email.TemplateSubject);
msg.Body = resolver.ResolveMacros(email.TemplateText);
EmailSender.SendEmail(SiteContext.CurrentSite.SiteName, msg, true);
}
}
catch (Exception ex)
{
EventLogProvider.LogException("ProductEmailNotifications", "SendEmail", ex, SiteContext.CurrentSite.SiteID, ex.Message);
}
}
protected void btnSend_Click(object sender, EventArgs e)
{
// Check 'Modify' permission
if (!CheckPermissions("cms.eventmanager", "Modify"))
{
return;
}
txtSenderName.Text = txtSenderName.Text.Trim();
txtSenderEmail.Text = txtSenderEmail.Text.Trim();
txtSubject.Text = txtSubject.Text.Trim();
// Validate the fields
string errorMessage = new Validator().NotEmpty(txtSenderName.Text, GetString("Events_SendEmail.EmptySenderName"))
.NotEmpty(txtSenderEmail.Text, GetString("Events_SendEmail.EmptySenderEmail"))
.NotEmpty(txtSubject.Text, GetString("Events_SendEmail.EmptyEmailSubject"))
.IsEmail(txtSenderEmail.Text, GetString("Events_SendEmail.InvalidEmailFormat"))
.Result;
if (!String.IsNullOrEmpty(errorMessage))
{
lblError.Visible = true;
lblError.Text = errorMessage;
return;
}
string subject = txtSubject.Text;
string emailBody = htmlEmail.ResolvedValue;
// Get event node data
TreeProvider mTree = new TreeProvider();
TreeNode node = mTree.SelectSingleNode(EventID);
if (node != null && String.Equals(node.NodeClassName, "cms.bookingevent", StringComparison.InvariantCultureIgnoreCase))
{
// Initialize macro resolver
MacroResolver resolver = new MacroResolver();
resolver.KeepUnresolvedMacros = true;
resolver.SourceData = new object[] { node };
// Resolve e-mail body and subject macros and make links absolute
emailBody = resolver.ResolveMacros(emailBody);
emailBody = URLHelper.MakeLinksAbsolute(emailBody);
subject = TextHelper.LimitLength(resolver.ResolveMacros(subject), 450);
// EventSendEmail manages sending e-mails to all attendees
EventSendEmail ese = new EventSendEmail(EventID, CMSContext.CurrentSiteName,
subject, emailBody, txtSenderName.Text.Trim(), txtSenderEmail.Text.Trim());
lblInfo.Visible = true;
lblInfo.Text = GetString("Events_SendEmail.EmailSent");
}
}
private TreeNode CreateTreeNode(CMS.DocumentEngine.TreeNode Node)
{
string tooltip = null;
string customName = null;
if ((!string.IsNullOrWhiteSpace(ToolTipFormat) || !string.IsNullOrWhiteSpace(DisplayNameFormat)) && AllowedPageTypes.ToLower().Split(";,|".ToCharArray()).Contains(Node.NodeClassName.ToLower()))
{
MacroResolver NodeResolver = GetNodeMacroResolver(Node);
if (!string.IsNullOrWhiteSpace(ToolTipFormat))
{
tooltip = NodeResolver.ResolveMacros(ToolTipFormat);
}
if (!string.IsNullOrWhiteSpace(DisplayNameFormat))
{
customName = NodeResolver.ResolveMacros(DisplayNameFormat);
}
}
RelatedPage_Tree_CustomTreeNode newNode = new RelatedPage_Tree_CustomTreeNode((!string.IsNullOrWhiteSpace(customName) ? customName : Node.NodeName), Node.NodeID.ToString(), tooltip);
if (AlreadySelectedNodes.Contains(Node.NodeID) || (FilterSelectableNodes && !SelectableSelectedNodes.Contains(Node.NodeID)))
{
newNode.SelectAction = TreeNodeSelectAction.None;
newNode.ShowCheckBox = false;
newNode.Text = newNode.Text;
newNode.CssClass = "AlreadySelected";
newNode.PossiblySelectable = AlreadySelectedNodes.Contains(Node.NodeID);
}
else
{
if ((AllowAllTypes || ClassNames.Contains(Node.ClassName)))
{
newNode.PossiblySelectable = true;
newNode.CssClass = "Selectable";
if (SelectionMode == "Checkbox")
{
newNode.ShowCheckBox = true;
newNode.SelectAction = TreeNodeSelectAction.None;
}
else
{
newNode.SelectAction = TreeNodeSelectAction.Select;
}
}
else
{
newNode.SelectAction = TreeNodeSelectAction.None;
newNode.CssClass = "NotSelectable";
}
}
return(newNode);
}
protected void btnUnsubscribe_click(object sender, EventArgs ea)
{
// Validate email
if (String.IsNullOrEmpty(email) || !ValidationHelper.IsEmail(email))
{
ShowError(GetString("om.contact.enteremail"));
return;
}
// Delete subscription if email is valid
if (rsi != null)
{
if (rsi.ReportSubscriptionEmail.Trim() != email)
{
ShowError(GetString("reportsubscription.emailnotmatch"));
return;
}
ReportSubscriptionInfoProvider.DeleteReportSubscriptionInfo(rsi.ReportSubscriptionID);
ShowInformation(GetString("reportsubscription.unsubscription.success"));
btnUnsubscribe.Visible = false;
pnlInfo.Visible = false;
// Send info about successful unsubscription to set email
String siteName = SiteContext.CurrentSiteName;
EmailTemplateInfo eti = EmailTemplateProvider.GetEmailTemplate("Reporting_Unsubscription_template", siteName);
if (eti != null)
{
// Create email
EmailMessage em = new EmailMessage();
em.EmailFormat = EmailFormatEnum.Default;
em.From = String.IsNullOrEmpty(eti.TemplateFrom) ? EmailHelper.Settings.NotificationsSenderAdress(siteName) : eti.TemplateFrom;;
em.Recipients = rsi.ReportSubscriptionEmail;
em.Subject = eti.TemplateSubject;
em.BccRecipients = eti.TemplateBcc;
em.CcRecipients = eti.TemplateCc;
MacroResolver resolver = ReportSubscriptionSender.CreateSubscriptionMacroResolver(ri, rsi, SiteContext.CurrentSite, em.Recipients);
em.Body = resolver.ResolveMacros(eti.TemplateText);
em.PlainTextBody = resolver.ResolveMacros(eti.TemplatePlainText);
EmailHelper.ResolveMetaFileImages(em, eti.TemplateID, EmailTemplateInfo.OBJECT_TYPE, ObjectAttachmentsCategories.TEMPLATE);
EmailSender.SendEmail(siteName, em);
}
}
}
/// <summary>
/// Returns DiscountCoupnValue of products in current shopping cart.
/// </summary>
private object GetDiscountValueShoppingCart(MacroResolver resolver)
{
var currentOrderId = resolver.ResolveMacros("{% Order.OrderID %}");
double discountCoupon = 0;
CMS.Ecommerce.ShoppingCartInfo shoppingCartInfo =
resolver.SourceObject as CMS.Ecommerce.ShoppingCartInfo;
CMS.Ecommerce.CurrencyInfo currentCurrency = null;
DiscountCouponInfo currentDiscountCouponInfo = GetDiscountByOrderId(int.Parse(currentOrderId));
if (shoppingCartInfo != null)
{
currentCurrency = shoppingCartInfo.Currency;
discountCoupon = currentDiscountCouponInfo.DiscountCouponValue;
if (currentDiscountCouponInfo.DiscountCouponIsFlatValue)
{
return(discountCoupon + " €");
}
return(discountCoupon + " %");
}
return(string.Empty);
}
protected void btnPostAtTwitter_Click(object sender, EventArgs e)
{
if (txtTemplateTwitter.Text.Trim() == "")
{
ShowError(ResHelper.GetString("socialnetworking.twitter.emptyerror"));
return;
}
string template = txtTemplateTwitter.Text;
// Process template.
MacroResolver mr = MacroResolver.GetInstance();
string textToSend = mr.ResolveMacros(template);
// Shorten URLs.
textToSend = URLShortenerHelper.ShortenURLsInText(textToSend, SocialNetworkType.Twitter);
ShowInformation(String.Format(ResHelper.GetString("socialnetworking.lengthafterprocessing"), textToSend.Length));
// Send tweet
string tweetUrl = TwitterProvider.PublishTweet(textToSend, CMSContext.CurrentSiteName);
// Check if tweet was succesfully published.
bool success = !string.IsNullOrEmpty(tweetUrl);
if (success)
{
ShowConfirmation(ResHelper.GetString("socialnetworking.twitter.sendsuccess"));
dataElement.IsPublished = true;
dataElement.PostURL = tweetUrl;
dataElement.AutoPostAfterPublishing = false;
dataElement.Template = txtTemplateTwitter.Text;
try
{
// Save dataElement into database
node.SetValue(FieldInfo.Name, SerializeData().OuterXml);
if (IsWorkflow)
{
DocumentHelper.UpdateDocument(node, node.TreeProvider);
}
else
{
node.Update();
}
RenderControls();
}
catch (Exception ex)
{
EventLogProvider ev = new EventLogProvider();
ev.LogEvent("TwitterAutoPost", "AfterPost", ex, CMSContext.CurrentSiteID);
}
}
else
{
ShowError(ResHelper.GetString("socialnetworking.twitter.senderror"));
}
}
protected void btnPostAtFacebook_Click(object sender, EventArgs e)
{
if (txtTemplateFacebook.Text.Trim() == "")
{
ShowError(ResHelper.GetString("socialnetworking.facebook.emptyerror"));
return;
}
string template = txtTemplateFacebook.Text;
// Process template
MacroResolver mr = MacroResolver.GetInstance();
string textToSend = mr.ResolveMacros(template);
// Send text
string postUrl = FacebookProvider.Publish(textToSend, CMSContext.CurrentSiteName);
// Check if post was succesfully published
bool success = !string.IsNullOrEmpty(postUrl);
if (success)
{
ShowConfirmation(ResHelper.GetString("socialnetworking.facebook.sendsuccess"));
dataElement.IsPublished = true;
dataElement.AutoPostAfterPublishing = false;
dataElement.Template = txtTemplateFacebook.Text;
dataElement.PostURL = postUrl;
try
{
// Save dataElement into database
node.SetValue(FieldInfo.Name, SerializeData().OuterXml);
if (IsWorkflow)
{
DocumentHelper.UpdateDocument(node, node.TreeProvider);
}
else
{
node.Update();
}
RenderControls();
}
catch (Exception ex)
{
EventLogProvider ev = new EventLogProvider();
ev.LogEvent("FacebookAutoPost", "AfterPost", ex, CMSContext.CurrentSiteID);
}
}
else
{
ShowError(ResHelper.GetString("socialnetworking.facebook.senderror"));
}
}
/// <summary>
/// Binds the grid columns.
/// </summary>
/// <param name="sender">Sender</param>
/// <param name="sourceName">Source name</param>
/// <param name="parameter">Parameter</param>
private object UniGridRelationship_OnExternalDataBound(object sender, string sourceName, object parameter)
{
switch (sourceName.ToLowerInvariant())
{
case "lefnodename":
case "rightnodename":
string tooltip = null;
string customName = null;
int NodeID = ValidationHelper.GetInteger(parameter, 0);
var NodeObj = new DocumentQuery().WhereEquals("NodeID", NodeID).Columns("NodeID, NodeName, NodeLevel, ClassName").FirstOrDefault();
// Not root and is in the allowed page types
if (NodeObj.NodeLevel != 0 && (!string.IsNullOrWhiteSpace(ToolTipFormat) || !string.IsNullOrWhiteSpace(DisplayNameFormat)) && AllowedPageTypes.ToLower().Split(";,|".ToCharArray()).Contains(NodeObj.NodeClassName.ToLower()))
{
ValidationHelper.GetInteger(parameter, 0);
MacroResolver NodeResolver = GetNodeMacroResolver(NodeObj.NodeID, NodeObj.ClassName);
if (!string.IsNullOrWhiteSpace(ToolTipFormat))
{
tooltip = NodeResolver.ResolveMacros(ToolTipFormat);
}
if (!string.IsNullOrWhiteSpace(DisplayNameFormat))
{
customName = NodeResolver.ResolveMacros(DisplayNameFormat);
}
return(string.Format("<div title=\"{0}\">{1}</div>", HTMLHelper.EncodeForHtmlAttribute(tooltip), (!string.IsNullOrWhiteSpace(customName) ? customName : NodeObj.NodeName)));
}
else
{
var tr = new ObjectTransformation(PredefinedObjectType.NODE, NodeID);
tr.EncodeOutput = false;
tr.Transformation = "{%NodeName|(default)" + GetString("general.root") + "|(encode)%}";
return(tr);
}
case "delete":
var btn = ((CMSGridActionButton)sender);
btn.PreRender += imgDelete_PreRender;
break;
}
return(parameter);
}
private void SendFormEmail(BizFormItem item)
{
if (item.BizFormInfo != null)
{
MacroResolver resolver = MacroContext.CurrentResolver.CreateChild();
resolver.SetAnonymousSourceData(item);
resolver.Settings.EncodeResolvedValues = true;
resolver.Culture = CultureHelper.GetPreferredCulture();
string body = DataHelper.GetNotEmpty(item.BizFormInfo.FormEmailTemplate, string.Empty);
body = resolver.ResolveMacros(body);
EmailMessage message = new EmailMessage();
message.From = item.BizFormInfo.FormSendFromEmail;
message.Recipients = resolver.ResolveMacros(item.BizFormInfo.FormSendToEmail);
message.Subject = resolver.ResolveMacros(item.BizFormInfo.FormEmailSubject);
message.Body = URLHelper.MakeLinksAbsolute(body);
message.EmailFormat = EmailFormatEnum.Html;
EmailSender.SendEmail(message);
}
}
/// <summary>
/// Resolves the macros within current WebPart context, with special handling for onclickaction field.
/// </summary>
/// <param name="inputText">Input text to resolve</param>
public string ResolveOnClickMacros(string inputText)
{
// Special "macro" with two '%' will be resolveed later
if (!String.IsNullOrEmpty(inputText) && !inputText.Contains("%%"))
{
// Resolve macros
MacroResolver resolver = ContextResolver.CreateChild();
resolver.Settings.KeepUnresolvedMacros = true;
resolver.Settings.AvoidInjection = false;
return(resolver.ResolveMacros(inputText));
}
return(inputText);
}
private void SendEmail(string templateName, MacroResolver resolver, string emailTo)
{
CMS.EmailEngine.EmailMessage msg = new CMS.EmailEngine.EmailMessage();
EmailTemplateInfo emailTemplate = EmailTemplateProvider.GetEmailTemplate(templateName, SiteContext.CurrentSiteID);
msg.EmailFormat = EmailFormatEnum.Both;
msg.From = emailTemplate.TemplateFrom;
msg.Recipients = emailTo;
if (resolver != null)
{
msg.Body = resolver.ResolveMacros(emailTemplate.TemplateText);
}
EmailSender.SendEmailWithTemplateText(SiteContext.CurrentSiteName, msg, emailTemplate, null, true);
}
public string GetPageBuilderContainerAfter(object ComponentModel)
{
string HtmlContainer = "";
string HtmlWrapper = "";
if (ComponentModel is IHtmlBeforeAfterContainerProperties HtmlBeforeAfterProps)
{
if (!string.IsNullOrWhiteSpace(HtmlBeforeAfterProps.HtmlAfter))
{
HtmlWrapper = HtmlBeforeAfterProps.HtmlAfter;
// Apply macro engine if needed
if (HtmlWrapper.IndexOf("{") > -1)
{
MacroResolver Resolver = MacroResolver.GetInstance();
//HtmlWrapper = Resolver.ResolveMacros(HtmlWrapper, new EvaluationContext(Resolver, HtmlWrapper));
HtmlWrapper = Resolver.ResolveMacros(HtmlWrapper);
}
}
}
if (ComponentModel is IPageBuilderContainerProperties ContainerProps)
{
if (!string.IsNullOrWhiteSpace(ContainerProps.ContainerName))
{
var Container = GetPageBuilderContainer(ContainerProps.ContainerName);
MacroResolver Resolver = MacroResolver.GetInstance();
if (Container != null)
{
Resolver.SetNamedSourceData("ContainerTitle", ContainerProps.ContainerTitle);
Resolver.SetNamedSourceData("ContainerCustomContent", ContainerProps.ContainerCustomContent);
Resolver.SetNamedSourceData("ContainerCSSClass", ContainerProps.ContainerCSSClass);
HtmlContainer = Resolver.ResolveMacros(Container.ContainerTextAfter);
}
}
}
return(HtmlContainer + HtmlWrapper);
}
/// <summary>
/// Renders any IHtmlBeforeAfterContainerProperties and IPageBuilderContainerProperties
/// </summary>
/// <param name="helper">Html Helper</param>
/// <param name="ComponentModel">The component model object that should inherit IHtmlBeforeAfterContainerProperties and/or IPageBuilderContainerProperties</param>
/// <returns>The content after the component</returns>
public static MvcHtmlString PageBuilderContainerAfter(this HtmlHelper helper, object ComponentModel)
{
string HtmlContainer = "";
string HtmlWrapper = "";
if (ComponentModel is IHtmlBeforeAfterContainerProperties HtmlBeforeAfterProps)
{
if (!string.IsNullOrWhiteSpace(HtmlBeforeAfterProps.HtmlAfter))
{
HtmlWrapper = HtmlBeforeAfterProps.HtmlAfter;
// Apply macro engine if needed
if (HtmlWrapper.IndexOf("{") > -1)
{
MacroResolver Resolver = MacroResolver.GetInstance();
HtmlWrapper = Resolver.ResolveMacros(HtmlWrapper);
}
}
}
if (ComponentModel is IPageBuilderContainerProperties ContainerProps)
{
if (!string.IsNullOrWhiteSpace(ContainerProps.ContainerName))
{
var Container = GetPageBuilderContainer(ContainerProps.ContainerName);
MacroResolver Resolver = MacroResolver.GetInstance();
if (Container != null)
{
Resolver.SetNamedSourceData("ContainerTitle", ContainerProps.ContainerTitle);
Resolver.SetNamedSourceData("ContainerCustomContent", ContainerProps.ContainerCustomContent);
Resolver.SetNamedSourceData("ContainerCSSClass", ContainerProps.ContainerCSSClass);
string StyleContent = (!string.IsNullOrWhiteSpace(Container.ContainerCSS) ? string.Format("<style>{0}</style>", Container.ContainerCSS) : "");
HtmlContainer = StyleContent + Resolver.ResolveMacros(Container.ContainerTextAfter);
}
}
}
return(new MvcHtmlString(HtmlContainer + HtmlWrapper));
}
/// <summary>
/// Sets new UserInfo for approved user.
/// </summary>
/// <param name="userID">User to be approved</param>
protected void SetUserInfo(int userID)
{
UserInfo user = UserInfoProvider.GetFullUserInfo(userID);
// Cancel waiting for approval attribute
user.UserSettings.UserWaitingForApproval = false;
// Set activation time to now
user.UserSettings.UserActivationDate = DateTime.Now;
// Set user who activated this account
user.UserSettings.UserActivatedByUserID = CMSContext.CurrentUser.UserID;
// Enable user
user.UserEnabled = true;
UserInfoProvider.SetUserInfo(user);
// Send e-mail to user
if (!String.IsNullOrEmpty(user.Email))
{
EmailTemplateInfo template = EmailTemplateProvider.GetEmailTemplate("RegistrationUserApproved", CMSContext.CurrentSiteName);
if (template != null)
{
string from = EmailHelper.GetSender(template, SettingsKeyProvider.GetStringValue(CMSContext.CurrentSiteName + ".CMSNoreplyEmailAddress"));
if (!String.IsNullOrEmpty(from))
{
EmailMessage email = new EmailMessage();
email.EmailFormat = EmailFormatEnum.Default;
// Get e-mail sender and subject from template, if used
email.From = from;
email.Recipients = user.Email;
string[,] replacements = new string[1, 2];
// Prepare macro replacements
replacements[0, 0] = "homepageurl";
replacements[0, 1] = URLHelper.GetAbsoluteUrl("~/");
MacroResolver resolver = CMSContext.CurrentResolver;
resolver.EncodeResolvedValues = true;
resolver.SourceParameters = replacements;
email.Body = resolver.ResolveMacros(template.TemplateText);
resolver.EncodeResolvedValues = false;
string emailSubject = EmailHelper.GetSubject(template, GetString("registrationform.registrationapprovalemailsubject"));
email.Subject = resolver.ResolveMacros(emailSubject);
email.PlainTextBody = resolver.ResolveMacros(template.TemplatePlainText);
email.CcRecipients = template.TemplateCc;
email.BccRecipients = template.TemplateBcc;
try
{
// Add attachments
MetaFileInfoProvider.ResolveMetaFileImages(email, template.TemplateID, EmailObjectType.EMAILTEMPLATE, MetaFileInfoProvider.OBJECT_CATEGORY_TEMPLATE);
EmailSender.SendEmail(CMSContext.CurrentSiteName, email);
}
catch
{
EventLogProvider ev = new EventLogProvider();
ev.LogEvent("E", DateTime.Now, "Membership", "WaitingForApprovalEmail", CMSContext.CurrentSite.SiteID);
}
}
else
{
EventLogProvider eventLog = new EventLogProvider();
eventLog.LogEvent(EventLogProvider.EVENT_TYPE_ERROR, DateTime.Now, "WaitingForApproval", "EmailSenderNotSpecified");
}
}
else
{
// Log missing e-mail template
try
{
EventLogProvider el = new EventLogProvider();
el.LogEvent("E", DateTime.Now, "RegistrationUserApproved", "GetEmailTemplate", HTTPHelper.GetAbsoluteUri());
}
catch
{
}
}
}
// User is approved and enabled, could be logged into statistics
AnalyticsHelper.LogRegisteredUser(CMSContext.CurrentSiteName, user);
}
/// <summary>
/// Initializes the control properties.
/// </summary>
protected void SetupControl()
{
if (StopProcessing)
{
// Do nothing
}
else
{
if (!RequestHelper.IsPostBack())
{
// If user is public
if (MembershipContext.AuthenticatedUser.IsPublic())
{
// Get logon URL
string logonUrl = SettingsKeyInfoProvider.GetStringValue(SiteContext.CurrentSiteName + ".CMSSecuredAreasLogonPage");
logonUrl = DataHelper.GetNotEmpty(LoginURL, logonUrl);
// Create redirect URL
logonUrl = URLHelper.ResolveUrl(logonUrl) + "?ReturnURL=" + HttpUtility.UrlEncode(RequestContext.CurrentURL);
URLHelper.Redirect(logonUrl);
}
else
{
// Get invitation by GUID
Guid invitationGuid = QueryHelper.GetGuid("invitationguid", Guid.Empty);
if (invitationGuid != Guid.Empty)
{
InvitationInfo invitation = InvitationInfoProvider.GetInvitationInfo(invitationGuid);
if (invitation != null)
{
// Check if invitation is valid
if ((invitation.InvitationValidTo == DateTimeHelper.ZERO_TIME) ||
(invitation.InvitationValidTo >= DateTime.Now))
{
GroupInfo group = GroupInfoProvider.GetGroupInfo(invitation.InvitationGroupID);
if (group != null)
{
// Check whether current user is the user who should be invited
if ((invitation.InvitedUserID > 0) && (invitation.InvitedUserID != MembershipContext.AuthenticatedUser.UserID))
{
lblInfo.CssClass = "InvitationErrorLabel";
lblInfo.Text = InvitationIsNotValid;
lblInfo.Visible = true;
return;
}
// If user was invited by e-mail
if (invitation.InvitedUserID == 0)
{
invitation.InvitedUserID = MembershipContext.AuthenticatedUser.UserID;
}
if (!GroupMemberInfoProvider.IsMemberOfGroup(invitation.InvitedUserID, invitation.InvitationGroupID))
{
// Create group member info object
GroupMemberInfo groupMember = new GroupMemberInfo();
groupMember.MemberInvitedByUserID = invitation.InvitedByUserID;
groupMember.MemberUserID = MembershipContext.AuthenticatedUser.UserID;
groupMember.MemberGroupID = invitation.InvitationGroupID;
groupMember.MemberJoined = DateTime.Now;
// Set proper status depending on grouo settings
switch (group.GroupApproveMembers)
{
// Only approved members can join
case GroupApproveMembersEnum.ApprovedCanJoin:
groupMember.MemberStatus = GroupMemberStatus.WaitingForApproval;
lblInfo.Text = MemberWaiting.Replace("##GROUPNAME##", HTMLHelper.HTMLEncode(group.GroupDisplayName));
break;
// Only invited members
case GroupApproveMembersEnum.InvitedWithoutApproval:
// Any site members can join
case GroupApproveMembersEnum.AnyoneCanJoin:
groupMember.MemberApprovedWhen = DateTime.Now;
groupMember.MemberStatus = GroupMemberStatus.Approved;
lblInfo.Text = MemberJoined.Replace("##GROUPNAME##", HTMLHelper.HTMLEncode(group.GroupDisplayName));
break;
}
// Store info object to database
GroupMemberInfoProvider.SetGroupMemberInfo(groupMember);
// Handle sending e-mails
if (SendEmailToInviter || SendDefaultGroupEmails)
{
UserInfo sender = UserInfoProvider.GetFullUserInfo(groupMember.MemberUserID);
UserInfo recipient = UserInfoProvider.GetFullUserInfo(groupMember.MemberInvitedByUserID);
if (SendEmailToInviter)
{
EmailTemplateInfo template = EmailTemplateProvider.GetEmailTemplate("Groups.MemberAcceptedInvitation", SiteContext.CurrentSiteName);
// Resolve macros
MacroResolver resolver = MacroContext.CurrentResolver;
resolver.SetAnonymousSourceData(sender, recipient, group, groupMember);
resolver.SetNamedSourceData("Sender", sender);
resolver.SetNamedSourceData("Recipient", recipient);
resolver.SetNamedSourceData("Group", group);
resolver.SetNamedSourceData("GroupMember", groupMember);
if (!String.IsNullOrEmpty(recipient.Email) && !String.IsNullOrEmpty(sender.Email))
{
// Send e-mail
EmailMessage message = new EmailMessage();
message.Recipients = recipient.Email;
message.From = EmailHelper.GetSender(template, SettingsKeyInfoProvider.GetStringValue(SiteContext.CurrentSiteName + ".CMSNoreplyEmailAddress"));
message.Subject = resolver.ResolveMacros(template.TemplateSubject);
message.PlainTextBody = resolver.ResolveMacros(template.TemplatePlainText);
// Enable macro encoding for body
resolver.Settings.EncodeResolvedValues = true;
message.Body = resolver.ResolveMacros(template.TemplateText);
message.CcRecipients = template.TemplateCc;
message.BccRecipients = template.TemplateBcc;
message.EmailFormat = EmailFormatEnum.Default;
EmailHelper.ResolveMetaFileImages(message, template.TemplateID, EmailTemplateInfo.OBJECT_TYPE, ObjectAttachmentsCategories.TEMPLATE);
EmailSender.SendEmail(SiteContext.CurrentSiteName, message);
}
}
if (SendDefaultGroupEmails)
{
// Send join or leave notification
if (group.GroupSendJoinLeaveNotification &&
(groupMember.MemberStatus == GroupMemberStatus.Approved))
{
GroupMemberInfoProvider.SendNotificationMail("Groups.MemberJoin", SiteContext.CurrentSiteName, groupMember, true);
GroupMemberInfoProvider.SendNotificationMail("Groups.MemberJoinedConfirmation", SiteContext.CurrentSiteName, groupMember, false);
}
// Send 'waiting for approval' notification
if (group.GroupSendWaitingForApprovalNotification && (groupMember.MemberStatus == GroupMemberStatus.WaitingForApproval))
{
GroupMemberInfoProvider.SendNotificationMail("Groups.MemberWaitingForApproval", SiteContext.CurrentSiteName, groupMember, true);
GroupMemberInfoProvider.SendNotificationMail("Groups.MemberJoinedWaitingForApproval", SiteContext.CurrentSiteName, groupMember, false);
}
}
}
// Delete all invitations to specified group for specified user (based on e-mail or userId)
string whereCondition = "InvitationGroupID = " + invitation.InvitationGroupID + " AND (InvitedUserID=" + MembershipContext.AuthenticatedUser.UserID + " OR InvitationUserEmail = N'" + SqlHelper.GetSafeQueryString(MembershipContext.AuthenticatedUser.Email, false) + "')";
InvitationInfoProvider.DeleteInvitations(whereCondition);
// Log activity
LogJoinActivity(groupMember, group);
}
else
{
lblInfo.Text = UserIsAlreadyMember.Replace("##GROUPNAME##", HTMLHelper.HTMLEncode(group.GroupDisplayName));
lblInfo.CssClass = "InvitationErrorLabel";
// Delete this invitation
InvitationInfoProvider.DeleteInvitationInfo(invitation);
}
}
else
{
lblInfo.Text = GroupNoLongerExists;
lblInfo.CssClass = "InvitationErrorLabel";
// Delete this invitation
InvitationInfoProvider.DeleteInvitationInfo(invitation);
}
}
else
{
lblInfo.Text = InvitationIsNotValid;
lblInfo.CssClass = "InvitationErrorLabel";
// Delete this invitation
InvitationInfoProvider.DeleteInvitationInfo(invitation);
}
}
else
{
lblInfo.Text = InvitationNoLongerExists;
lblInfo.CssClass = "InvitationErrorLabel";
}
lblInfo.Visible = true;
}
else
{
// Hide control if invitation GUID isn't set
Visible = false;
}
}
}
}
}
/// <summary>
/// Render override.
/// </summary>
protected override void Render(HtmlTextWriter writer)
{
// if everything ok, email should be send
if (mSendEmail)
{
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
Html32TextWriter mwriter = new Html32TextWriter(sw);
repItems.RenderControl(mwriter);
repItems.Visible = false;
// Prepare the macro resolver
MacroResolver resolver = ContextResolver.CreateChild();
string[,] replacements = new string[2, 2];
// Prepare macro replacements
replacements[0, 0] = "message";
replacements[0, 1] = txtMessageText.Text;
replacements[1, 0] = "document";
replacements[1, 1] = URLHelper.MakeLinksAbsolute(sb.ToString());
resolver.SetNamedSourceData(replacements);
if (EmailTemplate != null)
{
EmailMessage message = new EmailMessage();
message.EmailFormat = EmailFormatEnum.Html;
message.From = EmailFrom;
message.Recipients = txtEmailTo.Text;
// Get current css stylesheet
string styleSheet = GetCssFileLink();
if (!String.IsNullOrEmpty(styleSheet))
{
styleSheet = URLHelper.MakeLinksAbsolute(styleSheet);
}
// resolve EmailSubject here
message.Subject = resolver.ResolveMacros(EmailSubject);
// resolve EmailTemplate, wrap to HTML code and add the CSS files
message.Body = "<html><head>" + styleSheet + "</head><body class=\"EmailBody\">" + resolver.ResolveMacros(EmailTemplate) + "</body></html>";
// check recipients
if ((message.Recipients != null) && (message.Recipients.Trim() != ""))
{
try
{
EmailSender.SendEmail(SiteContext.CurrentSiteName, message);
// Display message, email was sent successfully
lblInfo.Text = GetString("sendtofriend.emailsent");
txtEmailTo.Text = "";
txtMessageText.Text = "";
if (HideAfterEmailSent)
{
plcForm.Visible = false;
}
}
catch (Exception ex)
{
lblError.Text = GetString("SendToFriend.SendEmailError");
try
{
EventLogProvider.LogException("Send email", "SendToFriend", ex);
}
catch
{
// Unable to log the event
}
}
}
}
}
base.Render(writer);
}
/// <summary>
/// Loads fields to drop down control.
/// </summary>
private void SetupFieldSelector(string selectedValue, bool forceReload)
{
if (forceReload || (fieldSelector.Items.Count == 0))
{
// Clear dropdown list
fieldSelector.Items.Clear();
// Get data class info
string className = ValidationHelper.GetString(classSelector.Value, null);
if (!String.IsNullOrEmpty(className) && (className != SpecialFieldValue.NONE.ToString()))
{
// Get fields of type file
var dci = DataClassInfoProvider.GetDataClassInfo(className);
var fi = FormHelper.GetFormInfo(dci.ClassName, false);
var ffi = fi.GetFields(true, true);
// Filter fields
if (!String.IsNullOrEmpty(FieldCondition))
{
MacroResolver resolver = MacroResolver.GetInstance();
var visibleFields = new List <FormFieldInfo>();
foreach (FormFieldInfo field in ffi)
{
resolver.SetAnonymousSourceData(field);
bool result = ValidationHelper.GetBoolean(resolver.ResolveMacros(FieldCondition), true);
if (result)
{
visibleFields.Add(field);
}
}
ffi = visibleFields;
}
if (ffi.Count > 0)
{
// Fill dropdown list with fields
var list = ffi.Select(t => new Tuple <string, string>(!String.IsNullOrEmpty(t.GetPropertyValue(FormFieldPropertyEnum.FieldCaption, ContextResolver)) ? t.GetPropertyValue(FormFieldPropertyEnum.FieldCaption, ContextResolver) : t.Name, t.Guid.ToString())).OrderBy(t => t.Item1);
foreach (var item in list)
{
fieldSelector.Items.Add(new ListItem(item.Item1, item.Item2));
}
if (!String.IsNullOrEmpty(selectedValue) && (fieldSelector.Items.FindByValue(selectedValue) != null) && !forceReload)
{
// Selected value from database
fieldSelector.SelectedValue = selectedValue;
}
else
{
// Select first item if nothing selected or class name was changed
fieldSelector.SelectedIndex = 0;
}
fieldSelector.Enabled = true;
}
else
{
fieldSelector.Enabled = false;
}
pnlFields.Visible = true;
}
else
{
// Hide field selector for (none) option
pnlFields.Visible = false;
}
}
}
/// <summary>
/// Sends the email.
/// </summary>
protected void Send()
{
// Check "modify" permission
if (!MembershipContext.AuthenticatedUser.IsAuthorizedPerResource("CMS.Users", "Modify"))
{
RedirectToAccessDenied("CMS.Users", "Modify");
}
var sender = emailSender.Text;
// Validate first
if (!emailSender.IsValid() || string.IsNullOrEmpty(sender))
{
ShowError(GetString("general.correctemailformat"));
return;
}
// Get recipients
string groupIds = null;
if (groupsControl != null)
{
groupIds = Convert.ToString(groupsControl.Value);
}
string userIDs = Convert.ToString(users.Value);
string roleIDs = Convert.ToString(roles.Value);
if (string.IsNullOrEmpty(groupIds) && string.IsNullOrEmpty(userIDs) && string.IsNullOrEmpty(roleIDs))
{
ShowError(GetString("massemail.norecipients"));
return;
}
// Get resolver to resolve context macros
MacroResolver resolver = MacroResolver.GetInstance();
// Create the message
EmailMessage message = new EmailMessage();
message.Subject = resolver.ResolveMacros(txtSubject.Text);
message.From = sender;
if (plcText.Visible)
{
message.Body = resolver.ResolveMacros(htmlText.ResolvedValue);
}
if (plcPlainText.Visible)
{
message.PlainTextBody = resolver.ResolveMacros(txtPlainText.Text);
}
// Get the attachments
HttpPostedFile[] attachments = uploader.PostedFiles;
foreach (HttpPostedFile att in attachments)
{
message.Attachments.Add(new EmailAttachment(att.InputStream, Path.GetFileName(att.FileName), Guid.NewGuid(), DateTime.Now, siteId));
}
// Check if list of roleIds contains generic role 'Everyone'
bool containsEveryone = false;
if (!String.IsNullOrEmpty(roleIDs))
{
RoleInfo roleEveryone = RoleInfoProvider.GetRoleInfo(RoleName.EVERYONE, siteId);
if ((roleEveryone != null) && (";" + roleIDs + ";").Contains(";" + roleEveryone.RoleID + ";"))
{
containsEveryone = true;
}
}
// Send messages using email engine
EmailSender.SendMassEmails(message, userIDs, roleIDs, groupIds, siteId, containsEveryone);
// Clear the form if email was sent successfully
Clear();
ShowConfirmation(GetString("system_email.emailsent"));
}
/// <summary>
/// OK click handler (Proceed registration).
/// </summary>
private void btnRegister_Click(object sender, EventArgs e)
{
string currentSiteName = SiteContext.CurrentSiteName;
string[] siteList = { currentSiteName };
// If AssignToSites field set
if (!String.IsNullOrEmpty(AssignToSites))
{
siteList = AssignToSites.Split(';');
}
if ((PageManager.ViewMode == ViewModeEnum.Design) || (HideOnCurrentPage) || (!IsVisible))
{
// Do not process
}
else
{
// Ban IP addresses which are blocked for registration
if (!BannedIPInfoProvider.IsAllowed(currentSiteName, BanControlEnum.Registration))
{
lblError.Visible = true;
lblError.Text = GetString("banip.ipisbannedregistration");
return;
}
// Check if captcha is required and verify captcha text
if (DisplayCaptcha && !captchaElem.IsValid())
{
// Display error message if captcha text is not valid
lblError.Visible = true;
lblError.Text = GetString("Webparts_Membership_RegistrationForm.captchaError");
return;
}
string userName = String.Empty;
string nickName = String.Empty;
string firstName = String.Empty;
string lastName = String.Empty;
string emailValue = String.Empty;
string pwd = string.Empty;
string confPassword = string.Empty;
string educationLevel = String.Empty;
string interestArea = String.Empty;
string industry = String.Empty;
string referralSource = string.Empty;
// Check duplicate user
// 1. Find appropriate control and get its value (i.e. user name)
// 2. Try to find user info
//FormEngineUserControl txtUserName = formUser.FieldControls["UserName"];
//if (txtUserName != null)
//{
// userName = ValidationHelper.GetString(txtUserName.Value, String.Empty);
//}
FormEngineUserControl txtEmail = formUser.FieldControls["Email"];
if (txtEmail != null)
{
emailValue = ValidationHelper.GetString(txtEmail.Value, String.Empty);
userName = emailValue;
}
// If user name and e-mail aren't filled stop processing and display error.
if (string.IsNullOrEmpty(userName) && String.IsNullOrEmpty(emailValue))
{
formUser.StopProcessing = true;
lblError.Visible = true;
lblError.Text = GetString("customregistrationform.usernameandemail");
return;
}
else
{
formUser.Data.SetValue("UserName", userName);
}
//check if email is valid
if (!ValidationHelper.IsEmail(txtEmail.Text.ToLowerCSafe()))
{
lblError.Visible = true;
lblError.Text = GetString("Webparts_Membership_RegistrationForm.EmailIsNotValid");
return;
}
FormEngineUserControl txtNickName = formUser.FieldControls["UserNickName"];
if (txtNickName != null)
{
nickName = ValidationHelper.GetString(txtNickName.Value, String.Empty);
}
FormEngineUserControl txtFirstName = formUser.FieldControls["FirstName"];
if (txtFirstName != null)
{
firstName = ValidationHelper.GetString(txtFirstName.Value, String.Empty);
}
FormEngineUserControl txtLastName = formUser.FieldControls["LastName"];
if (txtLastName != null)
{
lastName = ValidationHelper.GetString(txtLastName.Value, String.Empty);
}
FormEngineUserControl txtPwd = formUser.FieldControls["UserPassword"];
if (txtPwd != null)
{
pwd = ValidationHelper.GetString(txtPwd.Value, String.Empty);
}
FormEngineUserControl txtConfPassword = formUser.FieldControls["ReenterPassword"];
if (txtConfPassword != null)
{
confPassword = ValidationHelper.GetString(txtConfPassword.Value, String.Empty);
}
if (string.IsNullOrEmpty(pwd) || string.IsNullOrEmpty(confPassword))
{
lblError.Visible = true;
lblError.Text = "please enter password with confirmation";
return;
}
if (pwd != confPassword)
{
lblError.Visible = true;
lblError.Text = "Password doesn't match";
return;
}
if (validateFields(formUser.FieldControls["UserPassword"].Value.ToString()))
{
// Test if "global" or "site" user exists.
SiteInfo si = SiteContext.CurrentSite;
UserInfo siteui = UserInfoProvider.GetUserInfo(UserInfoProvider.EnsureSitePrefixUserName(userName, si));
if ((UserInfoProvider.GetUserInfo(userName) != null) || (siteui != null))
{
lblError.Visible = true;
lblError.Text = GetString("Webparts_Membership_RegistrationForm.UserAlreadyExists").Replace("%%name%%", HTMLHelper.HTMLEncode(Functions.GetFormattedUserName(userName, true)));
return;
}
// Check for reserved user names like administrator, sysadmin, ...
if (UserInfoProvider.NameIsReserved(currentSiteName, userName))
{
lblError.Visible = true;
lblError.Text = GetString("Webparts_Membership_RegistrationForm.UserNameReserved").Replace("%%name%%", HTMLHelper.HTMLEncode(Functions.GetFormattedUserName(userName, true)));
return;
}
if (UserInfoProvider.NameIsReserved(currentSiteName, nickName))
{
lblError.Visible = true;
lblError.Text = GetString("Webparts_Membership_RegistrationForm.UserNameReserved").Replace("%%name%%", HTMLHelper.HTMLEncode(nickName));
return;
}
// Check limitations for site members
if (!UserInfoProvider.LicenseVersionCheck(RequestContext.CurrentDomain, FeatureEnum.SiteMembers, ObjectActionEnum.Insert, false))
{
lblError.Visible = true;
lblError.Text = GetString("License.MaxItemsReachedSiteMember");
return;
}
// Check whether email is unique if it is required
if (!UserInfoProvider.IsEmailUnique(emailValue, siteList, 0))
{
lblError.Visible = true;
lblError.Text = GetString("UserInfo.EmailAlreadyExist");
return;
}
// Validate and save form with new user data
if (!formUser.Save())
{
// Return if saving failed
return;
}
// Get user info from form
UserInfo ui = (UserInfo)formUser.Info;
// Add user prefix if settings is on
// Ensure site prefixes
if (UserInfoProvider.UserNameSitePrefixEnabled(currentSiteName))
{
ui.UserName = UserInfoProvider.EnsureSitePrefixUserName(userName, si);
}
ui.Enabled = EnableUserAfterRegistration;
ui.UserURLReferrer = MembershipContext.AuthenticatedUser.URLReferrer;
ui.UserCampaign = AnalyticsHelper.Campaign;
ui.SetPrivilegeLevel(UserPrivilegeLevelEnum.None);
// Fill optionally full user name
if (String.IsNullOrEmpty(ui.FullName))
{
ui.FullName = UserInfoProvider.GetFullName(ui.FirstName, ui.MiddleName, ui.LastName);
}
// Ensure nick name
if (ui.UserNickName.Trim() == String.Empty)
{
ui.UserNickName = Functions.GetFormattedUserName(ui.UserName, true);
}
ui.UserSettings.UserRegistrationInfo.IPAddress = RequestContext.UserHostAddress;
ui.UserSettings.UserRegistrationInfo.Agent = HttpContext.Current.Request.UserAgent;
ui.UserSettings.UserLogActivities = true;
ui.UserSettings.UserShowIntroductionTile = true;
// Check whether confirmation is required
bool requiresConfirmation = SettingsKeyInfoProvider.GetBoolValue(currentSiteName + ".CMSRegistrationEmailConfirmation");
bool requiresAdminApprove = SettingsKeyInfoProvider.GetBoolValue(currentSiteName + ".CMSRegistrationAdministratorApproval");
if (!requiresConfirmation)
{
// If confirmation is not required check whether administration approval is reqiures
if (requiresAdminApprove)
{
ui.Enabled = false;
ui.UserSettings.UserWaitingForApproval = true;
}
}
else
{
// EnableUserAfterRegistration is overrided by requiresConfirmation - user needs to be confirmed before enable
ui.Enabled = false;
}
// Set user's starting alias path
if (!String.IsNullOrEmpty(StartingAliasPath))
{
ui.UserStartingAliasPath = MacroResolver.ResolveCurrentPath(StartingAliasPath);
}
// Get user password and save it in apropriate format after form save
string password = ValidationHelper.GetString(ui.GetValue("UserPassword"), String.Empty);
UserInfoProvider.SetPassword(ui, password);
var customerToken = PersonifyRegistered(emailValue, password, firstName, lastName);
if (string.IsNullOrEmpty(customerToken))
{
UserInfoProvider.DeleteUser(ui);
return;
}
else
{
var roles = GetImsroles(customerToken);
string groupslist = "";
if (roles.Length > 0)
{
foreach (string s in roles)
{
if (s.Length > 0)
{
groupslist += s + ",";
}
}
}
//we need this mispelling.
groupslist += "peronifyUser" + ",";
new LoginUsertokentico().AddUserToRole(ui, groupslist, true, false);
}
// Prepare macro data source for email resolver
UserInfo userForMail = ui.Clone();
userForMail.SetValue("UserPassword", string.Empty);
object[] data = new object[1];
data[0] = userForMail;
// Prepare resolver for notification and welcome emails
MacroResolver resolver = MacroContext.CurrentResolver;
resolver.SetAnonymousSourceData(data);
#region "Welcome Emails (confirmation, waiting for approval)"
bool error = false;
EmailTemplateInfo template = null;
// Prepare macro replacements
string[,] replacements = new string[6, 2];
replacements[0, 0] = "confirmaddress";
replacements[0, 1] = AuthenticationHelper.GetRegistrationApprovalUrl(ApprovalPage, ui.UserGUID, currentSiteName, NotifyAdministrator);
replacements[1, 0] = "username";
replacements[1, 1] = userName;
replacements[2, 0] = "password";
replacements[2, 1] = password;
replacements[3, 0] = "Email";
replacements[3, 1] = emailValue;
replacements[4, 0] = "FirstName";
replacements[4, 1] = firstName;
replacements[5, 0] = "LastName";
replacements[5, 1] = lastName;
// Set resolver
resolver.SetNamedSourceData(replacements);
// Email message
EmailMessage emailMessage = new EmailMessage();
emailMessage.EmailFormat = EmailFormatEnum.Default;
emailMessage.Recipients = ui.Email;
// Send welcome message with username and password, with confirmation link, user must confirm registration
if (requiresConfirmation)
{
template = EmailTemplateProvider.GetEmailTemplate("RegistrationConfirmation", currentSiteName);
emailMessage.Subject = GetString("RegistrationForm.RegistrationConfirmationEmailSubject");
}
// Send welcome message with username and password, with information that user must be approved by administrator
else if (SendWelcomeEmail)
{
if (requiresAdminApprove)
{
template = EmailTemplateProvider.GetEmailTemplate("Membership.RegistrationWaitingForApproval", currentSiteName);
emailMessage.Subject = GetString("RegistrationForm.RegistrationWaitingForApprovalSubject");
}
// Send welcome message with username and password, user can logon directly
else
{
template = EmailTemplateProvider.GetEmailTemplate("Membership.Registration", currentSiteName);
emailMessage.Subject = GetString("RegistrationForm.RegistrationSubject");
}
}
if (template != null)
{
emailMessage.From = EmailHelper.GetSender(template, SettingsKeyInfoProvider.GetStringValue(currentSiteName + ".CMSNoreplyEmailAddress"));
// Enable macro encoding for body
resolver.Settings.EncodeResolvedValues = true;
emailMessage.Body = resolver.ResolveMacros(template.TemplateText);
// Disable macro encoding for plaintext body and subject
resolver.Settings.EncodeResolvedValues = false;
emailMessage.PlainTextBody = resolver.ResolveMacros(template.TemplatePlainText);
emailMessage.Subject = resolver.ResolveMacros(EmailHelper.GetSubject(template, emailMessage.Subject));
emailMessage.CcRecipients = template.TemplateCc;
emailMessage.BccRecipients = template.TemplateBcc;
try
{
EmailHelper.ResolveMetaFileImages(emailMessage, template.TemplateID, EmailTemplateInfo.OBJECT_TYPE, ObjectAttachmentsCategories.TEMPLATE);
// Send the e-mail immediately
EmailSender.SendEmail(currentSiteName, emailMessage, true);
}
catch (Exception ex)
{
EventLogProvider.LogException("E", "RegistrationForm - SendEmail", ex);
error = true;
}
}
// If there was some error, user must be deleted
if (error)
{
lblError.Visible = true;
lblError.Text = GetString("RegistrationForm.UserWasNotCreated");
// Email was not send, user can't be approved - delete it
UserInfoProvider.DeleteUser(ui);
return;
}
#endregion
#region "Administrator notification email"
// Notify administrator if enabled and email confirmation is not required
if (!requiresConfirmation && NotifyAdministrator && (FromAddress != String.Empty) && (ToAddress != String.Empty))
{
EmailTemplateInfo mEmailTemplate = null;
if (requiresAdminApprove)
{
mEmailTemplate = EmailTemplateProvider.GetEmailTemplate("Registration.Approve", currentSiteName);
}
else
{
mEmailTemplate = EmailTemplateProvider.GetEmailTemplate("Registration.New", currentSiteName);
}
if (mEmailTemplate == null)
{
EventLogProvider.LogEvent(EventType.ERROR, "RegistrationForm", "GetEmailTemplate", eventUrl: RequestContext.RawURL);
}
else
{
// E-mail template ok
replacements = new string[4, 2];
replacements[0, 0] = "firstname";
replacements[0, 1] = ui.FirstName;
replacements[1, 0] = "lastname";
replacements[1, 1] = ui.LastName;
replacements[2, 0] = "email";
replacements[2, 1] = ui.Email;
replacements[3, 0] = "username";
replacements[3, 1] = userName;
// Set resolver
resolver.SetNamedSourceData(replacements);
// Enable macro encoding for body
resolver.Settings.EncodeResolvedValues = true;
EmailMessage message = new EmailMessage();
message.EmailFormat = EmailFormatEnum.Default;
message.From = EmailHelper.GetSender(mEmailTemplate, FromAddress);
message.Recipients = ToAddress;
message.Body = resolver.ResolveMacros(mEmailTemplate.TemplateText);
// Disable macro encoding for plaintext body and subject
resolver.Settings.EncodeResolvedValues = false;
message.Subject = resolver.ResolveMacros(EmailHelper.GetSubject(mEmailTemplate, GetString("RegistrationForm.EmailSubject")));
message.PlainTextBody = resolver.ResolveMacros(mEmailTemplate.TemplatePlainText);
message.CcRecipients = mEmailTemplate.TemplateCc;
message.BccRecipients = mEmailTemplate.TemplateBcc;
try
{
// Attach template meta-files to e-mail
EmailHelper.ResolveMetaFileImages(message, mEmailTemplate.TemplateID, EmailTemplateInfo.OBJECT_TYPE, ObjectAttachmentsCategories.TEMPLATE);
EmailSender.SendEmail(currentSiteName, message);
}
catch
{
EventLogProvider.LogEvent(EventType.ERROR, "Membership", "RegistrationEmail");
}
}
}
#endregion
#region "Web analytics"
// Track successful registration conversion
if (TrackConversionName != String.Empty)
{
if (AnalyticsHelper.AnalyticsEnabled(currentSiteName) && AnalyticsHelper.TrackConversionsEnabled(currentSiteName) && !AnalyticsHelper.IsIPExcluded(currentSiteName, RequestContext.UserHostAddress))
{
HitLogProvider.LogConversions(currentSiteName, LocalizationContext.PreferredCultureCode, TrackConversionName, 0, ConversionValue);
}
}
// Log registered user if confirmation is not required
if (!requiresConfirmation)
{
AnalyticsHelper.LogRegisteredUser(currentSiteName, ui);
}
#endregion
#region "On-line marketing - activity"
// Log registered user if confirmation is not required
if (!requiresConfirmation)
{
Activity activity = new ActivityRegistration(ui, DocumentContext.CurrentDocument, AnalyticsContext.ActivityEnvironmentVariables);
if (activity.Data != null)
{
activity.Data.ContactID = ModuleCommands.OnlineMarketingGetUserLoginContactID(ui);
activity.Log();
}
// Log login activity
if (ui.Enabled)
{
// Log activity
int contactID = ModuleCommands.OnlineMarketingGetUserLoginContactID(ui);
Activity activityLogin = new ActivityUserLogin(contactID, ui, DocumentContext.CurrentDocument, AnalyticsContext.ActivityEnvironmentVariables);
activityLogin.Log();
}
}
#endregion
#region "Site and roles addition and authentication"
string[] roleList = AssignRoles.Split(';');
foreach (string siteName in siteList)
{
// Add new user to the current site
UserInfoProvider.AddUserToSite(ui.UserName, siteName);
foreach (string roleName in roleList)
{
if (!String.IsNullOrEmpty(roleName))
{
String sn = roleName.StartsWithCSafe(".") ? String.Empty : siteName;
// Add user to desired roles
if (RoleInfoProvider.RoleExists(roleName, sn))
{
UserInfoProvider.AddUserToRole(ui.UserName, roleName, sn);
}
}
}
}
if (ui.Enabled)
{
if (this.AutoLoginAfterRegistration)
{
Session["UserName"] = userName;
Session["Password"] = password;
Session["RememberMe"] = true;
Session["RetryCount"] = null;
if (this.Request.QueryString["ReturnURL"] != null)
{
var returnURL = this.Request.QueryString["ReturnURL"];
Session["ReturnURL"] = returnURL;
}
else if (!String.IsNullOrEmpty(this.RedirectToURL))
{
var returnURL = this.Request.QueryString["ReturnURL"];
Session["ReturnURL"] = returnURL;
}
Response.Redirect("~/sso/ssohandler.aspx", true);
}
else if (!String.IsNullOrEmpty(this.LoginURL))
{
Response.Redirect(string.Format(this.LoginURL, userName), true);
}
else if (!String.IsNullOrEmpty(this.RedirectToURL))
{
Response.Redirect(this.RedirectToURL, true);
}
}
#endregion
lblError.Visible = false;
}
}
}
/// <summary>
/// Sends confirmation or welcome email.
/// </summary>
private void SendRegistrationEmail(UserInfo ui, string password)
{
bool error = false;
EmailTemplateInfo template = null;
// Email message
EmailMessage emailMessage = new EmailMessage();
emailMessage.EmailFormat = EmailFormatEnum.Default;
emailMessage.Recipients = ui.Email;
// Send welcome message with username and password, with confirmation link, user must confirm registration
if (ConfirmationRequired)
{
template = EmailTemplateProvider.GetEmailTemplate("RegistrationConfirmation", CurrentSiteName);
emailMessage.Subject = GetString("RegistrationForm.RegistrationConfirmationEmailSubject");
}
// Send welcome message with username and password, with information that user must be approved by administrator
else if (SendWelcomeEmail)
{
if (AdminApprovalRequired)
{
template = EmailTemplateProvider.GetEmailTemplate("Membership.RegistrationWaitingForApproval", CurrentSiteName);
emailMessage.Subject = GetString("RegistrationForm.RegistrationWaitingForApprovalSubject");
}
// Send welcome message with username and password, user can logon directly
else
{
template = EmailTemplateProvider.GetEmailTemplate("Membership.Registration", CurrentSiteName);
emailMessage.Subject = GetString("RegistrationForm.RegistrationSubject");
}
}
if (template != null)
{
// Create relation between contact and user. This ensures that contact will be correctly recognized when user approves registration (if approval is required)
int contactId = ModuleCommands.OnlineMarketingGetCurrentContactID();
if (contactId > 0)
{
ModuleCommands.OnlineMarketingCreateRelation(ui.UserID, MembershipType.CMS_USER, contactId);
}
// Prepare resolver for notification and welcome emails
MacroResolver resolver = MembershipResolvers.GetMembershipRegistrationResolver(ui, password, AuthenticationHelper.GetRegistrationApprovalUrl(ApprovalPage, ui.UserGUID, CurrentSiteName, NotifyAdministrator));
emailMessage.From = EmailHelper.GetSender(template, SettingsKeyInfoProvider.GetValue(CurrentSiteName + ".CMSNoreplyEmailAddress"));
// Enable macro encoding for body
resolver.Settings.EncodeResolvedValues = true;
emailMessage.Body = resolver.ResolveMacros(template.TemplateText);
// Disable macro encoding for plaintext body and subject
resolver.Settings.EncodeResolvedValues = false;
emailMessage.PlainTextBody = resolver.ResolveMacros(template.TemplatePlainText);
emailMessage.Subject = resolver.ResolveMacros(EmailHelper.GetSubject(template, emailMessage.Subject));
emailMessage.CcRecipients = template.TemplateCc;
emailMessage.BccRecipients = template.TemplateBcc;
try
{
EmailHelper.ResolveMetaFileImages(emailMessage, template.TemplateID, EmailTemplateInfo.OBJECT_TYPE, ObjectAttachmentsCategories.TEMPLATE);
// Send the e-mail immediately
EmailSender.SendEmail(CurrentSiteName, emailMessage, true);
}
catch (Exception ex)
{
EventLogProvider.LogException("E", "RegistrationForm - SendEmail", ex);
error = true;
}
}
// If there was some error, user must be deleted
if (error)
{
ShowError(GetString("RegistrationForm.UserWasNotCreated"));
// Email was not send, user can't be approved - delete it
UserInfoProvider.DeleteUser(ui);
}
}
protected object grid_OnExternalDataBound(object sender, string sourceName, object parameter)
{
DataRowView drv = null;
if (parameter is DataRowView)
{
drv = (DataRowView)parameter;
}
else if (parameter is GridViewRow)
{
drv = (DataRowView)((GridViewRow)parameter).DataItem;
}
var objectSettingsId = ValidationHelper.GetInteger(drv["ObjectSettingsID"], 0);
if ((tmpObjectSettings == null) || (tmpObjectSettings.ObjectSettingsID != objectSettingsId))
{
tmpObjectSettings = ObjectSettingsInfoProvider.GetObjectSettingsInfo(objectSettingsId);
if (tmpObjectSettings != null)
{
tmpInfo = BaseAbstractInfoProvider.GetInfoById(tmpObjectSettings.ObjectSettingsObjectType, tmpObjectSettings.ObjectSettingsObjectID);
}
}
if ((tmpInfo != null) && (tmpObjectSettings != null))
{
contextResolver.SetNamedSourceData("EditedObject", tmpInfo);
switch (sourceName.ToLowerCSafe())
{
case "edit":
var editButton = (CMSGridActionButton)sender;
var url = tmpInfo.Generalized.GetEditingPageURL();
if (!string.IsNullOrEmpty(url))
{
url = contextResolver.ResolveMacros(url);
// Resolve dialog relative url
if (url.StartsWith("~/"))
{
url = AuthenticationHelper.ResolveDialogUrl(url);
}
string queryString = URLHelper.GetQuery(url);
if (queryString.IndexOfCSafe("&hash=", true) < 0)
{
url = URLHelper.AddParameterToUrl(url, "hash", QueryHelper.GetHash(queryString));
}
editButton.OnClientClick = string.Format("modalDialog('{0}', 'objectEdit', '85%', '85%'); return false", url);
}
else
{
editButton.Enabled = false;
}
break;
case "checkin":
var checkinButton = (CMSGridActionButton)sender;
if (tmpInfo.TypeInfo.SupportsLocking)
{
checkinButton.OnClientClick = GetConfirmScript(GetString("ObjectEditMenu.CheckInConfirmation"), tmpObjectSettings.ObjectSettingsObjectType, tmpObjectSettings.ObjectSettingsObjectID, btnCheckIn);
}
else
{
checkinButton.Enabled = false;
}
break;
case "undocheckout":
var undoCheckoutButton = (CMSGridActionButton)sender;
if (tmpInfo.TypeInfo.SupportsLocking)
{
undoCheckoutButton.OnClientClick = GetConfirmScript(CMSObjectManager.GetUndoCheckOutConfirmation(tmpInfo, null), tmpObjectSettings.ObjectSettingsObjectType, tmpObjectSettings.ObjectSettingsObjectID, btnUndoCheckOut);
}
else
{
undoCheckoutButton.Enabled = false;
}
break;
}
}
return(parameter);
}
/// <summary>
/// Send notifications.
/// </summary>
private void SentNotification()
{
if (SendNotificationMessage || SendNotificationEmail)
{
// Get e-mail template
EmailTemplateInfo template = null;
// Get message subject
string messageSubject = null;
switch (action)
{
case FriendsActionEnum.Approve:
template = EmailTemplateProvider.GetEmailTemplate("Friends.Approve",
SiteContext.CurrentSiteName);
messageSubject = ApprovedCaption;
break;
case FriendsActionEnum.Reject:
template = EmailTemplateProvider.GetEmailTemplate("Friends.Reject",
SiteContext.CurrentSiteName);
messageSubject = RejectedCaption;
break;
}
if (template == null)
{
return;
}
// Get user infos
UserInfo recipient = UserInfoProvider.GetFullUserInfo(friendship.FriendUserID);
UserInfo sender = UserInfoProvider.GetFullUserInfo(friendship.FriendRequestedUserID);
MacroResolver resolver = MacroContext.CurrentResolver;
resolver.SetAnonymousSourceData(sender, recipient, friendship);
resolver.SetNamedSourceData("Sender", sender);
resolver.SetNamedSourceData("Recipient", recipient);
resolver.SetNamedSourceData("Friendship", friendship);
resolver.SetNamedSourceData("FORMATTEDSENDERNAME", Functions.GetFormattedUserName(sender.UserName), false);
if (SendNotificationMessage)
{
// Set message info object
MessageInfo mi = new MessageInfo();
mi.MessageLastModified = DateTime.Now;
mi.MessageSent = DateTime.Now;
mi.MessageRecipientUserID = recipient.UserID;
mi.MessageRecipientNickName = TextHelper.LimitLength(Functions.GetFormattedUserName(recipient.UserName, recipient.FullName, recipient.UserNickName, true), 200);
mi.MessageSenderUserID = friendship.FriendRequestedUserID;
mi.MessageSenderNickName = TextHelper.LimitLength(Functions.GetFormattedUserName(sender.UserName, sender.FullName, sender.UserNickName, true), 200);
mi.MessageSenderDeleted = true;
mi.MessageSubject = TextHelper.LimitLength(resolver.ResolveMacros(template.TemplateSubject), 200);
mi.MessageBody = resolver.ResolveMacros(template.TemplatePlainText);
MessageInfoProvider.SetMessageInfo(mi);
}
if (SendNotificationEmail && !String.IsNullOrEmpty(recipient.Email) &&
!String.IsNullOrEmpty(sender.Email))
{
// Send e-mail
EmailMessage message = new EmailMessage();
message.EmailFormat = EmailFormatEnum.Default;
message.Recipients = Functions.GetFormattedUserName(recipient.UserName, true) + " <" + recipient.Email + ">";
message.From = Functions.GetFormattedUserName(sender.UserName, true) + " <" + sender.Email + ">";
message.Subject = messageSubject;
EmailSender.SendEmailWithTemplateText(SiteContext.CurrentSiteName, message, template, resolver, false);
}
}
}
/// <summary>
/// Send e-mail to administrator about new registration.
/// </summary>
/// <param name="administrationApproval">Indicates if administration approval is required</param>
private void SendEmailToAdministrator(bool administrationApproval)
{
EmailTemplateInfo template = null;
if (administrationApproval)
{
template = EmailTemplateProvider.GetEmailTemplate("Registration.Approve", SiteContext.CurrentSiteName);
}
else
{
template = EmailTemplateProvider.GetEmailTemplate("Registration.New", SiteContext.CurrentSiteName);
}
if (template == null)
{
EventLogProvider.LogEvent(EventType.ERROR, "RegistrationForm", "GetEmailTemplate", eventUrl: RequestContext.RawURL);
}
else
{
// E-mail template ok
string from = EmailHelper.GetSender(template, (!String.IsNullOrEmpty(FromAddress)) ? FromAddress : SettingsKeyInfoProvider.GetStringValue(SiteContext.CurrentSiteName + ".CMSNoreplyEmailAddress"));
if (!String.IsNullOrEmpty(from))
{
// Prepare macro replacements
string[,] replacements = new string[4, 2];
replacements[0, 0] = "firstname";
replacements[0, 1] = RegisteredUser.FirstName;
replacements[1, 0] = "lastname";
replacements[1, 1] = RegisteredUser.LastName;
replacements[2, 0] = "email";
replacements[2, 1] = RegisteredUser.Email;
replacements[3, 0] = "username";
replacements[3, 1] = RegisteredUser.UserName;
// Set resolver
MacroResolver resolver = MacroContext.CurrentResolver;
resolver.SetNamedSourceData(replacements);
resolver.Settings.EncodeResolvedValues = true;
// Add user info data
resolver.SetAnonymousSourceData(new object[1] {
RegisteredUser
});
// Email message
EmailMessage email = new EmailMessage();
email.EmailFormat = EmailFormatEnum.Default;
email.Recipients = AdministratorEmail;
// Get e-mail sender and subject from template, if used
email.From = from;
email.Body = resolver.ResolveMacros(template.TemplateText);
resolver.Settings.EncodeResolvedValues = false;
email.PlainTextBody = resolver.ResolveMacros(template.TemplatePlainText);
string emailSubject = EmailHelper.GetSubject(template, GetString("RegistrationForm.EmailSubject"));
email.Subject = resolver.ResolveMacros(emailSubject);
email.CcRecipients = template.TemplateCc;
email.BccRecipients = template.TemplateBcc;
try
{
EmailHelper.ResolveMetaFileImages(email, template.TemplateID, EmailTemplateInfo.OBJECT_TYPE, ObjectAttachmentsCategories.TEMPLATE);
// Send the e-mail immediately
EmailSender.SendEmail(SiteContext.CurrentSiteName, email, true);
}
catch
{
EventLogProvider.LogEvent(EventType.ERROR, "Membership", "RegistrationApprovalEmail");
}
}
else
{
EventLogProvider.LogEvent(EventType.ERROR, "RegistrationApproval", "EmailSenderNotSpecified");
}
}
}
/// <summary>
/// Updates the current Group or creates new if no GroupID is present.
/// </summary>
public void SaveData()
{
// Check banned IP
if (!BannedIPInfoProvider.IsAllowed(SiteContext.CurrentSiteName, BanControlEnum.AllNonComplete))
{
ShowError(GetString("General.BannedIP"));
return;
}
// Validate form entries
string errorMessage = ValidateForm();
if (errorMessage == string.Empty)
{
try
{
codeName = GetSafeCodeName();
codeName = GetUniqueCodeName(codeName);
GroupInfo group = new GroupInfo();
group.GroupDisplayName = txtDisplayName.Text;
group.GroupName = codeName;
group.GroupDescription = txtDescription.Text;
group.GroupAccess = GetGroupAccess();
group.GroupSiteID = mSiteId;
group.GroupApproveMembers = GetGroupApproveMembers();
// Set columns GroupCreatedByUserID and GroupApprovedByUserID to current user
var user = MembershipContext.AuthenticatedUser;
if (user != null)
{
group.GroupCreatedByUserID = user.UserID;
if ((!RequireApproval) || (CurrentUserIsAdmin()))
{
group.GroupApprovedByUserID = user.UserID;
group.GroupApproved = true;
}
}
// Save Group in the database
GroupInfoProvider.SetGroupInfo(group);
// Create group admin role
RoleInfo roleInfo = new RoleInfo();
roleInfo.DisplayName = "Group admin";
roleInfo.RoleName = group.GroupName + "_groupadmin";
roleInfo.RoleGroupID = group.GroupID;
roleInfo.RoleIsGroupAdministrator = true;
roleInfo.SiteID = mSiteId;
// Save group admin role
RoleInfoProvider.SetRoleInfo(roleInfo);
if (user != null)
{
// Set user as member of group
GroupMemberInfo gmi = new GroupMemberInfo();
gmi.MemberUserID = user.UserID;
gmi.MemberGroupID = group.GroupID;
gmi.MemberJoined = DateTime.Now;
gmi.MemberStatus = GroupMemberStatus.Approved;
gmi.MemberApprovedWhen = DateTime.Now;
gmi.MemberApprovedByUserID = user.UserID;
// Save user as member of group
GroupMemberInfoProvider.SetGroupMemberInfo(gmi);
// Set user as member of admin group role
UserRoleInfo userRole = new UserRoleInfo();
userRole.UserID = user.UserID;
userRole.RoleID = roleInfo.RoleID;
// Save user as member of admin group role
UserRoleInfoProvider.SetUserRoleInfo(userRole);
}
// Clear user session a request
MembershipContext.AuthenticatedUser.Generalized.Invalidate(false);
MembershipContext.AuthenticatedUser = null;
string culture = CultureHelper.EnglishCulture.ToString();
if (DocumentContext.CurrentDocument != null)
{
culture = DocumentContext.CurrentDocument.DocumentCulture;
}
// Copy document
errorMessage = GroupInfoProvider.CopyGroupDocument(group, GroupTemplateSourceAliasPath, GroupTemplateTargetAliasPath, GroupProfileURLPath, culture, CombineWithDefaultCulture, MembershipContext.AuthenticatedUser, roleInfo);
if (!String.IsNullOrEmpty(errorMessage))
{
// Display error message
ShowError(errorMessage);
return;
}
// Create group forum
if (CreateForum)
{
CreateGroupForum(group);
// Create group forum search index
if (CreateSearchIndexes)
{
CreateGroupForumSearchIndex(group);
}
}
// Create group media library
if (CreateMediaLibrary)
{
CreateGroupMediaLibrary(group);
}
// Create search index for group documents
if (CreateSearchIndexes)
{
CreateGroupContentSearchIndex(group);
}
// Display information on success
ShowConfirmation(GetString("group.group.createdinfo"));
// If URL is set, redirect user to specified page
if (!String.IsNullOrEmpty(RedirectToURL))
{
URLHelper.Redirect(ResolveUrl(DocumentURLProvider.GetUrl(RedirectToURL)));
}
// After registration message
if ((RequireApproval) && (!CurrentUserIsAdmin()))
{
ShowConfirmation(SuccessfullRegistrationWaitingForApprovalText);
// Send approval email to admin
if (!String.IsNullOrEmpty(SendWaitingForApprovalEmailTo))
{
// Create the message
EmailTemplateInfo eti = EmailTemplateProvider.GetEmailTemplate("Groups.WaitingForApproval", SiteContext.CurrentSiteName);
if (eti != null)
{
EmailMessage message = new EmailMessage();
if (String.IsNullOrEmpty(eti.TemplateFrom))
{
message.From = SettingsKeyInfoProvider.GetStringValue(SiteContext.CurrentSiteName + ".CMSSendEmailNotificationsFrom");
}
else
{
message.From = eti.TemplateFrom;
}
MacroResolver resolver = MacroContext.CurrentResolver;
resolver.SetAnonymousSourceData(group);
resolver.SetNamedSourceData("Group", group);
message.Recipients = SendWaitingForApprovalEmailTo;
message.Subject = resolver.ResolveMacros(eti.TemplateSubject);
message.Body = resolver.ResolveMacros(eti.TemplateText);
resolver.Settings.EncodeResolvedValues = false;
message.PlainTextBody = resolver.ResolveMacros(eti.TemplatePlainText);
// Send the message using email engine
EmailSender.SendEmail(message);
}
}
}
else
{
string groupPath = SettingsKeyInfoProvider.GetStringValue(SiteContext.CurrentSiteName + ".CMSGroupProfilePath");
string url = String.Empty;
if (!String.IsNullOrEmpty(groupPath))
{
url = DocumentURLProvider.GetUrl(groupPath.Replace("{GroupName}", group.GroupName));
}
ShowConfirmation(String.Format(SuccessfullRegistrationText, url));
}
// Hide form
if (HideFormAfterRegistration)
{
plcForm.Visible = false;
}
else
{
ClearForm();
}
}
catch (Exception ex)
{
// Display error message
ShowError(GetString("general.saveerror"), ex.Message, null);
}
}
else
{
// Display error message
ShowError(errorMessage);
}
}
/// <summary>
/// Sends e-mail to all attendees.
/// </summary>
protected void Send()
{
// Check 'Modify' permission
if (!CheckPermissions("cms.eventmanager", "Modify"))
{
return;
}
txtSenderName.Text = txtSenderName.Text.Trim();
txtSenderEmail.Text = txtSenderEmail.Text.Trim();
txtSubject.Text = txtSubject.Text.Trim();
// Validate the fields
string errorMessage = new Validator()
.NotEmpty(txtSenderName.Text, GetString("Events_SendEmail.EmptySenderName"))
.NotEmpty(txtSenderEmail.Text, GetString("Events_SendEmail.EmptySenderEmail"))
.MatchesCondition(txtSenderEmail, input => input.IsValid(), GetString("Events_SendEmail.InvalidEmailFormat"))
.NotEmpty(txtSubject.Text, GetString("Events_SendEmail.EmptyEmailSubject"))
.Result;
if (!String.IsNullOrEmpty(errorMessage))
{
ShowError(errorMessage);
return;
}
string subject = txtSubject.Text;
string emailBody = htmlEmail.ResolvedValue;
// Get event node data
TreeProvider mTree = new TreeProvider();
DocTreeNode node = mTree.SelectSingleNode(EventID);
if (node != null && CMSString.Equals(node.NodeClassName, "cms.bookingevent", true))
{
// Initialize macro resolver
MacroResolver resolver = MacroResolver.GetInstance();
resolver.Settings.KeepUnresolvedMacros = true;
resolver.SetAnonymousSourceData(node);
// Add named source data
resolver.SetNamedSourceData("Event", node);
// Event date string macro
DateTime eventDate = ValidationHelper.GetDateTime(node.GetValue("EventDate"), DateTimeHelper.ZERO_TIME);
DateTime eventEndDate = ValidationHelper.GetDateTime(node.GetValue("EventEndDate"), DateTimeHelper.ZERO_TIME);
bool isAllDay = ValidationHelper.GetBoolean(node.GetValue("EventAllDay"), false);
resolver.SetNamedSourceData("eventdatestring", EventProvider.GetEventDateString(eventDate, eventEndDate, isAllDay, TimeZoneHelper.GetTimeZoneInfo(SiteContext.CurrentSite), SiteContext.CurrentSiteName), false);
// Resolve e-mail body and subject macros and make links absolute
emailBody = resolver.ResolveMacros(emailBody);
emailBody = URLHelper.MakeLinksAbsolute(emailBody);
subject = TextHelper.LimitLength(resolver.ResolveMacros(subject), 450);
// EventSendEmail manages sending e-mails to all attendees
EventSendEmail ese = new EventSendEmail(EventID, SiteContext.CurrentSiteName,
subject, emailBody, txtSenderName.Text.Trim(), txtSenderEmail.Text.Trim());
ShowConfirmation(GetString("Events_SendEmail.EmailSent"));
}
}
/// <summary>
/// Fills dropdown with data.
/// </summary>
/// <param name="parentID">Identifier of node which children you want to add</param>
/// <param name="level">Level of indentation</param>
private void FillDropDown(int parentID, int level)
{
if (GroupedCategories != null)
{
List <DataRowView> gCategory = GroupedCategories.GetGroup(parentID);
if (gCategory != null)
{
var categoryTypeInfo = CategoryInfo.TypeInfo;
foreach (DataRowView drCategory in gCategory)
{
if (!ExcludedItems.Contains(ValidationHelper.GetInteger(drCategory[categoryTypeInfo.IDColumn], 0)))
{
string name = ResHelper.LocalizeString(drCategory[CategoryInfo.Generalized.DisplayNameColumn].ToString());
int categoryId = ValidationHelper.GetInteger(drCategory[categoryTypeInfo.IDColumn], 0);
List <DataRowView> objectGroup = ((!ShowEmptyCategories || ShowObjects) && GroupedObjects != null) ? GroupedObjects.GetGroup(drCategory[categoryTypeInfo.IDColumn]) : null;
List <DataRowView> childCategoryGroup = !ShowEmptyCategories?GroupedCategories.GetGroup(categoryId) : null;
// Check for empty categories except the root
if ((level == 0) || ShowEmptyCategories || ((objectGroup != null) && (objectGroup.Count > 0)) || ((childCategoryGroup != null) && (childCategoryGroup.Count > 0)))
{
bool enabled = true;
// Resolve Enabled condition
if (!String.IsNullOrEmpty(EnabledCondition))
{
MacroResolver.SetAnonymousSourceData(drCategory);
enabled = ValidationHelper.GetBoolean(MacroResolver.ResolveMacros(EnabledCondition), true);
}
string indentation = String.Empty;
if ((level > 0) || ShowRoot)
{
// Create indentation for specified level
indentation = String.Concat(Enumerable.Repeat(SubItemPrefix, ShowRoot ? level : level - 1));
string value = ((level == 0) && (RootValue > 0) ? RootValue : categoryId).ToString();
// Prevent category list item to be selected by ID when selecting object
if (ShowObjects)
{
value = "cat_" + value;
}
// Insert category
ListItem listItem = new ListItem(indentation + ResHelper.LocalizeString(name), value);
if (ShowObjects || DisabledItems.Contains(categoryId) || !enabled)
{
listItem.Attributes.Add("style", DisabledItemStyle);
listItem.Attributes.Add("disabled", "disabled");
}
else
{
if (!firstItem && String.IsNullOrEmpty(mSelectedValue))
{
SetItem(parentID, value);
}
}
drpCategory.Items.Add(listItem);
}
// Go deeper
FillDropDown(categoryId, level + 1);
// Insert all child objects if needed
if (ShowObjects && !DataHelper.DataSourceIsEmpty(objectGroup))
{
if (objectGroup != null)
{
indentation += SubItemPrefix;
foreach (DataRowView childObject in objectGroup)
{
string text = indentation + ResHelper.LocalizeString(childObject[ObjectInfo.Generalized.DisplayNameColumn].ToString());
string objValue = childObject[ObjectInfo.TypeInfo.IDColumn].ToString();
drpCategory.Items.Add(new ListItem(text, objValue));
if (!firstItem && String.IsNullOrEmpty(mSelectedValue))
{
SetItem(parentID, objValue);
}
}
}
}
}
}
}
}
}
}
protected void btnSend_Click(object sender, EventArgs e)
{
// Check 'Modify' permission
if (!CheckPermissions("cms.eventmanager", "Modify"))
{
return;
}
txtSenderName.Text = txtSenderName.Text.Trim();
txtSenderEmail.Text = txtSenderEmail.Text.Trim();
txtSubject.Text = txtSubject.Text.Trim();
// Validate the fields
string errorMessage = new Validator().NotEmpty(txtSenderName.Text, GetString("Events_SendEmail.EmptySenderName"))
.NotEmpty(txtSenderEmail.Text, GetString("Events_SendEmail.EmptySenderEmail"))
.NotEmpty(txtSubject.Text, GetString("Events_SendEmail.EmptyEmailSubject"))
.IsEmail(txtSenderEmail.Text, GetString("Events_SendEmail.InvalidEmailFormat"))
.Result;
if (!String.IsNullOrEmpty(errorMessage))
{
lblError.Visible = true;
lblError.Text = errorMessage;
return;
}
string subject = txtSubject.Text;
string emailBody = htmlEmail.ResolvedValue;
// Get event node data
TreeProvider mTree = new TreeProvider();
TreeNode node = mTree.SelectSingleNode(EventID);
if (node != null && String.Equals(node.NodeClassName, "cms.bookingevent", StringComparison.InvariantCultureIgnoreCase))
{
// Initialize macro resolver
MacroResolver resolver = new MacroResolver();
resolver.KeepUnresolvedMacros = true;
resolver.SourceData = new object[] { node };
// Resolve e-mail body and subject macros and make links absolute
emailBody = resolver.ResolveMacros(emailBody);
emailBody = URLHelper.MakeLinksAbsolute(emailBody);
subject = TextHelper.LimitLength(resolver.ResolveMacros(subject), 450);
// EventSendEmail manages sending e-mails to all attendees
EventSendEmail ese = new EventSendEmail(EventID, CMSContext.CurrentSiteName,
subject, emailBody, txtSenderName.Text.Trim(), txtSenderEmail.Text.Trim());
lblInfo.Visible = true;
lblInfo.Text = GetString("Events_SendEmail.EmailSent");
}
}
/// <summary>
/// Saves the control. Returns false, if error occurred.
/// </summary>
public bool Save()
{
// Validates input data
String error = ValidateData();
if (!String.IsNullOrEmpty(error))
{
ShowError(error);
return(false);
}
if (Report != null)
{
bool isNew = false;
if (mReportSubscriptionInfo.ReportSubscriptionID <= 0)
{
// Insert mode - initialize reportSubscriptionID
mReportSubscriptionInfo.ReportSubscriptionUserID = MembershipContext.AuthenticatedUser.UserID;
mReportSubscriptionInfo.ReportSubscriptionSiteID = SiteContext.CurrentSiteID;
mReportSubscriptionInfo.ReportSubscriptionSettings["ReportInterval"] = mIntervalStr;
isNew = true;
}
if (!SimpleMode)
{
// Save basic form & validates basic form data
if (!formElem.SaveData(null))
{
return(false);
}
// Store all parameters in basic form to string XML representation
mParameters = formElem.DataRow;
mReportSubscriptionInfo.ReportSubscriptionValueID = 0;
mReportSubscriptionInfo.ReportSubscriptionTableID = 0;
mReportSubscriptionInfo.ReportSubscriptionGraphID = 0;
// If subscription is not for whole report, store item ID
string drpValue = drpItems.SelectedValue;
if (drpValue != "all")
{
int id = ValidationHelper.GetInteger(drpValue.Substring(1), 0);
if (drpValue.Contains('g'))
{
mReportSubscriptionInfo.ReportSubscriptionGraphID = id;
}
if (drpValue.Contains('t'))
{
mReportSubscriptionInfo.ReportSubscriptionTableID = id;
}
if (drpValue.Contains('v'))
{
mReportSubscriptionInfo.ReportSubscriptionValueID = id;
}
}
}
else
{
mReportSubscriptionInfo.ReportSubscriptionGraphID = mGraphID;
mReportSubscriptionInfo.ReportSubscriptionTableID = mTableID;
mReportSubscriptionInfo.ReportSubscriptionValueID = mValueID;
}
if (mParameters != null)
{
// Find special 'from' and 'to' parameters.
DataColumn dcFrom = mParameters.Table.Columns["fromdate"];
DataColumn dcTo = mParameters.Table.Columns["todate"];
if (rbTime.Checked)
{
if (dcTo != null)
{
// Convert column from datetime to string to enable store macros
mParameters.Table.Columns.Remove(dcTo.ColumnName);
mParameters.Table.Columns.Add(dcTo.ColumnName, typeof(String));
// Add current date time macro
mParameters[dcTo.ColumnName] = "{%CurrentDateTime%}";
}
// Create right macro datetime command based on given interval.
String command = String.Empty;
switch (drpLast.SelectedValue)
{
case "hour":
command = "AddHours";
break;
case "day":
command = "AddDays";
break;
case "week":
command = "AddWeeks";
break;
case "month":
command = "AddMonths";
break;
case "year":
command = "AddYears";
break;
}
// Create todate macro
int last = ValidationHelper.GetInteger(txtLast.Text.Trim(), 0);
String dateCommand = String.Format("{{%CurrentDateTime.{0}({1})%}}", command, last * (-1));
// Convert fromdate to string
if (dcFrom != null)
{
mParameters.Table.Columns.Remove(dcFrom.ColumnName);
mParameters.Table.Columns.Add(dcFrom.ColumnName, typeof(String));
mParameters[dcFrom.ColumnName] = dateCommand;
}
}
else
{
// Empty fromdate and todate for uncheck limit date
if (dcFrom != null)
{
mParameters[dcFrom.ColumnName] = DBNull.Value;
}
if (dcTo != null)
{
mParameters[dcTo.ColumnName] = DBNull.Value;
}
}
// Write parameters to XML string representation
mReportSubscriptionInfo.ReportSubscriptionParameters = ReportHelper.WriteParametersToXml(mParameters);
}
String email = txtEmail.Text.Trim();
bool emailChanged = mReportSubscriptionInfo.ReportSubscriptionEmail != email;
mReportSubscriptionInfo.ReportSubscriptionEnabled = chkEnabled.Checked;
mReportSubscriptionInfo.ReportSubscriptionReportID = Report.ReportID;
mReportSubscriptionInfo.ReportSubscriptionInterval = ucInterval.ScheduleInterval;
mReportSubscriptionInfo.ReportSubscriptionEmail = email;
mReportSubscriptionInfo.ReportSubscriptionSubject = txtSubject.Text;
mReportSubscriptionInfo.ReportSubscriptionCondition = ucMacroEditor.Text;
mReportSubscriptionInfo.ReportSubscriptionOnlyNonEmpty = chkNonEmpty.Checked;
mReportSubscriptionInfo.ReportSubscriptionNextPostDate = SchedulingHelper.GetFirstRunTime(ucInterval.TaskInterval);
ReportSubscriptionInfoProvider.SetReportSubscriptionInfo(mReportSubscriptionInfo);
// Check whether email changed (applies for new subscription also)
if (emailChanged)
{
String siteName = SiteContext.CurrentSiteName;
EmailTemplateInfo eti = EmailTemplateProvider.GetEmailTemplate("Reporting_Subscription_information", siteName);
if (eti != null)
{
// Send information email
EmailMessage em = new EmailMessage();
em.EmailFormat = EmailFormatEnum.Default;
em.From = String.IsNullOrEmpty(eti.TemplateFrom) ? EmailHelper.Settings.NotificationsSenderAddress(siteName) : eti.TemplateFrom;
em.Recipients = email;
em.Subject = eti.TemplateSubject;
em.BccRecipients = eti.TemplateBcc;
em.CcRecipients = eti.TemplateCc;
MacroResolver resolver = ReportSubscriptionSender.CreateSubscriptionMacroResolver(Report, mReportSubscriptionInfo, SiteContext.CurrentSite, em.Recipients);
em.Body = resolver.ResolveMacros(eti.TemplateText);
em.PlainTextBody = resolver.ResolveMacros(eti.TemplatePlainText);
EmailHelper.ResolveMetaFileImages(em, eti.TemplateID, EmailTemplateInfo.OBJECT_TYPE, ObjectAttachmentsCategories.TEMPLATE);
EmailSender.SendEmail(siteName, em);
}
}
// For new item and advanced mode redirect to store ID in query string
if ((isNew) && (!SimpleMode))
{
URLHelper.Redirect(RequestContext.CurrentURL + "&saved=1&subscriptionid=" + mReportSubscriptionInfo.ReportSubscriptionID);
}
ShowChangesSaved();
return(true);
}
return(false);
}
/// <summary>
/// Unigrid external data bound handler.
/// </summary>
protected object uniGrid_OnExternalDataBound(object sender, string sourceName, object parameter)
{
switch (sourceName.ToLowerCSafe())
{
case "yesno":
return(UniGridFunctions.ColoredSpanYesNo(parameter));
case "select":
{
DataRowView drv = (parameter as DataRowView);
// Get item ID
string itemID = drv[returnColumnName].ToString();
string hashKey = itemID;
// Add global object name prefix if required
if (AddGlobalObjectNamePrefix && !String.IsNullOrEmpty(iObjectType.SiteIDColumn) && (ValidationHelper.GetInteger(DataHelper.GetDataRowValue(drv.Row, iObjectType.SiteIDColumn), 0) == 0))
{
itemID = "." + itemID;
}
// Store hash codes for grid items
if (!hashItems.ContainsKey(hashKey))
{
hashItems.Add(hashKey, ValidationHelper.GetHashString(itemID));
}
// Add checkbox for multiple selection
switch (selectionMode)
{
case SelectionModeEnum.Multiple:
case SelectionModeEnum.MultipleTextBox:
case SelectionModeEnum.MultipleButton:
{
string checkBox = string.Format("<span class=\"checkbox\"><input id=\"chk{0}\" type=\"checkbox\" onclick=\"ProcessItem(this,'{1}',false,true);\" class=\"chckbox\" ", itemID, hashItems[hashKey]);
if (hidItem.Value.IndexOfCSafe(valuesSeparator + itemID + valuesSeparator, true) >= 0)
{
checkBox += "checked=\"checked\" ";
}
if (disabledItems.Contains(string.Format("{0}{1}{0}", valuesSeparator, itemID)))
{
checkBox += "disabled=\"disabled\" ";
}
checkBox += string.Format("/><label for=\"chk{0}\"> </label></span>", itemID);
return(checkBox);
}
}
}
break;
case "itemname":
{
DataRowView drv = (parameter as DataRowView);
// Get item ID
string itemID = drv[returnColumnName].ToString();
string hashKey = itemID;
// Get item name
string itemName;
// Special formatted user name
if (displayNameFormat == UniSelector.USER_DISPLAY_FORMAT)
{
string userName = ValidationHelper.GetString(DataHelper.GetDataRowValue(drv.Row, "UserName"), String.Empty);
string fullName = ValidationHelper.GetString(DataHelper.GetDataRowValue(drv.Row, "FullName"), String.Empty);
itemName = Functions.GetFormattedUserName(userName, fullName, IsLiveSite);
}
else if (displayNameFormat == null)
{
itemName = drv[iObjectType.DisplayNameColumn].ToString();
}
else
{
MacroResolver resolver = MacroResolver.GetInstance();
foreach (DataColumn item in drv.Row.Table.Columns)
{
resolver.SetNamedSourceData(item.ColumnName, drv.Row[item.ColumnName]);
}
itemName = resolver.ResolveMacros(displayNameFormat);
}
if (RemoveMultipleCommas)
{
itemName = TextHelper.RemoveMultipleCommas(itemName);
}
// Add the prefixes
itemName = ItemPrefix + itemName;
itemID = ItemPrefix + itemID;
// Add global object name prefix if required
if (AddGlobalObjectNamePrefix && !String.IsNullOrEmpty(iObjectType.SiteIDColumn) && (ValidationHelper.GetInteger(DataHelper.GetDataRowValue(drv.Row, iObjectType.SiteIDColumn), 0) == 0))
{
itemID = "." + itemID;
}
if (String.IsNullOrEmpty(itemName))
{
itemName = emptyReplacement;
}
if (AddGlobalObjectSuffix)
{
if ((iObjectType != null) && !string.IsNullOrEmpty(iObjectType.SiteIDColumn))
{
itemName += (ValidationHelper.GetInteger(DataHelper.GetDataRowValue(drv.Row, iObjectType.SiteIDColumn), 0) > 0 ? string.Empty : " " + GlobalObjectSuffix);
}
}
// Link action
string onclick = null;
bool disabled = disabledItems.Contains(";" + itemID + ";");
if (!disabled)
{
string safeItemID = GetSafe(itemID);
string itemHash = ValidationHelper.GetHashString(itemID);
switch (selectionMode)
{
case SelectionModeEnum.Multiple:
case SelectionModeEnum.MultipleTextBox:
case SelectionModeEnum.MultipleButton:
onclick = string.Format("ProcessItem(document.getElementById('chk{0}'),'{1}',true,true); return false;", ScriptHelper.GetString(itemID).Trim('\''), hashItems[hashKey]);
break;
case SelectionModeEnum.SingleButton:
onclick = string.Format("SelectItems({0},'{1}'); return false;", safeItemID, itemHash);
break;
case SelectionModeEnum.SingleTextBox:
if (allowEditTextBox)
{
onclick = string.Format("SelectItems({0},{0},{1},{2},{3},'{4}'); return false;", safeItemID, ScriptHelper.GetString(hdnClientId), ScriptHelper.GetString(txtClientId), ScriptHelper.GetString(hashId), itemHash);
}
else
{
onclick = string.Format("SelectItems({0},{1},{2},{3},{4},'{5}'); return false;", safeItemID, GetSafe(itemName), ScriptHelper.GetString(hdnClientId), ScriptHelper.GetString(txtClientId), ScriptHelper.GetString(hashId), itemHash);
}
break;
default:
onclick = string.Format("SelectItemsReload({0},{1},{2},{3},{4},{5},'{6}'); return false;", safeItemID, GetSafe(itemName), ScriptHelper.GetString(hdnClientId), ScriptHelper.GetString(txtClientId), ScriptHelper.GetString(hdnDrpId), ScriptHelper.GetString(hashId), itemHash);
break;
}
onclick = "onclick=\"" + onclick + "\" ";
}
if (LocalizeItems)
{
itemName = ResHelper.LocalizeString(itemName);
}
return("<div " + (!disabled ? "class=\"SelectableItem\" " : null) + onclick + ">" + HTMLHelper.HTMLEncode(TextHelper.LimitLength(itemName, 100)) + "</div>");
}
}
return(null);
}
