public void Should_CRUD_BlogPost_WithLayout_Successfully_WithIdSpecified()
{
// Attach to events
Events.BlogEvents.Instance.BlogCreated += Instance_EntityCreated;
Events.BlogEvents.Instance.BlogUpdated += Instance_EntityUpdated;
Events.BlogEvents.Instance.BlogDeleted += Instance_EntityDeleted;
RunApiActionInTransaction(
(api, session) =>
{
masterPage = null;
layout = TestDataProvider.CreateNewLayout();
region = TestDataProvider.CreateNewRegion();
var layoutRegion = new LayoutRegion {
Layout = layout, Region = region
};
layout.LayoutRegions = new[] { layoutRegion };
session.SaveOrUpdate(region);
session.SaveOrUpdate(layout);
session.SaveOrUpdate(layoutRegion);
RunWithIdSpecified(session, api.Blog.BlogPost.Properties.Get, api.Blog.BlogPost.Properties.Put, api.Blog.BlogPost.Properties.Delete);
});
// Detach from events
Events.BlogEvents.Instance.BlogCreated -= Instance_EntityCreated;
Events.BlogEvents.Instance.BlogUpdated -= Instance_EntityUpdated;
Events.BlogEvents.Instance.BlogDeleted -= Instance_EntityDeleted;
}
public TemplateEditViewModel Execute(Guid?templateId)
{
TemplateEditViewModel templateModel;
if (!templateId.HasValue)
{
templateModel = new TemplateEditViewModel();
}
else
{
Root.Models.Layout templateAlias = null;
TemplateEditViewModel templateViewModelAlias = null;
var templateFuture = UnitOfWork.Session.QueryOver(() => templateAlias)
.Where(() => templateAlias.Id == templateId && !templateAlias.IsDeleted)
.SelectList(select => select
.Select(() => templateAlias.Id).WithAlias(() => templateViewModelAlias.Id)
.Select(() => templateAlias.Version).WithAlias(() => templateViewModelAlias.Version)
.Select(() => templateAlias.Name).WithAlias(() => templateViewModelAlias.Name)
.Select(() => templateAlias.PreviewUrl).WithAlias(() => templateViewModelAlias.PreviewImageUrl)
.Select(() => templateAlias.LayoutPath).WithAlias(() => templateViewModelAlias.Url))
.TransformUsing(Transformers.AliasToBean <TemplateEditViewModel>())
.FutureValue <TemplateEditViewModel>();
TemplateRegionItemViewModel templateRegionAlias = null;
LayoutRegion layoutRegionAlias = null;
Region regionAlias = null;
var regions = UnitOfWork.Session
.QueryOver(() => layoutRegionAlias)
.Inner.JoinAlias(c => c.Region, () => regionAlias)
.Where(() => layoutRegionAlias.Layout.Id == templateId && !regionAlias.IsDeleted && !layoutRegionAlias.IsDeleted)
.SelectList(select => select
.Select(() => regionAlias.Id).WithAlias(() => templateRegionAlias.Id)
.Select(() => layoutRegionAlias.Description).WithAlias(() => templateRegionAlias.Description)
.Select(() => regionAlias.Version).WithAlias(() => templateRegionAlias.Version)
.Select(() => regionAlias.RegionIdentifier).WithAlias(() => templateRegionAlias.Identifier))
.TransformUsing(Transformers.AliasToBean <TemplateRegionItemViewModel>())
.Future <TemplateRegionItemViewModel>();
templateModel = templateFuture.Value;
if (templateModel == null)
{
throw new EntityNotFoundException(typeof(TemplateRegionItemViewModel), templateId.Value);
}
templateModel.Regions = regions.ToList();
templateModel.Options = layoutService.GetLayoutOptions(templateId.Value);
}
templateModel.CustomOptions = optionService.GetCustomOptions();
return(templateModel);
}
public LayoutRegion CreateNewLayoutRegion(Layout layout = null, Region region = null)
{
var entity = new LayoutRegion();
PopulateBaseFields(entity);
entity.Description = ProvideRandomString(MaxLength.Name);
entity.Layout = layout ?? CreateNewLayout();
entity.Region = region ?? CreateNewRegion();
return(entity);
}
/// <summary>
/// Executes the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>The list of blog template view models</returns>
public IList <BlogTemplateViewModel> Execute(bool request)
{
BlogTemplateViewModel modelAlias = null;
Layout layoutAlias = null;
// Load templates
var templates = UnitOfWork.Session
.QueryOver(() => layoutAlias)
.Where(() => !layoutAlias.IsDeleted)
.SelectList(select => select
.Select(() => layoutAlias.Id).WithAlias(() => modelAlias.TemplateId)
.Select(() => layoutAlias.Name).WithAlias(() => modelAlias.Title)
.Select(() => layoutAlias.PreviewUrl).WithAlias(() => modelAlias.PreviewUrl))
.TransformUsing(Transformers.AliasToBean <BlogTemplateViewModel>())
.List <BlogTemplateViewModel>();
// Load regions
Region regionAlias = null;
LayoutRegion layoutRegionAlias = null;
var compatibleLayouts = UnitOfWork.Session
.QueryOver(() => layoutRegionAlias)
.Inner.JoinQueryOver(() => layoutRegionAlias.Region, () => regionAlias)
.Where(() => !layoutRegionAlias.IsDeleted &&
!regionAlias.IsDeleted &&
regionAlias.RegionIdentifier == BlogModuleConstants.BlogPostMainContentRegionIdentifier)
.Select(select => select.Layout.Id)
.List <Guid>();
foreach (var id in compatibleLayouts)
{
templates
.Where(t => t.TemplateId == id)
.ToList()
.ForEach(t => t.IsCompatible = true);
}
// Load default template
var defaultTemplateId = optionService.GetDefaultTemplateId();
if (defaultTemplateId.HasValue)
{
var defaultTemplate = templates.FirstOrDefault(t => t.TemplateId == defaultTemplateId.Value);
if (defaultTemplate != null)
{
defaultTemplate.IsActive = true;
}
}
return(templates);
}
/// <summary>
/// Creates the layout.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// Created layout entity
/// </returns>
public Layout CreateLayout(CreateLayoutRequest request)
{
ValidateRequest(request);
try
{
UnitOfWork.BeginTransaction();
var layout = new Layout
{
LayoutPath = request.LayoutPath,
Name = request.Name,
PreviewUrl = request.PreviewUrl
};
// reference or create new regions by identifiers
if (request.Regions != null)
{
layout.LayoutRegions = new List <LayoutRegion>();
foreach (var regionIdentifier in request.Regions)
{
if (string.IsNullOrWhiteSpace(regionIdentifier))
{
continue;
}
var region = LoadOrCreateRegion(regionIdentifier);
var layoutRegion = new LayoutRegion
{
Layout = layout,
Region = region
};
layout.LayoutRegions.Add(layoutRegion);
}
}
Repository.Save(layout);
UnitOfWork.Commit();
return(layout);
}
catch (Exception inner)
{
var message = string.Format("Failed to create layout. Path: {0}, Name: {1}, Url: {2}", request.LayoutPath, request.Name, request.PreviewUrl);
Logger.Error(message, inner);
throw new CmsApiException(message, inner);
}
}
public void Should_CRUD_BlogPost_WithNoLayoutSpecified_Successfully()
{
// Attach to events
Events.BlogEvents.Instance.BlogCreated += Instance_EntityCreated;
Events.BlogEvents.Instance.BlogUpdated += Instance_EntityUpdated;
Events.BlogEvents.Instance.BlogDeleted += Instance_EntityDeleted;
RunApiActionInTransaction(
(api, session) =>
{
isMarkdown = false;
isHtmlSet = true;
isNullUrl = false;
masterPage = null;
layout = null;
masterPage = null;
defaultLayout = TestDataProvider.CreateNewLayout();
region = TestDataProvider.CreateNewRegion();
var layoutRegion = new LayoutRegion {
Layout = defaultLayout, Region = region
};
defaultLayout.LayoutRegions = new[] { layoutRegion };
session.SaveOrUpdate(region);
session.SaveOrUpdate(defaultLayout);
session.SaveOrUpdate(layoutRegion);
// Set default layout
var repository = GetRepository(session);
var option = repository.AsQueryable <Option>().FirstOrDefault();
if (option == null)
{
option = new Option();
}
option.DefaultMasterPage = null;
option.DefaultLayout = defaultLayout;
session.SaveOrUpdate(defaultLayout);
Run(session, api.Blog.BlogPost.Properties.Post, api.Blog.BlogPost.Properties.Get, api.Blog.BlogPost.Properties.Put, api.Blog.BlogPost.Properties.Delete);
});
// Detach from events
Events.BlogEvents.Instance.BlogCreated -= Instance_EntityCreated;
Events.BlogEvents.Instance.BlogUpdated -= Instance_EntityUpdated;
Events.BlogEvents.Instance.BlogDeleted -= Instance_EntityDeleted;
}
/// <summary>
/// Creates the layout region.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// Created layout region entity
/// </returns>
public LayoutRegion CreateLayoutRegion(CreateLayoutRegionRequest request)
{
ValidateRequest(request);
try
{
var layout = Repository.AsProxy <Layout>(request.LayoutId);
var region = LoadOrCreateRegion(request.RegionIdentifier);
if (!region.Id.HasDefaultValue())
{
var exists = Repository.AsQueryable <LayoutRegion>(lr => lr.Region == region && lr.Layout == layout).Any();
if (exists)
{
var message = string.Format("Failed to create layout region: region {0} is already assigned.", request.RegionIdentifier);
var logMessage = string.Format("{0} LayoutId: {1}", message, request.LayoutId);
Logger.Error(logMessage);
throw new CmsApiValidationException(message);
}
}
var layoutRegion = new LayoutRegion {
Layout = layout, Region = region
};
Repository.Save(layoutRegion);
UnitOfWork.Commit();
return(layoutRegion);
}
catch (CmsApiValidationException)
{
throw;
}
catch (Exception inner)
{
var message = string.Format("Failed to create layout region.");
Logger.Error(message, inner);
throw new CmsApiException(message, inner);
}
}
/// <summary>
/// Gets the first compatible layout.
/// </summary>
/// <returns>Layout for blog post.</returns>
private Layout GetFirstCompatibleLayout()
{
LayoutRegion layoutRegionAlias = null;
Region regionAlias = null;
var compatibleLayouts = UnitOfWork.Session
.QueryOver(() => layoutRegionAlias)
.Inner.JoinQueryOver(() => layoutRegionAlias.Region, () => regionAlias)
.Where(() => !layoutRegionAlias.IsDeleted &&
!regionAlias.IsDeleted &&
regionAlias.RegionIdentifier == BlogModuleConstants.BlogPostMainContentRegionIdentifier)
.Select(select => select.Layout.Id)
.Take(1)
.List <Guid>();
if (compatibleLayouts != null && compatibleLayouts.Count > 0)
{
return(Repository.AsProxy <Layout>(compatibleLayouts[0]));
}
return(null);
}
public void Should_CRUD_BlogPost_WithLayout_Successfully()
{
// Attach to events
Events.BlogEvents.Instance.BlogCreated += Instance_EntityCreated;
Events.BlogEvents.Instance.BlogCreated += CheckTagCount;
Events.BlogEvents.Instance.BlogUpdated += Instance_EntityUpdated;
Events.BlogEvents.Instance.BlogDeleted += Instance_EntityDeleted;
RunApiActionInTransaction(
(api, session) =>
{
isNullUrl = true;
isMarkdown = false;
isHtmlSet = true;
masterPage = null;
layout = TestDataProvider.CreateNewLayout();
region = TestDataProvider.CreateNewRegion();
var layoutRegion = new LayoutRegion {
Layout = layout, Region = region
};
layout.LayoutRegions = new[] { layoutRegion };
session.SaveOrUpdate(region);
session.SaveOrUpdate(layout);
session.SaveOrUpdate(layoutRegion);
Run(session, api.Blog.BlogPost.Properties.Post, api.Blog.BlogPost.Properties.Get, api.Blog.BlogPost.Properties.Put, api.Blog.BlogPost.Properties.Delete);
});
// Detach from events
Events.BlogEvents.Instance.BlogCreated -= Instance_EntityCreated;
Events.BlogEvents.Instance.BlogCreated -= CheckTagCount;
Events.BlogEvents.Instance.BlogUpdated -= Instance_EntityUpdated;
Events.BlogEvents.Instance.BlogDeleted -= Instance_EntityDeleted;
}
public void Should_CRUD_PageProperties_WithLayout_Successfully()
{
changingPageProepertiesCount = 0;
// Attach to events
Events.PageEvents.Instance.PageCreated += Instance_EntityCreated;
Events.PageEvents.Instance.PagePropertiesChanging += Instance_PagePropertiesChanging;
Events.PageEvents.Instance.PagePropertiesChanged += Instance_EntityUpdated;
Events.PageEvents.Instance.PageDeleted += Instance_EntityDeleted;
RunApiActionInTransaction(
(api, session) =>
{
masterPage = null;
layout = TestDataProvider.CreateNewLayout();
region = TestDataProvider.CreateNewRegion();
var layoutRegion = new LayoutRegion {
Layout = layout, Region = region
};
layout.LayoutRegions = new[] { layoutRegion };
session.SaveOrUpdate(region);
session.SaveOrUpdate(layout);
session.SaveOrUpdate(layoutRegion);
Run(session, api.Pages.Page.Properties.Post, api.Pages.Page.Properties.Get, api.Pages.Page.Properties.Put, api.Pages.Page.Properties.Delete);
});
Assert.AreEqual(1, changingPageProepertiesCount, "Page properties changing events fired count");
// Detach from events
Events.PageEvents.Instance.PageCreated -= Instance_EntityCreated;
Events.PageEvents.Instance.PagePropertiesChanging -= Instance_PagePropertiesChanging;
Events.PageEvents.Instance.PagePropertiesChanged -= Instance_EntityUpdated;
Events.PageEvents.Instance.PageDeleted -= Instance_EntityDeleted;
}
/// <summary>
/// Saves the layout.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="treatNullsAsLists">if set to <c>true</c> treat null lists as empty lists.</param>
/// <param name="createIfNotExists">if set to <c>true</c> create if not exists.</param>
/// <returns>
/// Saved layout entity
/// </returns>
public Layout SaveLayout(TemplateEditViewModel model, bool treatNullsAsLists = true, bool createIfNotExists = false)
{
if (model.Options != null)
{
optionService.ValidateOptionKeysUniqueness(model.Options);
}
unitOfWork.BeginTransaction();
var isNew = model.Id.HasDefaultValue();
Layout template = null;
if (!isNew)
{
template = repository.AsQueryable <Layout>()
.Where(f => f.Id == model.Id)
.FetchMany(f => f.LayoutRegions)
.ToList()
.FirstOrDefault();
isNew = template == null;
if (isNew && !createIfNotExists)
{
throw new EntityNotFoundException(typeof(Layout), model.Id);
}
}
if (template == null)
{
template = new Layout {
Id = model.Id
};
}
else if (model.Version > 0)
{
template.Version = model.Version;
}
template.Name = model.Name;
template.LayoutPath = model.Url;
template.PreviewUrl = model.PreviewImageUrl;
// Set null list as empty
if (treatNullsAsLists)
{
model.Options = model.Options ?? new List <OptionViewModel>();
model.Regions = model.Regions ?? new List <TemplateRegionItemViewModel>();
}
// Edits or removes regions.
if (model.Regions != null)
{
if (template.LayoutRegions != null && template.LayoutRegions.Any())
{
foreach (var region in template.LayoutRegions)
{
var requestRegion = model.Regions != null
? model.Regions.FirstOrDefault(f => f.Identifier.ToLowerInvariant() == region.Region.RegionIdentifier.ToLowerInvariant())
: null;
if (requestRegion != null && region.Region.RegionIdentifier.ToLowerInvariant() == requestRegion.Identifier.ToLowerInvariant())
{
region.Description = requestRegion.Description;
repository.Save(region);
}
else
{
repository.Delete(region);
}
}
}
if (template.LayoutRegions == null)
{
template.LayoutRegions = new List <LayoutRegion>();
}
var regions = GetRegions(model.Regions);
foreach (var requestRegionOption in model.Regions)
{
if (!template.LayoutRegions.Any(f => f.Region.RegionIdentifier.Equals(requestRegionOption.Identifier, StringComparison.InvariantCultureIgnoreCase)))
{
var region = regions.Find(f => f.RegionIdentifier.Equals(requestRegionOption.Identifier, StringComparison.InvariantCultureIgnoreCase));
if (region == null)
{
if (requestRegionOption.Description == null)
{
requestRegionOption.Description = string.Empty;
}
var regionOption = new Region
{
RegionIdentifier = requestRegionOption.Identifier
};
template.LayoutRegions.Add(new LayoutRegion
{
Description = requestRegionOption.Description,
Region = regionOption,
Layout = template
});
repository.Save(regionOption);
}
else
{
var layoutRegion = new LayoutRegion
{
Description = requestRegionOption.Description,
Region = region,
Layout = template
};
template.LayoutRegions.Add(layoutRegion);
repository.Save(layoutRegion);
}
}
}
}
if (model.Options != null)
{
optionService.SetOptions <LayoutOption, Layout>(template, model.Options);
}
repository.Save(template);
unitOfWork.Commit();
// Notify
if (isNew)
{
Events.PageEvents.Instance.OnLayoutCreated(template);
}
else
{
Events.PageEvents.Instance.OnLayoutUpdated(template);
}
return(template);
}
/// <summary>
/// Executes the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
/// <exception cref="System.NotImplementedException"></exception>
public SaveTemplateResponse Execute(TemplateEditViewModel request)
{
if (request.Options != null)
{
OptionService.ValidateOptionKeysUniqueness(request.Options);
}
UnitOfWork.BeginTransaction();
var isNew = request.Id.HasDefaultValue();
var template = !isNew
? Repository.AsQueryable <Root.Models.Layout>()
.Where(f => f.Id == request.Id)
.FetchMany(f => f.LayoutRegions)
.ToList()
.FirstOrDefault()
: new Root.Models.Layout();
if (template == null)
{
template = new Root.Models.Layout();
}
template.Name = request.Name;
template.LayoutPath = request.Url;
template.Version = request.Version;
template.PreviewUrl = request.PreviewImageUrl;
// Edits or removes regions.
if (template.LayoutRegions != null && template.LayoutRegions.Any())
{
foreach (var region in template.LayoutRegions)
{
var requestRegion = request.Regions != null
? request.Regions.FirstOrDefault(f => f.Identifier == region.Region.RegionIdentifier)
: null;
if (requestRegion != null && region.Region.RegionIdentifier == requestRegion.Identifier)
{
region.Description = requestRegion.Description;
Repository.Save(region);
}
else
{
Repository.Delete(region);
}
}
}
// Adds new region.
if (request.Regions != null)
{
if (template.LayoutRegions == null)
{
template.LayoutRegions = new List <LayoutRegion>();
}
var regions = GetRegions(request.Regions);
foreach (var requestRegionOption in request.Regions)
{
if (!template.LayoutRegions.Any(f => f.Region.RegionIdentifier.Equals(requestRegionOption.Identifier, StringComparison.InvariantCultureIgnoreCase)))
{
var region = regions.Find(f => f.RegionIdentifier.Equals(requestRegionOption.Identifier, StringComparison.InvariantCultureIgnoreCase));
if (region == null)
{
if (requestRegionOption.Description == null)
{
requestRegionOption.Description = string.Empty;
}
var regionOption = new Region
{
RegionIdentifier = requestRegionOption.Identifier
};
template.LayoutRegions.Add(new LayoutRegion
{
Description = requestRegionOption.Description,
Region = regionOption,
Layout = template
});
Repository.Save(regionOption);
}
else
{
var layoutRegion = new LayoutRegion
{
Description = requestRegionOption.Description,
Region = region,
Layout = template
};
template.LayoutRegions.Add(layoutRegion);
Repository.Save(layoutRegion);
}
}
}
}
OptionService.SetOptions <LayoutOption, Root.Models.Layout>(template, request.Options);
Repository.Save(template);
UnitOfWork.Commit();
// Notify
if (isNew)
{
Events.PageEvents.Instance.OnLayoutCreated(template);
}
else
{
Events.PageEvents.Instance.OnLayoutUpdated(template);
}
return(new SaveTemplateResponse
{
Id = template.Id,
TemplateName = template.Name,
Version = template.Version
});
}
public void PrepareLayout(string layoutPath)
{
Action method = null;
Action start2 = null;
Action start3 = null;
Action <RegionOptions> action = null;
LayoutModel layout;
ClientManager.Instance.Stat = new ClientApp.Core.Stat();
ClientManager.Instance.Stat.FileType = StatType.Layout;
ClientManager.Instance.Stat.ScheduleID = ClientManager.Instance.ScheduleId;
ClientManager.Instance.Stat.LayoutID = this._layoutId;
ClientManager.Instance.Stat.FromDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
if ((layoutPath == (Settings.Default.LibraryPath + @"\Default.xml")) || string.IsNullOrEmpty(layoutPath))
{
throw new Exception("Default layout");
}
try
{
using (FileStream stream = File.Open(layoutPath, FileMode.Open, FileAccess.Read, FileShare.Write))
{
XmlSerializer serializer = new XmlSerializer(typeof(LayoutModel));
layout = (LayoutModel)serializer.Deserialize(stream);
}
}
catch (Exception exception)
{
Trace.WriteLine(string.Format("Could not find the layout file {0}: {1}", layoutPath, exception.Message));
throw;
}
this._layoutWidth = layout.Width;
this._layoutHeight = layout.Height;
int width = this._clientSize.Width;
int height = this._clientSize.Height;
this._regions = new Collection <ClientApp.Core.Region>();
RegionOptions options = new RegionOptions();
try
{
if (!string.IsNullOrEmpty(layout.Bgcolor))
{
if (method == null)
{
method = new Action(() =>
{
this.MediaCanvas.Background = new SolidColorBrush((System.Windows.Media.Color)System.Windows.Media.ColorConverter.ConvertFromString(layout.Bgcolor));
});
}
base.Dispatcher.BeginInvoke(DispatcherPriority.Normal, method);
options.backgroundColor = layout.Bgcolor;
}
}
catch
{
if (start2 == null)
{
start2 = new Action(() =>
{
this.MediaCanvas.Background = new SolidColorBrush(Colors.Black);
});
}
base.Dispatcher.BeginInvoke(DispatcherPriority.Normal, start2);
options.backgroundColor = "#000000";
}
try
{
if (layout.Background == null)
{
this.MediaCanvas.Background = null;
options.backgroundImage = "";
}
else
{
string bgFilePath = string.Concat(new object[] { Settings.Default.LibraryPath, @"\backgrounds\", width, "x", height, "_", layout.Background });
Utilities.CreateFolder(Path.GetDirectoryName(bgFilePath));
if (!File.Exists(bgFilePath))
{
System.Drawing.Image original = System.Drawing.Image.FromFile(Settings.Default.LibraryPath + @"\" + layout.Background);
Bitmap bitmap = new Bitmap(original, width, height);
EncoderParameters encoderParams = new EncoderParameters(1);
EncoderParameter parameter = new EncoderParameter(Encoder.Quality, 90L);
encoderParams.Param[0] = parameter;
ImageCodecInfo encoderInfo = GetEncoderInfo("image/jpeg");
bitmap.Save(bgFilePath, encoderInfo, encoderParams);
original.Dispose();
bitmap.Dispose();
}
base.Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(() =>
{
this.MediaCanvas.Background = new ImageBrush(new BitmapImage(new Uri(bgFilePath.Replace(@"\", "/"), UriKind.Relative)));
}));
options.backgroundImage = bgFilePath;
}
}
catch (Exception)
{
if (start3 == null)
{
start3 = new Action(() =>
{
this.MediaCanvas.Background = System.Windows.Media.Brushes.Black;
});
}
base.Dispatcher.BeginInvoke(DispatcherPriority.Normal, start3);
options.backgroundImage = "";
}
App.DoEvents();
List <LayoutRegion> regions = layout.Regions;
List <List <LayoutRegionMedia> > list2 = (from r in layout.Regions select r.Media).ToList <List <LayoutRegionMedia> >();
if ((regions.Count == 0) || (list2.Count == 0))
{
Trace.WriteLine(new LogMessage("PrepareLayout", string.Format("A layout with {0} regions and {1} media has been detected.", regions.Count.ToString(), list2.Count.ToString())), LogType.Info.ToString());
if (ClientManager.Instance.Schedule.ActiveLayouts == 1)
{
Trace.WriteLine(new LogMessage("PrepareLayout", "Only 1 layout scheduled and it has nothing to show."), LogType.Info.ToString());
throw new Exception("Only 1 layout schduled and it has nothing to show");
}
Trace.WriteLine(new LogMessage("PrepareLayout", string.Format(string.Format("An empty layout detected, will show for {0} seconds.", Settings.Default.emptyLayoutDuration.ToString()), new object[0])), LogType.Info.ToString());
List <LayoutRegion> list3 = new List <LayoutRegion>();
LayoutRegion region = new LayoutRegion
{
Id = "blah",
Width = 1,
Height = 1,
Top = 1,
Left = 1
};
List <LayoutRegionMedia> list4 = new List <LayoutRegionMedia>();
LayoutRegionMedia media = new LayoutRegionMedia
{
Id = "blah",
Type = "Text",
Duration = 0
};
LayoutRegionMediaRaw raw = new LayoutRegionMediaRaw
{
Text = ""
};
media.Raw = raw;
list4.Add(media);
region.Media = list4;
list3.Add(region);
regions = list3;
}
else
{// Keep Running region, preventing visual blank out;
regions.Add(
new LayoutRegion()
{
Height = 0, Width = 0, Name = "Keep Alive Region", Media = new List <LayoutRegionMedia>()
{
new LayoutRegionMedia()
{
Duration = (int)TimeSpan.FromDays(10).TotalMilliseconds,
Type = "KeepAlive"
}
}
});
}
foreach (LayoutRegion region2 in regions)
{
if (region2.Media.Count != 0)
{
options.scheduleId = ClientManager.Instance.ScheduleId;
options.layoutId = this._layoutId;
options.regionId = region2.Id;
options.Width = (int)((((double)(region2.Width + 14)) / this._layoutWidth) * this._clientSize.Width);
options.Height = (int)((((double)(region2.Height + 14)) / this._layoutHeight) * this._clientSize.Height);
int left = region2.Left;
if (left < 0)
{
left = 0;
}
int top = region2.Top;
if (top < 0)
{
top = 0;
}
options.Left = (int)((((double)left) / this._layoutWidth) * this._clientSize.Width);
options.Top = (int)((((double)top) / this._layoutHeight) * this._clientSize.Height);
options.ScaleFactor = this._scaleFactor;
options.BackgroundLeft = options.Left * -1;
options.BackgroundTop = options.Top * -1;
options.mediaNodes = region2.Media;
if (action == null)
{
action = delegate(RegionOptions opts)
{
Core.Region region = new ClientApp.Core.Region(ClientManager.Instance.StatLog, ClientManager.Instance.CacheManager);
region.DurationElapsedEvent += new ClientApp.Core.Region.DurationElapsedDelegate(this.TempDurationElapsedEvent);
if (opts.FileType != "Widget")
{
region.RegionOptions = opts;
this._regions.Add(region);
region.Opacity = 0.0;
this.MediaCanvas.Children.Add(region);
region.AnimateIn();
}
else if (!WidgetsFactory.Widgets.ContainsKey(opts.Name))
{
region.RegionOptions = opts;
region.Opacity = 0.0;
this.MediaCanvas.Children.Add(region);
region.AnimateIn();
}
};
}
base.Dispatcher.BeginInvoke(DispatcherPriority.Normal, action, options);
App.DoEvents();
}
}
regions = null;
list2 = null;
}
public void Should_CRUD_BlogPost_WithLayout_TestPermalink_Successfully()
{
// Attach to events
Events.BlogEvents.Instance.BlogCreated += Instance_EntityCreated;
Events.BlogEvents.Instance.BlogUpdated += Instance_EntityUpdated;
Events.BlogEvents.Instance.BlogDeleted += Instance_EntityDeleted;
RunApiActionInTransaction(
(api, session) =>
{
var permalinkCreation = UrlHelper.GeneratePageUrl;
try
{
var failedToCheckCategory = true;
UrlHelper.GeneratePageUrl = request =>
{
if ((request.CategoryId == null && categories != null) ||
(request.CategoryId != null && categories == null) ||
request.CategoryId.Count() != categories.Count ||
request.CategoryId.Any(c => categories.All(c1 => c1 != c)))
{
throw new Exception("Failed to check category");
}
failedToCheckCategory = false;
return(permalinkCreation(request));
};
isNullUrl = true;
isMarkdown = false;
isHtmlSet = true;
masterPage = null;
layout = TestDataProvider.CreateNewLayout();
region = TestDataProvider.CreateNewRegion();
var layoutRegion = new LayoutRegion {
Layout = layout, Region = region
};
layout.LayoutRegions = new[] { layoutRegion };
session.SaveOrUpdate(region);
session.SaveOrUpdate(layout);
session.SaveOrUpdate(layoutRegion);
Run(
session,
api.Blog.BlogPost.Properties.Post,
api.Blog.BlogPost.Properties.Get,
api.Blog.BlogPost.Properties.Put,
api.Blog.BlogPost.Properties.Delete);
Assert.IsFalse(failedToCheckCategory, "Failed to check category passed to the URL creation function.");
}
finally
{
UrlHelper.GeneratePageUrl = permalinkCreation;
}
});
// Detach from events
Events.BlogEvents.Instance.BlogCreated -= Instance_EntityCreated;
Events.BlogEvents.Instance.BlogUpdated -= Instance_EntityUpdated;
Events.BlogEvents.Instance.BlogDeleted -= Instance_EntityDeleted;
}
public void TestInit() {
_writer = new StringBuilderWriter();
_option = new LayoutRegion( _writer );
}
/// <summary>
/// Creates the layout region.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// Created layout region entity
/// </returns>
public LayoutRegion CreateLayoutRegion(CreateLayoutRegionRequest request)
{
ValidateRequest(request);
try
{
var layout = Repository.AsProxy<Layout>(request.LayoutId);
var region = LoadOrCreateRegion(request.RegionIdentifier);
if (!region.Id.HasDefaultValue())
{
var exists = Repository.AsQueryable<LayoutRegion>(lr => lr.Region == region && lr.Layout == layout).Any();
if (exists)
{
var message = string.Format("Failed to create layout region: region {0} is already assigned.", request.RegionIdentifier);
var logMessage = string.Format("{0} LayoutId: {1}", message, request.LayoutId);
Logger.Error(logMessage);
throw new CmsApiValidationException(message);
}
}
var layoutRegion = new LayoutRegion { Layout = layout, Region = region };
Repository.Save(layoutRegion);
UnitOfWork.Commit();
return layoutRegion;
}
catch (CmsApiValidationException)
{
throw;
}
catch (Exception inner)
{
var message = string.Format("Failed to create layout region.");
Logger.Error(message, inner);
throw new CmsApiException(message, inner);
}
}
/// <summary>
/// Creates the layout.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// Created layout entity
/// </returns>
public Layout CreateLayout(CreateLayoutRequest request)
{
ValidateRequest(request);
try
{
UnitOfWork.BeginTransaction();
var layout = new Layout
{
LayoutPath = request.LayoutPath,
Name = request.Name,
PreviewUrl = request.PreviewUrl
};
// reference or create new regions by identifiers
if (request.Regions != null)
{
layout.LayoutRegions = new List<LayoutRegion>();
foreach (var regionIdentifier in request.Regions)
{
if (string.IsNullOrWhiteSpace(regionIdentifier))
{
continue;
}
var region = LoadOrCreateRegion(regionIdentifier);
var layoutRegion = new LayoutRegion
{
Layout = layout,
Region = region
};
layout.LayoutRegions.Add(layoutRegion);
}
}
Repository.Save(layout);
UnitOfWork.Commit();
return layout;
}
catch (Exception inner)
{
var message = string.Format("Failed to create layout. Path: {0}, Name: {1}, Url: {2}", request.LayoutPath, request.Name, request.PreviewUrl);
Logger.Error(message, inner);
throw new CmsApiException(message, inner);
}
}
/// <summary>
/// Saves the layout.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="treatNullsAsLists">if set to <c>true</c> treat null lists as empty lists.</param>
/// <param name="createIfNotExists">if set to <c>true</c> create if not exists.</param>
/// <returns>
/// Saved layout entity
/// </returns>
public Layout SaveLayout(TemplateEditViewModel model, bool treatNullsAsLists = true, bool createIfNotExists = false)
{
if (model.Options != null)
{
optionService.ValidateOptionKeysUniqueness(model.Options);
}
unitOfWork.BeginTransaction();
var isNew = model.Id.HasDefaultValue();
Layout template = null;
if (!isNew)
{
template = repository.AsQueryable<Layout>()
.Where(f => f.Id == model.Id)
.FetchMany(f => f.LayoutRegions)
.ToList()
.FirstOrDefault();
isNew = template == null;
if (isNew && !createIfNotExists)
{
throw new EntityNotFoundException(typeof(Layout), model.Id);
}
}
if (template == null)
{
template = new Layout { Id = model.Id };
}
else if (model.Version > 0)
{
template.Version = model.Version;
}
template.Name = model.Name;
template.LayoutPath = model.Url;
template.PreviewUrl = model.PreviewImageUrl;
// Set null list as empty
if (treatNullsAsLists)
{
model.Options = model.Options ?? new List<OptionViewModel>();
model.Regions = model.Regions ?? new List<TemplateRegionItemViewModel>();
}
// Edits or removes regions.
if (model.Regions != null)
{
if (template.LayoutRegions != null && template.LayoutRegions.Any())
{
foreach (var region in template.LayoutRegions)
{
var requestRegion = model.Regions != null
? model.Regions.FirstOrDefault(f => f.Identifier.ToLowerInvariant() == region.Region.RegionIdentifier.ToLowerInvariant())
: null;
if (requestRegion != null && region.Region.RegionIdentifier.ToLowerInvariant() == requestRegion.Identifier.ToLowerInvariant())
{
region.Description = requestRegion.Description;
repository.Save(region);
}
else
{
repository.Delete(region);
}
}
}
if (template.LayoutRegions == null)
{
template.LayoutRegions = new List<LayoutRegion>();
}
var regions = GetRegions(model.Regions);
foreach (var requestRegionOption in model.Regions)
{
if (!template.LayoutRegions.Any(f => f.Region.RegionIdentifier.Equals(requestRegionOption.Identifier, StringComparison.InvariantCultureIgnoreCase)))
{
var region = regions.Find(f => f.RegionIdentifier.Equals(requestRegionOption.Identifier, StringComparison.InvariantCultureIgnoreCase));
if (region == null)
{
if (requestRegionOption.Description == null)
{
requestRegionOption.Description = string.Empty;
}
var regionOption = new Region
{
RegionIdentifier = requestRegionOption.Identifier
};
template.LayoutRegions.Add(new LayoutRegion
{
Description = requestRegionOption.Description,
Region = regionOption,
Layout = template
});
repository.Save(regionOption);
}
else
{
var layoutRegion = new LayoutRegion
{
Description = requestRegionOption.Description,
Region = region,
Layout = template
};
template.LayoutRegions.Add(layoutRegion);
repository.Save(layoutRegion);
}
}
}
}
if (model.Options != null)
{
optionService.SetOptions<LayoutOption, Layout>(template, model.Options);
}
repository.Save(template);
unitOfWork.Commit();
// Notify
if (isNew)
{
Events.PageEvents.Instance.OnLayoutCreated(template);
}
else
{
Events.PageEvents.Instance.OnLayoutUpdated(template);
}
return template;
}
public void TestInit()
{
_writer = new StringBuilderWriter();
_option = new LayoutRegion(_writer);
}
