private async Task AddUrlAsync(string file, PageDefinition page, string canonicalUrl, DateTime?lastMod, PageDefinition.SiteMapPriorityEnum siteMapPriority, PageDefinition.ChangeFrequencyEnum changeFrequency)
{
if (!PagesFound.Contains(page.PageGuid)) // keep track of pages so we don't add it as a designed page in case it was dynamic
{
PagesFound.Add(page.PageGuid);
}
canonicalUrl = Manager.CurrentSite.MakeUrl(canonicalUrl, PagePageSecurity: page.PageSecurity);
if (!ValidForSiteMap(page))
{
return;
}
string cf = GetChangeFrequencyText(changeFrequency);
float prio = GetPriority(siteMapPriority);
var w3clastMod = lastMod != null?string.Format(" <lastmod>{0}</lastmod>\r\n", XmlConvert.ToString((DateTime)lastMod, XmlDateTimeSerializationMode.Utc)) : "";
#if MVC6
canonicalUrl = WebUtility.HtmlEncode(canonicalUrl);
#else
canonicalUrl = AntiXssEncoder.XmlEncode(canonicalUrl);
#endif
await FileSystem.FileSystemProvider.AppendAllTextAsync(file, string.Format(
" <url>\r\n" +
" <loc>{0}</loc>\r\n" +
"{1}" +
" <changefreq>{2}</changefreq>\r\n" +
" <priority>{3}</priority>\r\n" +
" </url>\r\n", canonicalUrl, w3clastMod, cf, prio)
);
}
protected override void SetupEditControls()
{
Category parentCategory = null;
var definition = PageDefinition.Load(PropertyData.PageDefinitionID);
if (!string.IsNullOrEmpty(definition.HelpText))
{
parentCategory = Category.Find(definition.HelpText);
}
if (parentCategory == null)
{
parentCategory = Category.Find(Name);
}
if (parentCategory == null)
{
parentCategory = Category.GetRoot();
}
CategorgyIds = GetCategoryIds(PropertyData.Value.ToString());
foreach (Category category in parentCategory.Categories)
{
var li = new ListItem(category.Description, category.ID.ToString(CultureInfo.InvariantCulture));
li.Selected = CategorgyIds.Any(c => c == category.ID);
EditControl.Items.Add(li);
}
}
public async Task <ActionResult> SetUser(Guid guid)
{
using (PageDefinitionDataProvider pageDP = new PageDefinitionDataProvider()) {
int adminRole = Resource.ResourceAccess.GetAdministratorRoleId();
int userRole = Resource.ResourceAccess.GetUserRoleId();
PageDefinition page = await PageDefinition.LoadAsync(guid);
if (page == null)
{
throw new InternalError($"Page with Guid {0} not found", guid);
}
page.AllowedRoles = new SerializableList <PageDefinition.AllowedRole>();
page.AllowedUsers = new SerializableList <PageDefinition.AllowedUser>();
page.AllowedRoles.Add(new PageDefinition.AllowedRole {
RoleId = userRole, View = PageDefinition.AllowedEnum.Yes
});
foreach (PageDefinition.ModuleEntry modEntry in page.ModuleDefinitions)
{
ModuleDefinition module = await modEntry.GetModuleAsync();
if (module != null)
{
module.AllowedRoles = new SerializableList <ModuleDefinition.AllowedRole>();
module.AllowedUsers = new SerializableList <ModuleDefinition.AllowedUser>();
module.AllowedRoles.Add(new ModuleDefinition.AllowedRole {
RoleId = userRole, View = ModuleDefinition.AllowedEnum.Yes
});
}
}
await page.SaveAsync();
}
return(Reload(null, Reload: ReloadEnum.ModuleParts));
}
public void Configure(ConfigNode node)
{
ConfigNode[] pages = node.GetNodes("PAGE_DEFINITION");
if (pages != null && pages.Length > 0)
{
definitions = new PageDefinition[pages.Length];
for (int i = 0; i < pages.Length; ++i)
{
string variableName = pages[i].GetValue("variableName");
string range = pages[i].GetValue("range");
string page = pages[i].GetValue("page");
if (string.IsNullOrEmpty(variableName) || string.IsNullOrEmpty(range) || string.IsNullOrEmpty(page))
{
JUtil.LogErrorMessage(this, "Incorrect page definition for page {0}", i);
definitions = null;
if (string.IsNullOrEmpty(definitionIn))
{
// Make sure we aren't crashing later.
definitionIn = definitionOut;
}
return;
}
definitions[i] = new PageDefinition(variableName, range, page);
}
}
}
public PropertySettingsContainer GetPageDefinitionsPropertySettingsContainer(PageDefinition pageDefinition)
{
PropertySettingsContainer container;
PropertySettingsRepository.TryGetContainer(pageDefinition.SettingsID, out container);
return(container);
}
private void HandleDefaultValues(PageDefinition pageDefinition)
{
if (pageDefinition.DefaultValue != null && pageDefinition.DefaultValue == string.Empty)
pageDefinition.DefaultValue = null;
if (pageDefinition.DefaultValue != null)
{
object value;
try
{
value = PropertyData.CreatePropertyDataObject(pageDefinition.Type.DataType).ParseToObject(pageDefinition.DefaultValue).Value;
}
catch
{
value = null;
}
if (value == null)
{
pageDefinition.DefaultValue = null;
}
}
if (pageDefinition.DefaultValue == null && pageDefinition.DefaultValueType == DefaultValueType.Value && pageDefinition.Type.DataType != PropertyDataType.Boolean)
pageDefinition.DefaultValueType = DefaultValueType.None;
}
public static void AddContentAreaProperty(PageType pageType, string name, string description)
{
Predicate<PageDefinition> match = null;
if (pageType.Definitions.Find(def => def.Name == name) == null)
{
match = delegate(PageDefinition def)
{
return def.Name == name;
};
if (pageType.Definitions.Find(match) == null)
{
var item = new PageDefinition();
item.PageTypeID = pageType.ID;
item.Name = name;
item.EditCaption = name;
item.HelpText = description;
item.DefaultValueType = DefaultValueType.None;
item.DefaultValue = "";
item.Type = PageTypeManager.ContentAreaPropertyType;
item.ID = 0;
item.Searchable = true;
item.Tab = PageTypeManager.LoadExtensionTab();
item.DisplayEditUI = false;
item.LanguageSpecific = false;
item.LongStringSettings = 0;
item.Save();
item.ClearCache();
pageType.Definitions.Add(item);
PageDefinitionType.ClearCache();
}
}
}
public PageDefinitionAction(
PageDefinition pageDefinition,
IMigrationContext context)
{
this.pageDefinition = pageDefinition;
this.context = context;
}
protected internal virtual void UpdatePropertySettings(PageTypeDefinition pageTypeDefinition, PageTypePropertyDefinition propertyDefinition, PageDefinition pageDefinition)
{
PropertySettingsContainer container = GetPropertySettingsContainer(pageDefinition);
UpdatePageDefinitionsGlobalPropertySettings(propertyDefinition, pageTypeDefinition, container);
UpdatePageDefinitionsLocalPropertySettings(propertyDefinition, pageTypeDefinition, container);
}
public void AddData(PageDefinition page)
{
if (page != null)
{
SelectedPane_List = page.GetPanes();
}
}
public static void AddContentAreaProperty(PageType pageType, string name, string description)
{
Predicate <PageDefinition> match = null;
if (pageType.Definitions.Find(def => def.Name == name) == null)
{
match = delegate(PageDefinition def)
{
return(def.Name == name);
};
if (pageType.Definitions.Find(match) == null)
{
var item = new PageDefinition();
item.PageTypeID = pageType.ID;
item.Name = name;
item.EditCaption = name;
item.HelpText = description;
item.DefaultValueType = DefaultValueType.None;
item.DefaultValue = "";
item.Type = PageTypeManager.ContentAreaPropertyType;
item.ID = 0;
item.Searchable = true;
item.Tab = PageTypeManager.LoadExtensionTab();
item.DisplayEditUI = false;
item.LanguageSpecific = false;
item.LongStringSettings = 0;
item.Save();
item.ClearCache();
pageType.Definitions.Add(item);
PageDefinitionType.ClearCache();
}
}
}
public void Configure(ConfigNode node)
{
ConfigNode[] pages = node.GetNodes("PAGE_DEFINITION");
if (pages != null && pages.Length > 0)
{
definitions = new PageDefinition[pages.Length];
for (int i = 0; i < pages.Length; ++i)
{
string variableName = pages[i].GetValue("variableName");
string range = pages[i].GetValue("range");
string page = pages[i].GetValue("page");
if (string.IsNullOrEmpty(variableName) || string.IsNullOrEmpty(range) || string.IsNullOrEmpty(page))
{
JUtil.LogErrorMessage(this, "Incorrect page definition for page {0}", i);
definitions = null;
if (string.IsNullOrEmpty(definitionIn))
{
// Make sure we aren't crashing later.
definitionIn = definitionOut;
}
return;
}
definitions[i] = new PageDefinition(variableName, range, page);
}
}
}
public async Task <ActionResult> AddNewPage_Partial(AddNewPageModel model)
{
if (!ModelState.IsValid)
{
return(PartialView(model));
}
PageDefinition basePage = null;
if (model.CopyPage)
{
basePage = await PageDefinition.LoadAsync(model.CurrentPageGuid);
}
PageDefinition.NewPageInfo newPage = await PageDefinition.CreateNewPageAsync(model.Title, model.Description, model.Url, basePage, model.CopyModules);
PageDefinition page = newPage.Page;
if (page == null)
{
ModelState.AddModelError(nameof(model.Url), newPage.Message);
return(PartialView(model));
}
await page.SaveAsync();
return(FormProcessed(model, this.__ResStr("okNewPage", "New page created"), NextPage: page.EvaluatedCanonicalUrl));
}
private async Task <PageDefinition> CreatePageDefinitionAsync(PageDefinition page)
{
using (ILockObject lockObject = await LockDesignedPagesAsync()) {
PageDefinition.DesignedPage desPage = new PageDefinition.DesignedPage()
{
PageGuid = page.PageGuid, Url = page.Url,
};
DesignedPagesDictionaryByUrl designedPagesByUrl = await GetDesignedPagesWithoutLockAsync();
if (designedPagesByUrl.ContainsKey(desPage.Url.ToLower()))
{
throw new Error(this.__ResStr("pageUrlErr", "A page with Url {0} already exists.", desPage.Url));
}
if (!await DataProvider.AddAsync(page))
{
throw new Error(this.__ResStr("pageGuidErr", "A page with Guid {0} already exists.", desPage.PageGuid));
}
await SetCachedPageAsync(page);
await AddDesignedPageAsync(designedPagesByUrl, page.Url.ToLower(), desPage);
await lockObject.UnlockAsync();
}
await Auditing.AddAuditAsync($"{nameof(PageDefinitionDataProvider)}.{nameof(CreatePageDefinitionAsync)}", page.Url, page.PageGuid,
"Create Page",
DataBefore : null,
DataAfter : page,
ExpensiveMultiInstance : true
);
return(page);
}
public async Task <ActionResult> UpdateAdminAndEditorAuthorization()
{
using (PageDefinitionDataProvider pageDP = new PageDefinitionDataProvider()) {
int adminRole = Resource.ResourceAccess.GetAdministratorRoleId();
int editorRole = Resource.ResourceAccess.GetEditorRoleId();
DataProviderGetRecords <PageDefinition> pages = await pageDP.GetItemsAsync(0, 0, null, null);
foreach (PageDefinition genericPage in pages.Data)
{
PageDefinition page = await PageDefinition.LoadAsync(genericPage.PageGuid);
if (page != null)
{
PageDefinition.AllowedRole role;
while ((role = PageDefinition.AllowedRole.Find(page.AllowedRoles, adminRole)) != null)
{
page.AllowedRoles.Remove(role);
}
page.AllowedRoles.Add(new PageDefinition.AllowedRole {
RoleId = adminRole, View = PageDefinition.AllowedEnum.Yes, Edit = PageDefinition.AllowedEnum.Yes, Remove = PageDefinition.AllowedEnum.Yes,
});
while ((role = PageDefinition.AllowedRole.Find(page.AllowedRoles, editorRole)) != null)
{
page.AllowedRoles.Remove(role);
}
page.AllowedRoles.Add(new PageDefinition.AllowedRole {
RoleId = editorRole, View = PageDefinition.AllowedEnum.Yes, Edit = PageDefinition.AllowedEnum.Yes,
});
await page.SaveAsync();
}
}
}
return(Reload(null, Reload: ReloadEnum.ModuleParts));
}
private bool TryPageTitle(PageDefinition page, List <string> lines)
{
if (lines.Count() <= 0)
{
return(false);
}
string line = lines.First();
string[] parts = line.Split(new char[] { '=' }, 2);
if (parts.Length < 1)
{
return(false);
}
string cmd = parts[0].Trim();
if (string.IsNullOrWhiteSpace(cmd))
{
return(false);
}
if (cmd != "Title")
{
return(false);
}
page.Title = page.Description = parts[1].Trim();
++_LineCounter; lines.RemoveAt(0);
return(true);
}
private string GetImage(PageDefinition pageDef)
{
string image;
string type;
if (pageDef.FavIcon != null)
{
type = PageDefinition.ImageType;
image = pageDef.FavIcon;
}
else if (Module.DefaultImage != null)
{
type = ModuleImageSupport.ImageType;
image = Module.DefaultImage;
}
else
{
type = PageDefinition.ImageType;
image = Guid.Empty.ToString();
}
int size;
switch (Module.Style)
{
default:
case PageBarModule.PanelStyleEnum.Vertical:
size = 32;
break;
case PageBarModule.PanelStyleEnum.Horizontal:
size = 32;
break;
}
return(ImageHTML.FormatUrl(type, null, image, size, size, Stretch: true));
}
protected internal virtual string SerializeValues(PageDefinition pageDefinition)
{
StringBuilder builder = new StringBuilder();
builder.Append(pageDefinition.EditCaption);
builder.Append("|");
builder.Append(pageDefinition.HelpText);
builder.Append("|");
builder.Append(pageDefinition.Required);
builder.Append("|");
builder.Append(pageDefinition.Searchable);
builder.Append("|");
builder.Append(pageDefinition.DefaultValue);
builder.Append("|");
builder.Append(pageDefinition.DefaultValueType);
builder.Append("|");
builder.Append(pageDefinition.LanguageSpecific);
builder.Append("|");
builder.Append(pageDefinition.DisplayEditUI);
builder.Append("|");
builder.Append(pageDefinition.FieldOrder);
builder.Append("|");
builder.Append(pageDefinition.LongStringSettings);
builder.Append("|");
builder.Append(pageDefinition.Tab.ID);
builder.Append("|");
return(builder.ToString());
}
public static void AddExtensionPageProperty(PageType pageType)
{
if (pageType.Definitions.Find(def => def.Name == "ExtensionPageProperty") == null)
{
if (pageType.Definitions.Find(def => def.Name == "ExtensionPageProperty") == null)
{
var item = new PageDefinition();
item.PageTypeID = pageType.ID;
item.Name = "ExtensionPageProperty";
item.EditCaption = "ExtensionPageProperty";
item.HelpText = "Specialized For Extension Added By Extension (Do not remove)";
item.DefaultValueType = DefaultValueType.None;
item.DefaultValue = "";
item.Type = PageTypeManager.ExtensionPageDefinitionType;
item.ID = 0;
item.Searchable = true;
item.Tab = PageTypeManager.LoadExtensionTab();
item.DisplayEditUI = true;
item.LanguageSpecific = true;
item.LongStringSettings = 0;
item.Save();
item.ClearCache();
pageType.Definitions.Add(item);
}
}
PageDefinitionType.ClearCache();
}
/// <summary>
/// Create a page list for the current site.
/// </summary>
public async Task <string> CreateAsync()
{
StringBuilder sb = new StringBuilder();
// Designed pages (only)
List <Guid> pageGuids = await PageDefinition.GetDesignedGuidsAsync();
List <string> pages = new List <string>();
foreach (Guid guid in pageGuids)
{
PageDefinition page = await PageDefinition.LoadPageDefinitionAsync(guid);
if (page != null)
{
pages.Add(page.EvaluatedCanonicalUrl);
}
}
pages = pages.OrderBy(s => s).ToList();
foreach (string page in pages)
{
sb.AppendLine(Manager.CurrentSite.MakeFullUrl(page));
}
return(sb.ToString());
}
public async Task <ActionResult> PageEdit_Partial(EditModel model)
{
PageDefinition page = await PageDefinition.LoadAsync(model.PageGuid);
if (page == null)
{
throw new Error(this.__ResStr("alreadyDeleted", "This page has been removed and can no longer be updated."));
}
model.UpdateData(page);
ObjectSupport.CopyData(page, model.Page, ReadOnly: true); // update read only properties in model in case there is an error
model.Page.FavIcon_Data = page.FavIcon_Data; // copy favicon
if (!ModelState.IsValid)
{
return(PartialView(model));
}
page = model.GetData(page); // merge new data into original
model.SetData(page); // and all the data back into model for final display
await page.SaveAsync(); // this handles changing the Url automatically
MenuList.ClearCachedMenus(); // page changes may affect all menus so clear the menu cache (this only clears current session)
// if we're in a popup and the parent page is the page we're editing, then force a reload
//$$$$ rename with querystring doesn't work
OnPopupCloseEnum popupClose = OnPopupCloseEnum.ReloadModule;
if (PageDefinition.IsSamePage(Manager.QueryReturnToUrl.Url, model.Page.Url))
{
popupClose = OnPopupCloseEnum.ReloadParentPage;
}
return(FormProcessed(model, this.__ResStr("okSaved", "Page settings saved"), OnPopupClose: popupClose));
}
protected internal virtual string SerializeValues(PageDefinition pageDefinition)
{
StringBuilder builder = new StringBuilder();
builder.Append(pageDefinition.EditCaption);
builder.Append("|");
builder.Append(pageDefinition.HelpText);
builder.Append("|");
builder.Append(pageDefinition.Required);
builder.Append("|");
builder.Append(pageDefinition.Searchable);
builder.Append("|");
builder.Append(pageDefinition.DefaultValue);
builder.Append("|");
builder.Append(pageDefinition.DefaultValueType);
builder.Append("|");
builder.Append(pageDefinition.LanguageSpecific);
builder.Append("|");
builder.Append(pageDefinition.DisplayEditUI);
builder.Append("|");
builder.Append(pageDefinition.FieldOrder);
builder.Append("|");
builder.Append(pageDefinition.LongStringSettings);
builder.Append("|");
builder.Append(pageDefinition.Tab.ID);
builder.Append("|");
return builder.ToString();
}
public void AddData(PageDefinition page)
{
if (page != null)
{
ExistingModulePane_List = page.GetPanes();
}
}
private async Task SearchPageAsync(SearchWords searchWords, PageDefinition page)
{
if (!searchWords.WantPage(page))
{
return;
}
if (await searchWords.SetUrlAsync(page.Url, page.PageSecurity, page.Title, page.Description, page.Created, page.Updated, page.IsAuthorized_View_Anonymous(), page.IsAuthorized_View_AnyUser()))
{
searchWords.AddKeywords(page.Keywords);
foreach (var m in page.ModuleDefinitions)
{
Guid modGuid = m.ModuleGuid;
ModuleDefinition mod = null;
try {
mod = await ModuleDefinition.LoadAsync(m.ModuleGuid);
} catch (Exception ex) {
Logging.AddErrorLog("An error occurred retrieving module {0} in page {1}", m.ModuleGuid, page.Url, ex);
}
if (mod != null)
{
SearchModule(searchWords, mod);
}
}
await searchWords.SaveAsync();
}
}
public static void AddExtensionPageProperty(PageType pageType)
{
if (pageType.Definitions.Find(def => def.Name == "ExtensionPageProperty") == null)
{
if (pageType.Definitions.Find(def => def.Name == "ExtensionPageProperty") == null)
{
var item = new PageDefinition();
item.PageTypeID = pageType.ID;
item.Name = "ExtensionPageProperty";
item.EditCaption = "ExtensionPageProperty";
item.HelpText = "Specialized For Extension Added By Extension (Do not remove)";
item.DefaultValueType = DefaultValueType.None;
item.DefaultValue = "";
item.Type = PageTypeManager.ExtensionPageDefinitionType;
item.ID = 0;
item.Searchable = true;
item.Tab = PageTypeManager.LoadExtensionTab();
item.DisplayEditUI = true;
item.LanguageSpecific = true;
item.LongStringSettings = 0;
item.Save();
item.ClearCache();
pageType.Definitions.Add(item);
}
}
PageDefinitionType.ClearCache();
}
public async Task <ActionResult> AddNewModule_Partial(AddNewModuleModel model)
{
PageDefinition page = await PageDefinition.LoadAsync(model.CurrentPageGuid);
if (page == null)
{
throw new Error("Can't edit this page");
}
model.AddData(page);
if (!ModelState.IsValid)
{
return(PartialView(model));
}
ModuleDefinition module = ModuleDefinition.CreateNewDesignedModule(model.SelectedModule, model.ModuleName, model.ModuleTitle);
if (!module.IsModuleUnique)
{
module.ModuleGuid = Guid.NewGuid();
}
page.AddModule(model.SelectedPane, module, model.ModuleLocation == Location.Top);
await page.SaveAsync();
return(Reload(model, PopupText: this.__ResStr("okNew", "New module added")));
}
public static void AddContentAreaProperty(PageType pageType, string name, string description)
{
Predicate<PageDefinition> match = null;
if (pageType.Definitions.Find(def => def.Name == name) == null)
{
match = delegate(PageDefinition def)
{
return def.Name == name;
};
if (pageType.Definitions.Find(match) == null)
{
var item = new PageDefinition
{
PageTypeID = pageType.ID,
Name = name,
EditCaption = name,
HelpText = string.IsNullOrEmpty(description) ? string.Empty : description,
DefaultValueType = DefaultValueType.None,
DefaultValue = "",
Type = PageTypeManager.ContentAreaPropertyType,
ID = 0,
Searchable = true,
Tab = PageTypeManager.LoadExtensionTab(),
DisplayEditUI = false,
LanguageSpecific = false,
LongStringSettings = 0
};
item.Save();
item.ClearCache();
pageType.Definitions.Add(item);
PageDefinitionType.ClearCache();
}
}
}
public async Task <ActionResult> ExportPage(Guid pageGuid, long cookieToReturn)
{
PageDefinition page = await PageDefinition.LoadAsync(pageGuid);
YetaWFZipFile zipFile = await page.ExportAsync();
return(new ZippedFileResult(zipFile, cookieToReturn));
}
private IObservable <FrameworkElement> SetPageDataContext(PageDefinition pageDefinition, IViewModel viewModel)
{
return(Observable.FromEventPattern <NavigatedEventHandler, NavigationEventArgs>(h => _frame.Navigated += h, h => _frame.Navigated -= h, _dispatcherScheduler)
.Where(args => args.EventArgs.SourcePageType == pageDefinition.PageType)
.Select(args => ((FrameworkElement)args.EventArgs.Content))
.Do(page => page.DataContext = viewModel)
.Take(1));
}
private void ModifyComposerPropertyTypes(PageDefinition pageDefinition, PropertyDefinition propertyDefinition)
{
if (pageDefinition.Type.TypeName == ComposerPropertyTypes.ContentArea)
{
propertyDefinition.DisplayEditUI = true;
propertyDefinition.Searchable = false;
propertyDefinition.LanguageSpecific = true;
}
}
public PageRenderItemDefinitionContext(PageDefinition pageDefinition, Item item, DisplayMode exteriorDisplayMode)
{
Assert.ArgumentNotNull(pageDefinition, nameof(pageDefinition));
Assert.ArgumentNotNull(item, nameof(item));
Definition = pageDefinition;
Item = item;
PageMode = exteriorDisplayMode;
}
private IEnumerable<PageDefinition> MapRecordsToExposedObjects(IEnumerable<PageDefinition> internalRecords)
{
return internalRecords.Select(pd =>
{
var exposedPageDefinition = new PageDefinition();
Mapper.Map(pd, exposedPageDefinition);
return exposedPageDefinition;
});
}
private IEnumerable <PageDefinition> MapRecordsToExposedObjects(IEnumerable <PageDefinition> internalRecords)
{
return(internalRecords.Select(pd =>
{
var exposedPageDefinition = new PageDefinition();
Mapper.Map(pd, exposedPageDefinition);
return exposedPageDefinition;
}));
}
public void GivenPageTypePropertyDefinition_CreateNewPageDefinition_CallsSetPageDefinitionTypeMethod()
{
PageTypePropertyUpdater partiallyMockedUtility = CreatePageTypePropertyUpdaterWithFakePageDefinitionFactoryAndFakedSetPageDefinitionTypeMethod();
PageTypePropertyDefinition pageTypePropertyDefinition = PageTypePropertyUpdaterTestsUtility.CreatePageTypePropertyDefinition();
PageDefinition returnedPageDefintion = partiallyMockedUtility.CreateNewPageDefinition(pageTypePropertyDefinition);
partiallyMockedUtility.AssertWasCalled(utility => utility.SetPageDefinitionType(returnedPageDefintion, pageTypePropertyDefinition));
}
protected internal virtual void UpdatePageDefinition(PageDefinition pageDefinition, PageTypePropertyDefinition pageTypePropertyDefinition)
{
string oldValues = SerializeValues(pageDefinition);
UpdatePageDefinitionValues(pageDefinition, pageTypePropertyDefinition);
if(SerializeValues(pageDefinition) != oldValues)
PageDefinitionFactory.Save(pageDefinition);
}
public void GivenPageTypePropertyDefinition_CreateNewPageDefinition_SavesPageDefinition()
{
PageTypePropertyUpdater utility = CreatePageTypePropertyUpdaterWithFakePageDefinitionFactoryAndFakedSetPageDefinitionTypeMethod();
PageTypePropertyDefinition definition = PageTypePropertyUpdaterTestsUtility.CreatePageTypePropertyDefinition();
PageDefinition returnedPageDefinition = utility.CreateNewPageDefinition(definition);
utility.PageDefinitionFactory.AssertWasCalled(factory => factory.Save(returnedPageDefinition));
}
public void GivenPageTypePropertyDefinition_CreateNewPageDefinition_ReturnsPageDefinitionWithCorrectName()
{
PageTypePropertyUpdater utility = CreatePageTypePropertyUpdaterWithFakePageDefinitionFactoryAndFakedSetPageDefinitionTypeMethod();
PageTypePropertyDefinition definition = PageTypePropertyUpdaterTestsUtility.CreatePageTypePropertyDefinition();
PageDefinition returnedPageDefintion = utility.CreateNewPageDefinition(definition);
Assert.Equal <string>(definition.Name, returnedPageDefintion.Name);
}
public void AddData(PageDefinition page, PageControlModule mod)
{
UploadFile = new FileUpload1 {
SelectButtonText = this.__ResStr("btnImportPage", "Import Page Data..."),
SaveURL = Utility.UrlFor(typeof(PageControlModuleController), nameof(PageControlModuleController.ImportPage), new { __ModuleGuid = mod.ModuleGuid }),
RemoveURL = Utility.UrlFor(typeof(PageControlModuleController), nameof(PageControlModuleController.RemovePage), new { __ModuleGuid = mod.ModuleGuid }),
SerializeForm = true,
};
}
public void GivenPropertyDefinitionWithNoHelpText_UpdatePageDefinition_SetsHelpTextToEmptyString()
{
var pageDefinitionUpdater = GetPageDefinitionUpdater();
PageDefinition pageDefinitionToUpdate = new PageDefinition();
PageTypePropertyDefinition propertyDefinition = CreatePageTypePropertyDefinition();
pageDefinitionUpdater.UpdateExistingPageDefinition(pageDefinitionToUpdate, propertyDefinition);
Assert.Equal<string>(string.Empty, pageDefinitionToUpdate.HelpText);
}
private async Task <PageDefinition> LoadPageAsync(Guid pageGuid)
{
PageDefinition page = await PageDefinition.LoadAsync(pageGuid);
if (page == null)
{
throw new Error(this.__ResStr("pageNotFound", "Page {0} doesn't exist"), pageGuid.ToString());
}
return(page);
}
public void GivenPageDefinitionWithSpecifiedLongStringSetting_UpdatePageDefinition_ReturnsDifferentStringThanWhenCalledWithPageDefinitionWithNoLongStringSettings()
{
PageTypePropertyUpdater pageTypePropertyUpdater = PageTypePropertyUpdaterFactory.Create();
PageDefinition pageDefinition = new PageDefinition();
string valuesWithOutClearAllLongStringSettings = pageTypePropertyUpdater.SerializeValues(pageDefinition);
pageDefinition.LongStringSettings = EditorToolOption.Bold;
string returnedValue = pageTypePropertyUpdater.SerializeValues(pageDefinition);
Assert.NotEqual<string>(valuesWithOutClearAllLongStringSettings, returnedValue);
}
public void GivenPropertyDefinition_UpdatePageDefinition_CallsUpdatePageDefinitionValues()
{
PageTypePropertyUpdater pageTypePropertyUpdater =
CreatePageTypePropertyUpdaterWithFakePageDefinitionFactoryAndFakeUpdatePageDefinitionValuesMethod();
PageDefinition pageDefinitionToUpdate = new PageDefinition();
PageTypePropertyDefinition propertyDefinition = CreatePageTypePropertyDefinition();
pageTypePropertyUpdater.UpdatePageDefinition(pageDefinitionToUpdate, propertyDefinition);
pageTypePropertyUpdater.AssertWasCalled(
utility => utility.UpdatePageDefinitionValues(pageDefinitionToUpdate, propertyDefinition));
}
protected internal virtual PageDefinition CreateNewPageDefinition(PageTypePropertyDefinition propertyDefinition)
{
PageDefinition pageDefinition = new PageDefinition();
pageDefinition.PageTypeID = propertyDefinition.PageType.ID;
pageDefinition.Name = propertyDefinition.Name;
pageDefinition.EditCaption = propertyDefinition.GetEditCaptionOrName();
SetPageDefinitionType(pageDefinition, propertyDefinition);
PageDefinitionFactory.Save(pageDefinition);
return pageDefinition;
}
public virtual void CreateNewPageDefinition(PageTypePropertyDefinition propertyDefinition)
{
PageDefinition pageDefinition = new PageDefinition();
pageDefinition.PageTypeID = propertyDefinition.PageType.ID;
pageDefinition.Name = propertyDefinition.Name;
pageDefinition.EditCaption = propertyDefinition.GetEditCaptionOrName();
SetPageDefinitionType(pageDefinition, propertyDefinition);
UpdatePageDefinitionValues(pageDefinition, propertyDefinition);
pageDefinitionRepository.Save(pageDefinition);
}
public virtual void UpdateExistingPageDefinition(PageDefinition pageDefinition, PageTypePropertyDefinition pageTypePropertyDefinition)
{
string oldValues = SerializeValues(pageDefinition);
UpdatePageDefinitionValues(pageDefinition, pageTypePropertyDefinition);
string updatedValues = SerializeValues(pageDefinition);
if (updatedValues != oldValues)
{
log.Debug(string.Format("Updating PageDefintion, old values: {0}, new values: {1}.", oldValues, updatedValues));
pageDefinitionRepository.Save(pageDefinition);
}
}
public void GivenPropertyDefinitionWithNoEditCaptionAndNameOtherThanPageDefinitionEditCaption_UpdatedPageDefinitionEditCaption()
{
PageTypePropertyUpdater pageTypePropertyUpdater = CreatePageTypePropertyUpdaterWithFakeUpdatePageDefinitionTabMethod();
PageDefinition pageDefinitionToUpdate = new PageDefinition();
pageDefinitionToUpdate.EditCaption = TestValueUtility.CreateRandomString();
string newEditCaption = TestValueUtility.CreateRandomString();
PageTypePropertyDefinition propertyDefinition = CreatePageTypePropertyDefinition();
propertyDefinition.Name = newEditCaption;
pageTypePropertyUpdater.UpdatePageDefinitionValues(pageDefinitionToUpdate, propertyDefinition);
Assert.Equal<string>(newEditCaption, pageDefinitionToUpdate.EditCaption);
}
public void GivenPropertyDefinitionWithNewEditCaption_UpdatePageDefinitionValues_UpdatedPageDefinitionEditCaption()
{
var pageDefinitionUpdater = GetPageDefinitionUpdater();
PageDefinition pageDefinitionToUpdate = new PageDefinition();
pageDefinitionToUpdate.EditCaption = TestValueUtility.CreateRandomString();
string newEditCaption = TestValueUtility.CreateRandomString();
PageTypePropertyDefinition propertyDefinition = CreatePageTypePropertyDefinition();
propertyDefinition.PageTypePropertyAttribute.EditCaption = newEditCaption;
pageDefinitionUpdater.UpdateExistingPageDefinition(pageDefinitionToUpdate, propertyDefinition);
Assert.Equal<string>(newEditCaption, pageDefinitionToUpdate.EditCaption);
}
protected internal virtual void UpdatePropertySettings(PageTypeDefinition pageTypeDefinition, PageTypePropertyDefinition propertyDefinition, PageDefinition pageDefinition)
{
PropertySettingsContainer container = GetPropertySettingsContainer(pageDefinition);
object[] attributes = GetPropertyAttributes(propertyDefinition, pageTypeDefinition);
var useGlobalSettingsAttribute = attributes.OfType<UseGlobalSettingsAttribute>().FirstOrDefault();
if(useGlobalSettingsAttribute != null)
{
//TODO: Should validate not null and valid type at startup
var globalSettingsUpdater = globalPropertySettingsLocator.GetGlobalPropertySettingsUpdaters().Where(u => u.WrappedInstanceType == useGlobalSettingsAttribute.Type).First();
var wrapper =_propertySettingsRepository.GetGlobals(globalSettingsUpdater.SettingsType)
.Where(w => globalSettingsUpdater.Match(w))
.First();
container.Settings[globalSettingsUpdater.SettingsType.FullName] = wrapper;
//TODO: Add spec validating that exception is thrown with the below uncommented (An item with the same key has already been added.)
//container.Settings.Add(globalSettingsUpdater.SettingsType.FullName, wrapper);
_propertySettingsRepository.Save(container);
}
List<PropertySettingsUpdater> settingsUpdaters = GetPropertySettingsUpdaters(pageTypeDefinition, propertyDefinition, pageDefinition);
settingsUpdaters.ForEach(updater =>
{
var wrapper = container.GetSetting(updater.SettingsType);
if (wrapper == null)
{
wrapper = new PropertySettingsWrapper();
container.Settings[updater.SettingsType.FullName] = wrapper;
//TODO: Add spec validating that exception is thrown with the below uncommented (An item with the same key has already been added.)
//container.Settings.Add(updater.SettingsType.FullName, wrapper);
}
bool settingsAlreadyExists = true;
if (wrapper.PropertySettings == null)
{
wrapper.PropertySettings = ((IPropertySettings)Activator.CreateInstance(updater.SettingsType)).GetDefaultValues();
settingsAlreadyExists = false;
}
if (settingsAlreadyExists && !updater.OverWriteExisting)
return;
int hashBeforeUpdate = updater.GetSettingsHashCode(wrapper.PropertySettings);
updater.UpdateSettings(wrapper.PropertySettings);
int hashAfterUpdate = updater.GetSettingsHashCode(wrapper.PropertySettings);
if (hashBeforeUpdate != hashAfterUpdate || !settingsAlreadyExists)
{
_propertySettingsRepository.Save(container);
}
});
}
public void GivenPageTypeWithPropertyAndCorrespondingPropertyDefition_GetExistingPropertyDefinition_ReturnsPageDefinition()
{
PageTypePropertyUpdater utility = PageTypePropertyUpdaterFactory.Create();
IPageType pageType = new NativePageType();
string name = TestValueUtility.CreateRandomString();
Type type = typeof(string);
PageTypePropertyAttribute attribute = new PageTypePropertyAttribute();
PageTypePropertyDefinition pageTypePropertyDefinition = new PageTypePropertyDefinition(name, type, pageType, attribute);
PageDefinition pageDefinition = new PageDefinition();
pageDefinition.Name = name;
pageType.Definitions.Add(pageDefinition);
PageDefinition returnedPageDefinition = utility.GetExistingPageDefinition(pageType, pageTypePropertyDefinition);
Assert.Equal<PageDefinition>(pageDefinition, returnedPageDefinition);
}
private PageDefinition CreateDefinition(PageDefinitionStore pageDefinitionStore, string name)
{
var def = new PageDefinition();
def.Name = name;
var container = new ContentItem { Name = "container", Type = "container"};
var row = new ContentItem { Name = "row1", Type = "row" };
var column = new ContentItem { Name = "col-1", Type = "column" };
row.Items.Add(column);
container.Items.Add(row);
def.Items.Add(container);
pageDefinitionStore.Add(def);
return def;
}
protected internal virtual void UpdatePropertySettings(PageTypeDefinition pageTypeDefinition, PageTypePropertyDefinition propertyDefinition, PageDefinition pageDefinition)
{
var prop =
pageTypeDefinition.Type.GetProperties().Where(p => p.Name == propertyDefinition.Name).FirstOrDefault
();
var attributes = prop.GetCustomAttributes(typeof(PropertySettingsAttribute), true);
foreach (var attribute in attributes)
{
PropertySettingsContainer container;
if (pageDefinition.SettingsID == Guid.Empty)
{
pageDefinition.SettingsID = Guid.NewGuid();
PageDefinitionFactory.Save(pageDefinition);
container = new PropertySettingsContainer(pageDefinition.SettingsID);
}
else
{
if (!_propertySettingsRepository.TryGetContainer(pageDefinition.SettingsID, out container))
{
container = new PropertySettingsContainer(pageDefinition.SettingsID);
}
}
var settingsAttribute = (PropertySettingsAttribute) attribute;
var wrapper = container.GetSetting(settingsAttribute.SettingType);
if (wrapper == null)
{
wrapper = new PropertySettingsWrapper();
container.Settings.Add(settingsAttribute.SettingType.FullName, wrapper);
}
bool settingsAlreadyExists = true;
if (wrapper.PropertySettings == null)
{
wrapper.PropertySettings = (IPropertySettings) Activator.CreateInstance(settingsAttribute.SettingType);
settingsAlreadyExists = false;
}
if(settingsAlreadyExists && !settingsAttribute.OverWriteExistingSettings)
return;
if(settingsAttribute.UpdateSettings(wrapper.PropertySettings) || !settingsAlreadyExists)
_propertySettingsRepository.Save(container);
}
}
void UpdatePageDefinitionsGlobalPropertySettings(PageTypePropertyDefinition propertyDefinition, PageTypeDefinition pageTypeDefinition, PageDefinition pageDefinition)
{
object[] attributes = GetPropertyAttributes(propertyDefinition, pageTypeDefinition);
var useGlobalSettingsAttribute = attributes.OfType<UseGlobalSettingsAttribute>().FirstOrDefault();
if (useGlobalSettingsAttribute != null)
{
var container = GetPropertySettingsContainer(pageDefinition);
//TODO: Should validate not null and valid type at startup
var globalSettingsUpdater = globalPropertySettingsLocator.GetGlobalPropertySettingsUpdaters().Where(u => u.WrappedInstanceType == useGlobalSettingsAttribute.Type).First();
var wrapper = propertySettingsRepository.GetGlobals(globalSettingsUpdater.SettingsType)
.Where(w => globalSettingsUpdater.Match(w))
.First();
container.Settings[globalSettingsUpdater.SettingsType.FullName] = wrapper;
//TODO: Add spec validating that exception is thrown with the below uncommented (An item with the same key has already been added.)
//container.Settings.Add(globalSettingsUpdater.SettingsType.FullName, wrapper);
propertySettingsRepository.Save(container);
}
}
protected virtual string SerializeValues(PageDefinition pageDefinition)
{
StringBuilder builder = new StringBuilder();
builder.Append("Name: ");
builder.Append(pageDefinition.Name);
builder.Append("|");
builder.Append("Type: ");
builder.Append(pageDefinition.Type.TypeName);
builder.Append("|");
builder.Append("EditCaption:");
builder.Append(pageDefinition.EditCaption);
builder.Append("|");
builder.Append("HelpText:");
builder.Append(pageDefinition.HelpText);
builder.Append("|");
builder.Append("Required:");
builder.Append(pageDefinition.Required);
builder.Append("|");
builder.Append("Searchable:");
builder.Append(pageDefinition.Searchable);
builder.Append("|");
builder.Append("DefaultValue:");
builder.Append(pageDefinition.DefaultValue);
builder.Append("|");
builder.Append("DefaultValueType:");
builder.Append(pageDefinition.DefaultValueType);
builder.Append("|");
builder.Append("LanguageSpecific:");
builder.Append(pageDefinition.LanguageSpecific);
builder.Append("|");
builder.Append("DisplayEditUI:");
builder.Append(pageDefinition.DisplayEditUI);
builder.Append("|");
builder.Append("FieldOrder:");
builder.Append(pageDefinition.FieldOrder);
builder.Append("|");
builder.Append("Tab.ID:");
builder.Append(pageDefinition.Tab.ID);
builder.Append("|");
return builder.ToString();
}
public virtual void UpdateExistingPageDefinition(PageDefinition pageDefinition, PageTypePropertyDefinition pageTypePropertyDefinition)
{
string oldValues = SerializeValues(pageDefinition);
UpdatePageDefinitionValues(pageDefinition, pageTypePropertyDefinition);
string updatedValues = SerializeValues(pageDefinition);
if (updatedValues != oldValues)
{
string diff = ValueDiff(oldValues, updatedValues);
log.DebugFormat(
"Updating PageDefintion for page {0}({1}), diff: {2}, old values: {3}, new values: {4}.",
pageTypePropertyDefinition.PageType.ID,
pageTypePropertyDefinition.PageType.Name,
diff,
oldValues,
updatedValues);
pageDefinitionRepository.Save(pageDefinition);
}
}
public void Save(PageDefinition pageDefinition)
{
if (string.IsNullOrEmpty(pageDefinition.Name) || string.IsNullOrEmpty(pageDefinition.EditCaption))
{
throw new DataAbstractionException("Cannot save a type without name and caption");
}
if(pageDefinition.ID <= 0)
{
pageDefinition.ID = nextId++;
var pageDefinitionRecord = new PageDefinition();
Mapper.Map(pageDefinition, pageDefinitionRecord);
pageDefinitions.Add(pageDefinitionRecord);
}
else
{
var pageDefinitionRecord = pageDefinitions.First(p => p.ID == pageDefinition.ID);
Mapper.Map(pageDefinition, pageDefinitionRecord);
}
}
public void GivenUpdatedPropertyDefinition_UpdatePageDefinition_CallsPageDefinitionFactorySave()
{
PageDefinition pageDefinitionToUpdate = new PageDefinition();
MockRepository fakes = new MockRepository();
PageTypePropertyUpdater pageTypePropertyUpdater = PageTypePropertyUpdaterFactory.PartialMock(fakes);
pageTypePropertyUpdater.Stub(
utility => utility.UpdatePageDefinitionValues(
Arg<PageDefinition>.Is.Anything, Arg<PageTypePropertyDefinition>.Is.Anything));
PageDefinitionFactory fakeFactory = fakes.Stub<PageDefinitionFactory>();
fakeFactory.Stub(factory => factory.Save(Arg<PageDefinition>.Is.Anything));
fakeFactory.Replay();
pageTypePropertyUpdater.PageDefinitionFactory = fakeFactory;
pageTypePropertyUpdater.Stub(updater => updater.SerializeValues(pageDefinitionToUpdate)).Return(Guid.NewGuid().ToString()).Repeat.Once();
pageTypePropertyUpdater.Stub(updater => updater.SerializeValues(pageDefinitionToUpdate)).Return(Guid.NewGuid().ToString());
pageTypePropertyUpdater.Replay();
PageTypePropertyDefinition propertyDefinition = CreatePageTypePropertyDefinition();
pageTypePropertyUpdater.UpdatePageDefinition(pageDefinitionToUpdate, propertyDefinition);
pageTypePropertyUpdater.PageDefinitionFactory.AssertWasCalled(factory => factory.Save(pageDefinitionToUpdate));
}
void UpdatePageDefinitionsLocalPropertySettings(PageTypePropertyDefinition propertyDefinition, PageTypeDefinition pageTypeDefinition, PageDefinition pageDefinition)
{
List<PropertySettingsUpdater> settingsUpdaters = GetPropertySettingsUpdaters(pageTypeDefinition, propertyDefinition);
if(!settingsUpdaters.Any())
{
return;
}
var container = GetPropertySettingsContainer(pageDefinition);
settingsUpdaters.ForEach(updater =>
{
var wrapper = container.GetSetting(updater.SettingsType);
if (wrapper == null)
{
wrapper = new PropertySettingsWrapper();
container.Settings[updater.SettingsType.FullName] = wrapper;
//TODO: Add spec validating that exception is thrown with the below uncommented (An item with the same key has already been added.)
//container.Settings.Add(updater.SettingsType.FullName, wrapper);
}
bool settingsAlreadyExists = true;
if (wrapper.PropertySettings == null)
{
wrapper.PropertySettings = ((IPropertySettings)Activator.CreateInstance(updater.SettingsType)).GetDefaultValues();
settingsAlreadyExists = false;
}
if (settingsAlreadyExists && !updater.OverWriteExisting)
return;
int hashBeforeUpdate = updater.GetSettingsHashCode(wrapper.PropertySettings);
updater.UpdateSettings(wrapper.PropertySettings);
int hashAfterUpdate = updater.GetSettingsHashCode(wrapper.PropertySettings);
if (hashBeforeUpdate != hashAfterUpdate || !settingsAlreadyExists)
{
_propertySettingsRepositoryMethod().Save(container);
AddToUpdatedCacheKeys(container);
}
});
}
void UpdatePageDefinitionsGlobalPropertySettings(PageTypePropertyDefinition propertyDefinition, PageTypeDefinition pageTypeDefinition, PageDefinition pageDefinition)
{
IEnumerable<object> attributes = GetPropertyAttributes(propertyDefinition, pageTypeDefinition);
var useGlobalSettingsAttribute = attributes.OfType<UseGlobalSettingsAttribute>().FirstOrDefault();
if (useGlobalSettingsAttribute != null)
{
var container = GetPropertySettingsContainer(pageDefinition);
//TODO: Should validate not null and valid type at startup
var globalSettingsUpdater = globalPropertySettingsLocator.GetGlobalPropertySettingsUpdaters().First(u => u.WrappedInstanceType == useGlobalSettingsAttribute.Type);
var wrapper = _propertySettingsRepositoryMethod().GetGlobals(globalSettingsUpdater.SettingsType)
.First(w => globalSettingsUpdater.Match(w));
PropertySettingsWrapper existingWrapper = container.Settings.ContainsKey(globalSettingsUpdater.SettingsType.FullName)
? container.Settings[globalSettingsUpdater.SettingsType.FullName]
: null;
if (existingWrapper == null || existingWrapper.Id != wrapper.Id)
{
container.Settings[globalSettingsUpdater.SettingsType.FullName] = wrapper;
//TODO: Add spec validating that exception is thrown with the below uncommented (An item with the same key has already been added.)
//container.Settings.Add(globalSettingsUpdater.SettingsType.FullName, wrapper);
_propertySettingsRepositoryMethod().Save(container);
AddToUpdatedCacheKeys(container);
}
}
}
protected internal virtual void SetPageDefinitionType(PageDefinition pageDefinition, PageTypePropertyDefinition propertyDefinition)
{
pageDefinition.Type = GetPageDefinitionType(propertyDefinition);
}
private void UpdateLongStringSettings(PageDefinition pageDefinition, PageTypePropertyAttribute propertyAttribute)
{
EditorToolOption longStringSettings = propertyAttribute.LongStringSettings;
if (longStringSettings == default(EditorToolOption) && !propertyAttribute.ClearAllLongStringSettings)
{
longStringSettings = EditorToolOption.All;
}
pageDefinition.LongStringSettings = longStringSettings;
}