public CompositeTypedEntity(TypedEntity entity)
{
Attributes.Clear();
entity.Attributes.ForEach(x => Attributes.Add(x));
RelationProxies.LazyLoadDelegate = entity.RelationProxies.LazyLoadDelegate;
}
public void GetIdPath_Returns_In_Correct_Order_For_Entities()
{
//mock hive
IReadonlyEntityRepositoryGroup<IContentStore> readonlyEntitySession;
IReadonlySchemaRepositoryGroup<IContentStore> readonlySchemaSession;
IEntityRepositoryGroup<IContentStore> entityRepository;
ISchemaRepositoryGroup<IContentStore> schemaSession;
var hive = MockHiveManager.GetManager().MockContentStore(out readonlyEntitySession, out readonlySchemaSession, out entityRepository, out schemaSession);
var entity = new TypedEntity {Id = new HiveId(100)};
entityRepository.Get<TypedEntity>(Arg.Any<bool>(), Arg.Any<HiveId[]>()).Returns(new[] {entity});
entityRepository.GetAncestorRelations(new HiveId(100), FixedRelationTypes.DefaultRelationType)
.Returns(new[]
{
new Relation(FixedRelationTypes.DefaultRelationType, new TypedEntity{Id = new HiveId(99)}, entity),
new Relation(FixedRelationTypes.DefaultRelationType, new TypedEntity{Id = new HiveId(98)}, new TypedEntity{Id = new HiveId(99)}),
new Relation(FixedRelationTypes.DefaultRelationType, new TypedEntity{Id = new HiveId(97)}, new TypedEntity{Id = new HiveId(98)}),
});
using (var uow = hive.OpenWriter<IContentStore>())
{
var path = uow.Repositories.GetEntityPath<TypedEntity>(new HiveId(100), FixedRelationTypes.DefaultRelationType);
Assert.AreEqual(new HiveId(97), path.ElementAt(0));
Assert.AreEqual(new HiveId(98), path.ElementAt(1));
Assert.AreEqual(new HiveId(99), path.ElementAt(2));
Assert.AreEqual(new HiveId(100), path.ElementAt(3));
}
}
/// <summary>
/// Returns the TooltipContents after proxying through the task system to allow developers to modify the output
/// </summary>
/// <param name="ds"></param>
/// <param name="sender"></param>
/// <param name="entity"> </param>
/// <param name="htmlContent"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <returns></returns>
public static TooltipContents CreateTooltipContentsViaTask(this INodeSelectorDataSource ds,
object sender,
TypedEntity entity,
string htmlContent,
int width = -1,
int height = -1)
{
var args = new NodeSelectorTooltipEventArgs(entity, htmlContent)
{
Height = height,
Width = width
};
//launch task to modify the contents
ds.FrameworkContext.TaskManager
.ExecuteInContext(
NodeSelectorTaskTriggers.GetTooltipContents,
sender,
new TaskEventArgs(ds.FrameworkContext, args));
return new TooltipContents(args.HtmlContents)
{
Height = args.Height,
Width = args.Width
};
}
public static TypedEntity MapTypedEntity(XElement xElement)
{
Mandate.ParameterNotNull(xElement, "xElement");
var attribs = new HashSet<TypedAttribute>();
var ordinal = 0;
foreach (var childElement in xElement.Elements().Where(x => !x.HasAttributes))
{
var typedAttribute = new TypedAttribute(new AttributeDefinition()
{
Alias = childElement.Name.LocalName,
Name = childElement.Name.LocalName,
Ordinal = ordinal,
Id = HiveId.Empty
}, childElement.Value)
{
Id = HiveId.Empty
};
attribs.Add(typedAttribute);
ordinal++;
}
var nodeId = (int)xElement.Attribute("id");
var returnValue = new TypedEntity
{
// TODO: Replace provider id with injected value inside UoWFactory
Id = new HiveId("content", "r-xmlstore-01", new HiveIdValue(nodeId))
};
returnValue.Attributes.Reset(attribs);
return returnValue;
}
public EntityPig(TypedEntity e)
: base(e)
{
EntityPig e2 = e as EntityPig;
if (e2 != null) {
_saddle = e2._saddle;
}
}
public EntityVillager(TypedEntity e)
: base(e)
{
EntityVillager e2 = e as EntityVillager;
if (e2 != null) {
_profession = e2._profession;
}
}
public EntityPrimedTnt(TypedEntity e)
: base(e)
{
EntityPrimedTnt e2 = e as EntityPrimedTnt;
if (e2 != null) {
_fuse = e2._fuse;
}
}
public EntityGuardian (TypedEntity e)
: base(e)
{
EntityGuardian e2 = e as EntityGuardian;
if (e2 != null) {
_elder = e2._elder;
}
}
public EntityPigZombie(TypedEntity e)
: base(e)
{
EntityPigZombie e2 = e as EntityPigZombie;
if (e2 != null) {
_anger = e2._anger;
}
}
public EntityCreeper(TypedEntity e)
: base(e)
{
EntityCreeper e2 = e as EntityCreeper;
if (e2 != null) {
_powered = e2._powered;
}
}
public EntityMinecart (TypedEntity e)
: base(e)
{
EntityMinecart e2 = e as EntityMinecart;
if (e2 != null) {
_type = e2._type;
}
}
public EntityMinecartChest (TypedEntity e)
: base(e)
{
EntityMinecartChest e2 = e as EntityMinecartChest;
if (e2 != null) {
_items = e2._items.Copy();
}
}
public EntitySlime(TypedEntity e)
: base(e)
{
EntitySlime e2 = e as EntitySlime;
if (e2 != null) {
_size = e2._size;
}
}
public EntityFallingSand(TypedEntity e)
: base(e)
{
EntityFallingSand e2 = e as EntityFallingSand;
if (e2 != null) {
_tile = e2._tile;
}
}
public EntityEnderman (TypedEntity e)
: base(e)
{
EntityEnderman e2 = e as EntityEnderman;
if (e2 != null) {
_carried = e2._carried;
_carryingData = e2._carryingData;
}
}
public EntityEndermite(TypedEntity e)
: base(e)
{
EntityEndermite e2 = e as EntityEndermite;
if (e2 != null) {
_life = e2._life;
_player = e2._player;
}
}
public EntityAnimal(TypedEntity e)
: base(e)
{
EntityAnimal e2 = e as EntityAnimal;
if (e2 != null) {
_age = e2._age;
_inLove = e2._inLove;
}
}
public EntityArrow(TypedEntity e)
: base(e)
{
EntityArrow e2 = e as EntityArrow;
if (e2 != null) {
_inData = e2._inData;
_player = e2._player;
}
}
public EntityBat(TypedEntity e)
: base(e)
{
EntityBat e2 = e as EntityBat;
if (e2 != null)
{
_flag = e2._flag;
}
}
public EntitySheep (TypedEntity e)
: base(e)
{
EntitySheep e2 = e as EntitySheep;
if (e2 != null) {
_sheared = e2._sheared;
_color = e2._color;
}
}
public EntityChicken (TypedEntity e)
: base(e)
{
EntityChicken e2 = e as EntityChicken;
if (e2 != null)
{
_eggTime = e2._eggTime;
}
}
public EntityRabbit(TypedEntity e)
: base(e)
{
EntityRabbit e2 = e as EntityRabbit;
if (e2 != null) {
_type = e2._type;
_carrots = e2._carrots;
}
}
public EntityXPOrb (TypedEntity e)
: base(e)
{
EntityXPOrb e2 = e as EntityXPOrb;
if (e2 != null) {
_health = e2._health;
_age = e2._age;
_value = e2._value;
}
}
public void RecycleCacheFor(TypedEntity entity)
{
string niceUrl = entity.NiceUrl();
RemoveFromProvider(entity, frameworkContext.Caches.LimitedLifetime, niceUrl);
RemoveFromProvider(entity, frameworkContext.Caches.ExtendedLifetime, niceUrl);
RemoveFromProvider(frameworkContext.ApplicationCache, niceUrl);
RegenerateCache(niceUrl);
}
public EntityItem(TypedEntity e)
: base(e)
{
EntityItem e2 = e as EntityItem;
if (e2 != null) {
_health = e2._health;
_age = e2._age;
_item = e2._item.Copy();
}
}
public EntityMinecartFurnace(TypedEntity e)
: base(e)
{
EntityMinecartFurnace e2 = e as EntityMinecartFurnace;
if (e2 != null) {
_pushX = e2._pushX;
_pushZ = e2._pushZ;
_fuel = e2._fuel;
}
}
public EntityWolf (TypedEntity e)
: base(e)
{
EntityWolf e2 = e as EntityWolf;
if (e2 != null) {
_owner = e2._owner;
_sitting = e2._sitting;
_angry = e2._angry;
}
}
public EntityPigZombie (TypedEntity e)
: base(e)
{
EntityPigZombie e2 = e as EntityPigZombie;
if (e2 != null) {
_anger = e2._anger;
_villager = e2._villager;
_baby = e2._baby;
_breakDoors = e2._breakDoors;
}
}
protected TypedEntity AddChildNode(TypedEntity parent, TypedEntity child, int sortOrder = 0)
{
using (var uow = this.HiveManager.OpenWriter<IContentStore>())
{
parent.RelationProxies.EnlistChild(child, FixedRelationTypes.DefaultRelationType, sortOrder);
uow.Repositories.AddOrUpdate(parent);
uow.Repositories.AddOrUpdate(child);
uow.Complete();
}
return child;
}
/// <summary>
/// Creates a new instance of a nonspecific <see cref="TypedEntity"/> object by NBT node.
/// </summary>
/// <param name="tree">A <see cref="TagNodeCompound"/> representing a single Entity, containing an 'id' field.</param>
/// <returns>A new instance of a <see cref="TypedEntity"/> object, or null if the entity is not typed.</returns>
public static TypedEntity CreateGeneric (TagNodeCompound tree)
{
TagNode type;
if (!tree.TryGetValue("id", out type)) {
return null;
}
TypedEntity te = new TypedEntity(type.ToTagString().Data);
return te.LoadTreeSafe(tree);
}
/// <summary>
/// Gets the URL of the file in the first upload field found on the given TypedEntity
/// </summary>
/// <param name="entity">The entity.</param>
/// <returns></returns>
public string GetMediaUrl(TypedEntity entity)
{
return(_urlHelper.GetMediaUrl(entity));
}
/// <summary>
/// Gets the URL for the given entity.
/// </summary>
/// <param name="entity">The entity.</param>
/// <returns></returns>
public string GetUrl(TypedEntity entity)
{
return(_requestContext.RoutingEngine.GetUrl(entity.Id));
}
public EntityCow(TypedEntity e)
: base(e)
{
}
public MethodEntity Parse(TypedEntity typedEntity, String selector, IEnumerable <XElement> elements)
{
MethodEntity methodEntity = new MethodEntity();
XElement declarationElement = (from el in elements
where el.Name == "div" &&
el.Attribute("class") != null &&
el.Attribute("class").Value == "declaration_indent"
select el).FirstOrDefault();
XElement parameterElement = (from el in elements
where el.Name == "div" &&
el.Attribute("class") != null &&
el.Attribute("class").Value == "param_indent"
select el).FirstOrDefault();
XElement returnValueElement = (from el in elements
where el.Name == "h5" && el.Value.Trim() == "Return Value"
select el).FirstOrDefault();
//XElement discussionElement = (from el in elements
// where el.Name == "h5" && el.Value.Trim() == "Discussion"
// select el).FirstOrDefault();
XElement availabilityElement = (from el in elements
let term = el.Descendants("dt").FirstOrDefault()
let definition = el.Descendants("dd").FirstOrDefault()
where el.Name == "dl" &&
term != null &&
term.Value.Trim() == "Availability"
select definition).FirstOrDefault();
methodEntity.Selector = selector;
methodEntity.Name = GetMethodName(methodEntity);
methodEntity.Signature = declarationElement.TrimAll();
methodEntity.Signature = methodEntity.Signature.TrimEnd(';');
methodEntity.Static = methodEntity.Signature.StartsWith("+");
// Extract abstract
IEnumerable <XElement> abstractElements = elements.SkipWhile(el => el.Name != "p").TakeWhile(el => el.Name == "p");
foreach (XElement element in abstractElements)
{
String line = element.TrimAll();
if (!String.IsNullOrEmpty(line))
{
methodEntity.Summary.Add(line);
}
}
//// Extract discussion
//if (discussionElement != null)
//{
// IEnumerable<XElement> discussionElements = discussionElement.ElementsAfterSelf().TakeWhile(el => el.Name == "p");
// foreach (XElement element in discussionElements)
// {
// String line = element.TrimAll();
// if (!String.IsNullOrEmpty(line))
// {
// methodEntity.Summary.Add(line);
// }
// }
//}
// Extract return type
MethodSignatureEnumerator signatureEnumerator = new MethodSignatureEnumerator(methodEntity.Signature);
if (signatureEnumerator.MoveNext())
{
methodEntity.ReturnType = this.TypeManager.ConvertType(signatureEnumerator.Current.TrimAll(), this.Logger);
}
else
{
methodEntity.ReturnType = "Id";
}
// Extract parameter type and name
MethodParametersEnumerator parameterTypesEnumerator = new MethodParametersEnumerator(methodEntity.Signature, false);
MethodParametersEnumerator parameterNamesEnumerator = new MethodParametersEnumerator(methodEntity.Signature, true);
while (parameterTypesEnumerator.MoveNext() && parameterNamesEnumerator.MoveNext())
{
MethodParameterEntity parameterEntity = new MethodParameterEntity();
bool isOut, isByRef, isBlock;
parameterEntity.Type = this.TypeManager.ConvertType(parameterTypesEnumerator.Current, out isOut, out isByRef, out isBlock, this.Logger);
parameterEntity.IsOut = isOut;
parameterEntity.IsByRef = isByRef;
parameterEntity.IsBlock = isBlock;
parameterEntity.Name = parameterNamesEnumerator.Current.Trim();
methodEntity.Parameters.Add(parameterEntity);
}
if (methodEntity.Parameters.Count > 0 && parameterElement != null)
{
XElement termList = parameterElement.Descendants("dl").FirstOrDefault();
if (termList != null)
{
IEnumerable <XElement> dtList = from el in termList.Elements("dt") select el;
IEnumerable <XElement> ddList = from el in termList.Elements("dd") select el;
if (dtList.Count() == ddList.Count())
{
// Iterate over definitions
for (int i = 0; i < dtList.Count(); i++)
{
String term = dtList.ElementAt(i).TrimAll();
//String summary = ddList.ElementAt(i).TrimAll();
IEnumerable <String> summaries = ddList.ElementAt(i).Elements("p").Select(p => p.Value.TrimAll());
// Find the parameter
MethodParameterEntity parameterEntity = methodEntity.Parameters.Find(p => String.Equals(p.Name, term));
if (parameterEntity != null)
{
//parameterEntity.Summary.Add(summary);
foreach (string sum in summaries)
{
parameterEntity.Summary.Add(sum);
}
}
}
}
}
}
// Fix the name only after looking for the documentation
for (int i = 0; i < methodEntity.Parameters.Count; i++)
{
methodEntity.Parameters[i].Name = this.TypeManager.ConvertName(methodEntity.Parameters[i].Name);
}
// Get the summary for return type
if (!String.Equals(methodEntity.ReturnType, "void", StringComparison.OrdinalIgnoreCase) && returnValueElement != null)
{
IEnumerable <XElement> returnTypeElements = returnValueElement.ElementsAfterSelf().TakeWhile(el => el.Name == "p");
methodEntity.ReturnsDocumentation = String.Empty;
foreach (XElement element in returnTypeElements)
{
String line = element.TrimAll();
if (!String.IsNullOrEmpty(line))
{
methodEntity.ReturnsDocumentation += line;
}
}
}
// Get the availability
if (availabilityElement != null)
{
methodEntity.MinAvailability = CommentHelper.ExtractAvailability(availabilityElement.TrimAll());
}
return(methodEntity);
}
/// <summary>
/// Determines whether the specified entity is content.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="uow"></param>
/// <returns>
/// <c>true</c> if the specified entity is content; otherwise, <c>false</c>.
/// </returns>
public static bool IsContent(this TypedEntity entity, IReadonlyGroupUnit <IContentStore> uow)
{
var ancestorRelations = uow.Repositories.GetAncestorRelations(entity.Id, FixedRelationTypes.DefaultRelationType).ToArray();
return(ancestorRelations.Any(x => x.SourceId.Value == FixedHiveIds.ContentVirtualRoot.Value));
}
/// <summary>
/// Parses the specified property element.
/// </summary>
/// <param name = "propertyElement">The property element.</param>
/// <returns></returns>
public PropertyEntity Parse(TypedEntity typedEntity, XElement propertyElement)
{
XElement nameElement = propertyElement.Element("h3");
String name = nameElement.TrimAll();
this.Logger.WriteLine(" Property '" + name + "'");
// Extract the declaration
XElement signatureElement = (from el in propertyElement.Elements("div")
where (String)el.Attribute("class") == "declaration"
select el).FirstOrDefault();
String signature = signatureElement.TrimAll();
// Extract the abstract
XElement abstractElement = (from el in propertyElement.Elements("p")
where (String)el.Attribute("class") == "abstract"
select el).FirstOrDefault();
List <String> summary = new List <String>();
summary.Add(abstractElement.TrimAll());
//// Extract discussion
//XElement discussionElement = (from el in propertyElement.Elements("div")
// where (String) el.Attribute("class") == "api discussion"
// select el).FirstOrDefault();
//if (discussionElement != null)
//{
// foreach (XElement paragraph in discussionElement.Elements("p"))
// {
// summary.Add(paragraph.TrimAll());
// }
//}
// Get the availability
XElement availabilityElement = (from el in propertyElement.Elements("div")
where (String)el.Attribute("class") == "api availability"
select el).FirstOrDefault();
String minAvailability = null;
if (availabilityElement != null)
{
minAvailability = availabilityElement.Elements("ul").Elements("li").FirstOrDefault().TrimAll();
}
minAvailability = CommentHelper.ExtractAvailability(minAvailability);
// Extract property's attribute
List <String> attributes = new List <String>();
int attributesStart = signature.IndexOf('(');
int attributesEnd = signature.IndexOf(')');
if (attributesStart > 0 && attributesEnd > attributesStart)
{
String attributesAll = signature.Substring(attributesStart + 1, attributesEnd - attributesStart - 1);
attributes.AddRange(attributesAll.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(attr => attr.Trim()));
}
int typeStart = attributesEnd > 0 ? (attributesEnd + 1) : "@property".Length;
int typeEnd = signature.LastIndexOf(name);
string returnType = (typeStart > 0 && typeEnd > typeStart) ? signature.Substring(typeStart, typeEnd - typeStart).Trim() : "MISSING";
// Is the property readonly ?
bool readOnly = attributes.Contains("readonly");
// Is there an explicit getter
String getterSelector = attributes.Find(a => a.Contains("getter"));
if (getterSelector != null)
{
getterSelector = getterSelector.Substring(getterSelector.IndexOf('=') + 1);
}
else
{
getterSelector = name;
}
// Alter the name
name = name.UpperCaseFirstLetter();
// Is there an explicit setter
String setterSelector = attributes.Find(a => a.Contains("setter"));
if (setterSelector != null)
{
setterSelector = setterSelector.Substring(setterSelector.IndexOf('=') + 1);
}
else
{
setterSelector = "set" + name + ":";
}
bool isOut, isByRef, isBlock;
String type = this.TypeManager.ConvertType(returnType, out isOut, out isByRef, out isBlock, this.Logger);
PropertyEntity propertyEntity = new PropertyEntity();
propertyEntity.MinAvailability = minAvailability;
propertyEntity.Name = getterSelector.UpperCaseFirstLetter();
propertyEntity.Static = false;
propertyEntity.Summary = summary;
propertyEntity.Type = type;
propertyEntity.Getter = new MethodEntity();
propertyEntity.Getter.Signature = signature;
propertyEntity.Getter.Selector = getterSelector;
if (readOnly)
{
propertyEntity.Setter = null;
}
else
{
propertyEntity.Setter = new MethodEntity();
propertyEntity.Setter.Signature = signature;
propertyEntity.Setter.Selector = setterSelector;
}
return(propertyEntity);
}
public MethodEntity Parse(TypedEntity typedEntity, XElement methodElement)
{
MethodEntity methodEntity = new MethodEntity();
bool isStatic = (methodElement.Attribute("static").Value == "yes");
String selector = methodElement.Element("name").TrimAll();
String returnType = methodElement.Element("type").TrimAll();
// Elements for brief description
IEnumerable <XElement> abstractElements = methodElement.Element("briefdescription").Elements("para");
// Extract for detailed description
IEnumerable <XElement> detailsElements = (from el in methodElement.Element("detaileddescription").Elements("para")
where !el.Elements("simplesect").Any() &&
el.Elements("parameterlist").Any() &&
el.Elements("xrefsect").Any()
select el);
// Element for parameters
IEnumerable <XElement> parameterElements = methodElement.Elements("param");
// Element for detailed description
XElement detailedDescriptionElement = methodElement.Element("detaileddescription");
// Sets some data
methodEntity.Selector = selector;
methodEntity.Name = GetMethodName(methodEntity);
methodEntity.Static = isStatic;
// Add brief description
foreach (XElement paragraph in abstractElements)
{
methodEntity.Summary.Add(paragraph.TrimAll());
}
foreach (XElement paragraph in detailsElements)
{
methodEntity.Summary.Add(paragraph.TrimAll());
}
// Recreate the signature
StringBuilder signature = new StringBuilder();
signature.Append(isStatic ? "+ " : "- ");
signature.AppendFormat("({0})", returnType);
if (selector.IndexOf(":") != -1)
{
String[] parts = selector.Split(':');
for (int i = 0; i < parameterElements.Count(); i++)
{
XElement parameterElement = parameterElements.ElementAt(i);
String parameterType = parameterElement.Element("type").TrimAll();
String parameterName;
if (parameterType.Equals("..."))
{
parameterName = String.Empty;
}
else
{
parameterName = parameterElement.Element("declname").TrimAll();
if (parameterElement.Element("defname") != null)
{
parameterName = parameterElement.Element("defname").TrimAll();
}
}
signature.Append(parts [i]);
signature.AppendFormat(":({0}){1} ", parameterType, parameterName);
}
}
else
{
signature.Append(selector);
}
methodEntity.Signature = signature.ToString().Trim() + ";";
// Set the return type
methodEntity.ReturnType = this.TypeManager.ConvertType(returnType, this.Logger);
// Extract documentation for return type
if (!String.Equals(returnType, "void", StringComparison.OrdinalIgnoreCase))
{
XElement returnTypeSectionElement = (from el in detailedDescriptionElement.Descendants("simplesect")
where el.Attribute("kind") != null &&
el.Attribute("kind").Value == "return"
select el).FirstOrDefault();
if (returnTypeSectionElement != null)
{
IEnumerable <String> documentations = (from el in returnTypeSectionElement.Elements("para")
select el.TrimAll());
methodEntity.ReturnsDocumentation = String.Join(" ", documentations.ToArray());
}
}
// Create the parameters
for (int i = 0; i < parameterElements.Count(); i++)
{
XElement parameterElement = parameterElements.ElementAt(i);
String parameterType = parameterElement.Element("type").TrimAll();
String parameterName;
if (parameterType.Equals("..."))
{
parameterType = "params Object[]";
parameterName = "values";
}
else
{
parameterName = parameterElement.Element("declname").TrimAll();
if (parameterElement.Element("defname") != null)
{
parameterName = parameterElement.Element("defname").TrimAll();
}
}
MethodParameterEntity parameterEntity = new MethodParameterEntity();
bool isOut, isByRef, isBlock;
parameterEntity.Type = this.TypeManager.ConvertType(parameterType, out isOut, out isByRef, out isBlock, this.Logger);
parameterEntity.IsOut = isOut;
parameterEntity.IsByRef = isByRef;
parameterEntity.IsBlock = isBlock;
parameterEntity.Name = parameterName;
methodEntity.Parameters.Add(parameterEntity);
}
// Extract documentation for parameters
XElement parameterSectionElement = (from el in detailedDescriptionElement.Descendants("parameterlist")
where el.Attribute("kind") != null &&
el.Attribute("kind").Value == "param"
select el).FirstOrDefault();
if (parameterSectionElement != null)
{
IEnumerable <XElement> parameterItemElements = parameterSectionElement.Elements("parameteritem");
for (int i = 0; i < parameterElements.Count(); i++)
{
XElement parameterElement = parameterElements.ElementAt(i);
String parameterType = parameterElement.Element("type").TrimAll();
String parameterName;
if (parameterType.Equals("..."))
{
continue;
}
else
{
parameterName = parameterElement.Element("declname").TrimAll();
if (parameterElement.Element("defname") != null)
{
parameterName = parameterElement.Element("defname").TrimAll();
}
}
MethodParameterEntity parameterEntity = methodEntity.Parameters.Find(p => String.Equals(p.Name, parameterName));
IEnumerable <XElement> documentations = (from el in parameterItemElements
let filter = el.Element("parameternamelist").Value.TrimAll()
where String.Equals(filter, parameterName)
select el);
if (documentations.Count() > 0)
{
XElement documentation = documentations.Elements("parameterdescription").First();
foreach (XElement element in documentation.Elements("para"))
{
parameterEntity.Summary.Add(element.TrimAll());
}
}
}
}
// Fix the name only after looking for the documentation
for (int i = 0; i < methodEntity.Parameters.Count; i++)
{
methodEntity.Parameters [i].Name = this.TypeManager.ConvertName(methodEntity.Parameters [i].Name);
}
/*
*
* // Get the availability
* if (availabilityElement != null)
* {
* methodEntity.MinAvailability = CommentHelper.ExtractAvailability(availabilityElement.TrimAll());
* }
*/
return(methodEntity);
}
/// <summary>
/// Gets the URL of the file in the upload field with the given property alias on the given TypedEntity
/// </summary>
/// <param name="url">The URL.</param>
/// <param name="entity">The entity.</param>
/// <param name="propertyAlias">The property alias.</param>
/// <returns></returns>
public static string GetMediaUrl(this UrlHelper url, TypedEntity entity, string propertyAlias)
{
return(url.GetMediaUrl(entity, propertyAlias, 0));
}
protected TypedEntity AddChildNodeWithId(TypedEntity parent, HiveId childGuid, int sortOrder = 0)
{
var child = HiveModelCreationHelper.MockTypedEntity(childGuid);
return(AddChildNode(parent, child, sortOrder));
}
public EntityEnderEye(TypedEntity e)
: base(e)
{
}
public EntitySilverfish(TypedEntity e)
: base(e)
{
}
public EntityCaveSpider(TypedEntity e)
: base(e)
{
}
/// <summary>
/// Gets the URL of the file in the first upload field found on the given TypedEntity at the specific size
/// </summary>
/// <param name="url">The URL.</param>
/// <param name="entity">The entity.</param>
/// <param name="size">The size (must be a prevalue on the upload property editor).</param>
/// <returns></returns>
public static string GetMediaUrl(this UrlHelper url, TypedEntity entity, int size)
{
return(url.GetMediaUrl(entity, null, size));
}
/// <summary>
/// Gets the URL of the file in the first upload field found on the given TypedEntity at the specific size
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="size">The size (must be a prevalue on the upload property editor).</param>
/// <returns></returns>
public string GetMediaUrl(TypedEntity entity, int size)
{
return(_urlHelper.GetMediaUrl(entity, size));
}
public EntitySkeleton(TypedEntity e)
: base(e)
{
}
public EntityEgg(TypedEntity e)
: base(e)
{
}
public UrlResolutionResult GetUrlForEntity(TypedEntity entity)
{
return(new UrlResolutionResult("/this-is-a-test", UrlResolutionStatus.SuccessWithoutHostname));
}
/// <summary>
/// Creates a new RedirectToUmbracoResult
/// </summary>
/// <param name="pageEntity"></param>
public RedirectToUmbracoPageResult(TypedEntity pageEntity)
: this(pageEntity, DependencyResolver.Current.GetService <IRoutableRequestContext>())
{
}
/// <summary>
/// Redirects to the Rebel page with the given id
/// </summary>
/// <param name="pageEntity"></param>
/// <returns></returns>
protected RedirectToRebelPageResult RedirectToRebelPage(TypedEntity pageEntity)
{
return(new RedirectToRebelPageResult(pageEntity, RoutableRequestContext));
}
/// <summary>
/// Determines whether the specified entity is media.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="uow"></param>
/// <returns>
/// <c>true</c> if the specified entity is media; otherwise, <c>false</c>.
/// </returns>
public static bool IsMedia(this TypedEntity entity, IReadonlyGroupUnit <IContentStore> uow)
{
return(uow.Repositories.GetAncestorRelations(entity.Id, FixedRelationTypes.DefaultRelationType).Any(x => x.SourceId.Value == FixedHiveIds.MediaVirtualRoot.Value));
}
/// <summary>
/// Executes the task.
/// </summary>
protected override void ExecuteTask()
{
String baseFolder = this.CreateBaseDir();
DocSet docSet = this.CreateDocSet();
IEnumerable <Framework> frameworks = this.CreateFrameworks(docSet);
IList <FrameworkEntity> entities = frameworks.SelectMany(f => f.GetEntities()).ToList();
String mixedTypesFile = this.MixedTypesFile.ToString();
Dictionary <String, String> mixedTypesTable = new Dictionary <String, String> ();
this.LoadMixedTypes(mixedTypesFile, mixedTypesTable);
foreach (var e in entities)
{
String sourcePath = e.GetPath(baseFolder, DocumentType.Model);
if (sourcePath == null || !File.Exists(sourcePath))
{
continue;
}
if (sourcePath.IsOlderThan(mixedTypesFile))
{
continue;
}
this.Log(Level.Verbose, String.Format("Scanning '{0}' for mixed types...", e.name));
switch (e.type)
{
case FrameworkEntityType.T:
{
TypedEntity entity = BaseEntity.LoadFrom <TypedEntity> (sourcePath);
if (entity.Generate)
{
foreach (EnumerationEntity enumerationEntity in entity.Enumerations)
{
if (!enumerationEntity.Generate)
{
continue;
}
this.AddMixedType(mixedTypesTable, enumerationEntity);
}
}
}
break;
case FrameworkEntityType.C:
{
ClassEntity entity = BaseEntity.LoadFrom <ClassEntity> (sourcePath);
if (entity.Generate)
{
foreach (EnumerationEntity enumerationEntity in entity.Enumerations)
{
if (!enumerationEntity.Generate)
{
continue;
}
this.AddMixedType(mixedTypesTable, enumerationEntity);
}
}
}
break;
case FrameworkEntityType.P:
{
ProtocolEntity entity = BaseEntity.LoadFrom <ProtocolEntity> (sourcePath);
if (entity.Generate)
{
foreach (EnumerationEntity enumerationEntity in entity.Enumerations)
{
if (!enumerationEntity.Generate)
{
continue;
}
this.AddMixedType(mixedTypesTable, enumerationEntity);
}
}
}
break;
case FrameworkEntityType.S:
{
StructureEntity entity = BaseEntity.LoadFrom <StructureEntity> (sourcePath);
if (entity.Generate)
{
this.AddMixedType(mixedTypesTable, entity);
}
}
break;
case FrameworkEntityType.E:
{
EnumerationEntity entity = BaseEntity.LoadFrom <EnumerationEntity> (sourcePath);
if (entity.Generate)
{
this.AddMixedType(mixedTypesTable, entity);
}
}
break;
default:
throw new NotSupportedException("Entity type not support: " + e.type);
}
}
this.SaveMixedTypes(mixedTypesFile, mixedTypesTable);
}
public EntitySnowman(TypedEntity e)
: base(e)
{
}
public void Initialize()
{
#region Vars
IReadonlyEntityRepositoryGroup <IContentStore> readonlyContentStoreRepository;
IReadonlySchemaRepositoryGroup <IContentStore> readonlyContentStoreSchemaRepository;
IEntityRepositoryGroup <IContentStore> contentStoreRepository;
ISchemaRepositoryGroup <IContentStore> contentStoreSchemaRepository;
IReadonlyEntityRepositoryGroup <IFileStore> readonlyFileStoreRepository;
IReadonlySchemaRepositoryGroup <IFileStore> readonlyFileStoreSchemaRepository;
IEntityRepositoryGroup <IFileStore> fileStoreRepository;
ISchemaRepositoryGroup <IFileStore> fileStoreSchemaRepository;
#endregion
var hive = MockHiveManager.GetManager()
.MockContentStore(out readonlyContentStoreRepository, out readonlyContentStoreSchemaRepository, out contentStoreRepository, out contentStoreSchemaRepository)
.MockFileStore(out readonlyFileStoreRepository, out readonlyFileStoreSchemaRepository, out fileStoreRepository, out fileStoreSchemaRepository);
//Setup file store
var fileId = new HiveId("storage", "file-uploader", new HiveIdValue("test.jpg"));
var file = new File
{
Id = fileId,
Name = "test.jpg",
ContentBytes = Encoding.UTF8.GetBytes("test")
};
readonlyFileStoreRepository
.Get <File>(true, Arg.Any <HiveId[]>())
.Returns(new[] { file });
var thumbnailId = new HiveId("storage", "file-uploader", new HiveIdValue("test_100.jpg"));
var thumbnail = new File
{
Id = thumbnailId,
Name = "test_100.jpg",
ContentBytes = Encoding.UTF8.GetBytes("test_100")
};
var relation = Substitute.For <IReadonlyRelation <IRelatableEntity, IRelatableEntity> >();
relation.MetaData.Returns(new RelationMetaDataCollection(new[] { new RelationMetaDatum("size", "100") }));
relation.Source.Returns(file);
relation.SourceId.Returns(fileId);
relation.Destination.Returns(thumbnail);
relation.DestinationId.Returns(thumbnailId);
readonlyFileStoreRepository.GetLazyChildRelations(fileId, FixedRelationTypes.ThumbnailRelationType)
.Returns(new[] { relation });
//Setup media store
var mediaPickerAttributeDefType = new AttributeType {
RenderTypeProvider = CorePluginConstants.FileUploadPropertyEditorId
};
var mediaPickerAttributeDef = new AttributeDefinition("umbracoFile", "")
{
Id = FixedHiveIds.FileUploadAttributeType, AttributeType = mediaPickerAttributeDefType
};
var mediaPickerProperty = new TypedAttribute(mediaPickerAttributeDef, fileId.ToString());
var mediaId = new HiveId("0A647849-BF5C-413B-9420-7AB4C9521505");
var mediaEntity = new TypedEntity {
Id = mediaId
};
mediaEntity.Attributes.Add(mediaPickerProperty);
//readonlyContentStoreRepository
// .Get<TypedEntity>(true, Arg.Any<HiveId[]>())
// .Returns(new[] { mediaEntity });
//readonlyContentStoreRepository
// .SingleOrDefault<TypedEntity>(Arg.Any<Expression<Func<TypedEntity, bool>>>())
// .Returns(mediaEntity);
var mediaEntityList = new List <TypedEntity> {
mediaEntity
};
readonlyContentStoreRepository
.Provider
.Returns(mediaEntityList.AsQueryable().Provider);
// Setup application
var appContext = Substitute.For <IUmbracoApplicationContext>();
appContext.Hive.Returns(hive);
// Setup back office request
_backOfficeRequestContext = Substitute.For <IBackOfficeRequestContext>();
_backOfficeRequestContext.Application.Returns(appContext);
}
public EntityGhast(TypedEntity e)
: base(e)
{
}
/// <summary>
/// Gets the URL of the file in the upload field with the given property alias on the given TypedEntity
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="propertyAlias">The property alias.</param>
/// <returns></returns>
public string GetMediaUrl(TypedEntity entity, string propertyAlias)
{
return(_urlHelper.GetMediaUrl(entity, propertyAlias));
}
/// <summary>
/// Creates a new RedirectToUmbracoResult
/// </summary>
/// <param name="pageEntity"></param>
/// <param name="routableRequestContext"></param>
public RedirectToUmbracoPageResult(TypedEntity pageEntity, IRoutableRequestContext routableRequestContext)
{
_pageEntity = pageEntity;
_pageId = pageEntity.Id;
_routableRequestContext = routableRequestContext;
}
/// <summary>
/// Gets the URL of the file in the upload field with the given property alias on the given TypedEntity at the specific size
/// </summary>
/// <param name="url">The URL.</param>
/// <param name="entity">The entity.</param>
/// <param name="propertyAlias">The property alias.</param>
/// <param name="size">The size (must be a prevalue on the upload property editor).</param>
/// <returns></returns>
public static string GetMediaUrl(this UrlHelper url, TypedEntity entity, string propertyAlias, int size)
{
//TODO: There is a lot of duplication between this and the MediaProxyController (with slight differences). Need to find a way to reuse code.
var appContext = DependencyResolver.Current.GetService <IUmbracoApplicationContext>();
using (var securityUow = appContext.Hive.OpenReader <ISecurityStore>())
{
// Get anonymous role
var resultIds = entity.Id.AsEnumerableOfOne().ToArray();
using (var contentUow = appContext.Hive.OpenReader <IContentStore>())
resultIds = resultIds.FilterAnonymousWithPermissions(appContext.Security, contentUow, securityUow, new Guid(FixedPermissionIds.View)).ToArray();
// Check to see if anonymous view is allowed
var anonymousViewAllowed = resultIds.Length != 0;
// Get upload property
var prop = propertyAlias.IsNullOrWhiteSpace()
? entity.Attributes.SingleOrDefault(x => x.AttributeDefinition.AttributeType.RenderTypeProvider.InvariantEquals(CorePluginConstants.FileUploadPropertyEditorId))
: entity.Attributes.SingleOrDefault(x => x.AttributeDefinition.Alias == propertyAlias);
if (prop == null || !prop.Values.ContainsKey("MediaId"))
{
return(null); // Couldn't find property so return null
}
var mediaId = prop.Values["MediaId"].ToString();
var fileId = new HiveId(prop.Values["Value"].ToString());
// Get the file
using (var fileUow = appContext.Hive.OpenReader <IFileStore>(fileId.ToUri()))
{
var file = fileUow.Repositories.Get <File>(fileId);
if (file == null)
{
return(null); // Couldn't find file so return null
}
// Fetch the thumbnail
if (size > 0)
{
var relation = fileUow.Repositories.GetLazyChildRelations(fileId, FixedRelationTypes.ThumbnailRelationType)
.SingleOrDefault(x => x.MetaData.Single(y => y.Key == "size").Value == size.ToString());
file = (relation != null && relation.Destination != null)
? (File)relation.Destination
: null;
}
if (file == null)
{
return(null); // Couldn't find file so return null
}
if (anonymousViewAllowed && !file.PublicUrl.StartsWith("~/App_Data/")) // Don't proxy
{
return(url.Content(file.PublicUrl));
}
else // Proxy
{
//NOTE: THIS IS TEMPORARY CODE UNTIL MEMBER PERMISSIONS IS DONE
if (anonymousViewAllowed)
{
// If they are anonymous, but media happens to be in app_data folder proxy
return(url.Action("Proxy", "MediaProxy", new { area = "", propertyAlias = prop.AttributeDefinition.Alias, mediaId, size, fileName = file.Name }));
}
return(null);
// Check permissions
//var authAttr = new UmbracoAuthorizeAttribute {AllowAnonymous = true, Permissions = new [] { FixedPermissionIds.View }};
//var authorized = authAttr.IsAuthorized(url.RequestContext.HttpContext, entity.Id);
//if (!authorized)
// return null; // Not authorized so return null
//return url.Action("Proxy", "MediaProxy", new { area = "", propertyAlias = prop.AttributeDefinition.Alias, mediaId, size, fileName = file.Name });
}
}
}
}
public EntityEnderPearl(TypedEntity e)
: base(e)
{
}
public EntityMonster(TypedEntity e)
: base(e)
{
}
