private void HandleDelete(IEnumerable <RoleMedia> RoleMediaDetails)
{
selectedItem = BaseMapper.GetObjectFromContext((MediaDetail)selectedItem);
Role role = null;
Return obj = BaseMapper.GenerateReturn();
foreach (RoleMedia RoleMediaDetail in RoleMediaDetails)
{
obj = RolesMediasMapper.DeletePermanently(RoleMediaDetail);
role = RoleMediaDetail.Role;
}
if (!obj.IsError)
{
IEnumerable <UserMedia> userMediaDetails = selectedItem.Media.UsersMedias.Where(i => i.User.IsInRole(role));
foreach (UserMedia userMediaDetail in userMediaDetails)
{
UsersMediasMapper.DeletePermanently(userMediaDetail);
}
Bind();
}
if (obj.IsError)
{
BasePage.DisplayErrorMessage("Error deleting association", obj.Error);
}
else
{
BasePage.DisplaySuccessMessage("Successfully deleted association");
Bind();
}
}
protected void RemoveFromUser_OnClick(object sender, EventArgs e)
{
var currentMediaDetail = BaseMapper.GetObjectFromContext((MediaDetail)MediaDetailToAdd);
var found = currentMediaDetail.Media.UsersMedias.SingleOrDefault(i => i.MediaID == currentMediaDetail.MediaID);
if (found == null)
{
return;
}
var returnObj = UsersMediasMapper.DeletePermanently(found);
if (!returnObj.IsError)
{
currentMediaDetail.Media.UsersMedias.Remove(found);
returnObj = MediaDetailsMapper.Update(currentMediaDetail);
UpdateVisibility();
}
if (!returnObj.IsError)
{
BasePage.DisplaySuccessMessage("Successfully removed from My Plan");
}
else
{
BasePage.DisplayErrorMessage("Error removing from My Plan", returnObj.Error);
}
}
protected void Save_OnClick(object sender, EventArgs e)
{
if (!canAccessSection)
{
return;
}
var settings = BaseMapper.GetObjectFromContext(SettingsMapper.GetSettings());
UpdateObjectFromFields(settings);
var returnObj = SettingsMapper.Update(settings);
if (returnObj.IsError)
{
DisplayErrorMessage("Error saving settings", returnObj.Error);
}
else
{
ContextHelper.ClearAllMemoryCache();
FileCacheHelper.ClearAllCache();
SettingsMapper.ClearCache();
DisplaySuccessMessage("Successfully saved settings");
}
}
private Return SaveHistory(IMediaDetail history)
{
selectedItem = BaseMapper.GetObjectFromContext((MediaDetail)selectedItem);
history.HistoryForMediaDetailID = selectedItem.ID;
if (selectedItem.History.Count == 0)
{
history.HistoryVersionNumber = 1;
}
else
{
history.HistoryVersionNumber = selectedItem.History.OrderByDescending(i => i.HistoryVersionNumber).Take(1).FirstOrDefault().HistoryVersionNumber + 1;
}
if (selectedItem.History.Count >= MediaDetailsMapper.MaxHistory)
{
int count = selectedItem.History.Count - MediaDetailsMapper.MaxHistory;
IEnumerable <MediaDetail> items = selectedItem.History.OrderBy(i => i.HistoryVersionNumber).Take(count);
foreach (MediaDetail item in items)
{
if (!item.IsDraft)
{
MediaDetailsMapper.ClearObjectRelations(item);
MediaDetailsMapper.DeleteObjectFromContext(item);
}
}
}
/*if (history.MainContent.Trim() == "")
* history.MainContent = "TBD";*/
return(MediaDetailsMapper.Insert(history));
}
protected void AddToUser_OnClick(object sender, EventArgs e)
{
var usersMediaDetails = new UserMedia();
usersMediaDetails.MediaID = MediaDetailToAdd.MediaID;
usersMediaDetails.UserID = BasePage.CurrentUser.ID;
usersMediaDetails.DateCreated = usersMediaDetails.DateLastModified = DateTime.Now;
//usersMediaDetails.PermissionID = PermissionsMapper.GetPermissionsFromEnum(PermissionsEnum.AccessProtectedSections).ID;
var currentMediaDetail = BaseMapper.GetObjectFromContext((MediaDetail)MediaDetailToAdd);
currentMediaDetail.Media.UsersMedias.Add(usersMediaDetails);
var returnObj = MediaDetailsMapper.Update(currentMediaDetail);
if (!returnObj.IsError)
{
BasePage.DisplaySuccessMessage("Successfully added to My Plan");
UpdateVisibility();
}
else
{
BasePage.DisplayErrorMessage("Error adding to My Plan", returnObj.Error);
}
}
private void SetDeleteStatus(IMediaDetail detail, bool isDeleted)
{
UserMustHaveAccessTo(detail);
if (!FrameworkSettings.CurrentUser.HasPermission(PermissionsEnum.Delete))
{
throw new Exception("You do not have the appropriate permissions to delete/undelete items");
}
detail = BaseMapper.GetObjectFromContext((MediaDetail)detail);
detail.IsDeleted = isDeleted;
Return returnObj = MediaDetailsMapper.Update(detail);
if (returnObj.IsError)
{
throw returnObj.Error.Exception;
}
else
{
ContextHelper.ClearAllMemoryCache();
detail.RemoveFromCache();
FileCacheHelper.DeleteCacheDir("generatenav");
}
}
private void HandleDelete(IEnumerable <UserMedia> selectedUserMediaDetails)
{
selectedItem = BaseMapper.GetObjectFromContext((MediaDetail)selectedItem);
Return obj = BaseMapper.GenerateReturn();
foreach (UserMedia selectedUserMediaDetail in selectedUserMediaDetails)
{
UserMedia item = BaseMapper.GetObjectFromContext(selectedUserMediaDetail);
selectedItem.Media.UsersMedias.Remove(selectedUserMediaDetail);
obj = UsersMediasMapper.DeletePermanently(selectedUserMediaDetail);
if (obj.IsError)
{
break;
}
}
if (obj.IsError)
{
BasePage.DisplayErrorMessage("Error deleting association", obj.Error);
}
else
{
BasePage.DisplaySuccessMessage("Successfully deleted association");
Bind();
}
}
public void UpdateObjectFromFields()
{
selectedItem.CanLimitedRolesAccessAllChildPages = CanLimitedRolesAccessAllChildPages.Checked;
selectedItem.EnforceRoleLimitationsOnFrontEnd = EnforceRoleLimitationOnFrontEnd.Checked;
var roles = MultiRoleSelector.GetSelectedRoles();
if (roles == null)
{
return;
}
var rolesMedias = selectedItem.Media.RolesMedias.ToList();
foreach (var roleMedia in rolesMedias)
{
BaseMapper.DeleteObjectFromContext(roleMedia);
}
foreach (var role in roles)
{
var contextRole = BaseMapper.GetObjectFromContext(role);
var newMediaRole = new RoleMedia()
{
Media = selectedItem.Media, Role = contextRole, DateCreated = DateTime.Now, DateLastModified = DateTime.Now
};
selectedItem.Media.RolesMedias.Add(newMediaRole);
}
}
protected void Save_OnClick(object sender, EventArgs e)
{
selectedItem = BaseMapper.GetObjectFromContext((MediaDetail)selectedItem);
IEnumerable <UserMedia> UserMediaDetails = UserPermissionsSelector.GetUserMediaDetails();
User User = UserPermissionsSelector.GetSelectedUser();
IEnumerable <UserMedia> removeItems = selectedItem.Media.UsersMedias.Where(i => i.UserID == User.ID);
foreach (UserMedia removeItem in removeItems)
{
UsersMediasMapper.DeletePermanently(removeItem);
}
foreach (UserMedia UserMediaDetail in UserMediaDetails)
{
selectedItem.Media.UsersMedias.Add(UserMediaDetail);
}
Return obj = MediaDetailsMapper.Update(selectedItem);
if (obj.IsError)
{
BasePage.DisplayErrorMessage("Error assigning User", obj.Error);
}
else
{
BasePage.DisplaySuccessMessage("Successfully assigned User");
Bind();
EditPanel.Visible = false;
}
}
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());
}
protected void Save_OnClick(object sender, EventArgs e)
{
if (selectedItem == null)
{
selectedItem = GlossaryTermsMapper.CreateObject();
}
else
{
selectedItem = BaseMapper.GetObjectFromContext <GlossaryTerm>(selectedItem);
}
UpdateObjectFromFields();
Return returnObj;
if (selectedItem.ID == 0)
{
returnObj = GlossaryTermsMapper.Insert(selectedItem);
}
else
{
returnObj = GlossaryTermsMapper.Update(selectedItem);
}
if (returnObj.IsError)
{
DisplayErrorMessage("Error Saving Item", returnObj.Error);
}
else
{
UpdateFieldsFromObject();
DisplaySuccessMessage("Successfully Saved Item");
}
}
protected void Save_OnClick(object sender, EventArgs e)
{
selectedItem = BaseMapper.GetObjectFromContext((MediaDetail)selectedItem);
IEnumerable <RoleMedia> RoleMediaDetails = RolePermissionsSelector.GetRoleMediaDetails();
Role role = RolePermissionsSelector.GetSelectedRole();
IEnumerable <RoleMedia> removeItems = selectedItem.Media.RolesMedias.Where(i => i.RoleID == role.ID);
foreach (RoleMedia removeItem in removeItems)
{
RolesMediasMapper.DeletePermanently(removeItem);
}
foreach (RoleMedia RoleMediaDetail in RoleMediaDetails)
{
selectedItem.Media.RolesMedias.Add(RoleMediaDetail);
}
Return obj = MediaDetailsMapper.Update(selectedItem);
if (obj.IsError)
{
BasePage.DisplayErrorMessage("Error assigning role", obj.Error);
}
else
{
BasePage.DisplaySuccessMessage("Successfully assigned role");
Bind();
EditPanel.Visible = false;
}
}
private void UpdateObjectFromFields()
{
SelectedItem.UserName = Username.Text;
var password = Password.Text.Trim();
var encryptedPassword = StringHelper.Encrypt(password);
if (password != "")
{
SelectedItem.Password = encryptedPassword;
}
SelectedItem.EmailAddress = EmailAddress.Text;
SelectedItem.IsActive = IsActive.Checked;
SelectedItem.ProfilePhoto = ProfilePhoto.GetValue().ToString();
SelectedItem.FirstName = FirstName.Text;
SelectedItem.LastName = LastName.Text;
SelectedItem.AfterLoginStartPage = AfterLoginStartPage.Text;
SelectedItem.Roles.Clear();
foreach (ListItem item in RolesList.Items)
{
if (item.Selected)
{
SelectedItem.Roles.Add(BaseMapper.GetObjectFromContext <Role>(RolesMapper.GetByID(long.Parse(item.Value))));
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (CurrentMedia == null)
{
CurrentMedia = BaseMapper.GetObjectFromContext((Media)BasePage.CurrentMedia);
}
//Bind();
}
public IEnumerable <Tag> GetTags()
{
var items = new List <Tag>();
IEnumerable <string> values = TagValues.Value.Trim().Split(',').Distinct();
var count = 0;
foreach (string value in values)
{
var tagName = value.Trim();
var lowerCaseTagName = tagName.ToLower();
if ((tagName == "") || (items.Any(i => i.Name.ToLower() == lowerCaseTagName)))
{
continue;
}
long id;
long.TryParse(tagName, out id);
Tag item = null;
if (id != 0)
{
item = TagsMapper.GetByID(long.Parse(tagName));
}
if (item == null)
{
item = TagsMapper.GetByName(tagName);
}
if (item != null)
{
item = BaseMapper.GetObjectFromContext <Tag>(item);
}
if ((item == null) || (item.ID == 0))
{
item = TagsMapper.CreateObject();
item.Name = tagName;
item.Description = tagName;
item.OrderIndex = count;
item.SefTitle = URIHelper.PrepairUri(tagName);
item.DateCreated = item.DateLastModified = DateTime.Now;
}
if (item != null)
{
items.Add(item);
}
count++;
}
return(items);
}
protected void PublishNow_OnClick(object sender, EventArgs e)
{
if (!CurrentUser.HasPermission(PermissionsEnum.Publish))
{
DisplayErrorMessage("Error publishing item", ErrorHelper.CreateError(new Exception("You do not have the appropriate permissions to publish items")));
return;
}
selectedItem = BaseMapper.GetObjectFromContext((MediaDetail)selectedItem);
if (selectedItem == null)
{
return;
}
var mediaType = MediaTypesMapper.GetByID(selectedItem.MediaTypeID);
selectedItem.PublishDate = DateTime.Now;
if (selectedItem.ExpiryDate != null)
{
selectedItem.ExpiryDate = null;
}
selectedItem.ShowInMenu = mediaType.ShowInMenu;
selectedItem.ShowInSearchResults = mediaType.ShowInSearchResults;
selectedItem.EnableCaching = mediaType.EnableCaching;
Return returnObj = MediaDetailsMapper.Update(selectedItem);
if (returnObj.IsError)
{
DisplayErrorMessage("Error Publishing Item", returnObj.Error);
}
else
{
DisplaySuccessMessage("Successfully Published Item");
var mediaId = (selectedItem.Media.ParentMediaID != null) ? selectedItem.Media.ParentMediaID : selectedItem.MediaID;
ExecuteRawJS("RefreshSiteTreeNodeById(" + mediaId + "); ReloadPreviewPanel();");
UpdateFieldsFromObject();
PublishNow.Visible = false;
ContextHelper.Clear(ContextType.Cache);
FileCacheHelper.ClearAllCache();
}
UpdateFieldsFromObject();
OnPublishExecuteCode();
}
protected void Save_OnClick(object sender, EventArgs e)
{
if (selectedItem == null)
{
selectedItem = LanguagesMapper.CreateObject();
}
else
{
selectedItem = BaseMapper.GetObjectFromContext <Language>(selectedItem);
}
UpdateObjectFromFields();
Return returnObj = selectedItem.Validate();
if (!returnObj.IsError)
{
if (selectedItem.ID == 0)
{
returnObj = LanguagesMapper.Insert(selectedItem);
}
else
{
returnObj = LanguagesMapper.Update(selectedItem);
}
}
if (returnObj.IsError)
{
DisplayErrorMessage("Error Saving Item", returnObj.Error);
}
else
{
DisplaySuccessMessage("Successfully Saved Item");
LanguagesMapper.ClearAllActiveCache();
/*var rootDetails = BaseMapper.GetObjectFromContext((MediaDetail)FrameworkBaseMedia.RootMediaDetail);
* rootDetails.VirtualPath = URIHelper.GetBaseUrlWithLanguage(selectedItem);*/
/*returnObj = MediaDetailsMapper.Update(rootDetails);
*
* if (!returnObj.IsError)
* MediaDetailsMapper.StartUpdateVirtualPathForAllChildren(rootDetails);
* else
* DisplaySuccessMessage("Error updating root media item");*/
}
}
protected void DeletePermanently_OnClick(object sender, EventArgs e)
{
Comment comment = CommentsMapper.GetByID(long.Parse(((Button)sender).CommandArgument));
comment = BaseMapper.GetObjectFromContext <Comment>(comment);
//comment.MediaDetails.Clear();
Return obj = CommentsMapper.DeletePermanently(comment);
if (obj.IsError)
{
this.BasePage.DisplayErrorMessage("Error", obj.Error);
}
SetComments(statusEnum, mode, media);
}
private void HandleDelete(IMediaDetail item)
{
Return returnObj = MediaDetailsMapper.DeletePermanently((MediaDetail)item);
if (returnObj.IsError)
{
BasePage.DisplayErrorMessage("Error deleting association", returnObj.Error);
}
else
{
BasePage.DisplaySuccessMessage("Successfully deleted association");
selectedItem = BaseMapper.GetObjectFromContext((MediaDetail)selectedItem);
Bind();
}
}
protected void Reject_OnClick(object sender, EventArgs e)
{
Comment comment = CommentsMapper.GetByID(long.Parse(((Button)sender).CommandArgument));
comment = BaseMapper.GetObjectFromContext <Comment>(comment);
comment.Status = StatusEnum.Rejected.ToString();
Return obj = CommentsMapper.Update(comment);
if (obj.IsError)
{
this.BasePage.DisplayErrorMessage("Error", obj.Error);
}
SetComments(statusEnum, mode, media);
}
private void UpdateObjectFromFields()
{
SelectedItem.IsActive = IsActive.Checked;
SelectedItem.Name = Name.Text;
SelectedItem.Description = Description.Text;
SelectedItem.EnumName = EnumName.Text;
IEnumerable <Permission> items = PermissionsSelector.GetSelectedPermissions();
SelectedItem.Permissions.Clear();
foreach (Permission item in items)
{
SelectedItem.Permissions.Add(BaseMapper.GetObjectFromContext(item));
}
}
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 void Save_OnClick(object sender, EventArgs e)
{
if (!canAccessSection)
{
return;
}
if (SelectedItem == null)
{
SelectedItem = UsersMapper.CreateObject();
}
else
{
SelectedItem = BaseMapper.GetObjectFromContext <User>(SelectedItem);
}
SelectedItem.AuthenticationType = AuthType.Forms.ToString();
SelectedItem.ResetCode = "";
UpdateObjectFromFields();
Return returnObj = SelectedItem.Validate();
if (!returnObj.IsError)
{
if (SelectedItem.ID == 0)
{
returnObj = UsersMapper.Insert(SelectedItem);
}
else
{
returnObj = UsersMapper.Update(SelectedItem);
}
}
if (returnObj.IsError)
{
DisplayErrorMessage("Error Saving Item", returnObj.Error);
}
else
{
DisplaySuccessMessage("Successfully Saved Item");
}
}
protected void Save_OnClick(object sender, EventArgs e)
{
if (selectedItem == null)
{
selectedItem = MediaTypesMapper.CreateObject();
}
else
{
selectedItem = BaseMapper.GetObjectFromContext <MediaType>(selectedItem);
}
UpdateObjectFromFields();
Return returnObj = selectedItem.Validate();
if (!returnObj.IsError)
{
if (selectedItem.ID == 0)
{
returnObj = MediaTypesMapper.Insert(selectedItem);
}
else
{
returnObj = MediaTypesMapper.Update(selectedItem);
}
}
if (returnObj.IsError)
{
DisplayErrorMessage("Error Saving Item", returnObj.Error);
}
else
{
/*var mediaDetails = selectedItem.MediaDetails.Where(i => i.HistoryForMediaDetail == null);
*
* foreach (var mediaDetail in mediaDetails)
* {
* mediaDetail.RemoveFromCache();
* }*/
DisplaySuccessMessage("Successfully Saved Item");
}
}
public string DeleteItemPermanently(long id)
{
MediaType item = BaseMapper.GetObjectFromContext(MediaTypesMapper.GetByID(id));
if (item != null)
{
Return returnObj = MediaTypesMapper.DeletePermanently(item);
if (returnObj.IsError)
{
return(jGrowlHelper.GenerateCode(new jGrowlMessage("Error", "Error deleting item permanently", jGrowlMessage.jGrowlMessageType.Error, returnObj.Error), true));
}
else
{
return(jGrowlHelper.GenerateCode(new jGrowlMessage("Success", "Item was successfully deleted permanently", jGrowlMessage.jGrowlMessageType.Success), false));
}
}
return("");
}
private IMediaDetail CreateHistory(MediaDetail fromItem, bool isDraft)
{
if (fromItem == null)
{
return(null);
}
IMediaDetail history = null;
if ((selectedItem.ID != 0) && (historyVersion == 0))
{
history = MediaDetailsMapper.CreateObject(fromItem.MediaTypeID, fromItem.Media, fromItem.Media.ParentMedia, false);
history.CopyFrom(BaseMapper.GetObjectFromContext(fromItem));
history.IsDraft = isDraft;
CopyProperties(history, fromItem);
}
return(history);
}
public string TakeOwnership(long id)
{
User item = BaseMapper.GetObjectFromContext(UsersMapper.GetByID(id));
if (item != null)
{
Return returnObj = UsersMapper.TransferOwnership(item, FrameworkSettings.CurrentUser);
if (returnObj.IsError)
{
return(jGrowlHelper.GenerateCode(new jGrowlMessage("Error", "Error taking ownership", jGrowlMessage.jGrowlMessageType.Error, returnObj.Error), true));
}
else
{
return(jGrowlHelper.GenerateCode(new jGrowlMessage("Success", "Successfully took ownership of all items assigned to user: (" + item.UserName + ")", jGrowlMessage.jGrowlMessageType.Success), false));
}
}
return("");
}
private Return SetPublishStatus(MediaDetail detail, bool publishStatus)
{
if ((detail == null) || (detail.IsPublished == publishStatus))
{
return(new Return());
}
detail = BaseMapper.GetObjectFromContext(detail);
if (publishStatus)
{
detail.PublishDate = DateTime.Now;
}
else
{
detail.PublishDate = null;
}
Return returnObj = MediaDetailsMapper.Update(detail);
if (returnObj.IsError)
{
return(returnObj);
}
else
{
ContextHelper.ClearAllMemoryCache();
FileCacheHelper.DeleteCacheDir("generatenav");
if (publishStatus)
{
detail.PublishDate = DateTime.Now;
returnObj = detail.RunOnPublishExecuteCode();
return(returnObj);
}
return(returnObj);
}
}
private void HandleDeleteAssociation(Media selectedMedia)
{
selectedItem = BaseMapper.GetObjectFromContext <Tag>(selectedItem);
selectedMedia = BaseMapper.GetObjectFromContext <Media>(selectedMedia);
var mediaTag = selectedItem.MediaTags.SingleOrDefault(i => i.MediaID == selectedMedia.ID);
selectedItem.MediaTags.Remove(mediaTag);
Return obj = TagsMapper.Update(selectedItem);
if (obj.IsError)
{
BasePage.DisplayErrorMessage("Error deleting association", obj.Error);
}
else
{
BasePage.DisplaySuccessMessage("Successfully deleted association");
Bind();
}
}
private void SetShowInMenuStatus(MediaDetail detail, bool showInMenu)
{
if ((detail == null) || (detail.ShowInMenu == showInMenu))
{
return;
}
detail = BaseMapper.GetObjectFromContext(detail);
detail.ShowInMenu = showInMenu;
Return returnObj = MediaDetailsMapper.Update(detail);
if (returnObj.IsError)
{
throw returnObj.Error.Exception;
}
else
{
ContextHelper.ClearAllMemoryCache();
FileCacheHelper.DeleteCacheDir("generatenav");
}
}