//public ViewMode Mode { get; set; }
protected void AddItem_Click(object sender, EventArgs e)
{
var field = GetField();
var media = MediasMapper.GetByID(field.MediaDetail.MediaID);
var fieldAssociation = new FieldAssociation();
fieldAssociation.MediaDetail = (MediaDetail)PagesMapper.CreateObject(MediaTypeID, MediasMapper.CreateObject(), media);
fieldAssociation.MediaDetail.SectionTitle = fieldAssociation.MediaDetail.ShortDescription = fieldAssociation.MediaDetail.MainContent = fieldAssociation.MediaDetail.LinkTitle;
fieldAssociation.MediaDetail.PathToFile = "/media/images/icons/File.jpg";
fieldAssociation.MediaDetail.PublishDate = DateTime.Now;
fieldAssociation.MediaDetail.CreatedByUserID = fieldAssociation.MediaDetail.LastUpdatedByUserID = FrameworkSettings.CurrentUser.ID;
fieldAssociation.MediaDetail.CachedVirtualPath = fieldAssociation.MediaDetail.CalculatedVirtualPath();
fieldAssociation.MediaDetail.LanguageID = AdminBasePage.CurrentLanguage.ID;
fieldAssociation.MediaDetail.UseDefaultLanguageLayouts = false;
var mediaType = MediaTypesMapper.GetByID(fieldAssociation.MediaDetail.MediaTypeID);
if (mediaType != null)
{
fieldAssociation.MediaDetail.UseMediaTypeLayouts = mediaType.UseMediaTypeLayouts;
}
field.FieldAssociations.Add(fieldAssociation);
var returnObj = BaseMapper.SaveDataModel();
BindValues();
}
protected void Page_PreRender(object sender, EventArgs e)
{
var items = MediasMapper.GetDataModel().AllMedia.Where(i => i.ParentMediaID == null).OrderBy(i => i.OrderIndex);
ListView.DataSource = items;
ListView.DataBind();
}
public string HandleNodeDragDrop(long sourceMediaId, long parentMediaId, int newPosition)
{
var sourceMedia = BaseMapper.GetObjectFromContext(MediasMapper.GetByID(sourceMediaId));
var parentMedia = BaseMapper.GetObjectFromContext(MediasMapper.GetByID(parentMediaId));
UserMustHaveAccessTo(sourceMedia.GetLiveMediaDetail());
var oldParentId = sourceMedia.ParentMediaID;
sourceMedia.MoveToIndex(newPosition);
sourceMedia.ParentMedia = parentMedia;
if (oldParentId != parentMedia.ID)
{
foreach (var item in sourceMedia.MediaDetails)
{
item.CachedVirtualPath = item.CalculatedVirtualPath();
}
}
var returnObj = MediasMapper.Update(sourceMedia);
return(returnObj.ToJson());
}
public void UpdateFieldsFromObject()
{
MediaDetailID.Text = selectedItem.ID.ToString();
MediaID.Text = selectedItem.MediaID.ToString();
Handler.SetValue(selectedItem.Handler);
MediaTypeID.Text = selectedItem.MediaTypeID.ToString();
MediaType.Text = MediaTypesMapper.GetByID(selectedItem.MediaTypeID).Name.ToString();
EnableCaching.Checked = selectedItem.EnableCaching;
if (selectedItem.LastUpdatedByUserID != 0)
{
LastModifiedByUser.Text = UsersMapper.GetByID(selectedItem.LastUpdatedByUserID).UserName;
}
if (selectedItem.CreatedByUserID != 0)
{
CreatedByUser.Text = UsersMapper.GetByID(selectedItem.CreatedByUserID).UserName;
}
if (selectedItem.ID != 0)
{
OrderIndex.Text = MediasMapper.GetByMediaDetail(selectedItem).OrderIndex.ToString();
}
MasterPageSelector.SelectedValue = selectedItem.MasterPageID.ToString();
}
public void GetByMediaID(long id)
{
string json = "";
var mediaDetail = MediasMapper.GetByID(id).GetLiveMediaDetail() as MediaDetail;
json = JsonConvert.SerializeObject(mediaDetail.GetFieldValuePairs());
WriteJSON(json);
}
public void GetField(long id, string fieldCode)
{
string json = "";
var field = MediasMapper.GetByID(id).GetLiveMediaDetail()?.LoadField(fieldCode);
json = field.ToJson(3);
WriteJSON(json);
}
private void HandleDeletePermanently(Media item)
{
if (!FrameworkSettings.CurrentUser.HasPermission(PermissionsEnum.Delete))
{
throw new Exception("You do not have the appropriate permissions to delete items permanently");
}
if (item == null)
{
return;
}
MediaDetail detail = (MediaDetail)GetAtleastOneByMedia(item);
Media parentMedia = null;
if (item.ParentMediaID != null)
{
parentMedia = MediasMapper.GetByID((long)item.ParentMediaID);
}
Return returnObj = BaseMapper.GenerateReturn("No action performed");
if (detail == null)
{
if (item.ChildMedias.Count == 0)
{
returnObj = MediasMapper.DeletePermanently(item);
}
}
else
{
item = BaseMapper.GetObjectFromContext(item);
if ((item.MediaDetails.Count == 1) && (item.ChildMedias.Count > 0))
{
throw new Exception("You cannot delete this item because it has child items");
}
detail = BaseMapper.GetObjectFromContext(detail);
returnObj = MediaDetailsMapper.DeletePermanently(detail);
if (!returnObj.IsError)
{
ContextHelper.ClearAllMemoryCache();
detail.RemoveFromCache();
}
}
}
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
if (renderParentNav)
{
Media parentMedia = null;
if (this.BasePage.CurrentMedia.ParentMediaID != null)
{
parentMedia = MediasMapper.GetByID((long)this.BasePage.CurrentMedia.ParentMediaID);
}
if (parentMedia == null)
{
return;
}
var children = MediaDetailsMapper.FilterByMediaTypeShowInMenuStatus(MediaDetailsMapper.FilterByShowInMenuStatus(MediaDetailsMapper.FilterByCanRenderStatus(MediaDetailsMapper.GetAllChildMediaDetails(parentMedia.ID, this.BasePage.CurrentLanguage.ID), true), true), true);
if (children.Count() > 0)
{
GenerateNav.RootMedia = parentMedia;
}
else
{
if (parentMedia.ParentMediaID == null)
{
return;
}
parentMedia = MediasMapper.GetByID((long)parentMedia.ParentMediaID);
//if ((parentMedia != null) && (parentMedia.ID != FrameworkSettings.RootMedia.ID))
if (parentMedia != null)
{
GenerateNav.RootMedia = parentMedia;
}
}
}
else
{
GenerateNav.RootMedia = this.BasePage.CurrentMedia;
}
}
private void BindItems()
{
if (ParentMediaID == 0 && MediaTypeID == 0)
{
ParentMediaID = AdminBasePage.SelectedMedia.ID;
}
var parentMedia = MediasMapper.GetByID(ParentMediaID);
IEnumerable <IMediaDetail> mediaDetailItems = new List <IMediaDetail>();
if (parentMedia != null)
{
var liveMediaDetail = parentMedia.GetLiveMediaDetail();
if (MediaTypeID > 0)
{
mediaDetailItems = liveMediaDetail.ChildMediaDetails.Where(i => i.MediaTypeID == MediaTypeID && i.HistoryVersionNumber == 0 && i.MediaType.ShowInSiteTree && !i.IsDeleted);
}
else
{
mediaDetailItems = liveMediaDetail.ChildMediaDetails.Where(i => i.HistoryVersionNumber == 0 && i.MediaType.ShowInSiteTree && !i.IsDeleted);
}
}
else
{
if (MediaTypeID > 0)
{
mediaDetailItems = BaseMapper.GetDataModel().MediaDetails.Where(i => i.MediaTypeID == MediaTypeID && i.HistoryVersionNumber == 0 && i.MediaType.ShowInSiteTree && !i.IsDeleted);
}
}
if (ShowInMenu != ShowStatus.Any)
{
mediaDetailItems = mediaDetailItems.Where(i => i.ShowInMenu == bool.Parse(ShowInMenu.ToString()));
}
ItemsList.DataSource = mediaDetailItems.ToList();
ItemsList.DataTextField = "SectionTitle";
ItemsList.DataValueField = "ID";
ItemsList.DataBind();
}
private void Bind()
{
if (selectedItem == null)
{
return;
}
var details = new List <IMediaDetail>();
var medias = MediasMapper.GetByTag(selectedItem);
foreach (Media media in medias)
{
IMediaDetail detail = MediaDetailsMapper.GetByMedia(media, AdminBasePage.CurrentLanguage);
if (detail != null)
{
details.Add(detail);
}
}
this.ItemList.DataSource = details;
this.ItemList.DataBind();
}
protected void Page_Init(object sender, EventArgs e)
{
var mediaDetail = BasePage.CurrentMediaDetail;
if (MediaID != 0)
{
mediaDetail = MediasMapper.GetByID(MediaID)?.GetLiveMediaDetail();
}
if (mediaDetail != null)
{
if (string.IsNullOrEmpty(PropertyName))
{
PropertyName = "{UseMainLayout}";
}
else
{
PropertyName = "{" + PropertyName + "}";
}
DynamicContent.Controls.Add(this.ParseControl(MediaDetailsMapper.ParseSpecialTags(mediaDetail, PropertyName)));
}
}
public string GetDataJson()
{
var media = MediasMapper.GetByID(ParentMediaID);
var autoSuggestList = new List <AutoSuggest>();
IEnumerable <IMediaDetail> mediaDetailItems = new List <IMediaDetail>();
if (media != null)
{
var liveMediaDetail = media.GetLiveMediaDetail();
if (MediaTypeID > 0)
{
mediaDetailItems = liveMediaDetail.ChildMediaDetails.Where(i => i.MediaTypeID == MediaTypeID && i.HistoryVersionNumber == 0 && i.MediaType.ShowInSiteTree && !i.IsDeleted);
}
else
{
mediaDetailItems = liveMediaDetail.ChildMediaDetails.Where(i => i.HistoryVersionNumber == 0 && i.MediaType.ShowInSiteTree && !i.IsDeleted);
}
}
else
{
if (MediaTypeID > 0)
{
mediaDetailItems = BaseMapper.GetDataModel().MediaDetails.Where(i => i.MediaTypeID == MediaTypeID && i.HistoryVersionNumber == 0 && i.MediaType.ShowInSiteTree && !i.IsDeleted);
}
}
if (ShowInMenu != ShowStatus.Any)
{
mediaDetailItems = mediaDetailItems.Where(i => i.ShowInMenu == bool.Parse(ShowInMenu.ToString()));
}
autoSuggestList = GetAutoSuggestList(mediaDetailItems);
return(StringHelper.ObjectToJson(autoSuggestList));
}
public IHttpHandler GetHttpHandler(RequestContext requestContext)
{
RedisCacheHelper.SetRedisCacheConnectionString(AppSettings.RedisCacheConnectionString);
FileCacheHelper.SetFileSystemCacheDirPath(AppSettings.FileSystemCacheDirPath);
virtualPath = URIHelper.GetCurrentVirtualPath().ToLower();
var queryString = HttpContext.Current.Request.QueryString.ToString();
queryString = System.Web.HttpUtility.UrlDecode(queryString);
if (!Request.Path.EndsWith("/") || ((virtualPath != "~/") && (!virtualPath.EndsWith("/"))))
{
var path = Request.Path + "/";
if (!string.IsNullOrEmpty(queryString))
{
path = path + "?" + queryString;
}
HttpContext.Current.Response.RedirectPermanent(path);
}
Settings cmsSettings = null;
bool isAttemptingAdminLogin = false;
if ((virtualPath != "~/login/") && (virtualPath != "~/admin/") && string.IsNullOrEmpty(Request.QueryString["format"]))
{
cmsSettings = SettingsMapper.GetSettings();
if (cmsSettings != null)
{
var isSiteOnline = cmsSettings.IsSiteOnline();
if (isSiteOnline)
{
if (virtualPath.Contains(cmsSettings.SiteOfflineUrl))
{
Response.Redirect("~/");
}
AttemptToLoadFromCache();
}
else
{
if (!virtualPath.Contains(cmsSettings.SiteOfflineUrl))
{
Response.Redirect(cmsSettings.SiteOfflineUrl);
}
}
}
else
{
AttemptToLoadFromCache();
}
}
else
{
isAttemptingAdminLogin = true;
}
var languageSegment = FrameworkSettings.GetCurrentLanguage().UriSegment;
if (LanguagesMapper.GetAllActive().Count() > 1 && !Request.Url.PathAndQuery.Contains($"/{languageSegment}/"))
{
var url = URIHelper.ConvertToAbsUrl("/" + languageSegment + Request.Url.PathAndQuery);
Response.RedirectPermanent(url, true);
}
var segments = URIHelper.GetUriSegments(virtualPath).ToList();
string firstSegment = "";
if (segments.Count > 0)
{
firstSegment = segments[0];
var language = LanguagesMapper.GetAllActive().SingleOrDefault(i => i.UriSegment == firstSegment);
if (language != null)
{
FrameworkSettings.SetCurrentLanguage(language);
}
}
if (!isAttemptingAdminLogin && AppSettings.EnableUrlRedirectRules)
{
var path = virtualPath;
if (!string.IsNullOrEmpty(queryString))
{
path = path + "?" + queryString;
}
var redirectRule = UrlRedirectRulesMapper.GetRuleForUrl(path);
if (redirectRule != null)
{
var newUrl = redirectRule.RedirectToUrl;
if (newUrl.Contains("{"))
{
newUrl = MediaDetailsMapper.ParseSpecialTags(redirectRule, newUrl);
}
newUrl = URIHelper.ConvertToAbsUrl(newUrl);
var possibleLoopRules = UrlRedirectRulesMapper.GetRulesFromUrl(URIHelper.ConvertAbsUrlToTilda(newUrl));
var foundActiveVirtualPath = MediaDetailsMapper.GetByVirtualPath(path);
if (possibleLoopRules.Any())
{
foreach (var rule in possibleLoopRules)
{
var returnObj = MediaDetailsMapper.DeletePermanently(rule);
}
}
if (foundActiveVirtualPath != null)
{
var returnObj = MediaDetailsMapper.DeletePermanently(redirectRule);
}
if (Request.QueryString.Count > 0)
{
newUrl += "?" + Request.QueryString;
}
if (redirectRule.Is301Redirect)
{
Response.RedirectPermanent(newUrl);
}
else
{
Response.Redirect(newUrl);
}
}
}
if (!File.Exists(HttpContext.Current.Server.MapPath(virtualPath)) && !virtualPath.Contains(ParserHelper.OpenToken) && !virtualPath.Contains(ParserHelper.CloseToken))
{
string viewPath = "";
long mediaDetailId = 0;
long.TryParse(requestContext.HttpContext.Request["MediaDetailID"], out mediaDetailId);
long mediaId = 0;
long.TryParse(requestContext.HttpContext.Request["MediaID"], out mediaId);
MediaDetail detail = null;
if (mediaDetailId == 0 && mediaId == 0)
{
FrameworkSettings.Current = FrameworkBaseMedia.GetInstanceByVirtualPath(virtualPath, true);
detail = (MediaDetail)FrameworkSettings.Current.CurrentMediaDetail;
}
else if (mediaDetailId != 0)
{
var mediaDetail = MediaDetailsMapper.GetByID(mediaDetailId);
FrameworkSettings.Current = FrameworkBaseMedia.GetInstanceByMediaDetail(mediaDetail);
detail = (MediaDetail)FrameworkSettings.Current.CurrentMediaDetail;
}
else if (mediaId != 0)
{
var media = MediasMapper.GetByID(mediaId);
FrameworkSettings.Current = FrameworkBaseMedia.GetInstanceByMedia(media);
detail = (MediaDetail)FrameworkSettings.Current.CurrentMediaDetail;
}
/*if (detail != null && !detail.CanUserAccessSection(FrameworkSettings.CurrentUser))
* {
* FormsAuthentication.RedirectToLoginPage();
* }*/
/*if (detail != null)
* {
* var absUrlBase = URIHelper.ConvertAbsUrlToTilda(detail.AbsoluteUrl).Replace("~", "");
* var absPathBase = URIHelper.ConvertAbsUrlToTilda(Request.Url.AbsolutePath).Replace("~", "");
*
* if (absUrlBase != absPathBase)
* {
* Response.Redirect(detail.AbsoluteUrl + Request.Url.Query);
* }
* }*/
if (detail != null)
{
if (detail.ForceSSL || AppSettings.ForceSSL)
{
URIHelper.ForceSSL();
}
}
else
{
var currentLanguageId = FrameworkSettings.GetCurrentLanguage().ID;
var historyVersion = BaseMapper.GetDataModel().MediaDetails.FirstOrDefault(i => i.LanguageID == currentLanguageId && i.CachedVirtualPath == virtualPath && i.MediaType.ShowInSiteTree && i.HistoryVersionNumber != 0 && i.HistoryForMediaDetail != null);
if (historyVersion != null && historyVersion.VirtualPath != historyVersion.HistoryForMediaDetail.VirtualPath)
{
var foundRedirectUrl = UrlRedirectRulesMapper.GetRuleForUrl(virtualPath);
if (foundRedirectUrl == null)
{
var urlRedirectRule = UrlRedirectRulesMapper.CreateUrlRedirect(virtualPath, historyVersion.HistoryForMediaDetail.Media);
if (urlRedirectRule != null)
{
var returnObj = UrlRedirectRulesMapper.Insert(urlRedirectRule);
HttpContext.Current.Response.RedirectPermanent(historyVersion.HistoryForMediaDetail.CachedVirtualPath);
}
else
{
HttpContext.Current.Response.RedirectPermanent("/");
}
}
}
else
{
HttpContext.Current.Response.RedirectPermanent("/");
}
}
if ((detail == null) || (!IsValidRequest(detail)))
{
detail = null;
if (cmsSettings != null)
{
if (!string.IsNullOrEmpty(cmsSettings.PageNotFoundUrl))
{
ErrorHelper.LogException(new Exception($"Page Not Found: {virtualPath}"));
Response.Redirect(cmsSettings.PageNotFoundUrl);
/*FrameworkSettings.CurrentFrameworkBaseMedia = null;
*
* FrameworkSettings.CurrentFrameworkBaseMedia = FrameworkBaseMedia.GetInstanceByVirtualPath(cmsSettings.PageNotFoundUrl, true);
* detail = (MediaDetail)FrameworkSettings.CurrentFrameworkBaseMedia.CurrentMediaDetail;
*
* ErrorHelper.LogException(new Exception($"Page Not Found: {virtualPath}"));*/
//Response.StatusCode = 301;
}
}
}
if (detail != null)
{
var draft = detail.GetLatestDraft();
if (draft != null && (draft.PublishDate - detail.PublishDate) > TimeSpan.FromSeconds(10) && draft.CanRender)
{
var returnObj = draft.PublishLive();
if (!returnObj.IsError)
{
detail.RemoveFromCache();
draft.RemoveFromCache();
FrameworkSettings.Current = FrameworkBaseMedia.GetInstanceByMediaDetail(draft);
detail = (MediaDetail)FrameworkSettings.Current.CurrentMediaDetail;
}
}
if (detail.RedirectToFirstChild)
{
var child = detail.ChildMediaDetails.FirstOrDefault();
if (child != null)
{
var redirectPath = child.AutoCalculatedVirtualPath;
if (!string.IsNullOrEmpty(queryString))
{
redirectPath = redirectPath + "?" + queryString;
}
HttpContext.Current.Response.Redirect(redirectPath);
}
}
viewPath = FrameworkSettings.Current.CurrentMediaDetail.Handler;
if ((viewPath == null) || (viewPath.Trim() == ""))
{
viewPath = MediaTypesMapper.GetByID(FrameworkSettings.Current.CurrentMediaDetail.MediaTypeID).MediaTypeHandler;
}
viewPath = URIHelper.ConvertAbsUrlToTilda(viewPath);
if (!string.IsNullOrEmpty(Request.QueryString["format"]))
{
FrontEndBasePage.HandleFormatQueryString(detail, Request.QueryString["format"], Request.QueryString["depth"]);
}
return(CreateInstanceFromVirtualPath(viewPath, typeof(BasePage)));
}
}
return(new DefaultHttpHandler());
}
public Return FieldFrontEndFormSubmissionHandler(long fieldId)
{
var returnObj = BaseMapper.GenerateReturn("No action performed");
if (HttpContext.Current.Request.Form["fieldId"] == null)
{
returnObj = BaseMapper.GenerateReturn("'fieldId' is missing");
return(returnObj);
}
var field = (MediaDetailField)FieldsMapper.GetByID(fieldId);
if (field == null)
{
returnObj = BaseMapper.GenerateReturn($"Cannot find field with id '{fieldId}'");
return(returnObj);
}
var FormDictionary = new Dictionary <string, string>();
foreach (string key in HttpContext.Current.Request.Form.Keys)
{
var value = HttpContext.Current.Request.Form[key];
if (value.Contains(","))
{
value = "\"" + value + "\"";
}
FormDictionary.Add(key, value);
}
FormDictionary.Add("DateSubmitted", StringHelper.FormatDateTime(DateTime.Now));
var currentEntries = StringHelper.JsonToObject <Newtonsoft.Json.Linq.JArray>(field.FrontEndSubmissions);
var files = new Dictionary <string, List <string> >();
var fileIndex = 0;
foreach (string key in HttpContext.Current.Request.Files)
{
var postedFile = HttpContext.Current.Request.Files[fileIndex];
var uploadFolder = MediaDetailField.GetUploadFolder(field);
if (!uploadFolder.Exists)
{
uploadFolder.Create();
}
var fieldName = postedFile.FileName.ToLower().Replace(" ", "-");
var uploadFilePath = uploadFolder.FullName + key + "_" + fieldName;
postedFile.SaveAs(uploadFilePath);
var relativePath = URIHelper.ConvertAbsPathToAbsUrl(uploadFilePath);
if (files.ContainsKey(key))
{
files[key].Add(relativePath);
}
else
{
files.Add(key, new List <string>()
{
relativePath
});
}
fileIndex++;
}
var jObjectUploadFiles = JObject.Parse(StringHelper.ObjectToJson(files));
var jsonEntry = new JavaScriptSerializer().Serialize(FormDictionary);
var jObject = JObject.Parse(jsonEntry);
jObject.Merge(jObjectUploadFiles);
if (currentEntries == null)
{
currentEntries = new JArray();
currentEntries.Add(jObject);
}
else
{
currentEntries.Add(jObject);
}
field.FrontEndSubmissions = currentEntries.ToString(Formatting.None);
returnObj = FieldsMapper.Update(field);
var formFieldSettings = StringHelper.JsonToObject <FormFieldSettings>(field.FieldSettings);
if (formFieldSettings != null && !string.IsNullOrEmpty(formFieldSettings.EmailTemplateMediaID) && long.TryParse(formFieldSettings.EmailTemplateMediaID, out long i))
{
var media = MediasMapper.GetByID(long.Parse(formFieldSettings.EmailTemplateMediaID));
if (media != null)
{
var layout = MediaDetailsMapper.ParseSpecialTags(media.GetLiveMediaDetail());
var parsedLayout = ParserHelper.ParseData(layout, jObject);
EmailHelper.Send(AppSettings.SystemEmailAddress, EmailHelper.GetMailAddressesFromString(formFieldSettings.EmailAddress), formFieldSettings.Subject, parsedLayout, (AppSettings.AttemptSMTPMailer)? EmailHelper.EmailMode.Both : EmailHelper.EmailMode.Direct);
}
}
return(returnObj);
}
//private void ChangeLinksForAllMediaDetails(string oldAbsoluteUrl, string newAbsoluteUrl)
//{
// if (string.IsNullOrEmpty(oldAbsoluteUrl) || oldAbsoluteUrl == newAbsoluteUrl)
// return;
// var oldTemplateVarUrl = ParserHelper.ParseData(oldAbsoluteUrl, this.TemplateVars, true);
// var newTemplateVarUrl = ParserHelper.ParseData(newAbsoluteUrl, this.TemplateVars, true);
// var foundItems = MediaDetailsMapper.GetDataModel().MediaDetails.Where(i => i.MainContent.Contains(oldTemplateVarUrl) || i.ShortDescription.Contains(oldTemplateVarUrl));
// if (foundItems.Any())
// {
// foreach (var item in foundItems)
// {
// item.ShortDescription = item.ShortDescription.Replace(oldTemplateVarUrl, newTemplateVarUrl);
// item.MainContent = item.MainContent.Replace(oldTemplateVarUrl, newTemplateVarUrl);
// }
// var numberOfItemsEffected = MediaDetailsMapper.GetDataModel().SaveChanges();
// }
//}
protected void Save_OnClick(object sender, EventArgs e)
{
if (CanAccessItem != null && CanAccessItem.IsError)
{
DisplayErrorMessage("Error saving item", CanAccessItem.Error);
return;
}
if (!CurrentUser.HasPermission(PermissionsEnum.Publish))
{
DisplayErrorMessage("Error saving item", ErrorHelper.CreateError(new Exception("You do not have the appropriate permissions to save items")));
return;
}
string commandArgument = ((LinkButton)sender).CommandArgument;
bool isDraft = false;
if (commandArgument == "CreateDraft")
{
isDraft = true;
}
IMediaDetail history = CreateHistory(isDraft);
Return returnObj = BaseMapper.GenerateReturn();
if ((history != null) && (history.IsDraft))
{
history.CopyFrom(selectedItem);
UpdateObjectFromFields(history);
history.IsDraft = isDraft;
returnObj = SaveHistory(history);
if (returnObj.IsError)
{
DisplayErrorMessage("Error Saving Item", returnObj.Error);
}
else
{
DisplaySuccessMessage("Successfully Saved Item as Draft");
UpdateFieldsFromObject();
}
RedirectToAdminUrl(selectedItem, history.HistoryVersionNumber);
return;
}
var tmpSelectedItem = BaseMapper.GetObjectFromContext((MediaDetail)selectedItem);
if (tmpSelectedItem != null)
{
selectedItem = tmpSelectedItem;
}
if (parentMediaItem != null)
{
parentMediaItem = BaseMapper.GetObjectFromContext(parentMediaItem);
}
else
{
parentMediaItem = selectedItem?.Media?.ParentMedia;
}
if (selectedItem == null)
{
selectedItem = MediaDetailsMapper.CreateObject(mediaTypeId, selectedMediaItem, parentMediaItem);
}
var oldLinkTitle = selectedItem.LinkTitle;
var oldVirtualPath = selectedItem.VirtualPath;
var canRender = selectedItem.CanRender;
var oldAbsoluteUrl = selectedItem.AbsoluteUrl;
var oldPostPublishDate = selectedItem.PublishDate;
UpdateObjectFromFields(selectedItem);
var validate = selectedItem.Validate();
if (validate.IsError)
{
DisplayErrorMessage("Error saving item", validate.Error);
return;
}
if ((oldPostPublishDate != selectedItem.PublishDate) && !CurrentUser.HasPermission(PermissionsEnum.Publish))
{
DisplayErrorMessage("Error saving item", ErrorHelper.CreateError(new Exception("You do not have the appropriate permissions to publish items")));
return;
}
if (selectedItem.ID == 0)
{
selectedItem.CreatedByUserID = CurrentUser.ID;
if ((parentMediaItem != null) && (selectedItem.Media.ID == 0))
{
selectedItem.Media.OrderIndex = parentMediaItem.ChildMedias.Count(i => i.ID != 0);
}
returnObj = MediaDetailsMapper.Insert(selectedItem);
if (!returnObj.IsError)
{
ContextHelper.Clear(ContextType.Cache);
FileCacheHelper.ClearAllCache();
}
else
{
DisplayErrorMessage("Error", returnObj.Error);
}
}
else
{
if (!isDraft)
{
if (history != null)
{
returnObj = SaveHistory(history);
}
//selectedItem.Media.ReorderChildren();
if (!returnObj.IsError)
{
returnObj = MediaDetailsMapper.Update(selectedItem);
}
}
}
if (returnObj.IsError)
{
DisplayErrorMessage("Error Saving Item", returnObj.Error);
}
else
{
if (history != null)
{
selectedItem.History.Add((MediaDetail)history);
Return historyReturnObj = MediaDetailsMapper.Update(selectedItem);
}
selectedItem.RemoveFromCache();
FileCacheHelper.DeleteGenerateNavCache();
if (oldVirtualPath != selectedItem.VirtualPath || canRender != selectedItem.CanRender || oldLinkTitle != selectedItem.LinkTitle)
{
ContextHelper.Clear(ContextType.Cache);
//FileCacheHelper.ClearCacheDir("generatenav");
//FileCacheHelper.ClearAllCache();
selectedItem.ClearAutoCalculatedVirtualPathCache();
if (commandArgument == "SaveAndPublish")
{
PublishNow_OnClick(sender, e);
//RedirectToMediaDetail(mediaTypeEnum, selectedItem.MediaID, selectedItem.Media.ParentMediaID);
}
else
{
RedirectToAdminUrl(selectedItem.MediaTypeID, selectedItem.MediaID, selectedItem.Media.ParentMediaID);
}
//ChangeLinksForAllMediaDetails(oldAbsoluteUrl, selectedItem.AbsoluteUrl);
}
DisplaySuccessMessage("Successfully Saved Item");
ExecuteRawJS("ReloadPreviewPanel()");
if (!selectedItem.IsHistory)
{
SelectedMediaDetail = selectedItem;
SelectedMedia = MediasMapper.GetByID(selectedItem.MediaID);
}
if (((Request["selectedMediaId"] == null) || (Request["selectedMediaId"].ToString() == "0")) && (commandArgument != "SaveAndPublish"))
{
RedirectToAdminUrl(selectedItem.MediaTypeID, selectedItem.MediaID, selectedItem.Media.ParentMediaID);
}
else
{
if (commandArgument == "SaveAndPublish")
{
PublishNow_OnClick(sender, e);
//RedirectToMediaDetail(mediaTypeEnum, selectedItem.MediaID, selectedItem.Media.ParentMediaID);
}
UpdateFieldsFromObject();
/*else
* Response.Redirect(Request.Url.AbsoluteUri);*/
//UpdateFieldsFromObject();
//RedirectToMediaDetail(mediaTypeEnum, selectedItem.MediaID, selectedItem.Media.ParentMediaID);
}
}
}
protected void Page_Init(object sender, EventArgs e)
{
long id;
long parentId;
long.TryParse(Request["historyVersion"], out historyVersion);
long.TryParse(Request["mediaTypeId"], out mediaTypeId);
if (long.TryParse(Request["selectedMediaId"], out id))
{
selectedMediaItem = MediasMapper.GetByID(id);
SelectedMedia = selectedMediaItem;
if (selectedMediaItem != null)
{
selectedItem = MediaDetailsMapper.GetByMedia(selectedMediaItem, CurrentLanguage);
if (historyVersion > 0)
{
selectedItem = BaseMapper.GetObjectFromContext((MediaDetail)selectedItem);
historyVersionItem = BaseMapper.GetObjectFromContext((MediaDetail)MediaDetailsMapper.GetByMedia(selectedMediaItem, CurrentLanguage, historyVersion));
}
if ((selectedItem != null) && (historyVersionItem != null))
{
tmpSelectedItem = BaseMapper.GetObjectFromContext((MediaDetail)selectedItem);
selectedItem = historyVersionItem;
}
}
}
if (long.TryParse(Request["parentMediaId"], out parentId))
{
parentMediaItem = MediasMapper.GetByID(parentId);
}
if (selectedItem == null)
{
if (parentMediaItem != null)
{
SelectedMedia = parentMediaItem;
}
/*if (parentMediaItem == null)
* return;*/
selectedItem = MediaDetailsMapper.CreateObject(mediaTypeId, selectedMediaItem, parentMediaItem);
}
Return canAccessReturnObj = BaseMapper.GenerateReturn();
if (selectedItem.ID != 0)
{
canAccessReturnObj = MediaDetailsMapper.CanAccessMediaDetail(selectedItem, CurrentUser);
if (canAccessReturnObj.IsError)
{
DisplayErrorMessage("Cannot edit item", canAccessReturnObj.Error);
CanAccessItem = canAccessReturnObj;
return;
}
else
{
KeyValuePair <IMediaDetail, User> checkedOutItem = IsCheckedOut(selectedItem);
if (checkedOutItem.Key == null)
{
CheckOut(selectedItem);
}
else
{
if (checkedOutItem.Value.ID != CurrentUser.ID)
{
Return returnObj = BaseMapper.GenerateReturn("Cannot edit item", "The item has been checked out by user: ( " + checkedOutItem.Value.UserName + " )");
CanAccessItem = returnObj;
DisplayErrorMessage("Error", returnObj.Error);
return;
}
}
}
}
SelectedMediaDetail = selectedItem;
SelectedMedia = selectedMediaItem;
if (selectedMediaItem == null)
{
SelectedMedia = parentMediaItem;
}
if (selectedItem.ID == 0)
{
Save.Text = "Create";
SaveAndPublish.Text = "Create And Publish";
LoadLatestDraft.Visible = false;
CreateDraft.Visible = false;
var mediaType = MediaTypesMapper.GetByID(selectedItem.MediaTypeID);
if (mediaType == null)
{
return;
}
selectedItem.MainLayout = mediaType.MainLayout;
selectedItem.SummaryLayout = mediaType.SummaryLayout;
selectedItem.FeaturedLayout = mediaType.FeaturedLayout;
selectedItem.UseMediaTypeLayouts = mediaType.UseMediaTypeLayouts;
var liveMediaDetail = selectedItem.Media?.GetLiveMediaDetail();
if (liveMediaDetail != null)
{
selectedItem.CopyFrom(liveMediaDetail);
var fieldsNotInMediaType = liveMediaDetail.Fields.Where(i => i.MediaTypeFieldID == null);
if (fieldsNotInMediaType != null)
{
foreach (var field in fieldsNotInMediaType)
{
var newField = new MediaDetailField();
newField.CopyFrom(field);
if (field.FieldAssociations.Count > 0)
{
newField.FieldValue = "";
}
else
{
newField.FieldValue = field.FieldValue;
}
newField.DateCreated = DateTime.Now;
newField.DateLastModified = DateTime.Now;
selectedItem.Fields.Add(newField);
}
}
var fieldsThatCanBeCopied = liveMediaDetail.Fields.Where(i => !i.FieldAssociations.Any());
foreach (var field in fieldsThatCanBeCopied)
{
var foundField = selectedItem.Fields.FirstOrDefault(i => i.FieldCode == field.FieldCode);
if (foundField != null)
{
foundField.CopyFrom(field);
}
}
}
}
else
{
Save.Text = "Save Page";
SaveAndPublish.Text = "Save And Publish";
}
if ((historyVersion > 0) && (historyVersionItem != null) && (!historyVersionItem.IsDraft))
{
//SavePanel.Visible = false;
}
else
{
var draftItems = selectedItem.History.Where(i => i.IsDraft);
if (draftItems.Count() > 0)
{
LoadLatestDraft.Visible = true;
CreateDraft.Visible = false;
}
SaveAndPublish.Visible = true;
SavePanel.Visible = true;
HistoryPanel.Visible = false;
}
if (historyVersion > 0)
{
SavePanel.Visible = true;
if (!selectedItem.IsDraft)
{
Save.Visible = false;
}
CreateDraft.Visible = false;
PublishNow.Visible = false;
PublishLive.Visible = true;
HistoryPanel.Visible = true;
HistoryVersionNumber.Text = historyVersion.ToString();
}
if (CurrentUser.IsInRole(RoleEnum.Developer))
{
EditMediaType.NavigateUrl = "~/Admin/Views/PageHandlers/MediaTypes/Detail.aspx?id=" + SelectedMediaDetail.MediaTypeID;
EditMediaType.Visible = true;
}
Panel.SetObject(SelectedMediaDetail);
if (Request.QueryString["masterFilePath"] != null)
{
PreviewPanel.Visible = false;
RemovePreviewPanelScript.Visible = true;
}
else
{
PreviewPanel.Visible = true;
RemovePreviewPanelScript.Visible = false;
}
UpdateSectionTitles();
}
public void CopyProperties(IMediaDetail toItem, IMediaDetail fromItem)
{
foreach (var field in fromItem.Fields)
{
var newField = new MediaDetailField();
var foundField = toItem.Fields.FirstOrDefault(i => i.FieldCode == field.FieldCode);
if (foundField != null)
{
newField = foundField;
}
newField.CopyFrom(field);
foreach (var fieldAssociation in field.FieldAssociations)
{
var newFieldAssociation = new FieldAssociation();
newFieldAssociation.CopyFrom(fieldAssociation);
var associatedMediaDetail = (MediaDetail)MediaDetailsMapper.GetByID(newFieldAssociation.AssociatedMediaDetailID);
if (associatedMediaDetail == null)
{
continue;
}
if (!associatedMediaDetail.MediaType.ShowInSiteTree)
{
newFieldAssociation.MediaDetail = (MediaDetail)MediaDetailsMapper.CreateObject(associatedMediaDetail.MediaType.ID, MediasMapper.CreateObject(), associatedMediaDetail.Media.ParentMedia);
newFieldAssociation.MediaDetail.CopyFrom(associatedMediaDetail);
newFieldAssociation.MediaDetail.DateCreated = newFieldAssociation.MediaDetail.DateLastModified = DateTime.Now;
newFieldAssociation.MediaDetail.CreatedByUser = newFieldAssociation.MediaDetail.LastUpdatedByUser = FrameworkSettings.CurrentUser;
CopyProperties(newFieldAssociation.MediaDetail, associatedMediaDetail);
}
/*if (newFieldAssociation.MediaDetail != null)
* {
* newFieldAssociation.MediaDetail.HistoryForMediaDetailID = fieldAssociation.AssociatedMediaDetailID;
* newFieldAssociation.MediaDetail.HistoryVersionNumber = newFieldAssociation.MediaDetail.HistoryVersionNumber + 1;
* }*/
newField.FieldAssociations.Add(newFieldAssociation);
}
if (newField.ID == 0)
{
toItem.Fields.Add(newField);
}
}
}
protected void Page_Init(object sender, EventArgs e)
{
IEnumerable <IMediaDetail> children = new List <IMediaDetail>();
try
{
IMediaDetail mediaDetail = null;
if (MediaID != null)
{
mediaDetail = MediasMapper.GetByID((long)MediaID)?.GetLiveMediaDetail();
}
if (mediaDetail == null)
{
mediaDetail = BasePage.CurrentMediaDetail;
}
if (mediaDetail != null)
{
if (!string.IsNullOrEmpty(Where))
{
children = mediaDetail.ChildMediaDetails.Where(Where);
}
else
{
children = mediaDetail.ChildMediaDetails;
}
if (!string.IsNullOrEmpty(OrderBy))
{
children = children.OrderBy(OrderBy);
}
if (Take > 0)
{
children = children.Take(Take);
}
}
}
catch (Exception ex)
{
ErrorHelper.LogException(ex);
}
if (MediaTypeID != null && MediaTypeID != 0)
{
children.Where(i => i.MediaTypeID == MediaTypeID);
}
Children.DataSource = children.ToList();
Pager.ShowDataPager = ShowPager;
if (PageSize == null)
{
PageSize = 0;
}
if (!ShowPager)
{
PageSize = 0;
//Pager.Visible = false;
//Pager.ShowDataPager = false;
Children.DataBind();
}
if (PageSize == 0)
{
PageSize = children.Count();
}
if (PageSize is int)
{
Pager.PageSize = int.Parse(PageSize.ToString());
}
}
protected void UploadFilesNow_Click(object sender, EventArgs e)
{
try
{
var field = GetField();
if (IsPostBack && Request.Files.Count > 0 && !hasRun)
{
hasRun = true;
var index = 0;
for (int i = 0; i < Request.Files.Count; i++)
{
var file = Request.Files[i];
if (string.IsNullOrEmpty(file.FileName))
{
continue;
}
var fileInfo = (new System.IO.FileInfo(GetFolderPath() + file.FileName));
if (!fileInfo.Directory.Exists)
{
fileInfo.Directory.Create();
}
if (fileInfo.Directory.Exists)
{
file.SaveAs(fileInfo.FullName);
var filePath = URIHelper.ConvertAbsUrlToTilda(URIHelper.ConvertAbsPathToAbsUrl(fileInfo.FullName)).Replace("~", "");
if (!field.FieldAssociations.Any(j => j.MediaDetail.PathToFile == filePath))
{
var fieldAssociation = new FieldAssociation();
fieldAssociation.MediaDetail = (MediaDetail)PagesMapper.CreateObject(MediaTypeID, MediasMapper.CreateObject(), AdminBasePage.SelectedMedia);
fieldAssociation.MediaDetail.LinkTitle = fieldAssociation.MediaDetail.SectionTitle = fieldAssociation.MediaDetail.ShortDescription = fieldAssociation.MediaDetail.MainContent = fileInfo.Name;
fieldAssociation.MediaDetail.PathToFile = filePath;
fieldAssociation.MediaDetail.PublishDate = DateTime.Now;
fieldAssociation.MediaDetail.CreatedByUser = fieldAssociation.MediaDetail.LastUpdatedByUser = FrameworkSettings.CurrentUser;
fieldAssociation.MediaDetail.CachedVirtualPath = fieldAssociation.MediaDetail.CalculatedVirtualPath();
fieldAssociation.MediaDetail.LanguageID = SettingsMapper.GetSettings().DefaultLanguage.ID;
field.FieldAssociations.Add(fieldAssociation);
index++;
var returnObj = BaseMapper.SaveDataModel();
}
}
}
}
SetValue(GetValue());
}
catch (Exception ex)
{
}
}
