public static bool SetCurrentTheme(string theme, bool mobile)
{
if (!WebUtils.CheckRightsForAdminSettingsPage(false))
{
return(false);
}
try
{
if (mobile)
{
BlogSettings.Instance.MobileTheme = theme;
}
else
{
BlogSettings.Instance.Theme = theme;
}
BlogSettings.Instance.Save();
return(true);
}
catch (Exception ex)
{
Utils.Log("Error setting current theme: " + ex.Message);
}
return(false);
}
public static JsonResponse Save(string hdr, string ftr)
{
JsonResponse response = new JsonResponse();
response.Success = false;
if (!WebUtils.CheckRightsForAdminSettingsPage(true))
{
response.Message = "Not authorized";
return(response);
}
try
{
BlogSettings.Instance.HtmlHeader = hdr;
BlogSettings.Instance.TrackingScript = ftr;
BlogSettings.Instance.Save();
}
catch (Exception ex)
{
Utils.Log(string.Format("admin.Settings.HeadTrack.Save(): {0}", ex.Message));
response.Message = string.Format("Could not save settings: {0}", ex.Message);
return(response);
}
response.Success = true;
response.Message = "Settings saved";
return(response);
}
/// <summary>
/// Raises the <see cref="E:System.Web.UI.Control.Init"/> event to initialize the page.
/// </summary>
/// <param name="e">An <see cref="T:System.EventArgs"/> that contains the event data.</param>
protected override void OnInit(EventArgs e)
{
WebUtils.CheckRightsForAdminSettingsPage(false);
infoPanel.Visible = false;
if (BlogSettings.Instance.EnableReferrerTracking)
{
this.BindDays();
this.BindReferrers();
}
else
{
this.ddlDays.Enabled = false;
infoPanel.InnerText = "Referrers disabled. If you want to enable referrer tracking open settings from the link in the top right corner of the page.";
infoPanel.Visible = true;
referrersPanel.Visible = false;
possibleSmapPanel.Visible = false;
}
this.txtNumberOfDays.Text = BlogSettings.Instance.NumberOfReferrerDays.ToString();
this.cbEnableReferrers.Checked = BlogSettings.Instance.EnableReferrerTracking;
this.ddlDays.SelectedIndexChanged += this.DdlDaysSelectedIndexChanged;
this.Page.Title = labels.referrers;
base.OnInit(e);
}
public static JsonResponse Save(string enable, string days)
{
var response = new JsonResponse {
Success = false
};
if (!WebUtils.CheckRightsForAdminSettingsPage(true))
{
response.Message = "Not authorized";
return(response);
}
try
{
BlogSettings.Instance.EnableReferrerTracking = bool.Parse(enable);
BlogSettings.Instance.NumberOfReferrerDays = int.Parse(days);
BlogSettings.Instance.Save();
response.Success = true;
response.Message = string.Format("Settings saved");
return(response);
}
catch (Exception ex)
{
Utils.Log(string.Format("admin.Tracking.referrers.Save(): {0}", ex.Message));
response.Message = string.Format("Could not save settings: {0}", ex.Message);
return(response);
}
}
public static bool ChangePriority(int priority, string ext)
{
if (!WebUtils.CheckRightsForAdminSettingsPage(false))
{
return(false);
}
if (!WebUtils.CheckIfPrimaryBlog(false))
{
return(false);
}
try
{
var x = ExtensionManager.GetExtension(ext);
if (x != null)
{
x.Priority = priority;
ExtensionManager.SaveToStorage(x);
return(true);
}
}
catch (Exception ex)
{
Utils.Log("Error changing priority: " + ex.Message);
}
return(false);
}
public static JsonResponse Save(string name,
string desc,
string postsPerPage,
string themeCookieName,
string useBlogNameInPageTitles,
string enableRelatedPosts,
string enableRating,
string showDescriptionInPostList,
string descriptionCharacters,
string showDescriptionInPostListForPostsByTagOrCategory,
string descriptionCharactersForPostsByTagOrCategory,
string timeStampPostLinks,
string showPostNavigation,
string culture,
string timezone,
string removeFileExtension)
{
var response = new JsonResponse {
Success = false
};
if (!WebUtils.CheckRightsForAdminSettingsPage(true))
{
response.Message = "Not authorized";
return(response);
}
try
{
BlogSettings.Instance.Name = name;
BlogSettings.Instance.Description = desc;
BlogSettings.Instance.PostsPerPage = int.Parse(postsPerPage);
BlogSettings.Instance.ThemeCookieName = themeCookieName;
BlogSettings.Instance.UseBlogNameInPageTitles = bool.Parse(useBlogNameInPageTitles);
BlogSettings.Instance.EnableRelatedPosts = bool.Parse(enableRelatedPosts);
BlogSettings.Instance.EnableRating = bool.Parse(enableRating);
BlogSettings.Instance.ShowDescriptionInPostList = bool.Parse(showDescriptionInPostList);
BlogSettings.Instance.DescriptionCharacters = int.Parse(descriptionCharacters);
BlogSettings.Instance.ShowDescriptionInPostListForPostsByTagOrCategory =
bool.Parse(showDescriptionInPostListForPostsByTagOrCategory);
BlogSettings.Instance.DescriptionCharactersForPostsByTagOrCategory =
int.Parse(descriptionCharactersForPostsByTagOrCategory);
BlogSettings.Instance.TimeStampPostLinks = bool.Parse(timeStampPostLinks);
BlogSettings.Instance.ShowPostNavigation = bool.Parse(showPostNavigation);
BlogSettings.Instance.Culture = culture;
BlogSettings.Instance.Timezone = double.Parse(timezone);
BlogSettings.Instance.RemoveExtensionsFromUrls = bool.Parse(removeFileExtension);
BlogSettings.Instance.Save();
}
catch (Exception ex)
{
Utils.Log(string.Format("admin.Settings.Main.Save(): {0}", ex.Message));
response.Message = string.Format("Could not save settings: {0}", ex.Message);
return(response);
}
response.Success = true;
response.Message = "Settings saved";
return(response);
}
public DashboardController(IDashboardRepository repository)
{
if (!WebUtils.CheckRightsForAdminSettingsPage(true))
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
this.repository = repository;
}
/// <summary>
/// Raises the <see cref="E:System.Web.UI.Control.Init"/> event to initialize the page.
/// </summary>
/// <param name="e">An <see cref="T:System.EventArgs"/> that contains the event data.</param>
protected override void OnInit(EventArgs e)
{
WebUtils.CheckRightsForAdminSettingsPage(false);
BindSettings();
Page.MaintainScrollPositionOnPostBack = true;
Page.Title = labels.settings;
base.OnInit(e);
}
/// <summary>
/// Raises the <see cref="E:System.Web.UI.Control.Init"/> event to initialize the page.
/// </summary>
/// <param name="e">An <see cref="T:System.EventArgs"/> that contains the event data.</param>
protected override void OnInit(EventArgs e)
{
WebUtils.CheckRightsForAdminSettingsPage(false);
BindSettings();
btnSave.Click += BtnSaveClick;
btnSave.Text = string.Format("{0} {1}", labels.save, labels.settings);
Page.Title = labels.controls;
base.OnInit(e);
}
public static IEnumerable LoadGalleryPage(string pkgType, int page, PackageManager.OrderType sortOrder, string searchVal)
{
if (!WebUtils.CheckRightsForAdminSettingsPage(false))
{
return(null);
}
if (!WebUtils.CheckIfPrimaryBlog(false))
{
return(null);
}
return(JsonPackages.GetPage(pkgType, page, sortOrder, searchVal));
}
public static JsonResponse UninstallPackage(string pkgId)
{
if (!WebUtils.CheckRightsForAdminSettingsPage(false))
{
return(null);
}
if (!WebUtils.CheckIfPrimaryBlog(false))
{
return(null);
}
return(Installer.UninstallPackage(pkgId));
}
public static IEnumerable LoadGalleryPager()
{
if (!WebUtils.CheckRightsForAdminSettingsPage(false))
{
return(null);
}
if (!WebUtils.CheckIfPrimaryBlog(false))
{
return(null);
}
return(Gallery.GalleryPager == null ? null : Gallery.GalleryPager.PageItems);
}
public static IEnumerable LoadGalleryPage(string pkgType, int page, Gallery.OrderType sortOrder, string searchVal)
{
if (!WebUtils.CheckRightsForAdminSettingsPage(false))
{
return(null);
}
if (!WebUtils.CheckIfPrimaryBlog(false))
{
return(null);
}
return(PackageRepository.FromGallery(pkgType, page, sortOrder, searchVal));
}
protected void Page_Load(object sender, EventArgs e)
{
WebUtils.CheckRightsForAdminSettingsPage(false);
if (!IsPostBack)
{
BindSettings();
}
Page.MaintainScrollPositionOnPostBack = true;
Page.Title = Resources.labels.comments;
btnSave.Click += btnSave_Click;
btnSave.Text = Resources.labels.saveSettings;
}
/// <summary>
/// Handles the Load event of the Page control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
protected void Page_Load(object sender, EventArgs e)
{
WebUtils.CheckRightsForAdminSettingsPage(false);
if (!Page.IsPostBack)
{
BindGrid();
}
grid.RowEditing += grid_RowEditing;
grid.RowUpdating += grid_RowUpdating;
grid.RowCancelingEdit += delegate { Response.Redirect(Request.RawUrl); };
grid.RowDeleting += grid_RowDeleting;
btnAdd.Click += btnAdd_Click;
btnAdd.Text = Resources.labels.add + " ping service";
}
protected void Page_Load(object sender, EventArgs e)
{
WebUtils.CheckRightsForAdminSettingsPage(false);
if (!Page.IsPostBack)
{
BindSettings();
BindBlogroll();
}
btnSaveSettings.Text = Resources.labels.save + " " + Resources.labels.settings.ToLowerInvariant();
btnSave.Click += new EventHandler(btnSave_Click);
btnSaveSettings.Click += new EventHandler(btnSaveSettings_Click);
Page.Title = Resources.labels.blogroll;
btnSave.Text = Resources.labels.add;
}
public static bool UpdateExtensionSourceCode(string sourceCode, string extensionName)
{
if (!WebUtils.CheckRightsForAdminSettingsPage(false))
{
return(false);
}
if (!WebUtils.CheckIfPrimaryBlog(false))
{
return(false);
}
if (string.IsNullOrWhiteSpace(extensionName))
{
return(false);
}
var ext = ExtensionManager.GetExtension(extensionName);
if (ext == null)
{
return(false);
}
string extensionFilename = ext.GetPathAndFilename(true);
if (string.IsNullOrWhiteSpace(extensionFilename))
{
return(false);
}
try
{
using (var f = File.CreateText(extensionFilename))
{
f.Write(sourceCode);
f.Close();
return(true);
}
}
catch (Exception ex)
{
Utils.Log("Error saving source code: " + ex.Message);
return(false);
}
}
public static JsonResponse Save(
string email,
string smtpServer,
string smtpServerPort,
string smtpUserName,
string smtpPassword,
string sendMailOnComment,
string enableSsl,
string emailSubjectPrefix)
{
var response = new JsonResponse {
Success = false
};
if (!WebUtils.CheckRightsForAdminSettingsPage(true))
{
response.Message = "Not authorized";
return(response);
}
try
{
BlogSettings.Instance.Email = email;
BlogSettings.Instance.SmtpServer = smtpServer;
BlogSettings.Instance.SmtpServerPort = int.Parse(smtpServerPort);
BlogSettings.Instance.SmtpUserName = smtpUserName;
BlogSettings.Instance.SmtpPassword = smtpPassword;
BlogSettings.Instance.SendMailOnComment = bool.Parse(sendMailOnComment);
BlogSettings.Instance.EnableSsl = bool.Parse(enableSsl);
BlogSettings.Instance.EmailSubjectPrefix = emailSubjectPrefix;
BlogSettings.Instance.Save();
}
catch (Exception ex)
{
Utils.Log(string.Format("admin.Settings.Email.Save(): {0}", ex.Message));
response.Message = string.Format("Could not save settings: {0}", ex.Message);
return(response);
}
response.Success = true;
response.Message = "Settings saved";
return(response);
}
protected void Page_Load(object sender, EventArgs e)
{
WebUtils.CheckRightsForAdminSettingsPage(false);
Filters = ExtensionManager.GetSettings("MetaExtension", "BeCommentFilters");
if (!IsPostBack)
{
BindFilters();
}
Page.MaintainScrollPositionOnPostBack = true;
Page.Title = Resources.labels.comments;
btnSave.Click += btnSave_Click;
btnSave.Text = Resources.labels.saveSettings;
btnSave2.Click += btnSave_Click;
btnSave2.Text = Resources.labels.saveSettings;
}
public static JsonResponse TestSmtp(
string email,
string smtpServer,
string smtpServerPort,
string smtpUserName,
string smtpPassword,
string sendMailOnComment,
string enableSsl,
string emailSubjectPrefix
)
{
var response = new JsonResponse {
Success = false
};
StringBuilder errorMsg = new StringBuilder();
if (!WebUtils.CheckRightsForAdminSettingsPage(true))
{
response.Message = "Not authorized";
return(response);
}
try
{
var mail = new MailMessage
{
From = new MailAddress(email, smtpUserName),
Subject = string.Format("Test mail from {0}", smtpUserName),
IsBodyHtml = true
};
mail.To.Add(mail.From);
var body = new StringBuilder();
body.Append("<div style=\"font: 11px verdana, arial\">");
body.Append("Success");
if (HttpContext.Current != null)
{
body.Append(
"<br /><br />_______________________________________________________________________________<br /><br />");
body.AppendFormat("<strong>IP address:</strong> {0}<br />", HttpContext.Current.Request.UserHostAddress);
body.AppendFormat("<strong>User-agent:</strong> {0}", HttpContext.Current.Request.UserAgent);
}
body.Append("</div>");
mail.Body = body.ToString();
string error = Utils.SendMailMessage(mail);
if (!string.IsNullOrEmpty(error))
{
errorMsg.Append(error);
}
}
catch (Exception ex)
{
Exception current = ex;
while (current != null)
{
if (errorMsg.Length > 0)
{
errorMsg.Append(" ");
}
errorMsg.Append(current.Message);
current = current.InnerException;
}
}
if (errorMsg.Length > 0)
{
response.Message = string.Format("Error: {0}", errorMsg.ToString());
return(response);
}
response.Success = true;
response.Message = "Test successful";
return(response);
}
public static JsonResponse Save(bool enableCompression,
bool enableOptimization,
bool compressWebResource,
bool enableOpenSearch,
bool requireSslForMetaWeblogApi,
string wwwSubdomain,
/*bool enableTrackBackSend,
* bool enableTrackBackReceive,
* bool enablePingBackSend,
* bool enablePingBackReceive,*/
bool enableErrorLogging,
bool allowRemoteFileDownloads,
int remoteTimeout,
int remoteMaxFileSize,
string galleryFeedUrl,
string enablePasswordReset,
string enableSelfRegistration,
string selfRegistrationInitialRole)
{
var response = new JsonResponse {
Success = false
};
var settings = BlogSettings.Instance;
if (!WebUtils.CheckRightsForAdminSettingsPage(true))
{
response.Message = "Not authorized";
return(response);
}
try
{
// Validate values before setting any of them to the BlogSettings instance.
// Because it's a singleton, we don't want partial data being stored to
// it if there's any exceptions thrown prior to saving.
if (remoteTimeout < 0)
{
throw new ArgumentOutOfRangeException("RemoteFileDownloadTimeout must be greater than or equal to 0 milliseconds.");
}
else if (remoteMaxFileSize < 0)
{
throw new ArgumentOutOfRangeException("RemoteMaxFileSize must be greater than or equal to 0 bytes.");
}
settings.EnableHttpCompression = enableCompression;
settings.EnableOptimization = enableOptimization;
settings.CompressWebResource = compressWebResource;
settings.EnableOpenSearch = enableOpenSearch;
settings.RequireSslMetaWeblogApi = requireSslForMetaWeblogApi;
settings.HandleWwwSubdomain = wwwSubdomain;
settings.EnableErrorLogging = enableErrorLogging;
settings.GalleryFeedUrl = galleryFeedUrl;
settings.AllowServerToDownloadRemoteFiles = allowRemoteFileDownloads;
settings.RemoteFileDownloadTimeout = remoteTimeout;
settings.RemoteMaxFileSize = remoteMaxFileSize;
settings.EnablePasswordReset = bool.Parse(enablePasswordReset);
settings.EnableSelfRegistration = bool.Parse(enableSelfRegistration);
settings.SelfRegistrationInitialRole = selfRegistrationInitialRole;
settings.Save();
}
catch (Exception ex)
{
Utils.Log(string.Format("admin.Settings.Advanced.Save(): {0}", ex.Message));
response.Message = string.Format("Could not save settings: {0}", ex.Message);
return(response);
}
response.Success = true;
response.Message = "Settings saved";
return(response);
}
public static JsonResponse Save(
string syndicationFormat,
string postsPerFeed,
string dublinCoreCreator,
string feedemail,
string dublinCoreLanguage,
string geocodingLatitude,
string geocodingLongitude,
string blogChannelBLink,
string alternateFeedUrl,
string enableEnclosures)
{
var response = new JsonResponse {
Success = false
};
if (!WebUtils.CheckRightsForAdminSettingsPage(true))
{
response.Message = "Not authorized";
return(response);
}
try
{
BlogSettings.Instance.SyndicationFormat = syndicationFormat;
BlogSettings.Instance.PostsPerFeed = int.Parse(postsPerFeed, CultureInfo.InvariantCulture);
BlogSettings.Instance.AuthorName = dublinCoreCreator;
BlogSettings.Instance.FeedAuthor = feedemail;
BlogSettings.Instance.Language = dublinCoreLanguage;
float latitude;
BlogSettings.Instance.GeocodingLatitude = Single.TryParse(
geocodingLatitude.Replace(",", "."),
NumberStyles.Any,
CultureInfo.InvariantCulture,
out latitude) ? latitude : Single.MinValue;
float longitude;
BlogSettings.Instance.GeocodingLongitude = Single.TryParse(
geocodingLongitude.Replace(",", "."),
NumberStyles.Any,
CultureInfo.InvariantCulture,
out longitude) ? longitude : Single.MinValue;
BlogSettings.Instance.Endorsement = blogChannelBLink;
if (alternateFeedUrl.Trim().Length > 0 && !alternateFeedUrl.Contains("://"))
{
alternateFeedUrl = string.Format("http://{0}", alternateFeedUrl);
}
BlogSettings.Instance.AlternateFeedUrl = alternateFeedUrl;
BlogSettings.Instance.EnableEnclosures = bool.Parse(enableEnclosures);
BlogSettings.Instance.Save();
}
catch (Exception ex)
{
Utils.Log(string.Format("admin.Settings.Feed.Save(): {0}", ex.Message));
response.Message = string.Format("Could not save settings: {0}", ex.Message);
return(response);
}
response.Success = true;
response.Message = "Settings saved";
return(response);
}
protected void Page_Load(object sender, EventArgs e)
{
WebUtils.CheckRightsForAdminSettingsPage(false);
}
public static string LoadPager(int page)
{
WebUtils.CheckRightsForAdminSettingsPage(false);
return(JsonTrashList.GetPager(page));
}
