public IFragment TryParse(string markup, ITemplate template) {
if (markup.StartsWith("code:"))
return new CodeExpressionFragment(Utils.Substring(markup, 5, markup.Length - 5).Trim());
else if (markup.StartsWith("{=") && markup.EndsWith("}"))
return new CodeExpressionFragment(Utils.Substring(markup, 2, markup.Length - 3).Trim());
return null;
}
public TemplateOveridingDefinitionTile(string name, ITemplate template, ITile extends,
IEnumerable<TileAttribute> attributes)
: base(name, template, attributes)
{
_extends = extends;
Attributes.MergeTileLazy(_extends);
}
private void AddTemplateAsControl(ITemplate anyTemplate, object cuurentItem)
{
javascript.Visible = false;
templateContentHolder = new EbuyPopupContenido(cuurentItem);
MensajePopUp.Text = Titulo;
if (BotonCancelar)
Cancelar.Visible = true;
else
Cancelar.Visible = false;
if (BotonAceptar)
{
Aceptar.Visible = true;
if (BotonAceptarDesapareceAlApretar)
{
javascript.Visible = true;
Literal1.Text = this.ID;
Aceptar.OnClientClick += "javascript:BotonAceptarDesaparece"+this.ID+"();";
}
}
else
Aceptar.Visible = false;
if (BotonOK)
OK.Visible = true;
else
OK.Visible = false;
Aceptar.Click += AceptarOnClick;
anyTemplate.InstantiateIn(templateContentHolder);
PanelContenedor.Controls.Add(templateContentHolder);
// this.Controls.Add(PanelContenedor);
}
public DocumentParser(ITemplate template)
{
Ensure.ArgumentNotNull(template, "template");
_template = template;
_markdown = new Markdown();
}
public TypedMarkupData Parse(string registeredPrefix, bool isArray, string value, ITemplate template) {
if (isArray) {
StringBuilder sb = new StringBuilder();
sb.Append("new int[] {");
int[] ints;
if (value.Trim() != "") {
string[] split = value.Split('|');
ints = new int[split.Length];
for (int i = 0; i < split.Length; i++) {
if (Utils.RegexExec(split[i], Utils.IntRegex, "") == null)
throw ParserUtils.TemplateErrorException(ParserUtils.MakeTypedMarkupErrorMessage(registeredPrefix, isArray, value));
sb.Append(i > 0 ? ", " : " ");
ints[i] = Utils.ParseInt(split[i]);
sb.Append(Utils.ToStringInvariantInt(ints[i]));
}
}
else
ints = new int[0];
sb.Append(" }");
return new TypedMarkupData(sb.ToString(), delegate() { return ints; });
}
else {
if (Utils.RegexExec(value, Utils.IntRegex, "") == null)
throw ParserUtils.TemplateErrorException(ParserUtils.MakeTypedMarkupErrorMessage(registeredPrefix, isArray, value));
int i = Utils.ParseInt(value);
return new TypedMarkupData(Utils.ToStringInvariantInt(i), delegate() { return i; });
}
}
/// <summary>
/// Adds an item with the specified template.
/// </summary>
/// <param name="template"></param>
/// <param name="item"></param>
/// <param name="itemNumber"></param>
/// <param name="selected"></param>
protected void AddItemTemplate(ITemplate template, PageData item, int itemNumber, bool selected)
{
if (AddSeparator)
AddSeparatorTemplate();
AddTemplate(new PageDataItemTemplateContainer(item, itemNumber, selected), template);
Added = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="Tpl" /> class.
/// </summary>
/// <param name="template">The template.</param>
/// <param name="title">The site title.</param>
public Tpl(ITemplate template, string title)
{
if (template != null)
Data = template.Get();
Title = title;
}
public RuntimeEntity(int uniqueId, ITemplate template, IEventDispatcher eventDispatcher)
: this(uniqueId, eventDispatcher, "") {
foreach (DataAccessor accessor in template.SelectData()) {
Data.IData data = template.Current(accessor);
AddData_unlocked(accessor, data.Duplicate());
}
}
/// <summary>
/// Set template variable value with data from template (all occurrences will be replaced)
/// </summary>
/// <param name="variableName">Variable name in master template file</param>
/// <param name="template">The template.</param>
public void Add(string variableName, ITemplate template)
{
if (template == null)
return;
Add(variableName, template.Get());
}
public static double ProbabilityCalculation(ITemplate template, IDictionary<JointType, InputVector> input)
{
var end = template.EndCondition(input);
var start = template.StartCondition(input);
var motion = template.MotionCharacteristic(input);
return end*start*motion;
}
protected void AddTemplate(ITemplate template) {
if (template != null) {
TemplateItem i = new TemplateItem();
template.InstantiateIn(i);
Controls.Add(i);
}
}
public bool TryProcess(IDocumentProcessor docProcessor, XmlNode node, bool isRoot, ITemplate template, IRenderFunction currentRenderFunction) {
if (node.NodeType != XmlNodeType.Element)
return false;
GenericElementProcessorContext context = new GenericElementProcessorContext();
currentRenderFunction.AddFragment(new LiteralFragment("<" + node.Name));
AddAttributeFragments(docProcessor, node, isRoot, template, currentRenderFunction, context);
if (context.Id != null) {
string tagName = node.Name;
if (tagName.ToLowerCase() == "input" && context.Type != null)
tagName += "/" + context.Type;
template.AddMember(new NamedElementMember(tagName, context.Id));
}
if (noContentTags.Contains(node.Name)) {
if (Utils.GetNumChildNodes(node) > 0)
throw ParserUtils.TemplateErrorException("The tag " + node.Name + " can not have children.");
currentRenderFunction.AddFragment(new LiteralFragment("/>"));
}
else {
currentRenderFunction.AddFragment(new LiteralFragment(">"));
Utils.DoForEachChild(node, delegate(XmlNode child) {
docProcessor.ProcessRecursive(child, template, currentRenderFunction);
});
currentRenderFunction.AddFragment(new LiteralFragment("</" + node.Name + ">"));
}
return true;
}
public static bool TryGet(string name, out ITemplate template)
{
if (name == null)
throw new ArgumentNullException ("name");
return templates.TryGetValue (name, out template);
}
public bool TryProcess(IDocumentProcessor docProcessor, XmlNode node, bool isRoot, ITemplate template, IRenderFunction currentRenderFunction) {
if (node.NodeType != XmlNodeType.ProcessingInstruction || node.Name != "view")
return false;
if (!isRoot)
throw ParserUtils.TemplateErrorException(string.Format("The view directive can only appear outside of the template.", node.Name));
string[] serverTypeArr = Utils.RegexExec(node.Value, "modelType=\"([^\"]*)\"", "");
string[] clientTypeArr = Utils.RegexExec(node.Value, "clientModelType=\"([^\"]*)\"", "");
if (serverTypeArr == null && clientTypeArr != null)
throw ParserUtils.TemplateErrorException("You cannot specify a client type for the model if you don't specify a server type");
if (template.HasMember("Model") || template.HasMember("model") || template.HasMember("Saltarelle.Mvc.IView.Model"))
throw ParserUtils.TemplateErrorException("The template already defines at least one of the members essential to use the view directive. Have you specified <?view?> more than once?");
string serverType = (serverTypeArr != null ? serverTypeArr[1] : "object"), clientType = (clientTypeArr != null ? clientTypeArr[1] : null);
string viewInterface = "Saltarelle.Mvc.IView<" + serverType + ">";
if (template.ImplementsServerInterface(viewInterface))
throw ParserUtils.TemplateErrorException("The template already implements the interface " + viewInterface + ".");
template.AddServerInterface(viewInterface);
template.AddMember(new FieldMember("model", serverType, clientType));
template.AddMember(new PropertyMember("Model", serverType, null, AccessModifier._Public, "model", serverType, null, true, true, "ModelChanged", false));
template.AddMember(new PropertyMember("Saltarelle.Mvc.IView.Model", "object", null, AccessModifier._None, "model", serverType, null, true, true, "ModelChanged", false));
return true;
}
private void ActualProcess(XmlNode node, bool isRoot, ITemplate template, IRenderFunction currentRenderFunction) {
foreach (INodeProcessor p in processors) {
if (p.TryProcess(this, node, isRoot, template, currentRenderFunction))
return;
}
throw ParserUtils.TemplateErrorException("The node " + node.ToString() + " could not be handled.");
}
public void ProcessRecursive(XmlNode node, ITemplate template, IRenderFunction currentRenderFunction) {
if (template == null) throw Utils.ArgumentException("template");
if (currentRenderFunction == null) throw Utils.ArgumentException("currentRenderFunction");
if (node == null) throw Utils.ArgumentNullException("node");
ActualProcess(node, false, template, currentRenderFunction);
}
public void InstantiateTemplate (ITemplate template)
{
if (!renderOuterTable)
template.InstantiateIn (this);
else
template.InstantiateIn (_containerCell);
}
public StatsModule(ITemplate tmpl, IIdGenerator idgen, SavegameStorage storage)
{
Post["/games"] = _ =>
{
// Get the temporary location of the file on the server
var file = Request.Headers["X-FILE"].FirstOrDefault();
// Get the extension of the file when it was uploaded as the
// temporary file doesn't have an extension
var extension = Request.Headers["X-FILE-EXTENSION"].FirstOrDefault();
if (file == null)
throw new ArgumentException("File can't be null");
if (extension == null)
throw new ArgumentException("File extension can't be null");
Save savegame;
using (var stream = getStream(file, extension))
using (parsingTimer.NewContext())
savegame = new Save(stream);
// Turn the savegame into html and return the url for it
var stats = statsTimer.Time(() => Aggregate(savegame));
string contents = templateTimer.Time(() => tmpl.Render(stats));
string id = idgen.NextId();
return storage.Store(contents, id);
};
}
public void Render(ITemplate tpl, IInstantiatedTemplateControl ctl, StringBuilder sb) {
if (IsCData)
sb.Append("<![CDATA[");
sb.Append(Text);
if (IsCData)
sb.Append("]]>");
}
public TypedMarkupData Parse(string registeredPrefix, bool isArray, string value, ITemplate template) {
if (isArray) {
StringBuilder sb = new StringBuilder();
sb.Append("new Position[] {");
Position[] positions;
if (value.Trim() != "") {
string[] split = value.Split('|');
positions = new Position[split.Length];
for (int i = 0; i < split.Length; i++) {
StringPositionPair v = ParseSingle(split[i]);
if (v == null)
throw ParserUtils.TemplateErrorException(ParserUtils.MakeTypedMarkupErrorMessage(registeredPrefix, isArray, value));
sb.Append(i > 0 ? ", " : " ");
positions[i] = v.p;
sb.Append(v.s);
}
}
else
positions = new Position[0];
sb.Append(" }");
return new TypedMarkupData(sb.ToString(), delegate() { return positions; });
}
else {
StringPositionPair v = ParseSingle(value);
if (v == null)
throw ParserUtils.TemplateErrorException(ParserUtils.MakeTypedMarkupErrorMessage(registeredPrefix, isArray, value));
return new TypedMarkupData(v.s, delegate { return v.p; });
}
}
public BasicTester()
{
_hostRoot = Path.Combine(Directory.GetCurrentDirectory(), "Templates");
_pak1 = Path.Combine(_hostRoot, "Pak1");
_pak2 = Path.Combine(_hostRoot, "Pak2");
_hostHomeView = new Template(Path.Combine(_hostRoot, "Home", "Home.spark"), _hostRoot, TemplateConstants.HostOrigin);
_hostApplicationView = new Template(Path.Combine(_hostRoot, "Shared", "application.spark"), _hostRoot, TemplateConstants.HostOrigin);
_hostFooterPartialView = new Template(Path.Combine(_hostRoot, "Shared", "_footer.spark"), _hostRoot, TemplateConstants.HostOrigin);
_pak1HomeView = new Template(Path.Combine(_pak1, "Home", "Home.spark"), _hostRoot, "Pak1");
_pak1NamePartialView = new Template(Path.Combine(_pak1, "Home", "_name.spark"), _hostRoot, "Pak1");
_pak2HomeView = new Template(Path.Combine(_pak2, "Home", "Home.spark"), _hostRoot, "Pak2");
_pak2ApplicationView = new Template(Path.Combine(_pak2, "Shared", "application.spark"), _hostRoot, "Pak2");
_pak2ThemeView = new Template(Path.Combine(_pak2, "Shared", "theme.spark"), _hostRoot, "Pak2");
var templates = new List<ITemplate>
{
_hostHomeView, _hostApplicationView, _hostFooterPartialView,
_pak1HomeView, _pak1NamePartialView,
_pak2HomeView, _pak2ApplicationView, _pak2ThemeView
};
var viewPathPolicy = new ViewPathPolicy<ITemplate>();
templates.Each(viewPathPolicy.Apply);
_viewFolder = new TemplateViewFolder(new TemplateRegistry<ITemplate>(templates));
}
private IEnumerable<string> getDirectories(ITemplate template, ITemplateRegistry templateRegistry, bool includeDirectAncestor)
{
foreach (var directory in _builder.BuildBy(template.FilePath, template.RootPath, includeDirectAncestor))
{
yield return directory;
}
if (template.FromHost())
{
yield break;
}
var hostTemplate = templateRegistry.FromHost().FirstOrDefault();
if (hostTemplate == null)
{
yield break;
}
var hostRoot = hostTemplate.RootPath;
if (includeDirectAncestor)
{
yield return hostRoot;
}
foreach (var sharedFolder in _builder.SharedFolderNames)
{
yield return Path.Combine(hostRoot, sharedFolder);
}
}
public override TemplateParseResult Parse(string template, ITemplate currentItem, int index, char nextChar)
{
currentItem.Children.Add(this);
if (nextChar != '(')
throw new ParseException("Expected '(' after if");
StringBuilder consumer = new StringBuilder();
consumer.Append(nextChar);
int stackCount = 1;
index++;
while (stackCount > 0)
{
nextChar = template[index + 1];
if (nextChar == '(')
stackCount--;
else if (nextChar == ')')
stackCount--;
else if (stackCount > 0 && (nextChar == '\r' || nextChar == '\n'))
throw new ParseException("Expected ')' but encountered newline in if-statement");
consumer.Append(nextChar);
index++;
}
index++;
this.Arguments = consumer.ToString();
return new TemplateParseResult(currentItem, index);
}
internal RowTextContent(int tableId, ITemplate template,
PointGeometry pos, IFont font, double height, double width, float rotation)
: base(pos, font, height, width, rotation)
{
m_TableId = tableId;
m_TemplateId = 0;
}
public TypedMarkupData Parse(string registeredPrefix, bool isArray, string value, ITemplate template) {
if (isArray) {
StringBuilder sb = new StringBuilder();
sb.Append("new bool[] {");
bool[] bools;
if (value.Trim() != "") {
string[] split = value.Split('|');
bools = new bool[split.Length];
for (int i = 0; i < split.Length; i++) {
int x = ParseSingle(split[i]);
if (x == -1)
throw ParserUtils.TemplateErrorException(ParserUtils.MakeTypedMarkupErrorMessage(registeredPrefix, isArray, value));
bools[i] = (x == 1);
sb.Append(i > 0 ? ", " : " ");
sb.Append(x == 1 ? "true" : "false");
}
}
else
bools = new bool[0];
sb.Append(" }");
return new TypedMarkupData(sb.ToString(), delegate() { return bools; });
}
else {
int x = ParseSingle(value);
if (x == -1)
throw ParserUtils.TemplateErrorException(ParserUtils.MakeTypedMarkupErrorMessage(registeredPrefix, isArray, value));
return new TypedMarkupData(x == 1 ? "true" : "false", delegate { return x == 1; });
}
}
protected internal void AddContentTemplate (string templateName, ITemplate template)
{
// LAMESPEC: should be ArgumentException
if (definedContentTemplates.ContainsKey (templateName))
throw new HttpException ("Multiple contents applied to " + templateName);
definedContentTemplates [templateName] = template;
}
public bool Matches(ITemplate template)
{
var descriptor = template.Descriptor as ViewDescriptor;
return descriptor != null
&& descriptor.HasViewModel()
&& descriptor.Namespace.IsEmpty();
}
public void enqueueMessage(ITemplate template)
{
var message = buildMessage(template);
var data = new MSSQLData(Globals.Instance.settings["MessagingConnection"]);
var orm = new Orm(data);
var res = orm.execObject<Result>(message, "mess.enqueue_message");
}
private IEnumerable<ITemplate> locateTemplates(string name, ITemplate fromTemplate, ITemplateRegistry templateRegistry, bool sharedsOnly)
{
var directories = sharedsOnly
? _provider.SharedPathsOf(fromTemplate, templateRegistry)
: _provider.ReachablesOf(fromTemplate, templateRegistry);
return templateRegistry.ByNameUnderDirectories(name, directories);
}
public void Initialize()
{
this.solution = (ISolution)VsIdeTestHostContext.ServiceProvider.GetService(typeof(ISolution));
this.solution.CreateInstance(this.DeploymentDirectory, "EmptySolution");
var templates = (ITemplateService)VsIdeTestHostContext.ServiceProvider.GetService(typeof(ITemplateService));
this.toolkitTemplate = templates.Find("MyTemplate2", "CSharp");
}
protected internal void AddContentTemplate(string templateName, ITemplate template)
{
}
internal static void ProcessDefFragment(IDocumentProcessor docProcessor, XmlNode node, ITemplate template)
{
XmlAttribute nameAttr = (XmlAttribute)node.Attributes.GetNamedItem("name");
XmlAttribute paramsAttr = (XmlAttribute)node.Attributes.GetNamedItem("params");
if (nameAttr == null)
{
throw ParserUtils.TemplateErrorException("The <def-fragment> element must have the name attribute specified.");
}
string name = nameAttr.Value;
if (!ParserUtils.IsValidUnqualifiedName(name))
{
throw ParserUtils.TemplateErrorException("The name " + name + " is not a valid unqualified identifier.");
}
if (template.HasMember(name))
{
throw ParserUtils.TemplateErrorException("Duplicate definition of member " + name + ".");
}
RenderFunctionMember m = new RenderFunctionMember(nameAttr.Value, paramsAttr != null ? paramsAttr.Value : "");
Utils.DoForEachChild(node, delegate(XmlNode n) {
docProcessor.ProcessRecursive(n, template, m);
});
if (template.HasMember(name))
{
throw ParserUtils.TemplateErrorException("Duplicate definition of member " + name + "."); // Just in case it has already been added during the recursive call.
}
template.AddMember(m);
}
/// <summary> /// When overriden in a derived class, this gets the value of the Property for a given Template /// </summary> /// <param name="template">Template for the View Model</param> /// <param name="propertyType">Actual return type for the Property</param> /// <param name="factory">View Model factory</param> /// <returns>The Property value</returns> public abstract IEnumerable GetPropertyValues(ITemplate template, Type propertyType, IViewModelFactory factory);
protected override IModel BuildModelData(object value, IField field, ITemplate template)
{
var keyword = (IKeyword)value;
return(keyword);
}
/// <summary>
/// Saves the data type
/// </summary>
/// <param name="display"></param>
/// <returns></returns>
public TemplateDisplay PostSave(TemplateDisplay display)
{
//Checking the submitted is valid with the Required attributes decorated on the ViewModel
if (ModelState.IsValid == false)
{
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
if (display.Id > 0)
{
// update
var template = Services.FileService.GetTemplate(display.Id);
if (template == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
var changeMaster = template.MasterTemplateAlias != display.MasterTemplateAlias;
var changeAlias = template.Alias != display.Alias;
Mapper.Map(display, template);
if (changeMaster)
{
if (string.IsNullOrEmpty(display.MasterTemplateAlias) == false)
{
var master = Services.FileService.GetTemplate(display.MasterTemplateAlias);
if (master == null || master.Id == display.Id)
{
template.SetMasterTemplate(null);
}
else
{
template.SetMasterTemplate(master);
//After updating the master - ensure we update the path property if it has any children already assigned
var templateHasChildren = Services.FileService.GetTemplateDescendants(display.Id);
foreach (var childTemplate in templateHasChildren)
{
//template ID to find
var templateIdInPath = "," + display.Id + ",";
if (string.IsNullOrEmpty(childTemplate.Path))
{
continue;
}
//Find position in current comma seperate string path (so we get the correct children path)
var positionInPath = childTemplate.Path.IndexOf(templateIdInPath) + templateIdInPath.Length;
//Get the substring of the child & any children (descendants it may have too)
var childTemplatePath = childTemplate.Path.Substring(positionInPath);
//As we are updating the template to be a child of a master
//Set the path to the master's path + its current template id + the current child path substring
childTemplate.Path = master.Path + "," + display.Id + "," + childTemplatePath;
//Save the children with the updated path
Services.FileService.SaveTemplate(childTemplate);
}
}
}
else
{
//remove the master
template.SetMasterTemplate(null);
}
}
Services.FileService.SaveTemplate(template);
if (changeAlias)
{
template = Services.FileService.GetTemplate(template.Id);
}
Mapper.Map(template, display);
}
else
{
//create
ITemplate master = null;
if (string.IsNullOrEmpty(display.MasterTemplateAlias) == false)
{
master = Services.FileService.GetTemplate(display.MasterTemplateAlias);
if (master == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
}
var template = Services.FileService.CreateTemplateWithIdentity(display.Name, display.Content, master);
Mapper.Map(template, display);
}
return(display);
}
public TypedMarkupData Parse(string registeredPrefix, bool isArray, string value, ITemplate template)
{
if (isArray)
{
StringBuilder sb = new StringBuilder();
sb.Append("new Position[] {");
Position[] positions;
if (value.Trim() != "")
{
string[] split = value.Split('|');
positions = new Position[split.Length];
for (int i = 0; i < split.Length; i++)
{
StringPositionPair v = ParseSingle(split[i]);
if (v == null)
{
throw ParserUtils.TemplateErrorException(ParserUtils.MakeTypedMarkupErrorMessage(registeredPrefix, isArray, value));
}
sb.Append(i > 0 ? ", " : " ");
positions[i] = v.p;
sb.Append(v.s);
}
}
else
{
positions = new Position[0];
}
sb.Append(" }");
return(new TypedMarkupData(sb.ToString(), delegate() { return positions; }));
}
else
{
StringPositionPair v = ParseSingle(value);
if (v == null)
{
throw ParserUtils.TemplateErrorException(ParserUtils.MakeTypedMarkupErrorMessage(registeredPrefix, isArray, value));
}
return(new TypedMarkupData(v.s, delegate { return v.p; }));
}
}
protected virtual void InitializeItem(ResSiteMapNodeItem item)
{
ITemplate nodeTemplate = null;
SiteMapNodeItemType itemType = item.ItemType;
SiteMapNode siteMapNode = item.SiteMapNode;
switch (itemType)
{
case SiteMapNodeItemType.Root:
nodeTemplate = (this.RootNodeTemplate != null) ? this.RootNodeTemplate : this.NodeTemplate;
break;
case SiteMapNodeItemType.Parent:
nodeTemplate = this.NodeTemplate;
break;
case SiteMapNodeItemType.Current:
nodeTemplate = (this.CurrentNodeTemplate != null) ? this.CurrentNodeTemplate : this.NodeTemplate;
break;
}
if (nodeTemplate == null)
{
if (itemType != SiteMapNodeItemType.PathSeparator)
{
if (itemType == SiteMapNodeItemType.Current)
{
item.Attributes["class"] = "active";
}
if ((itemType == SiteMapNodeItemType.Current) && !this.RenderCurrentNodeAsLink)
{
Literal literal2 = new Literal
{
Mode = LiteralMode.Encode,
Text = siteMapNode.Title
};
item.Controls.Add(literal2);
}
else
{
if (itemType == SiteMapNodeItemType.Root)
{
item.Controls.Add(new LiteralControl("<i class=\"icon-home\"></i> "));
}
HyperLink link = new HyperLink();
link.EnableTheming = false;
link.Enabled = this.Enabled;
if (string.IsNullOrEmpty(siteMapNode.Url))
{
link.NavigateUrl = "javascript:void(0);";
link.Enabled = false;
}
else if (siteMapNode.Url.StartsWith(@"\\", StringComparison.Ordinal))
{
link.NavigateUrl = base.ResolveClientUrl(HttpUtility.UrlPathEncode(siteMapNode.Url));
}
else
{
link.NavigateUrl = (this.Context != null) ? this.Context.Response.ApplyAppPathModifier(base.ResolveClientUrl(HttpUtility.UrlPathEncode(siteMapNode.Url))) : siteMapNode.Url;
}
link.Text = HttpUtility.HtmlEncode(siteMapNode.Title);
if (this.ShowToolTips)
{
link.ToolTip = siteMapNode.Description;
}
item.Controls.Add(link);
}
}
}
else
{
nodeTemplate.InstantiateIn(item);
}
}
// Get string value from template
string PersistTemplate(ITemplate template)
{
var host = (IDesignerHost)GetService(typeof(IDesignerHost));
return(ControlPersister.PersistTemplate(template, host));
}
/// <summary> /// When overriden in a derived class, this method should return the value of the View Model property from a Field object /// </summary> /// <param name="field">The Field</param> /// <param name="propertyType">The concrete type of the view model property for this attribute</param> /// <param name="template">The Component Template to use</param> /// <param name="factory">The View Model Builder</param> /// <returns></returns> public abstract IEnumerable GetFieldValues(IField field, IModelProperty property, ITemplate template, IViewModelFactory factory = null);
protected abstract IModel BuildModelData(object value, IField field, ITemplate template);
public override IEnumerable GetFieldValues(IField field, IModelProperty property, ITemplate template, IViewModelFactory factory = null)
{
IEnumerable fieldValue = null;
var values = GetRawValues(field);
if (values != null)
{
if (ComplexTypeMapping == null && ReturnRawData)
{
fieldValue = values;
}
else
{
fieldValue = values.Cast <object>()
.Select(value => BuildModel(factory, BuildModelData(value, field, template)))
.Where(value => value != null);
}
}
return(fieldValue);
}
public static void BuildTemplateOperacao(ITemplate template)
{
Console.WriteLine(template.NumeroContrato);
}
internal override void AddContentTemplate(object obj, string templateName, ITemplate template)
{
MasterPage master = (MasterPage)obj;
master.AddContentTemplate(templateName, template);
}
public List <WorldObject> findTemplate(ITemplate[] original, out string log)
{
tc.loadTemplates();//debug
List <ITemplate> resualtObjList = original.ToList();
do
{
original = resualtObjList.ToArray();
for (int k = 0; k <= tc.TEMPLATE_RANGE; k++)
{
if (k == 4)
{
var a = 1;
}
for (int i = 1; i <= 3; i++)
{
for (int j = resualtObjList.Count - i; j >= 0; j--)
{
if (i == 1)
{
//template of 1 words
var testPart = new ITemplate[] { resualtObjList[j] };
ITemplate o;
if ((o = tc.checkObjects(testPart, k)) != null)
{
resualtObjList.RemoveAt(j);
resualtObjList.Insert(j, o);
k = 0;
}
}
else if (i == 2)
{
//template of 2 words
var testPart = new ITemplate[] { resualtObjList[j], resualtObjList[j + 1] };
ITemplate o;
if ((o = tc.checkObjects(testPart, k)) != null)
{
resualtObjList.RemoveAt(j);
resualtObjList.RemoveAt(j);
resualtObjList.Insert(j, o);
k = 0;
// j = j + 1;
}
}
else
{
//template of 3 words
var testPart = new ITemplate[] { resualtObjList[j], resualtObjList[j + 1], resualtObjList[j + 2] };
ITemplate o;
if ((o = tc.checkObjects(testPart, k)) != null)
{
resualtObjList.RemoveAt(j);
resualtObjList.RemoveAt(j);
resualtObjList.RemoveAt(j);
resualtObjList.Insert(j, o);
k = 0;
// j = j + 2;
}
}
}
}
}
} while (resualtObjList.Count < original.Count());
List <WorldObject> res = new List <WorldObject>();
foreach (var o in resualtObjList)
{
if (o.ObjectType() == 1) //worldobject
{
res.Add(o as WorldObject);
}
else
{ //TODO take care of unknown objects
// res.Add(new WorldObject(o.ToString()));
}
}
log = tc.log;
return(res);
}
private static void TestTemplate(ITemplate tpl, ITemplate masterTemplate, ITemplate testTemplate, ITemplate masterTestTemplate)
{
masterTemplate.Set("Title", "Hello world!!!");
tpl.Set("ItemTitle", "Item1");
tpl.Add("var1", 15.5m);
tpl.Add("var1", (long)16);
tpl.Add("var1", 17);
tpl.Add("var1", 18.16);
tpl.Add("var1", new object());
tpl.Set("var2", 15.5m)
.Set("var3", (long)16)
.Set("var4", 17)
.Set("var5", 18.16)
.Set("var6", new object());
Assert.AreEqual(testTemplate.Get(), tpl.Get());
masterTemplate.Add("Items", tpl.GetAndRoll());
tpl.Set("ItemTitle", "Item2");
tpl.Add("var1", 16.5m)
.Add("var1", (long)255)
.Add("var1", 300)
.Add("var1", 26.15)
.Add("var1", new object());
tpl.Set("var2", 10.5m);
tpl.Set("var3", (long)1);
tpl.Set("var4", 3);
tpl.Set("var5", 4.1233);
tpl.Set("var6", new object());
tpl.Set("NotFoundItem", (ITemplate)null);
masterTemplate.Add("Items", tpl);
masterTemplate.Set("FromTemplateNull", (ITemplate)null);
masterTemplate.Set("FromTemplateNotNull", Template.FromString("test"));
Assert.AreEqual(masterTestTemplate.Get(), masterTemplate.Get());
}
///--------------------------------------------------------------------------------
/// <summary>Interpret this node to produce code, output, or model data..</summary>
///
/// <param name="interpreterType">The type of interpretation to perform.</param>
/// <param name="solutionContext">The associated solution.</param>
/// <param name="templateContext">The associated template.</param>
/// <param name="modelContext">The associated model context.</param>
///--------------------------------------------------------------------------------
public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext)
{
}
protected Entity(ulong instanceId, [CanBeNull] ITemplate template)
{
InstanceId = instanceId;
Template = template;
}
/// <summary>
/// Create an AccordionPane's item (either Header or Content) and raise the ItemCreated event
/// </summary>
/// <param name="dataItem">Item's data</param>
/// <param name="index">Index</param>
/// <param name="itemType">Type of the item (Header or Content)</param>
/// <param name="container">Control to fill</param>
/// <param name="template">Template for the binding</param>
/// <param name="dataBind">Whether or not to bind</param>
private void CreateItem(object dataItem, int index, AccordionItemType itemType, AccordionContentPanel container, ITemplate template, bool dataBind)
{
if (template == null)
{
return;
}
AccordionItemEventArgs itemArgs = new AccordionItemEventArgs(container, itemType);
OnItemCreated(itemArgs);
container.SetDataItemProperties(dataItem, index, itemType);
template.InstantiateIn(container);
if (dataBind)
{
container.DataBind();
OnItemDataBound(itemArgs);
}
}
public void Initialize()
{
try
{
var container = contentTypeService.GetContainers(DOCUMENT_TYPE_CONTAINER, 1).FirstOrDefault();
int containerId = -1;
if (container != null)
{
containerId = container.Id;
}
var contentType = contentTypeService.Get(DOCUMENT_TYPE_ALIAS);
if (contentType != null)
{
return;
}
const string CONTENT_TAB = "CONTENT";
ContentType docType = (ContentType)contentType ?? new ContentType(containerId)
{
Name = DOCUMENT_TYPE_NAME,
Alias = DOCUMENT_TYPE_ALIAS,
AllowedAsRoot = false,
Description = "",
Icon = NESTED_DOCUMENT_TYPE_ICON,
ParentId = contentTypeService.Get(NESTED_DOCUMENT_TYPE_PARENT_ALIAS).Id,
SortOrder = 0,
Variations = ContentVariation.Culture,
};
// Create the Template if it doesn't exist
if (fileService.GetTemplate(TEMPLATE_ALIAS) == null)
{
//then create the template
Template newTemplate = new Template(TEMPLATE_NAME, TEMPLATE_ALIAS);
ITemplate masterTemplate = fileService.GetTemplate(PARENT_TEMPLATE_ALIAS);
newTemplate.SetMasterTemplate(masterTemplate);
fileService.SaveTemplate(newTemplate);
}
var template = fileService.GetTemplate(TEMPLATE_ALIAS);
docType.AllowedTemplates = new List <ITemplate> {
template
};
docType.SetDefaultTemplate(template);
docType.AddPropertyGroup(CONTENT_TAB);
#region Content
PropertyType CotentPageTitlePropType = new PropertyType(dataTypeService.GetDataType(-88), "loginPageTitle")
{
Name = "Page Title",
Variations = ContentVariation.Culture
};
docType.AddPropertyType(CotentPageTitlePropType, CONTENT_TAB);
//PropertyType CotentPageContentPropType = new PropertyType(dataTypeService.GetDataType(-87), "genericInfoPageContent")
//{
// Name = "Page Content",
// Variations = ContentVariation.Culture
//};
//docType.AddPropertyType(CotentPageContentPropType, CONTENT_TAB);
#endregion
contentTypeService.Save(docType);
ConnectorContext.AuditService.Add(AuditType.New, -1, docType.Id, "Document Type", $"Document Type '{DOCUMENT_TYPE_NAME}' has been created");
ContentHelper.CopyPhysicalAssets(new LoginPageEmbeddedResources());
var parentDocType = contentTypeService.Get(PARENT_NODE_DOCUMENT_TYPE_ALIAS);
if (parentDocType.AllowedContentTypes.SingleOrDefault(x => x.Alias.Equals(DOCUMENT_TYPE_ALIAS)) == null)
{
// set as allowed content type in account home
ContentHelper.AddAllowedDocumentType(contentTypeService, PARENT_NODE_DOCUMENT_TYPE_ALIAS, DOCUMENT_TYPE_ALIAS);
ConnectorContext.AuditService.Add(AuditType.Move, -1, contentType.Id, "Document Type", $"Document Type '{DOCUMENT_TYPE_ALIAS}' has been updated");
}
}
catch (Exception ex)
{
logger.Error(typeof(_41_LoginPageDocumentType), ex.Message);
logger.Error(typeof(_41_LoginPageDocumentType), ex.StackTrace);
}
}
public bool TryProcess(IDocumentProcessor docProcessor, XmlNode node, bool isRoot, ITemplate template, IRenderFunction currentRenderFunction)
{
string name = node.Name;
if (node.NodeType == XmlNodeType.Element && name == "def-fragment")
{
if (isRoot)
{
throw ParserUtils.TemplateErrorException("Fragment definitions must be inside the template.");
}
ProcessDefFragment(docProcessor, node, template);
return(true);
}
else if (node.NodeType == XmlNodeType.Element && name == "call-fragment")
{
if (isRoot)
{
throw ParserUtils.TemplateErrorException("Fragment instantiations must be inside the template.");
}
currentRenderFunction.AddFragment(ProcessCallFragment(docProcessor, node));
return(true);
}
else
{
return(false);
}
}
internal bool ViewExists(ITemplate t)
{
return(_viewFileSystem.FileExists(ViewPath(t.Alias)));
}
/// <summary> /// When overriden in a derived class, this gets the value of the Property for a given Component /// </summary> /// <param name="component">Component for the View Model</param> /// <param name="propertyType">Actual return type for the Property</param> /// <param name="template">Component Template</param> /// <param name="factory">View Model factory</param> /// <returns>The Property value</returns> public abstract IEnumerable GetPropertyValues(IComponent component, IModelProperty property, ITemplate template, IViewModelFactory factory);
public IEnumerable <string> SharedPathsOf(ITemplate template)
{
return(getDirectories(template, false).ToList());
}
/// <summary>
/// Sets the template to use to display the requested content.
/// </summary>
/// <param name="template">The template.</param>
/// <remarks>Setting the template does refresh <c>RenderingEngine</c>.</remarks>
public void SetTemplate(ITemplate template)
{
EnsureWriteable();
TemplateModel = template;
}
public XElement Export(ITemplate template, bool raiseEvents = true)
{
return(realPackagingService.Export(template, raiseEvents));
}
public IEnumerable <string> ReachablesOf(ITemplate template)
{
return(getDirectories(template, true).ToList());
}
private static Template ImportTemplate(ServiceContext svces, string name, string alias, string text, ITemplate master = null)
{
var t = new Template(name, alias)
{
Content = text
};
if (master != null)
{
t.SetMasterTemplate(master);
}
svces.FileService.SaveTemplate(t);
return(t);
}
public IotaChi Add(ITemplate template, StreamingSource a)
{
return(B = new IotaChi {
Template = template, A = a
});
}
public override IEnumerable GetPropertyValues(IModel modelData, IModelProperty property, IViewModelFactory factory)
{
IEnumerable result = null;
if (modelData != null)
{
//need null checks on Template
IFieldSet fields = null;
ITemplate template = null;
if (IsTemplateMetadata)
{
if (modelData is IComponentPresentation)
{
var templateData = modelData as IComponentPresentation;
template = templateData.ComponentTemplate;
}
else if (modelData is IPage)
{
var templateData = modelData as IPage;
template = templateData.PageTemplate;
}
fields = template != null ? template.MetadataFields : null;
}
else if (IsMetadata)
{
if (modelData is IComponentPresentation)
{
fields = (modelData as IComponentPresentation).Component.MetadataFields;
}
else if (modelData is IComponent)
{
fields = (modelData as IComponent).MetadataFields;
}
else if (modelData is IPage)
{
fields = (modelData as IPage).MetadataFields;
}
else if (modelData is ITemplate)
{
fields = (modelData as ITemplate).MetadataFields;
}
else if (modelData is IKeyword)
{
fields = (modelData as IKeyword).MetadataFields;
}
//Any other things with MetadataFields?
}
else if (modelData is IComponentPresentation)
{
fields = (modelData as IComponentPresentation).Component.Fields;
}
if (String.IsNullOrEmpty(FieldName))
{
FieldName = GetFieldName(property.Name); //Convention over configuration by default -- Field name = Property name
}
if (fields != null && fields.ContainsKey(FieldName))
{
result = this.GetFieldValues(fields[FieldName], property, template, factory);
}
}
return(result);
}
public void SetTemplate(ITemplate template) => this.template = template;
