/// <summary>
/// Builds complete where condition to filter.
/// </summary>
private string BuildWhereCondition()
{
string where = null;
// Create WHERE condition with 'Expression'
string txt = txtExpression.Text.Trim().Replace("'", "''");
if (!string.IsNullOrEmpty(txt))
{
where = "(WordExpression LIKE N'%" + txt + "%')";
}
// Create WHERE condition with 'Action'
int action = ValidationHelper.GetInteger(ucBadWordAction.Value, -1);
if (action != -1)
{
if (!String.IsNullOrEmpty(where))
{
where += " AND ";
}
// Select also bad words that ihnerit action from settings
if (action == (int)BadWordsHelper.BadWordsAction(CMSContext.CurrentSiteName))
{
where += "(WordAction = " + action + " OR WordAction IS NULL)";
}
else
{
where += "(WordAction = " + action + ")";
}
}
return(where);
}
public JsonResult ValidateDescription(string Description)
{
if (!BadWordsHelper.HasBadWord(Description))
{
return(Json(true, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(false, JsonRequestBehavior.AllowGet));
}
}
public JsonResult NickNameExists(string nickName)
{
if (!MemberService.ExistsNickName(nickName) && !BadWordsHelper.HasBadWord(nickName))
{
return(Json(true, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(false, JsonRequestBehavior.AllowGet));
}
}
/// <summary>
/// Sets selected action.
/// </summary>
protected void SetSelectedAction(BadWordInfo badWordObj)
{
// Find postback invoker
string invokerName = Page.Request.Params.Get("__EVENTTARGET");
Control invokeControl = !string.IsNullOrEmpty(invokerName) ? Page.FindControl(invokerName) : null;
// Ensure right postback actions
if ((invokeControl == chkInheritAction) || !RequestHelper.IsPostBack())
{
// Deselect all items
SelectBadWordActionControl.ReloadData();
// Check inheritance of settings
if (chkInheritAction != null)
{
// Get action
if ((!chkInheritAction.Checked) && (badWordObj != null))
{
BadWordActionEnum action = badWordObj.WordAction;
SelectBadWordActionControl.Value = ((int)action).ToString();
}
else
{
SelectBadWordActionControl.Value = ((int)BadWordsHelper.BadWordsAction(CMSContext.CurrentSiteName)).ToString();
}
}
}
// Get replacement
if ((invokeControl == chkInheritReplacement) || !RequestHelper.IsPostBack())
{
if (chkInheritReplacement != null)
{
if (!chkInheritReplacement.Checked && (badWordObj != null))
{
txtWordReplacement.Text = badWordObj.WordReplacement;
}
else
{
txtWordReplacement.Text = BadWordsHelper.BadWordsReplacement(CMSContext.CurrentSiteName);
}
}
}
}
/// <summary>
/// OK click hadler.
/// </summary>
protected void btnOK_Click(object sender, EventArgs e)
{
#region "Security"
// Check whether forum exists
if (ForumContext.CurrentForum == null)
{
return;
}
// Check security
bool securityCheck = true;
switch (ForumContext.CurrentState)
{
case ForumStateEnum.NewThread:
securityCheck = IsAvailable(ForumContext.CurrentForum, ForumActionType.NewThread);
break;
case ForumStateEnum.ReplyToPost:
securityCheck = IsAvailable(ForumContext.CurrentForum, ForumActionType.Reply);
break;
case ForumStateEnum.EditPost:
securityCheck = ForumContext.CurrentPost != null && IsAvailable(ForumContext.CurrentPost, ForumActionType.Edit);
break;
}
if (!securityCheck)
{
ShowError(GetString("ForumNewPost.PermissionDenied"));
return;
}
#region "Captcha"
// Check security code if is required
if ((ForumContext.CurrentForum.ForumUseCAPTCHA) && (!SecurityCode1.IsValid()) && (ForumContext.CurrentState != ForumStateEnum.EditPost))
{
ShowError(GetString("ForumNewPost.InvalidCaptcha"));
return;
}
#endregion
#region "Email field"
// Create instance of validator
Validator validator = new Validator();
// Check whether email is valid
string result = validator.IsEmail(txtEmail.Text, rfvEmail.ErrorMessage).Result;
// Check whether email is present with correct format if email is required
// or when subscribtion to current post is checked
if ((ForumContext.CurrentForum.ForumRequireEmail || chkSubscribe.Checked) && (!String.IsNullOrEmpty(result)))
{
ShowError(result);
return;
}
// Check if email is added if is in correct format
if ((txtEmail.Text.Trim() != "") && (!String.IsNullOrEmpty(result)))
{
ShowError(rfvEmail.ErrorMessage);
return;
}
#endregion
#region "Subject"
// Check whether subject is filled
if (txtSubject.Text.Trim() == "")
{
ShowError(rfvSubject.ErrorMessage);
return;
}
#endregion
#region "Text"
validator = new Validator();
// Check post text in HTML editor or text area
if (!ForumContext.CurrentForum.ForumHTMLEditor)
{
// Check whether post text is added in text area
if ((result = validator.NotEmpty(DiscussionMacroHelper.RemoveTags(ucBBEditor.Text), rfvText.ErrorMessage).Result) != "")
{
ShowError(result);
return;
}
}
else
{
// Check whether post text is added in HTML editor
if ((result = validator.NotEmpty(htmlTemplateBody.ResolvedValue, rfvText.ErrorMessage).Result) != "")
{
ShowError(result);
return;
}
}
#endregion
#region "User name"
// Check whether user name is filled if user name field is visible
if (ForumContext.CurrentForum.ForumAllowChangeName || MembershipContext.AuthenticatedUser.IsPublic() || ((ForumContext.CurrentForum != null) && (ForumContext.UserIsModerator(ForumContext.CurrentForum.ForumID, ForumContext.CommunityGroupID))))
{
validator = new Validator();
if (!String.IsNullOrEmpty(result = validator.NotEmpty(txtUserName.Text, rfvUserName.ErrorMessage).Result))
{
ShowError(result);
return;
}
}
#endregion
#endregion
#region "Forum post properties"
bool newPost = false;
// Current forum info object
ForumInfo fi = ForumContext.CurrentForum;
// Forum post info object
ForumPostInfo fp = null;
// Get forum post info with dependence on current state
if (ForumContext.CurrentState == ForumStateEnum.EditPost)
{
// Get existing object
fp = ForumContext.CurrentPost;
fp.PostLastEdit = DateTime.Now;
}
else
{
// Create new forum post info object
fp = new ForumPostInfo();
newPost = true;
}
#region "Ad-hoc forum"
if (IsAdHocForum && (ForumContext.CurrentForum.ForumID == 0))
{
if (DocumentContext.CurrentDocument == null)
{
ShowError(GetString("forums.documentdoesnotexist"));
return;
}
fi.ForumGroupID = ForumGroupInfoProvider.GetAdHocGroupInfo(SiteID).GroupID;
fi.ForumName = "AdHoc-" + Guid.NewGuid();
fi.ForumDisplayName = TextHelper.LimitLength(DocumentContext.CurrentDocument.GetDocumentName(), POST_USERNAME_LENGTH, String.Empty);
fi.ForumOpen = true;
fi.ForumModerated = false;
fi.ForumAccess = 040000;
fi.ForumThreads = 0;
fi.ForumPosts = 0;
fi.ForumLogActivity = LogActivity;
ForumInfoProvider.SetForumInfo(fi);
ForumContext.CurrentForum.ForumID = fi.ForumID;
ForumContext.ForumID = fi.ForumID;
ForumID = fi.ForumID;
}
#endregion
// Post forum
fp.PostForumID = ForumContext.CurrentForum.ForumID;
// Get forum post info with dependence on current state
if (ForumContext.CurrentState != ForumStateEnum.EditPost)
{
// Post time
fp.PostTime = DateTime.Now;
// User IP address
fp.PostInfo.IPAddress = RequestContext.UserHostAddress;
// User agent
fp.PostInfo.Agent = Request.UserAgent;
// Post user id
if (!MembershipContext.AuthenticatedUser.IsPublic())
{
fp.PostUserID = MembershipContext.AuthenticatedUser.UserID;
}
// Post signature
fp.PostUserSignature = txtSignature.Text;
}
// Post subject
fp.PostSubject = txtSubject.Text;
// Post user email
fp.PostUserMail = txtEmail.Text;
// Post type
int forumType = ForumContext.CurrentForum.ForumType;
if (forumType == 0)
{
if (ForumContext.CurrentReplyThread == null)
{
// New thread - use type which user chosen
fp.PostType = (radTypeDiscussion.Checked ? 0 : 1);
}
else
{
// Reply - use parent type
fp.PostType = ForumContext.CurrentReplyThread.PostType;
}
}
else
{
// Fixed type - use the forum setting
fp.PostType = forumType - 1;
}
bool newThread = (ForumContext.CurrentReplyThread == null);
// Set username if change name is allowed
if (fi.ForumAllowChangeName || MembershipContext.AuthenticatedUser.IsPublic() || ForumContext.UserIsModerator(fp.PostForumID, ForumContext.CommunityGroupID))
{
fp.PostUserName = TextHelper.LimitLength(txtUserName.Text, POST_USERNAME_LENGTH, "");
}
else
{
// Get forum post info with dependence on current state
if (ForumContext.CurrentState != ForumStateEnum.EditPost)
{
fp.PostUserName = UserName;
}
}
// Post parent id -> reply to
if (ForumContext.CurrentReplyThread != null)
{
fp.PostParentID = ForumContext.CurrentReplyThread.PostId;
// Check max relative level
if ((MaxRelativeLevel > -1) && (ForumContext.CurrentReplyThread.PostLevel >= MaxRelativeLevel))
{
ShowError(GetString("Forums.MaxRelativeLevelError"));
return;
}
}
// Get post text from HTML editor if is enabled
fp.PostText = ForumContext.CurrentForum.ForumHTMLEditor ? htmlTemplateBody.ResolvedValue : ucBBEditor.Text;
// Approve post if forum is not moderated
if (newPost)
{
if (!ForumContext.CurrentForum.ForumModerated)
{
fp.PostApproved = true;
}
else
{
if (ForumContext.UserIsModerator(fp.PostForumID, CommunityGroupID))
{
fp.PostApproved = true;
fp.PostApprovedByUserID = MembershipContext.AuthenticatedUser.UserID;
}
}
}
// If signature is enabled then
if (EnableSignature)
{
fp.PostUserSignature = MembershipContext.AuthenticatedUser.UserSignature;
}
#endregion
if (!BadWordInfoProvider.CanUseBadWords(MembershipContext.AuthenticatedUser, SiteContext.CurrentSiteName))
{
// Prepare columns to check
Dictionary <string, int> columns = new Dictionary <string, int>();
columns.Add("PostText", 0);
columns.Add("PostSubject", 450);
columns.Add("PostUserSignature", 0);
columns.Add("PostUserName", 200);
// Perform bad words check
string badMessage = BadWordsHelper.CheckBadWords(fp, columns, "PostApproved", "PostApprovedByUserID", fp.PostText, MembershipContext.AuthenticatedUser.UserID, () => { return(ValidatePost(fp)); });
if (String.IsNullOrEmpty(badMessage))
{
if (!ValidatePost(fp))
{
badMessage = GetString("ForumNewPost.EmptyBadWord");
}
}
if (!String.IsNullOrEmpty(badMessage))
{
ShowError(badMessage);
return;
}
}
// Flood protection
if (FloodProtectionHelper.CheckFlooding(SiteContext.CurrentSiteName, MembershipContext.AuthenticatedUser))
{
ShowError(GetString("General.FloodProtection"));
return;
}
// Check banned ip
if (!BannedIPInfoProvider.IsAllowed(SiteContext.CurrentSiteName, BanControlEnum.AllNonComplete))
{
ShowError(GetString("General.BannedIP"));
return;
}
string baseUrl = ForumContext.CurrentForum.ForumBaseUrl;
if (String.IsNullOrEmpty(baseUrl))
{
baseUrl = FriendlyBaseURL;
}
string unsubscriptionUrl = ForumContext.CurrentForum.ForumUnsubscriptionUrl;
if (String.IsNullOrEmpty(unsubscriptionUrl))
{
unsubscriptionUrl = UnsubscriptionURL;
}
// USe parent post id for new post
int subscibePostId = newPost ? fp.PostParentID : fp.PostId;
// Check subscriptions
if ((chkSubscribe.Checked) && (!String.IsNullOrEmpty(txtEmail.Text)) && (ForumSubscriptionInfoProvider.IsSubscribed(txtEmail.Text.Trim(), fp.PostForumID, subscibePostId)))
{
// Post of the forum is already subscribed to this email -> show an error
chkSubscribe.Checked = false;
ShowError(GetString("Forums.EmailAlreadySubscribed"));
return;
}
// Save post object
ForumPostInfoProvider.SetForumPostInfo(fp, baseUrl, unsubscriptionUrl);
LogPostActivity(fp, fi);
#region "Subscription"
// If subscribe is checked create new subscription to the current post
if ((chkSubscribe.Checked) && (!ForumSubscriptionInfoProvider.IsSubscribed(fp.PostUserMail, fp.PostForumID, fp.PostId)))
{
// Create new subscription info object
ForumSubscriptionInfo fsi = new ForumSubscriptionInfo();
// Set info properties
fsi.SubscriptionForumID = fp.PostForumID;
fsi.SubscriptionEmail = fp.PostUserMail;
fsi.SubscriptionPostID = fp.PostId;
fsi.SubscriptionUserID = fp.PostUserID;
fsi.SubscriptionGUID = Guid.NewGuid();
// Save subscription
ForumSubscriptionInfoProvider.Subscribe(fsi, DateTime.Now, true, true);
if (fsi.SubscriptionApproved)
{
LogSubscriptionActivity(fsi, fi);
}
}
#endregion
bool moderationRequired = false;
if ((!fp.PostApproved) && (!ForumContext.UserIsModerator(fp.PostForumID, CommunityGroupID)))
{
moderationRequired = true;
if (OnModerationRequired != null)
{
OnModerationRequired(this, null);
}
}
// Keep current user info
CurrentUserInfo currentUser = MembershipContext.AuthenticatedUser;
if (currentUser.IsAuthenticated() && chkAttachFile.Checked && (currentUser.IsGlobalAdministrator || ForumContext.CurrentForum.AllowAttachFiles != SecurityAccessEnum.Nobody))
{
// Redirect to the post attachments
string attachmentUrl = GetURL(fp, ForumActionType.Attachment);
if (moderationRequired)
{
attachmentUrl = URLHelper.AddParameterToUrl(attachmentUrl, "moderated", "1");
}
URLHelper.Redirect(attachmentUrl);
}
else
{
if (!StopProcessing)
{
// Redirect back to the forum or forum thread
URLHelper.Redirect(ClearURL());
}
}
}
private object OnExternalDataBound(object sender, string sourceName, object parameter)
{
bool inherited = false;
BadWordActionEnum action = BadWordActionEnum.None;
string siteName = SiteContext.CurrentSiteName;
switch (sourceName.ToLowerCSafe())
{
case "wordaction":
if (!string.IsNullOrEmpty(parameter.ToString()))
{
action = (BadWordActionEnum)Enum.Parse(typeof(BadWordActionEnum), parameter.ToString());
}
else
{
action = BadWordsHelper.BadWordsAction(siteName);
inherited = true;
}
// Ensure displaying text labels instead of numbers
switch (action)
{
case BadWordActionEnum.Remove:
parameter = Control.GetString("general.remove");
break;
case BadWordActionEnum.Replace:
parameter = Control.GetString("general.replace");
break;
case BadWordActionEnum.ReportAbuse:
parameter = Control.GetString("BadWords_Edit.ReportAbuse");
break;
case BadWordActionEnum.RequestModeration:
parameter = Control.GetString("BadWords_Edit.RequestModeration");
break;
case BadWordActionEnum.Deny:
parameter = Control.GetString("Security.Deny");
break;
}
if (inherited)
{
parameter += " " + Control.GetString("BadWords_Edit.Inherited");
}
break;
case "wordreplacement":
// Get DataRowView
DataRowView drv = parameter as DataRowView;
if (drv != null)
{
string replacement = drv.Row["WordReplacement"].ToString();
string toReturn = replacement;
// Set 'inherited' only if WordReplacement is empty
if (string.IsNullOrEmpty(replacement))
{
// Get action from cell
string actionText = drv.Row["WordAction"].ToString();
// Get action enum value
if (string.IsNullOrEmpty(actionText))
{
action = BadWordsHelper.BadWordsAction(siteName);
}
else
{
action = (BadWordActionEnum)ValidationHelper.GetInteger(actionText, 0);
}
// Set replacement only if action is replace
if (action == BadWordActionEnum.Replace)
{
// Get inherited replacement from settings
if (string.IsNullOrEmpty(toReturn))
{
string inheritedSetting = SettingsKeyInfoProvider.GetValue(siteName + ".CMSBadWordsReplacement");
toReturn += inheritedSetting + " " + Control.GetString("BadWords_Edit.Inherited");
}
}
else
{
toReturn = string.Empty;
}
}
return(HTMLHelper.HTMLEncode(toReturn));
}
return(null);
case "global":
bool global = ValidationHelper.GetBoolean(parameter, false);
return(UniGridFunctions.ColoredSpanYesNo(global));
}
return(HTMLHelper.HTMLEncode(parameter.ToString()));
}
protected void btnOk_Click(object sender, EventArgs e)
{
// Let the parent control now new message is being saved
if (OnBeforeMessageSaved != null)
{
OnBeforeMessageSaved();
}
// Check if message board is opened
if (!IsBoardOpen())
{
return;
}
// Check banned IP
if (!BannedIPInfoProvider.IsAllowed(SiteContext.CurrentSiteName, BanControlEnum.AllNonComplete))
{
ShowError(GetString("General.BannedIP"));
return;
}
// Validate form
string errorMessage = ValidateForm();
if (errorMessage == String.Empty)
{
// Check flooding when message being inserted through the LiveSite
if (CheckFloodProtection && IsLiveSite && FloodProtectionHelper.CheckFlooding(SiteContext.CurrentSiteName, MembershipContext.AuthenticatedUser))
{
ShowError(GetString("General.FloodProtection"));
return;
}
var currentUser = MembershipContext.AuthenticatedUser;
BoardMessageInfo message;
if (MessageID > 0)
{
// Get message info
message = BoardMessageInfoProvider.GetBoardMessageInfo(MessageID);
MessageBoardID = message.MessageBoardID;
}
else
{
// Create new info
message = new BoardMessageInfo();
// User IP address
message.MessageUserInfo.IPAddress = RequestContext.UserHostAddress;
// User agent
message.MessageUserInfo.Agent = Request.UserAgent;
}
// Setup message info
message.MessageEmail = txtEmail.Text.Trim();
message.MessageText = txtMessage.Text.Trim();
// Handle message URL
string url = txtURL.Text.Trim();
if (!String.IsNullOrEmpty(url))
{
string protocol = URLHelper.GetProtocol(url);
if (String.IsNullOrEmpty(protocol))
{
url = "http://" + url;
}
}
message.MessageURL = TextHelper.LimitLength(url, txtURL.MaxLength);
message.MessageURL = message.MessageURL.ToLowerCSafe().Replace("javascript", "_javascript");
message.MessageUserName = TextHelper.LimitLength(txtUserName.Text.Trim(), txtUserName.MaxLength);
if ((message.MessageID <= 0) && (!currentUser.IsPublic()))
{
message.MessageUserID = currentUser.UserID;
if (!plcUserName.Visible)
{
message.MessageUserName = GetDefaultUserName();
}
}
message.MessageIsSpam = ValidationHelper.GetBoolean(chkSpam.Checked, false);
if (BoardProperties.EnableContentRating && (ratingControl != null) &&
(ratingControl.GetCurrentRating() > 0))
{
message.MessageRatingValue = ratingControl.CurrentRating;
// Update document rating, remember rating in cookie
TreeProvider.RememberRating(DocumentContext.CurrentDocument);
}
BoardInfo boardInfo;
// If there is message board
if (MessageBoardID > 0)
{
// Load message board
boardInfo = Board;
}
else
{
// Create new message board according to webpart properties
boardInfo = new BoardInfo(BoardProperties);
BoardInfoProvider.SetBoardInfo(boardInfo);
// Update information on current message board
MessageBoardID = boardInfo.BoardID;
// Set board-role relationship
BoardRoleInfoProvider.SetBoardRoles(MessageBoardID, BoardProperties.BoardRoles);
// Set moderators
BoardModeratorInfoProvider.SetBoardModerators(MessageBoardID, BoardProperties.BoardModerators);
}
if (boardInfo != null)
{
if (BoardInfoProvider.IsUserAuthorizedToAddMessages(boardInfo))
{
// If the very new message is inserted
if (MessageID == 0)
{
// If creating message set inserted to now and assign to board
message.MessageInserted = DateTime.Now;
message.MessageBoardID = MessageBoardID;
// Handle auto approve action
bool isAuthorized = BoardInfoProvider.IsUserAuthorizedToManageMessages(boardInfo);
if (isAuthorized)
{
message.MessageApprovedByUserID = currentUser.UserID;
message.MessageApproved = true;
}
else
{
// Is board moderated ?
message.MessageApprovedByUserID = 0;
message.MessageApproved = !boardInfo.BoardModerated;
}
}
else
{
if (chkApproved.Checked)
{
// Set current user as approver
message.MessageApproved = true;
message.MessageApprovedByUserID = currentUser.UserID;
}
else
{
message.MessageApproved = false;
message.MessageApprovedByUserID = 0;
}
}
if (!AdvancedMode)
{
if (!BadWordInfoProvider.CanUseBadWords(MembershipContext.AuthenticatedUser, SiteContext.CurrentSiteName))
{
// Columns to check
Dictionary <string, int> collumns = new Dictionary <string, int>();
collumns.Add("MessageText", 0);
collumns.Add("MessageUserName", 250);
// Perform bad words check
bool validateUserName = plcUserName.Visible;
errorMessage = BadWordsHelper.CheckBadWords(message, collumns, "MessageApproved", "MessageApprovedByUserID",
message.MessageText, currentUser.UserID, () => ValidateMessage(message, validateUserName));
// Additionally check empty fields
if (errorMessage == string.Empty)
{
if (!ValidateMessage(message, validateUserName))
{
errorMessage = GetString("board.messageedit.emptybadword");
}
}
}
}
// Subscribe this user to message board
if (chkSubscribe.Checked)
{
string email = message.MessageEmail;
// Check for duplicate e-mails
DataSet ds = BoardSubscriptionInfoProvider.GetSubscriptions("((SubscriptionApproved = 1) OR (SubscriptionApproved IS NULL)) AND SubscriptionBoardID=" + MessageBoardID +
" AND SubscriptionEmail='" + SqlHelper.GetSafeQueryString(email, false) + "'", null);
if (DataHelper.DataSourceIsEmpty(ds))
{
BoardSubscriptionInfo bsi = new BoardSubscriptionInfo();
bsi.SubscriptionBoardID = MessageBoardID;
bsi.SubscriptionEmail = email;
if (!currentUser.IsPublic())
{
bsi.SubscriptionUserID = currentUser.UserID;
}
BoardSubscriptionInfoProvider.Subscribe(bsi, DateTime.Now, true, true);
ClearForm();
if (bsi.SubscriptionApproved)
{
ShowConfirmation(GetString("board.subscription.beensubscribed"));
Service.Resolve <ICurrentContactMergeService>().UpdateCurrentContactEmail(bsi.SubscriptionEmail, MembershipContext.AuthenticatedUser);
LogSubscribingActivity(bsi, boardInfo);
}
else
{
string confirmation = GetString("general.subscribed.doubleoptin");
int optInInterval = BoardInfoProvider.DoubleOptInInterval(SiteContext.CurrentSiteName);
if (optInInterval > 0)
{
confirmation += "<br />" + String.Format(GetString("general.subscription_timeintervalwarning"), optInInterval);
}
ShowConfirmation(confirmation);
}
}
else
{
errorMessage = GetString("board.subscription.emailexists");
}
}
if (errorMessage == "")
{
try
{
// Save message info
BoardMessageInfoProvider.SetBoardMessageInfo(message);
Service.Resolve <ICurrentContactMergeService>().UpdateCurrentContactEmail(message.MessageEmail, MembershipContext.AuthenticatedUser);
LogCommentActivity(message, boardInfo);
if (BoardProperties.EnableContentRating && (ratingControl != null) && (ratingControl.GetCurrentRating() > 0))
{
LogRatingActivity(ratingControl.CurrentRating);
}
// If the message is not approved let the user know message is waiting for approval
if (message.MessageApproved == false)
{
ShowInformation(GetString("board.messageedit.waitingapproval"));
}
// Rise after message saved event
if (OnAfterMessageSaved != null)
{
OnAfterMessageSaved(message);
}
// Hide message form if user has rated and empty rating is not allowed
if (BoardProperties.CheckIfUserRated)
{
if (!BoardProperties.AllowEmptyRating && TreeProvider.HasRated(DocumentContext.CurrentDocument))
{
pnlMessageEdit.Visible = false;
lblAlreadyrated.Visible = true;
}
else
{
// Hide rating form if user has rated
if (BoardProperties.EnableContentRating && (ratingControl != null) && ratingControl.GetCurrentRating() > 0)
{
plcRating.Visible = false;
}
}
}
// Clear form content
ClearForm();
}
catch (Exception ex)
{
errorMessage = ex.Message;
}
}
}
else if (String.IsNullOrEmpty(errorMessage))
{
errorMessage = ResHelper.GetString("general.actiondenied");
}
}
}
if (!String.IsNullOrEmpty(errorMessage))
{
ShowError(errorMessage);
}
}
protected void btnOk_Click(object sender, EventArgs e)
{
// Let the parent control now new message is being saved
if (OnBeforeMessageSaved != null)
{
OnBeforeMessageSaved();
}
// Check banned ip
if (!BannedIPInfoProvider.IsAllowed(CMSContext.CurrentSiteName, BanControlEnum.AllNonComplete))
{
lblError.Visible = true;
lblError.Text = GetString("General.BannedIP");
return;
}
// Validate form
string errorMessage = ValidateForm();
if (errorMessage == "")
{
// Check flooding when message being inserted through the LiveSite
if (this.CheckFloodProtection && this.IsLiveSite && FloodProtectionHelper.CheckFlooding(CMSContext.CurrentSiteName, CMSContext.CurrentUser))
{
lblError.Visible = true;
lblError.Text = GetString("General.FloodProtection");
return;
}
CurrentUserInfo currentUser = CMSContext.CurrentUser;
BoardMessageInfo messageInfo = null;
if (MessageID > 0)
{
// Get message info
messageInfo = BoardMessageInfoProvider.GetBoardMessageInfo(MessageID);
MessageBoardID = messageInfo.MessageBoardID;
}
else
{
// Create new info
messageInfo = new BoardMessageInfo();
// User IP adress
messageInfo.MessageUserInfo.IPAddress = Request.UserHostAddress;
// User agent
messageInfo.MessageUserInfo.Agent = Request.UserAgent;
}
// Setup message info
messageInfo.MessageEmail = txtEmail.Text.Trim();
messageInfo.MessageText = txtMessage.Text.Trim();
// Handle message URL
string url = txtURL.Text.Trim();
if ((url != "http://") && (url != "https://") && (url != ""))
{
if ((!url.ToLower().StartsWith("http://")) && (!url.ToLower().StartsWith("https://")))
{
url = "http://" + url;
}
}
else
{
url = "";
}
messageInfo.MessageURL = url;
messageInfo.MessageURL = messageInfo.MessageURL.ToLower().Replace("javascript", "_javascript");
messageInfo.MessageUserName = this.txtUserName.Text.Trim();
if (!currentUser.IsPublic())
{
messageInfo.MessageUserID = currentUser.UserID;
}
messageInfo.MessageIsSpam = ValidationHelper.GetBoolean(this.chkSpam.Checked, false);
if (this.BoardProperties.EnableContentRating && (ratingControl != null) &&
(ratingControl.GetCurrentRating() > 0))
{
messageInfo.MessageRatingValue = ratingControl.CurrentRating;
}
BoardInfo boardInfo = null;
// If there is message board
if (MessageBoardID > 0)
{
// Load message board
boardInfo = Board;
}
else
{
// Create new message board according to webpart properties
boardInfo = new BoardInfo(this.BoardProperties);
BoardInfoProvider.SetBoardInfo(boardInfo);
// Update information on current message board
this.MessageBoardID = boardInfo.BoardID;
// Set board-role relationship
BoardRoleInfoProvider.SetBoardRoles(this.MessageBoardID, this.BoardProperties.BoardRoles);
// Set moderators
BoardModeratorInfoProvider.SetBoardModerators(this.MessageBoardID, this.BoardProperties.BoardModerators);
}
if (boardInfo != null)
{
// If the very new message is inserted
if (this.MessageID == 0)
{
// If creating message set inserted to now and assign to board
messageInfo.MessageInserted = currentUser.DateTimeNow;
messageInfo.MessageBoardID = MessageBoardID;
// Handle auto approve action
bool isAuthorized = BoardInfoProvider.IsUserAuthorizedToManageMessages(boardInfo);
if (isAuthorized)
{
messageInfo.MessageApprovedByUserID = currentUser.UserID;
messageInfo.MessageApproved = true;
}
else
{
// Is board moderated ?
messageInfo.MessageApprovedByUserID = 0;
messageInfo.MessageApproved = !boardInfo.BoardModerated;
}
}
else
{
if (this.chkApproved.Checked)
{
// Set current user as approver
messageInfo.MessageApproved = true;
messageInfo.MessageApprovedByUserID = currentUser.UserID;
}
else
{
messageInfo.MessageApproved = false;
messageInfo.MessageApprovedByUserID = 0;
}
}
if (!AdvancedMode)
{
if (!BadWordInfoProvider.CanUseBadWords(CMSContext.CurrentUser, CMSContext.CurrentSiteName))
{
// Columns to check
Dictionary <string, int> collumns = new Dictionary <string, int>();
collumns.Add("MessageText", 0);
collumns.Add("MessageUserName", 250);
// Perform bad words check
errorMessage = BadWordsHelper.CheckBadWords(messageInfo, collumns, "MessageApproved", "MessageApprovedByUserID",
messageInfo.MessageText, currentUser.UserID);
// Additionaly check empty fields
if (errorMessage == string.Empty)
{
if (!ValidateMessage(messageInfo))
{
errorMessage = GetString("board.messageedit.emptybadword");
}
}
}
}
// Subscribe this user to message board
if (chkSubscribe.Checked)
{
string email = messageInfo.MessageEmail;
// Check for duplicit e-mails
DataSet ds = BoardSubscriptionInfoProvider.GetSubscriptions("SubscriptionBoardID=" + this.MessageBoardID +
" AND SubscriptionEmail='" + SqlHelperClass.GetSafeQueryString(email, false) + "'", null);
if (DataHelper.DataSourceIsEmpty(ds))
{
BoardSubscriptionInfo bsi = new BoardSubscriptionInfo();
bsi.SubscriptionBoardID = this.MessageBoardID;
bsi.SubscriptionEmail = email;
if (!currentUser.IsPublic())
{
bsi.SubscriptionUserID = currentUser.UserID;
}
BoardSubscriptionInfoProvider.SetBoardSubscriptionInfo(bsi);
ClearForm();
LogSubscribingActivity(bsi, boardInfo);
}
else
{
errorMessage = GetString("board.subscription.emailexists");
}
}
if (errorMessage == "")
{
try
{
// Save message info
BoardMessageInfoProvider.SetBoardMessageInfo(messageInfo);
LogCommentActivity(messageInfo, boardInfo);
// If the board is moderated let the user know message is waiting for approval
if (boardInfo.BoardModerated && (messageInfo.MessageApproved == false))
{
this.lblInfo.Text = GetString("board.messageedit.waitingapproval");
this.lblInfo.Visible = true;
}
// Rise after message saved event
if (OnAfterMessageSaved != null)
{
OnAfterMessageSaved(messageInfo);
}
// Clear form content
ClearForm();
}
catch (Exception ex)
{
errorMessage = ex.Message;
}
}
}
}
if (errorMessage != "")
{
lblError.Text = errorMessage;
lblError.Visible = true;
}
else
{
// Regenerate new captcha
captchaElem.GenerateNew();
}
}
protected void btnSendMessage_Click(object sender, EventArgs e)
{
// This is because of ASP.NET default behaviour
// The first empty line was trimmed after each postback
if (BBEditor.Text.StartsWithCSafe("\n"))
{
BBEditor.Text = "\n" + BBEditor.Text;
}
// Flood protection
if (!FloodProtectionHelper.CheckFlooding(CMSContext.CurrentSiteName, CMSContext.CurrentUser))
{
CurrentUserInfo currentUser = CMSContext.CurrentUser;
// Check banned IP
if (BannedIPInfoProvider.IsAllowed(CMSContext.CurrentSiteName, BanControlEnum.AllNonComplete))
{
int recipientId = ucMessageUserSelector.Visible
? ucMessageUserSelector.SelectedUserID
: ValidationHelper.GetInteger(hdnUserId.Value, 0);
string message = string.Empty;
string nickName = HTMLHelper.HTMLEncode(txtFrom.Text.Trim());
if (!ValidateBody(DiscussionMacroHelper.RemoveTags(ucBBEditor.Text)))
{
message = GetString("SendMessage.EmptyBody");
}
// Check sender nick name if anonymous
if (isAnonymousUser && (nickName == string.Empty))
{
message = GetString("SendMesage.NoNickName");
}
UserInfo recipient = null;
// Check recipient
if (recipientId == 0)
{
if (string.IsNullOrEmpty(ucMessageUserSelector.UserNameTextBox.Text.Trim()))
{
message = GetString("SendMesage.NoRecipient");
}
else
{
message = GetString("SendMesage.UserDoesntExists");
}
}
else
{
recipient = UserInfoProvider.GetUserInfo(recipientId);
// Normal users can't send message to user from other site except for global admin
if (!recipient.IsInSite(CMSContext.CurrentSiteName) && !currentUser.IsGlobalAdministrator)
{
message = GetString("SendMesage.UserDoesntExists");
}
int defRecipientId = ValidationHelper.GetInteger(DefaultRecipient, 0);
// If default recipient selected and is same as message recipient, skip check on hidden users
if (recipient.UserID != defRecipientId)
{
// Manually disabled users Hidden users if not replying to them Not approved users
bool userAllowed = (recipient.UserIsDisabledManually || (recipient.UserIsHidden && (SendMessageMode != MessageActionEnum.Reply)) || recipient.UserSettings.UserWaitingForApproval);
// If live site mode hide not allowed users for all users except for global admins and public user for all users
if ((IsLiveSite && userAllowed && !currentUser.IsGlobalAdministrator) || (recipient.UserName.ToLowerCSafe() == "public"))
{
message = GetString("SendMesage.UserDoesntExists");
}
}
}
if (message == string.Empty)
{
// Send message
try
{
// Check if current user is in recipient's ignore list
bool isIgnored = IgnoreListInfoProvider.IsInIgnoreList(recipientId, currentUser.UserID);
Message = new MessageInfo();
Message.MessageBody = ucBBEditor.Text;
string subject = (txtSubject.Text.Trim() == string.Empty) ? GetString("Messaging.NoSubject") : txtSubject.Text.Trim();
Message.MessageSubject = TextHelper.LimitLength(subject, 200);
Message.MessageRecipientUserID = recipientId;
Message.MessageRecipientNickName = TextHelper.LimitLength(Functions.GetFormattedUserName(recipient.UserName, recipient.FullName, recipient.UserNickName, IsLiveSite), 200);
Message.MessageSent = DateTime.Now;
// Anonymous user
if (isAnonymousUser)
{
Message.MessageSenderNickName = TextHelper.LimitLength(nickName, 200);
Message.MessageSenderDeleted = true;
}
else
{
Message.MessageSenderUserID = currentUser.UserID;
Message.MessageSenderNickName = TextHelper.LimitLength(Functions.GetFormattedUserName(currentUser.UserName, currentUser.FullName, currentUser.UserNickName, IsLiveSite), 200);
// If the user is ignored, delete message automatically
if (isIgnored)
{
Message.MessageRecipientDeleted = true;
}
}
string error = string.Empty;
// Check bad words
if (!BadWordInfoProvider.CanUseBadWords(currentUser, CMSContext.CurrentSiteName))
{
// Prepare columns to check
Dictionary <string, int> columns = new Dictionary <string, int>();
columns.Add("MessageSubject", 200);
columns.Add("MessageBody", 0);
columns.Add("MessageSenderNickName", 200);
columns.Add("MessageRecipientNickName", 200);
// Perform bad word check
error = BadWordsHelper.CheckBadWords(Message, columns, currentUser.UserID, () => { return(ValidateBody(Message.MessageBody)); });
}
if (error != string.Empty)
{
ShowError(error);
}
else
{
// Check message subject, if empty set no subject text
if (Message.MessageSubject.Trim() == string.Empty)
{
Message.MessageSubject = GetString("Messaging.NoSubject");
}
// Whole text has been removed
if (!ValidateBody(Message.MessageBody))
{
ShowError(GetString("SendMessage.EmptyBodyBadWords"));
}
else
{
// Save the message
MessageInfoProvider.SetMessageInfo(Message);
// Send notification email, if not ignored
if (!isIgnored)
{
MessageInfoProvider.SendNotificationEmail(Message, recipient, currentUser, CMSContext.CurrentSiteName);
}
ShowConfirmation(GetString("SendMesage.MessageSent"));
MessageId = 0;
ucMessageUserSelector.SelectedUserID = 0;
}
}
}
catch (Exception ex)
{
ShowError(ex.Message);
ErrorMessage = ex.Message;
}
}
// Error in the form
else
{
ShowError(message);
ErrorMessage = message;
}
}
else
{
ShowError(GetString("General.BannedIP"));
}
}
else
{
ShowError(GetString("General.FloodProtection"));
}
// External event
if (SendButtonClick != null)
{
SendButtonClick(sender, e);
}
}
public void PerformAction()
{
// Check banned ip
if (!BannedIPInfoProvider.IsAllowed(SiteContext.CurrentSiteName, BanControlEnum.AllNonComplete))
{
lblError.Visible = true;
lblError.Text = GetString("General.BannedIP");
return;
}
if (OnBeforeCommentSaved != null)
{
OnBeforeCommentSaved();
}
// Validate form
string errorMessage = ValidateForm();
if (errorMessage == "")
{
// Check flooding when message being inserted through the LiveSite
if (IsLiveSite && FloodProtectionHelper.CheckFlooding(SiteContext.CurrentSiteName, MembershipContext.AuthenticatedUser))
{
lblError.Visible = true;
lblError.Text = GetString("General.FloodProtection");
return;
}
var currentUser = MembershipContext.AuthenticatedUser;
// Create new comment
BlogCommentInfo bci;
if (IsInsertMode)
{
bci = new BlogCommentInfo();
bci.CommentDate = DateTime.Now;
bci.CommentPostDocumentID = mPostDocumentId;
// User IP address
bci.CommentInfo.IPAddress = RequestContext.UserHostAddress;
// User agent
bci.CommentInfo.Agent = Request.UserAgent;
if (!currentUser.IsPublic())
{
bci.CommentUserID = currentUser.UserID;
}
bci.CommentIsTrackback = false;
}
// Get existing comment
else
{
bci = BlogCommentInfoProvider.GetBlogCommentInfo(mCommentId);
}
// Update basic comment properties
if (bci != null)
{
// Add http:// if needed
string url = txtUrl.Text.Trim();
if (url != "")
{
if ((!url.ToLowerCSafe().StartsWithCSafe("http://")) && (!url.ToLowerCSafe().StartsWithCSafe("https://")))
{
url = "http://" + url;
}
}
bci.CommentIsSpam = chkSpam.Checked;
bci.CommentApproved = chkApproved.Checked;
bci.CommentUserName = txtName.Text.Trim();
bci.CommentUrl = url;
bci.CommentText = txtComments.Text.Trim();
bci.CommentUrl = bci.CommentUrl.ToLowerCSafe().Replace("javascript", "_javascript");
bci.CommentEmail = txtEmail.Text.Trim();
}
if (IsInsertMode)
{
// Auto approve owner comments
if (bci != null)
{
TreeNode blogNode = BlogHelper.GetParentBlog(bci.CommentPostDocumentID, false);
if ((currentUser != null) && (blogNode != null))
{
bool isAuthorized = BlogHelper.IsUserAuthorizedToManageComments(blogNode);
if (isAuthorized)
{
bci.CommentApprovedByUserID = blogNode.NodeOwner;
bci.CommentApproved = true;
}
else
{
// Is blog moderated ?
bool moderated = ValidationHelper.GetBoolean(blogNode.GetValue("BlogModerateComments"), false);
bci.CommentApprovedByUserID = 0;
bci.CommentApproved = !moderated;
}
}
}
}
// Perform bad words check
if (!BadWordInfoProvider.CanUseBadWords(MembershipContext.AuthenticatedUser, SiteContext.CurrentSiteName))
{
if (bci != null)
{
// Prepare columns to check
Dictionary <string, int> columns = new Dictionary <string, int>();
columns.Add("CommentText", 0);
columns.Add("CommentUserName", 200);
// Perform bad words to check
errorMessage = BadWordsHelper.CheckBadWords(bci, columns, "CommentApproved", "CommentApprovedByUserID", bci.CommentText, MembershipContext.AuthenticatedUser.UserID, () => ValidateComment(bci));
}
}
if (errorMessage == string.Empty)
{
if (bci != null)
{
if (!ValidateComment(bci))
{
// Show error message
lblError.Visible = true;
lblError.Text = GetString("Blog.CommentEdit.EmptyBadWord");
}
else
{
// Subscribe new subscriber
if (chkSubscribe.Checked)
{
// Check for duplicate subscriptions
BlogPostSubscriptionInfo bpsi = BlogPostSubscriptionInfoProvider.GetBlogPostSubscriptionInfo(txtEmail.Text, mPostDocumentId);
if ((bpsi == null) || !bpsi.SubscriptionApproved)
{
bpsi = new BlogPostSubscriptionInfo();
bpsi.SubscriptionEmail = txtEmail.Text;
bpsi.SubscriptionPostDocumentID = mPostDocumentId;
bpsi.SubscriptionUserID = bci.CommentUserID;
BlogPostSubscriptionInfoProvider.Subscribe(bpsi, DateTime.Now, true, true);
if (bpsi.SubscriptionApproved)
{
LogRegistrationActivity(bpsi);
}
}
else
{
errorMessage = GetString("blog.subscription.emailexists");
}
}
if (errorMessage == "")
{
// Save changes to database
BlogCommentInfoProvider.SetBlogCommentInfo(bci);
if (!bci.CommentApproved)
{
CommentSavedText = GetString("blog.comments.requiresmoderationafteraction");
}
// Inform user
lblInfo.Visible = true;
lblInfo.Text = CommentSavedText;
// Clear form when required
if (mClearFormAfterSave)
{
txtComments.Text = "";
txtUrl.Text = "";
ctrlCaptcha.Value = "";
}
LogCommentActivity(bci, PostNodeId, PostCulture);
if (OnAfterCommentSaved != null)
{
OnAfterCommentSaved(bci);
}
}
}
}
}
}
if (errorMessage != "")
{
// Show error message
lblError.Visible = true;
lblError.Text = errorMessage;
}
}
protected void btnOk_Click(object sender, EventArgs e)
{
// Let the parent control now new message is being saved
if (OnBeforeMessageSaved != null)
{
OnBeforeMessageSaved();
}
// Check banned IP
if (!BannedIPInfoProvider.IsAllowed(SiteContext.CurrentSiteName, BanControlEnum.AllNonComplete))
{
ShowError(GetString("General.BannedIP"));
return;
}
// Validate form
string errorMessage = ValidateForm();
if (errorMessage == "")
{
// Check flooding when message being inserted through the LiveSite
if (CheckFloodProtection && IsLiveSite && FloodProtectionHelper.CheckFlooding(SiteContext.CurrentSiteName, MembershipContext.AuthenticatedUser))
{
ShowError(GetString("General.FloodProtection"));
return;
}
CurrentUserInfo currentUser = MembershipContext.AuthenticatedUser;
BoardMessageInfo messageInfo = null;
if (MessageID > 0)
{
// Get message info
messageInfo = BoardMessageInfoProvider.GetBoardMessageInfo(MessageID);
MessageBoardID = messageInfo.MessageBoardID;
}
else
{
// Create new info
messageInfo = new BoardMessageInfo();
// User IP address
messageInfo.MessageUserInfo.IPAddress = RequestContext.UserHostAddress;
// User agent
messageInfo.MessageUserInfo.Agent = Request.UserAgent;
}
// Setup message info
messageInfo.MessageEmail = txtEmail.Text.Trim();
messageInfo.MessageText = txtMessage.Text.Trim();
// Handle message URL
string url = txtURL.Text.Trim();
if ((url != "http://") && (url != "https://") && (url != ""))
{
if ((!url.ToLowerCSafe().StartsWithCSafe("http://")) && (!url.ToLowerCSafe().StartsWithCSafe("https://")))
{
url = "http://" + url;
}
}
else
{
url = "";
}
messageInfo.MessageURL = url;
messageInfo.MessageURL = messageInfo.MessageURL.ToLowerCSafe().Replace("javascript", "_javascript");
messageInfo.MessageUserName = txtUserName.Text.Trim();
if ((MessageID <= 0) && (!currentUser.IsPublic()))
{
messageInfo.MessageUserID = currentUser.UserID;
}
messageInfo.MessageIsSpam = ValidationHelper.GetBoolean(chkSpam.Checked, false);
if (BoardProperties.EnableContentRating && (ratingControl != null) &&
(ratingControl.GetCurrentRating() > 0))
{
messageInfo.MessageRatingValue = ratingControl.CurrentRating;
// Remember rating in cookie
string docs = CookieHelper.GetValue(CookieName.RatedDocuments) ?? "|";
if (!docs.Contains("|" + DocumentContext.CurrentDocument.DocumentID + "|"))
{
docs += DocumentContext.CurrentDocument.DocumentID + "|";
// Actualize the cookie
CookieHelper.SetValue(CookieName.RatedDocuments, docs, DateTime.Now.AddYears(1));
}
}
BoardInfo boardInfo = null;
// If there is message board
if (MessageBoardID > 0)
{
// Load message board
boardInfo = Board;
}
else
{
// Create new message board according to webpart properties
boardInfo = new BoardInfo(BoardProperties);
BoardInfoProvider.SetBoardInfo(boardInfo);
// Update information on current message board
MessageBoardID = boardInfo.BoardID;
// Set board-role relationship
BoardRoleInfoProvider.SetBoardRoles(MessageBoardID, BoardProperties.BoardRoles);
// Set moderators
BoardModeratorInfoProvider.SetBoardModerators(MessageBoardID, BoardProperties.BoardModerators);
}
if (boardInfo != null)
{
// If the very new message is inserted
if (MessageID == 0)
{
// If creating message set inserted to now and assign to board
messageInfo.MessageInserted = currentUser.DateTimeNow;
messageInfo.MessageBoardID = MessageBoardID;
// Handle auto approve action
bool isAuthorized = BoardInfoProvider.IsUserAuthorizedToManageMessages(boardInfo);
if (isAuthorized)
{
messageInfo.MessageApprovedByUserID = currentUser.UserID;
messageInfo.MessageApproved = true;
}
else
{
// Is board moderated ?
messageInfo.MessageApprovedByUserID = 0;
messageInfo.MessageApproved = !boardInfo.BoardModerated;
}
}
else
{
if (chkApproved.Checked)
{
// Set current user as approver
messageInfo.MessageApproved = true;
messageInfo.MessageApprovedByUserID = currentUser.UserID;
}
else
{
messageInfo.MessageApproved = false;
messageInfo.MessageApprovedByUserID = 0;
}
}
if (!AdvancedMode)
{
if (!BadWordInfoProvider.CanUseBadWords(MembershipContext.AuthenticatedUser, SiteContext.CurrentSiteName))
{
// Columns to check
Dictionary <string, int> collumns = new Dictionary <string, int>();
collumns.Add("MessageText", 0);
collumns.Add("MessageUserName", 250);
// Perform bad words check
errorMessage = BadWordsHelper.CheckBadWords(messageInfo, collumns, "MessageApproved", "MessageApprovedByUserID",
messageInfo.MessageText, currentUser.UserID, () => { return(ValidateMessage(messageInfo)); });
// Additionally check empty fields
if (errorMessage == string.Empty)
{
if (!ValidateMessage(messageInfo))
{
errorMessage = GetString("board.messageedit.emptybadword");
}
}
}
}
// Subscribe this user to message board
if (chkSubscribe.Checked)
{
string email = messageInfo.MessageEmail;
// Check for duplicate e-mails
DataSet ds = BoardSubscriptionInfoProvider.GetSubscriptions("((SubscriptionApproved = 1) OR (SubscriptionApproved IS NULL)) AND SubscriptionBoardID=" + MessageBoardID +
" AND SubscriptionEmail='" + SecurityHelper.GetSafeQueryString(email, false) + "'", null);
if (DataHelper.DataSourceIsEmpty(ds))
{
BoardSubscriptionInfo bsi = new BoardSubscriptionInfo();
bsi.SubscriptionBoardID = MessageBoardID;
bsi.SubscriptionEmail = email;
if (!currentUser.IsPublic())
{
bsi.SubscriptionUserID = currentUser.UserID;
}
BoardSubscriptionInfoProvider.Subscribe(bsi, DateTime.Now, true, true);
ClearForm();
if (bsi.SubscriptionApproved)
{
LogSubscribingActivity(bsi, boardInfo);
}
}
else
{
errorMessage = GetString("board.subscription.emailexists");
}
}
if (errorMessage == "")
{
try
{
// Save message info
BoardMessageInfoProvider.SetBoardMessageInfo(messageInfo);
LogCommentActivity(messageInfo, boardInfo);
if (BoardProperties.EnableContentRating && (ratingControl != null) && (ratingControl.GetCurrentRating() > 0))
{
LogRatingActivity(ratingControl.CurrentRating);
}
// If the message is not approved let the user know message is waiting for approval
if (messageInfo.MessageApproved == false)
{
ShowError(GetString("board.messageedit.waitingapproval"));
}
// Rise after message saved event
if (OnAfterMessageSaved != null)
{
OnAfterMessageSaved(messageInfo);
}
// Hide message form if user has rated and empty rating is not allowed
if (!BoardProperties.AllowEmptyRating && TreeProvider.HasRated(DocumentContext.CurrentDocument))
{
pnlMessageEdit.Visible = false;
lblAlreadyrated.Visible = true;
}
else
{
// Hide rating form if user has rated
if (BoardProperties.EnableContentRating && (ratingControl != null) && ratingControl.GetCurrentRating() > 0)
{
plcRating.Visible = false;
}
}
// Clear form content
ClearForm();
}
catch (Exception ex)
{
errorMessage = ex.Message;
}
}
}
}
if (!String.IsNullOrEmpty(errorMessage))
{
ShowError(errorMessage);
}
}