/// <summary>
/// Creates a new Shift from the given node.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The "shift" node.</param>
internal Shift(NodeValidator validator, Node node)
: base(validator, node)
{
if (!string.IsNullOrEmpty(node.Tag))
{
uuid = new Guid(node.Tag);
}
if (node.Attributes.ContainsKey(NAME_ATTRIBUTE))
{
name = node.Attributes[NAME_ATTRIBUTE];
}
if (node.Attributes.ContainsKey(FALLBACK_ATTRIBUTE))
{
fallback = new Guid(node.Attributes[FALLBACK_ATTRIBUTE]);
}
foreach (var child in node.Children)
{
switch (child.Name.ToUpperInvariant())
{
case SELECTIONSET_CHILD_NODE:
selectionset = child;
break;
case ASSIGNMENTS_CHILD_NODE:
assignments = new AssignmentList(validator, child);
break;
}
}
if (assignments == null)
{
assignments = new AssignmentList();
}
}
public Node CreateNode(Node newNode)
{
NodeValidator nodeValidator = new NodeValidator();
nodeValidator.Validate(newNode);
using (IdeaStorageEntities context = new IdeaStorageEntities())
{
NODE newDbNode = new NODE
{
Created = newNode.Created,
IsDeleted = newNode.IsDeleted,
Modified = newNode.Modified,
OwnerId = newNode.OwnerId,
Text = newNode.Text,
Title = newNode.Title
};
TagManager tagManager = new TagManager();
foreach (Tag tag in newNode.Tags)
{
tag.TagId = tagManager.CreateTag(tag).TagId;
context.TAGSETS.Add(new TAGSET {
NodeId = newDbNode.NodeId, TagId = tag.TagId
});
}
context.NODES.Add(newDbNode);
context.SaveChanges();
return(newDbNode.ToModel());
}
}
/// <summary>
/// Creates a new controller from the given node.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The controller node.</param>
internal Controller(NodeValidator validator, Node node)
: base(validator, node)
{
if (!string.IsNullOrEmpty(node.Tag))
{
uuid = new Guid(node.Tag);
}
if (node.Attributes.ContainsKey(GROUP_ATTRIBUTE))
{
group = DeviceGroupHelper.TryParse(node.Attributes[GROUP_ATTRIBUTE]);
}
foreach (var child in node.Children)
{
switch (child.Name.ToUpperInvariant())
{
case MEMBER_CHILD_NODE:
members.AddLast(new Member(validator, child));
break;
case CONTROLS_CHILD_NODE:
controls = new ControlList(validator, child);
break;
case SHIFTS_CHILD_NODE:
shifts = new ShiftList(validator, child);
break;
}
}
}
/// <summary>
/// Creates a new ControlList from the given node.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The "controls" node.</param>
internal ControlList(NodeValidator validator, Node node)
: base(validator, node)
{
foreach (var child in node.Children)
{
switch (child.Name.ToUpperInvariant())
{
case MOUSE_POINTER_CHILD_NODE:
Add(new MousePointerControl(validator, child));
break;
case MOUSE_AXIS_CHILD_NODE:
Add(new MouseAxisControl(validator, child));
break;
case BUTTON_CHILD_NODE:
Add(new ButtonControl(validator, child));
break;
case SLIDER_CHILD_NODE:
Add(new SliderControl(validator, child));
break;
}
}
}
/// <summary>
/// Creates a new ButtonAssignment.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The "button" node.</param>
internal ButtonAssignment(NodeValidator validator, Node node)
: base(validator, node)
{
if (node.Attributes.ContainsKey(NAME_ATTRIBUTE))
{
name = node.Attributes[NAME_ATTRIBUTE];
}
if (node.Attributes.ContainsKey(ROLE_ATTRIBUTE))
{
role = ButtonAssignmentRoleHelper.TryParse(node.Attributes[ROLE_ATTRIBUTE]);
}
if (role == ButtonAssignmentRole.Unprogrammed)
{
bands = new BandList();
}
else
{
foreach (var child in node.Children)
{
if (child.Name.ToUpperInvariant() == BANDS_CHILD_NODE)
{
bands = new BandList(validator, child);
}
}
}
}
/// <summary>
/// Loads a profile.
/// </summary>
/// <param name="stream">The stream to load from. The stream will get closed after the operation.</param>
/// <param name="report">The report to write infos, warnings and errors to.</param>
/// <returns>The loaded profile.</returns>
public static MadCatzProfile Load(Stream stream, ValidationReport report)
{
Node node = DocumentFactory.Load(stream);
NodeValidator validator = new NodeValidator(report);
return(new MadCatzProfile(validator, node));
}
/// <summary>
/// Creates a new Assignment.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The node to parse from.</param>
internal Assignment(NodeValidator validator, Node node)
: base(validator, node)
{
if (!string.IsNullOrEmpty(node.Tag))
{
identifier = ConversionHelper.ParseHexValue(node.Tag);
}
}
public void TokenTypeValidationAttributeTest()
{
var node = new PrintOperator(Tokenizer.TokenEnum.Unknown, false);
var validator = new NodeValidator();
node.Accept(validator);
Assert.True(validator.ValidationResults.Count > 0);
AppendLine(validator.ValidationResults.First()?.ErrorMessage ?? "");
}
public void ValidateNode_LongTitle_NotValid()
{
NodeValidator validator = new NodeValidator();
const string String256Lenght = @"1_____________________________________________________
___________________________________________________________________________________________________
________________________________________________________________________________________________256";
validator.ShouldHaveValidationErrorFor(node => node.Title, String256Lenght);
}
/// <summary>
/// Creates a new CommandList from the given node.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The "commands" node.</param>
internal CommandList(NodeValidator validator, Node node)
: base(validator, node)
{
foreach (var child in node.Children)
{
if (child.Name.ToUpperInvariant() == ACTION_COMMAND_CHILD_NODE)
{
Add(new ActionCommand(validator, child));
}
}
}
/// <summary>
/// Creates a new BlastList from the given node.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The node.</param>
internal BlastList(NodeValidator validator, Node node)
: base(validator, node)
{
foreach (var child in node.Children)
{
if (child.Name.ToUpperInvariant() == BLAST_CHILD_NODE)
{
Add(new Blast(validator, child));
}
}
}
/// <summary>
/// Creates a new MousePointer from a node.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The "mousepointer" node.</param>
internal MousePointerControl(NodeValidator validator, Node node)
: base(validator, node)
{
foreach (var child in node.Children)
{
if (child.Name == MOUSE_AXIS_CHILD_NODE)
{
axes.AddLast(new MouseAxisControl(validator, child));
}
}
}
/// <summary>
/// Creates a new ControllerList.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The "controllers" node.</param>
internal ControllerList(NodeValidator validator, Node node)
: base(validator, node)
{
foreach (var child in node.Children)
{
if (child.Name == CONTROLLER_CHILD_NODE)
{
Add(new Controller(validator, child));
}
}
}
/// <summary>
/// Creates a new Slider.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The "slider" node.</param>
internal SliderControl(NodeValidator validator, Node node)
: base(validator, node)
{
foreach (var child in node.Children)
{
if (child.Name.ToUpperInvariant() == BUTTON_CHILD_NODE)
{
buttons.AddLast(new ButtonControl(validator, child));
}
}
}
/// <summary>
/// Creates a new ActionCommand.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The "actioncommand" node.</param>
internal ActionCommand(NodeValidator validator, Node node)
: base(validator, node)
{
foreach (var child in node.Children)
{
if (child.Name.ToUpperInvariant() == "ACTIONBLOCK")
{
actionBlocks.AddLast(new ActionBlock(validator, child));
}
}
}
/// <summary>
/// Creates a new MousePointerAssignment.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The "mousepointer" node.</param>
internal MousePointerAssignment(NodeValidator validator, Node node)
: base(validator, node)
{
foreach (var child in node.Children)
{
if (child.Name.ToUpperInvariant() == MOUSE_AXIS_CHILD_NODE)
{
mouseAxes.AddLast(new MouseAxisAssignment(validator, child));
}
}
}
/// <summary>
/// Creates a new ShiftList from the given node.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The "shifts" node.</param>
internal ShiftList(NodeValidator validator, Node node)
: base(validator, node)
{
foreach (var child in node.Children)
{
if (child.Name == SHIFT_CHILD_NODE)
{
Add(new Shift(validator, child));
}
}
}
/// <summary>
/// Creates a new button from a given node.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The "button" node.</param>
internal ButtonControl(NodeValidator validator, Node node)
: base(validator, node)
{
if (node.Attributes.ContainsKey(LATCHABLE_ATTRIBUTE))
{
latchable = bool.Parse(node.Attributes[LATCHABLE_ATTRIBUTE]);
}
if (node.Attributes.ContainsKey(LATCHED_ATTRIBUTE))
{
latched = bool.Parse(node.Attributes[LATCHED_ATTRIBUTE]);
}
}
/// <summary>
/// Creates a new BandList from the given node.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The "bands" node.</param>
internal BandList(NodeValidator validator, Node node)
: base(validator, node)
{
foreach (var child in node.Children)
{
// Ignore the first empty tag, whatever it is for
if (child.Name.ToUpperInvariant() == BAND_CHILD_NODE && !string.IsNullOrEmpty(child.Tag))
{
Add(new Band(validator, child));
}
}
}
/// <summary>
/// Creates a new Band.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The "band" node.</param>
internal Band(NodeValidator validator, Node node)
: base(validator, node)
{
if (!string.IsNullOrEmpty(node.Tag))
{
identifier = uint.Parse(node.Tag, CultureInfo.InvariantCulture);
}
if (node.Attributes.ContainsKey(COMMAND_UUID_ATTRIBUTE))
{
commandUuid = new Guid(node.Attributes[COMMAND_UUID_ATTRIBUTE]);
}
}
/// <summary>
/// Creates a new Control.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The control node.</param>
internal Control(NodeValidator validator, Node node)
: base(validator, node)
{
if (!string.IsNullOrEmpty(node.Tag))
{
identifier = ConversionHelper.ParseHexValue(node.Tag);
}
if (node.Attributes.ContainsKey(NameAttribute))
{
name = node.Attributes[NameAttribute];
}
}
/// <summary>
/// Creates a new Blast from the given node.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The "blast" node.</param>
internal Blast(NodeValidator validator, Node node)
: base(validator, node)
{
if (!string.IsNullOrEmpty(node.Tag))
{
uuid = new Guid(node.Tag);
}
if (node.Attributes.ContainsKey(DATA_ATTRIBUTE))
{
data = Convert.FromBase64String(node.Attributes[DATA_ATTRIBUTE]);
}
}
/// <summary>
/// Creates a new Member from the given node.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The node to parse from.</param>
internal Member(NodeValidator validator, Node node)
: base(validator, node)
{
if (node.Tag != null)
{
uuid = new Guid(node.Tag);
}
if (node.Attributes.ContainsKey(NAME_ATTRIBUTE))
{
name = node.Attributes[NAME_ATTRIBUTE];
}
if (node.Attributes.ContainsKey(SHORT_NAME_ATTRIBUTE))
{
shortName = node.Attributes[SHORT_NAME_ATTRIBUTE];
}
}
/// <summary>
/// Creates a new Command from the given node.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The "controller" node.</param>
internal Command(NodeValidator validator, Node node)
: base(validator, node)
{
if (!string.IsNullOrEmpty(node.Tag))
{
uuid = new Guid(node.Tag);
}
if (node.Attributes.ContainsKey(NameAttribute))
{
name = node.Attributes[NameAttribute];
}
if (node.Attributes.ContainsKey(IconAttribute))
{
iconUuid = new Guid(node.Attributes[IconAttribute]);
}
}
public override SiteMapNode GetParentNode(SiteMapNode node)
{
var crmNode = node as CrmSiteMapNode;
if (crmNode == null)
{
return(null);
}
var portal = PortalContext;
var context = portal.ServiceContext;
var website = portal.Website;
var entity = context.MergeClone(crmNode.Entity);
if (crmNode.HasCrmEntityName("adx_communityforum"))
{
var parentPage = entity.GetRelatedEntity(context, "adx_webpage_communityforum");
// If this association doesn't exist, this is an old schema, return the "Forums" page as the parent.
if (parentPage == null)
{
var forumsRootPage = OrganizationServiceContextExtensions.GetPageBySiteMarkerName(context, website, "Forums");
return(SiteMap.Provider.FindSiteMapNode(context.GetUrl(forumsRootPage)));
}
return(SiteMap.Provider.FindSiteMapNode(context.GetUrl(parentPage)));
}
if (crmNode.HasCrmEntityName("adx_communityforumthread"))
{
var parentForum = entity.GetRelatedEntity(context, "adx_communityforum_communityforumthread");
if (parentForum == null)
{
return(null);
}
var parentForumNode = GetForumNode(context, parentForum);
return(NodeValidator.Validate(context, parentForumNode) ? parentForumNode : null);
}
return(null);
}
/// <summary>
/// Creates a new profile from a node.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The node.</param>
internal MadCatzProfile(NodeValidator validator, Node node)
: base(validator, node)
{
name = node.Tag;
if (node.Attributes.ContainsKey(VERSION_ATTRIBUTE))
{
version = ConversionHelper.ParseHexValue(node.Attributes[VERSION_ATTRIBUTE]);
if (!SUPPORTED_VERSIONS.Contains(version))
{
validator.Report.AddError("Unsupported version: " + version);
}
}
foreach (var child in node.Children)
{
switch (child.Name.ToUpperInvariant())
{
case CONTROLLERS_CHILD_NODE:
controllers = new ControllerList(validator, child);
break;
case COMMANDS_CHILD_NODE:
commands = new CommandList(validator, child);
break;
case BLASTS_CHILD_NODE:
blasts = new BlastList(validator, child);
break;
}
}
if (controllers == null)
{
controllers = new ControllerList();
}
if (commands == null)
{
commands = new CommandList();
}
if (blasts == null)
{
blasts = new BlastList();
}
}
/// <summary>
/// Creates a new ActionBlock.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The "actionblock" node.</param>
internal ActionBlock(NodeValidator validator, Node node)
: base(validator, node)
{
if (!string.IsNullOrEmpty(node.Tag))
{
blockType = ActionBlockTypeHelper.TryParse(node.Tag);
}
if (node.Attributes.ContainsKey(TYPE_ATTRIBUTE))
{
type = ActionBlockUsageTypeHelper.TryParse(node.Attributes[TYPE_ATTRIBUTE]);
}
foreach (var child in node.Children)
{
if (child.Name.ToUpperInvariant() == ACTION_CHILD_NODE)
{
Add(new Action(validator, child));
}
}
}
/// <summary>
/// Creates a new AssignmentList from the given node.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The "assignments" node.</param>
internal AssignmentList(NodeValidator validator, Node node)
: base(validator, node)
{
foreach (var child in node.Children)
{
switch (child.Name.ToUpperInvariant())
{
case MOUSE_POINTER_CHILD_NODE:
Add(new MousePointerAssignment(validator, child));
break;
case BUTTON_CHILD_NODE:
var assignment = new ButtonAssignment(validator, child);
if (assignment.Role == ButtonAssignmentRole.Bands)
{
Add(assignment);
}
break;
}
}
}
/// <summary>
/// Creates a new MouseAxisAssignment.
/// </summary>
/// <param name="validator">The validator to use for validation.</param>
/// <param name="node">The "mouseaxis" node.</param>
internal MouseAxisAssignment(NodeValidator validator, Node node)
: base(validator, node)
{
string envelopeName = null;
if (node.Attributes.ContainsKey(ENVELOPE_ATTRIBUTE))
{
envelopeName = node.Attributes[ENVELOPE_ATTRIBUTE].ToUpperInvariant();
envelope = MouseAxisEnvelopeHelper.TryParse(envelopeName);
}
if (!string.IsNullOrEmpty(envelopeName))
{
foreach (var child in node.Children)
{
if (child.Name.ToUpperInvariant() == envelopeName)
{
value = int.Parse(child.Tag, CultureInfo.InvariantCulture);
}
}
}
}
public void UpdateNode(Node node)
{
NodeValidator nodeValidator = new NodeValidator();
nodeValidator.Validate(node);
using (IdeaStorageEntities context = new IdeaStorageEntities())
{
NODE dbNode = context.NODES.FirstOrDefault(n => n.NodeId == node.NodeId);
if (dbNode == null)
{
string message = string.Format("Node with ID:'{0}' doesn't exist in data base.", node.NodeId);
Log.Debug(message);
throw new EntityDoesNotExistException(message);
}
dbNode.Modified = node.Modified;
dbNode.Text = node.Text;
dbNode.Title = node.Title;
List <TAGSET> dbDeleteTagsets = context.TAGSETS.Where(ts => ts.NodeId == node.NodeId).ToList();
context.TAGSETS.RemoveRange(dbDeleteTagsets);
TagManager tagManager = new TagManager();
foreach (Tag tag in node.Tags)
{
tag.TagId = tagManager.CreateTag(tag).TagId;
context.TAGSETS.Add(new TAGSET {
NodeId = dbNode.NodeId, TagId = tag.TagId
});
}
context.NODES.AddOrUpdate(dbNode);
context.SaveChanges();
}
}
