private void UpdatedFieldsFromObject(MediaDetailField mediaField)
{
FieldID.Value = mediaField.ID.ToString();
FieldCode.Text = mediaField.FieldCode;
FieldLabel.Text = mediaField.FieldLabel;
AdminControl.Text = mediaField.AdminControl;
FieldValue.Text = ParserHelper.ParseData(mediaField.FieldValue, BasePage.TemplateVars);
GroupName.Text = mediaField.GroupName;
RenderLabelAfterControl.Checked = mediaField.RenderLabelAfterControl;
FrontEndLayout.Text = mediaField.FrontEndLayout;
GetAdminControlValue.Text = mediaField.GetAdminControlValue;
SetAdminControlValue.Text = mediaField.SetAdminControlValue;
UseMediaTypeFieldFrontEndLayout.Checked = mediaField.UseMediaTypeFieldFrontEndLayout;
FieldDescription.SetValue(mediaField.FieldDescription);
UseMediaTypeFieldDescription.Checked = mediaField.UseMediaTypeFieldDescription;
ShowFrontEndFieldEditor.Checked = mediaField.ShowFrontEndFieldEditor;
IsGlobalField.Checked = mediaField.IsGlobalField;
UsageExample.Text = mediaField.UsageExample;
var jsonObj = JObject.Parse(mediaField.ToJson());
LoadJson.Text = jsonObj.ToString();
BindVisibility(mediaField);
}
protected void MediaTypeChange_Click(object sender, System.EventArgs e)
{
var mewMediaTypeId = long.Parse(MediaTypes.SelectedValue);
var newMediaType = MediaTypesMapper.GetDataModel().MediaTypes.FirstOrDefault(i => i.ID == mewMediaTypeId);
if ((newMediaType != null) && (newMediaType.ID != selectedItem.MediaType.ID))
{
selectedItem.MediaTypeID = newMediaType.ID;
selectedItem.ShowInMenu = newMediaType.ShowInMenu;
selectedItem.ShowInSearchResults = newMediaType.ShowInSearchResults;
foreach (var mediaTypeField in newMediaType.Fields)
{
var foundField = selectedItem.Fields.SingleOrDefault(i => i.FieldCode == mediaTypeField.FieldCode);
if (foundField != null)
{
foundField.MediaTypeField = mediaTypeField;
continue;
}
var newField = new MediaDetailField();
newField.CopyFrom(mediaTypeField);
newField.UseMediaTypeFieldFrontEndLayout = true;
newField.DateCreated = DateTime.Now;
newField.DateLastModified = DateTime.Now;
selectedItem.Fields.Add(newField);
}
if (selectedItem.UseMediaTypeLayouts)
{
selectedItem.MainLayout = newMediaType.MainLayout;
selectedItem.FeaturedLayout = newMediaType.FeaturedLayout;
selectedItem.SummaryLayout = newMediaType.SummaryLayout;
}
foreach (var field in selectedItem.Fields)
{
if (field.MediaTypeField != null && field.MediaTypeField.MediaType != newMediaType)
{
field.MediaTypeField = null;
}
}
var returnObj = MediaDetailsMapper.Update(selectedItem);
if (returnObj.IsError)
{
BasePage.DisplayErrorMessage("Error", returnObj.Error);
}
else
{
var url = AdminBasePage.GetAdminUrl(selectedItem.MediaTypeID, selectedItem.MediaID);
Response.Redirect(url);
}
}
}
private void BindVisibility(MediaDetailField mediaField)
{
var possibleMediaTypeField = mediaField?.MediaDetail?.MediaType.Fields.SingleOrDefault(i => i.FieldCode == mediaField.FieldCode);
if (possibleMediaTypeField != null)
{
AssociateWithMediaTypeFieldWrapper.Visible = true;
AssociateWithMediaTypeField.Checked = (mediaField.MediaTypeField != null);
if (AssociateWithMediaTypeField.Checked)
{
UseMediaTypeFieldFrontEndLayout.Checked = mediaField.UseMediaTypeFieldFrontEndLayout;
UseMediaTypeFieldFrontEndLayoutWrapper.Visible = true;
UseMediaTypeFieldDescriptionWrapper.Visible = true;
}
else
{
UseMediaTypeFieldFrontEndLayoutWrapper.Visible = false;
UseMediaTypeFieldFrontEndLayout.Checked = false;
mediaField.UseMediaTypeFieldFrontEndLayout = false;
UseMediaTypeFieldDescriptionWrapper.Visible = false;
}
}
else
{
UseMediaTypeFieldDescriptionWrapper.Visible = UseMediaTypeFieldFrontEndLayoutWrapper.Visible = AssociateWithMediaTypeFieldWrapper.Visible = false;
UseMediaTypeFieldFrontEndLayout.Checked = false;
mediaField.MediaTypeField = null;
mediaField.UseMediaTypeFieldFrontEndLayout = false;
}
}
protected void CopyFields_Click(object sender, EventArgs e)
{
var otherMediaType = MediaTypeSelector.GetSelectedMediaType();
foreach (var otherMediaTypeField in otherMediaType.Fields)
{
if (!mediaType.Fields.Any(i => i.FieldCode == otherMediaTypeField.FieldCode))
{
var mediaTypeField = new MediaTypeField();
mediaTypeField.CopyFrom(otherMediaTypeField);
mediaTypeField.DateCreated = mediaTypeField.DateLastModified = DateTime.Now;
mediaType.Fields.Add(mediaTypeField);
foreach (var mediaDetail in mediaType.MediaDetails)
{
var mediaDetailField = new MediaDetailField();
mediaDetailField.CopyFrom(mediaTypeField);
if (string.IsNullOrEmpty(mediaDetailField.UsageExample))
{
mediaDetailField.UsageExample = "{Field:" + mediaDetailField.FieldCode + "} OR {{Load:" + mediaDetail.MediaID + "}.Field:" + mediaDetailField.FieldCode + "}";
}
mediaDetailField.UseMediaTypeFieldFrontEndLayout = true;
mediaDetailField.UseMediaTypeFieldDescription = true;
if (mediaDetailField.FrontEndSubmissions == null)
{
mediaDetailField.FrontEndSubmissions = "";
}
if (mediaDetailField.FieldSettings == null)
{
mediaDetailField.FieldSettings = "";
}
mediaDetailField.MediaTypeField = mediaTypeField;
mediaDetailField.DateCreated = mediaDetailField.DateLastModified = DateTime.Now;
mediaDetailField.OrderIndex = mediaDetail.Fields.Count;
mediaDetail.Fields.Add(mediaDetailField);
}
}
}
var returnObj = MediaTypesMapper.Update(mediaType);
if (!returnObj.IsError)
{
Bind();
}
else
{
BasePage.DisplayErrorMessage("Error", returnObj.Error);
}
}
protected void Update_Click(object sender, EventArgs e)
{
if (mediaDetail.ID == 0)
{
BasePage.DisplayErrorMessage("You can only add fields once you have created the page");
return;
}
if (FieldCode.Text == "")
{
BasePage.DisplayErrorMessage("'FieldCode' cannot be blank");
return;
}
var fieldId = long.Parse(FieldID.Value);
MediaDetailField mediaField = null;
if (fieldId == 0)
{
mediaField = new MediaDetailField();
UpdatedObjectFromFields(mediaField);
mediaField.OrderIndex = mediaDetail.Fields.Count;
mediaField.FieldSettings = "";
mediaDetail.Fields.Add(mediaField);
}
else
{
mediaField = mediaDetail.Fields.SingleOrDefault(i => i.ID == fieldId);
var previouslyAssociateWithMediaTypeField = mediaField.MediaTypeFieldID;
UpdatedObjectFromFields(mediaField);
if ((previouslyAssociateWithMediaTypeField == 0 || previouslyAssociateWithMediaTypeField == null) && mediaField.MediaTypeFieldID != 0)
{
mediaField.UseMediaTypeFieldDescription = mediaField.UseMediaTypeFieldFrontEndLayout = true;
}
}
var returnObj = MediaDetailsMapper.Update(mediaDetail);
if (!returnObj.IsError)
{
FieldID.Value = mediaField.ID.ToString();
BindVisibility(mediaField);
BindItemList();
mediaField.MediaDetail.RemoveFromCache();
}
else
{
BasePage.DisplayErrorMessage("Error", returnObj.Error);
}
}
private void ImportNewFields(IEnumerable <MediaTypeField> importFields)
{
foreach (var field in importFields)
{
if (!mediaType.Fields.Any(i => i.FieldCode == field.FieldCode))
{
var mediaTypeField = new MediaTypeField();
mediaTypeField.CopyFrom(field);
mediaTypeField.DateCreated = mediaTypeField.DateLastModified = DateTime.Now;
mediaType.Fields.Add(mediaTypeField);
foreach (var mediaDetail in mediaType.MediaDetails)
{
var mediaDetailField = new MediaDetailField();
mediaDetailField.CopyFrom(mediaTypeField);
if (string.IsNullOrEmpty(mediaDetailField.UsageExample))
{
mediaDetailField.UsageExample = "{Field:" + mediaDetailField.FieldCode + "} OR {{Load:" + mediaDetail.MediaID + "}.Field:" + mediaDetailField.FieldCode + "}";
}
mediaDetailField.UseMediaTypeFieldFrontEndLayout = true;
mediaDetailField.UseMediaTypeFieldDescription = true;
if (mediaDetailField.FrontEndSubmissions == null)
{
mediaDetailField.FrontEndSubmissions = "";
}
if (mediaDetailField.FieldSettings == null)
{
mediaDetailField.FieldSettings = "";
}
mediaDetailField.MediaTypeField = mediaTypeField;
mediaDetailField.DateCreated = mediaDetailField.DateLastModified = DateTime.Now;
mediaDetailField.OrderIndex = mediaDetail.Fields.Count;
mediaDetail.Fields.Add(mediaDetailField);
}
}
}
var returnObj = MediaTypesMapper.Update(mediaType);
if (!returnObj.IsError)
{
Bind();
}
else
{
BasePage.DisplayErrorMessage("Error", returnObj.Error);
}
}
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);
}
}
}
public DirectoryInfo GetFolderPath()
{
var field = GetField();
var folderPath = SaveToFolder;
if (folderPath == "")
{
return(MediaDetailField.GetUploadFolder(field));
}
else
{
return(MediaDetailField.GetUploadFolder(field, folderPath));
}
}
public MediaDetailField GetField()
{
if (_field != null)
{
return(_field);
}
_field = (MediaDetailField)BaseMapper.GetDataModel().Fields.Find(FieldID);
if (_field == null)
{
_field = new MediaDetailField();
}
return(_field);
}
protected void Page_Init(object sender, EventArgs e)
{
var fieldIdStr = Request["fieldId"];
if (!string.IsNullOrEmpty(fieldIdStr))
{
if (!CurrentUser.HasPermission(PermissionsEnum.AccessAdvanceOptions))
{
LayoutsTab.Visible = false;
FrontEndLayout.Visible = false;
}
var fieldId = long.Parse(fieldIdStr);
var field = FieldsMapper.GetByID(fieldId);
if (field != null && field is MediaDetailField)
{
Field = field as MediaDetailField;
LoadField();
}
}
}
public IMediaDetail HandleDuplicate(IMediaDetail detail, Media parentMedia, bool duplicateChildren = false, string newName = "", bool autoPublish = true)
{
var duplicatedItem = MediaDetailsMapper.CreateObject(detail.MediaTypeID, null, parentMedia, false);
duplicatedItem.CopyFrom(detail, new List <string> {
"MediaID", "Media"
});
if (newName != "")
{
duplicatedItem.Title = duplicatedItem.LinkTitle = newName;
}
duplicatedItem.CachedVirtualPath = duplicatedItem.CalculatedVirtualPath();
/*if (duplicatedItem.ID == 0)
* {
* var mediaType = MediaTypesMapper.GetByID(detail.MediaTypeID);
* var createdItems = mediaType.MediaDetails.Where(i => !i.IsHistory && i.ParentMediaID == detail.ParentMediaID && i.LanguageID == detail.LanguageID).Select(i => i);
*
* var newIndex = createdItems.Count() + 1;
*
* duplicatedItem.LinkTitle = detail.Language.DisplayName + " - " + mediaType.Name + " " + newIndex;
* }*/
duplicatedItem.Media.OrderIndex = parentMedia.ChildMedias.Count(i => i.ID != 0);
duplicatedItem.PublishDate = duplicatedItem.DateCreated = duplicatedItem.DateLastModified = DateTime.Now;
//var fields = detail.Fields.ToList();
foreach (var item in detail.Fields)
{
var mediaDetailField = new MediaDetailField();
mediaDetailField.CopyFrom(item);
if (newName != "" && mediaDetailField.FieldCode == "SectionTitle")
{
mediaDetailField.FieldValue = newName;
}
mediaDetailField.DateCreated = mediaDetailField.DateLastModified = DateTime.Now;
foreach (var association in item.FieldAssociations)
{
var fieldAssociation = new FieldAssociation();
fieldAssociation.CopyFrom(association);
if (item.AdminControl.Contains("MultiFile"))
{
var associatedMediaDetail = MediaDetailsMapper.GetByID(fieldAssociation.AssociatedMediaDetailID);
fieldAssociation.AssociatedMediaDetailID = 0;
fieldAssociation.MediaDetail = (MediaDetail)HandleDuplicate(associatedMediaDetail, associatedMediaDetail.Media.ParentMedia, true);
}
mediaDetailField.FieldAssociations.Add(fieldAssociation);
}
duplicatedItem.Fields.Add(mediaDetailField);
}
if (!autoPublish)
{
duplicatedItem.PublishDate = null;
}
var returnObj = MediaDetailsMapper.Insert(duplicatedItem);
if (returnObj.IsError)
{
throw returnObj.Error.Exception;
}
else
{
if (duplicateChildren)
{
var childMediaDetails = detail.ChildMediaDetails;
foreach (var childDetail in childMediaDetails)
{
HandleDuplicate(childDetail, duplicatedItem.Media);
}
/*foreach (var child in detail.Media.ChildMedias)
* {
* var mediaDetailsToCopy = child.MediaDetails.Where(i => !i.IsDraft && !i.IsHistory);
*
* foreach (var childDetail in mediaDetailsToCopy)
* {
* HandleDuplicate(childDetail, duplicatedItem.Media);
* }
* }*/
}
}
return(duplicatedItem);
}
protected void Update_Click(object sender, EventArgs e)
{
if (mediaType.ID == 0)
{
BasePage.DisplayErrorMessage("You can only add fields once you have created the page");
return;
}
if (FieldCode.Text == "")
{
BasePage.DisplayErrorMessage("'FieldCode' cannot be blank");
return;
}
var fieldId = long.Parse(FieldID.Value);
if (fieldId == 0)
{
var mediaTypeField = new MediaTypeField();
UpdatedObjectFromFields(mediaTypeField);
mediaType.Fields.Add(mediaTypeField);
foreach (var mediaDetail in mediaType.MediaDetails)
{
var mediaDetailField = new MediaDetailField();
mediaDetailField.CopyFrom(mediaTypeField);
if (string.IsNullOrEmpty(mediaDetailField.UsageExample))
{
mediaDetailField.UsageExample = "{Field:" + mediaDetailField.FieldCode + "} OR {{Load:" + mediaDetail.MediaID + "}.Field:" + mediaDetailField.FieldCode + "}";
}
mediaDetailField.UseMediaTypeFieldFrontEndLayout = true;
mediaDetailField.UseMediaTypeFieldDescription = true;
if (mediaDetailField.FrontEndSubmissions == null)
{
mediaDetailField.FrontEndSubmissions = "";
}
if (mediaDetailField.FieldSettings == null)
{
mediaDetailField.FieldSettings = "";
}
mediaDetailField.MediaTypeField = mediaTypeField;
mediaDetailField.DateCreated = mediaDetailField.DateLastModified = DateTime.Now;
mediaDetailField.OrderIndex = mediaDetail.Fields.Count;
mediaDetail.Fields.Add(mediaDetailField);
}
}
else
{
var mediaTypeField = mediaType.Fields.SingleOrDefault(i => i.ID == fieldId);
var oldFieldCode = mediaTypeField.FieldCode;
UpdatedObjectFromFields(mediaTypeField);
foreach (var mediaDetailField in mediaTypeField.MediaDetailFields)
{
var mediaDetailFieldValue = mediaDetailField.FieldValue;
mediaDetailField.CopyFrom(mediaTypeField);
if (string.IsNullOrEmpty(mediaDetailField.UsageExample))
{
mediaDetailField.UsageExample = "{Field:" + mediaDetailField.FieldCode + "} OR {{Load:" + mediaDetailField.MediaDetail.MediaID + "}.Field:" + mediaDetailField.FieldCode + "}";
}
if (mediaDetailField.UseMediaTypeFieldDescription)
{
mediaDetailField.FieldDescription = mediaTypeField.FieldDescription;
}
if (mediaDetailField.UseMediaTypeFieldFrontEndLayout)
{
mediaDetailField.FrontEndLayout = mediaTypeField.FrontEndLayout;
}
if (string.IsNullOrEmpty(mediaDetailFieldValue))
{
mediaDetailField.FieldValue = mediaTypeField.FieldValue;
}
else
{
mediaDetailField.FieldValue = mediaDetailFieldValue;
}
mediaDetailField.DateLastModified = DateTime.Now;
}
}
var returnObj = MediaTypesMapper.Update(mediaType);
if (!returnObj.IsError)
{
Bind();
/*var liveMediaDetails = mediaType.MediaDetails.Where(i => i.HistoryVersionNumber == 0);
*
* foreach (var item in liveMediaDetails)
* {
* item.RemoveFromCache();
* }*/
}
else
{
BasePage.DisplayErrorMessage("Error", returnObj.Error);
}
}
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();
}
private void UpdatedObjectFromFields(MediaDetailField mediaField)
{
mediaField.MediaDetailID = mediaDetail.ID;
mediaField.FieldCode = FieldCode.Text;
mediaField.FieldLabel = FieldLabel.Text;
mediaField.AdminControl = AdminControl.Text;
mediaField.FieldValue = ParserHelper.ParseData(FieldValue.Text, BasePage.TemplateVars, true);
mediaField.GroupName = GroupName.Text;
mediaField.RenderLabelAfterControl = RenderLabelAfterControl.Checked;
mediaField.GetAdminControlValue = GetAdminControlValue.Text;
mediaField.SetAdminControlValue = SetAdminControlValue.Text;
mediaField.FrontEndLayout = FrontEndLayout.Text;
mediaField.FieldDescription = FieldDescription.GetValue().ToString();
mediaField.UseMediaTypeFieldDescription = UseMediaTypeFieldDescription.Checked;
mediaField.ShowFrontEndFieldEditor = ShowFrontEndFieldEditor.Checked;
mediaField.IsGlobalField = IsGlobalField.Checked;
if (string.IsNullOrEmpty(UsageExample.Text))
{
if (mediaField.MediaDetail == null && mediaField.MediaDetailID != 0)
{
mediaField.MediaDetail = (MediaDetail)MediaDetailsMapper.GetByID(mediaField.MediaDetailID);
}
if (mediaField.MediaDetail != null)
{
UsageExample.Text = "{Field:" + mediaField.FieldCode + "} OR {{Load:" + mediaField.MediaDetail.MediaID + "}.Field:" + mediaField.FieldCode + "}";
}
}
mediaField.UsageExample = UsageExample.Text;
if (mediaField.FieldSettings == null)
{
mediaField.FieldSettings = "";
}
if (mediaField.FrontEndSubmissions == null)
{
mediaField.FrontEndSubmissions = "";
}
var mediaTypeField = mediaDetail.MediaType.Fields.SingleOrDefault(i => i.FieldCode == mediaField.FieldCode);
if (mediaTypeField != null)
{
mediaField.UseMediaTypeFieldFrontEndLayout = UseMediaTypeFieldFrontEndLayout.Checked;
if (AssociateWithMediaTypeField.Checked)
{
mediaField.MediaTypeField = mediaTypeField;
}
else
{
mediaField.MediaTypeField = null;
}
}
else
{
mediaField.UseMediaTypeFieldFrontEndLayout = false;
}
mediaField.DateCreated = DateTime.Now;
mediaField.DateLastModified = DateTime.Now;
//BindVisibility(mediaField);
}
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);
}
