/// <summary> /// Constructs an section. /// </summary> /// <param name="context">The <see cref="IMansionContext"/>.</param> /// <param name="properties">The descriptor of this section.</param> /// <param name="expression">The expressio of this section.</param> public Section(IMansionContext context, IPropertyBag properties, IExpressionScript expression) { // validate arguments if (context == null) throw new ArgumentNullException("context"); if (properties == null) throw new ArgumentNullException("properties"); if (expression == null) throw new ArgumentNullException("expression"); // set values Properties = properties; Expression = expression; Id = Guid.NewGuid().ToString(); Name = Properties.Get<string>(context, "name"); ShouldBeRenderedOnce = !Properties.Get(context, "repeatable", true); TargetField = Properties.Get(context, "field", Name); // check if there is a requires property string requiresExpressionString; if (Properties.TryGet(context, "requires", out requiresExpressionString)) { // assemble the expression var expressionService = context.Nucleus.ResolveSingle<IExpressionScriptService>(); var requiresExpression = expressionService.Parse(context, new LiteralResource(requiresExpressionString)); // execute the expression areRequirementsSatisfied = requiresExpression.Execute<bool>; } else areRequirementsSatisfied = mansionContext => true; }
public void Get_Value_Type() { for (int i = 0; i < 30; i++) { subject.Get <int>(); } }
/// <summary> /// This method is called just after a node is updated by the repository. /// </summary> /// <param name="context">The <see cref="IMansionContext"/>.</param> /// <param name="record"> </param> /// <param name="properties">The properties which were set to the updated <paramref name="record"/>.</param> protected override void DoAfterUpdate(IMansionContext context, Record record, IPropertyBag properties) { // get the propagate property names var propagatePropertyNames = properties.Names.Where(x => x.StartsWith(PropagatePrefix, StringComparison.OrdinalIgnoreCase)); // get the property names who's value is true var propagatedNowProperties = propagatePropertyNames.Where(x => properties.Get(context, x, false)); // loop over all the updated properties and propagated properties foreach (var propagatePropertyName in propagatedNowProperties) { // get the name of the property being propagated var propagatedPropertyName = propagatePropertyName.Substring(PropagatePrefix.Length); // get the propagated property value var propagatedPropertyValue = properties.Get<object>(context, propagatedPropertyName); // retrieve all the children nodes and update them all foreach (var childNode in context.Repository.RetrieveNodeset(context, new PropertyBag { {"parentSource", record}, {"depth", "any"} }).Nodes) { context.Repository.UpdateNode(context, childNode, new PropertyBag { {propagatedPropertyName, propagatedPropertyValue} }); } } }
/// <summary> /// Creates a filled nodeset. /// </summary> /// <param name="context">The <see cref="IMansionContext"/>.</param> /// <param name="properties"></param> /// <param name="records"></param> public RecordSet(IMansionContext context, IPropertyBag properties, IEnumerable<Record> records) : base(properties) { // validate arguments if (records == null) throw new ArgumentNullException("records"); if (properties == null) throw new ArgumentNullException("properties"); // set values foreach (var node in records) RowCollection.Add(node); Set("count", RowCollection.Count); // check for paging var totalRowCount = properties.Get(context, "totalCount", -1); var pageNumber = properties.Get(context, "pageNumber", -1); var rowsPerPage = properties.Get(context, "pageSize", -1); if (totalRowCount != -1 && pageNumber != -1 && rowsPerPage != -1) SetPaging(totalRowCount, pageNumber, rowsPerPage); // check for sort string sortString; if (properties.TryGet(context, "sort", out sortString)) { foreach (var sort in Collections.Sort.Parse(sortString)) AddSort(sort); } }
/// <summary> /// Authenticates the user. /// </summary> /// <param name="context">The security context.</param> /// <param name="parameters">The parameters used for authentication.</param> /// <returns>Returns the <see cref="AuthenticationResult"/>.</returns> protected override AuthenticationResult DoAuthenticate(IMansionContext context, IPropertyBag parameters) { // get the credentials var username = parameters.Get<string>(context, "username"); if (string.IsNullOrEmpty(username)) { return AuthenticationResult.Failed(new PropertyBag { {AuthenticationResult.ReasonPropertyName, AuthenticationResult.NoUsernameSpecifiedReason} }); } var password = parameters.Get<string>(context, "password"); if (string.IsNullOrEmpty(password)) { return AuthenticationResult.Failed(new PropertyBag { {AuthenticationResult.ReasonPropertyName, AuthenticationResult.NoPasswordSpecifiedReason} }); } // check for incorrect credentials if (!username.Equals("System") || !password.Equals("Premotion")) { return AuthenticationResult.Failed(new PropertyBag { {AuthenticationResult.ReasonPropertyName, AuthenticationResult.InvalidCredentialsReason} }); } // return the user return AuthenticationResult.Success(new UserState(Guid.NewGuid(), this), new PropertyBag()); }
/// <summary> /// Maps the properties of the row. /// </summary> /// <param name="context">The <see cref="IMansionWebContext"/>.</param> /// <param name="row">The row which to map.</param> /// <returns>Returns the mapped result.</returns> protected override IPropertyBag DoMapRowProperties(IMansionWebContext context, IPropertyBag row) { return new PropertyBag { {"value", row.Get(context, valueProperty, string.Empty)}, {"label", row.Get(context, labelProperty, string.Empty)} }; }
public void Should_Set_ReferenceType_Property() { var item = new Tuple <string, int>("test", 3); subject.Set <Tuple <string, int> >(item); var actual = subject.Get <Tuple <string, int> >(); Assert.Same(item, actual); }
/// <summary> /// Interprets the input.. /// </summary> /// <param name="context">The <see cref="IMansionContext"/>.</param> /// <param name="input">The input which to interpret.</param> /// <returns>Returns the interpreted result.</returns> protected override IResourcePath DoInterpret(IMansionContext context, IPropertyBag input) { // get the path var path = input.Get<string>(context, "path"); if (string.IsNullOrEmpty(path)) throw new InvalidOperationException("The path should not be empty"); var overridable = input.Get(context, "overridable", true); // return the resource path return new RelativeResourcePath(path, overridable); }
/// <summary> /// This method is called just before a node is created by the repository. /// </summary> /// <param name="context">The <see cref="IMansionContext"/>.</param> /// <param name="properties">The new properties of the node.</param> protected override void DoBeforeCreate(IMansionContext context, IPropertyBag properties) { base.DoBeforeCreate(context, properties); // make sure the idenitifier is lowwercase var identifier = properties.Get<string>(context, "identifier").Trim().ToLower(); properties.Set("identifier", identifier); // make sure there is a name var name = properties.Get(context, "name", identifier).Trim().ToLower(); properties.Set("name", name); }
/// <summary> /// Prepares an insert query. /// </summary> /// <param name="context"></param> /// <param name="connection">The connection.</param> /// <param name="transaction">The transaction.</param> /// <param name="parent"></param> /// <param name="properties"></param> /// <returns></returns> public void Prepare(IMansionContext context, SqlConnection connection, SqlTransaction transaction, NodePointer parent, IPropertyBag properties) { // validate arguments if (connection == null) throw new ArgumentNullException("connection"); if (transaction == null) throw new ArgumentNullException("transaction"); if (parent == null) throw new ArgumentNullException("parent"); if (properties == null) throw new ArgumentNullException("properties"); // get the values var name = properties.Get<string>(context, "name", null); if (string.IsNullOrWhiteSpace(name)) throw new InvalidOperationException("The node must have a name"); var typeName = properties.Get<string>(context, "type", null); if (string.IsNullOrWhiteSpace(typeName)) throw new InvalidOperationException("The node must have a type"); // retrieve the type var type = typeService.Load(context, typeName); // get the schema of the root type var schema = Resolver.Resolve(context, type); // set the full text property SqlServerUtilities.PopulateFullTextColumn(context, type, properties, properties); // create the new pointer name = NodePointer.MakeSafeName(name); var newPointer = NodePointer.Parse(string.Join(NodePointer.PointerSeparator, new[] {parent.PointerString, 0.ToString(CultureInfo.InvariantCulture)}), string.Join(NodePointer.StructureSeparator, new[] {parent.StructureString, type.Name}), string.Join(NodePointer.PathSeparator, new[] {parent.PathString, name})); properties.Set("_newPointer", newPointer); // create the commands command = connection.CreateCommand(); command.CommandType = CommandType.Text; command.Transaction = transaction; // prepare the query var queryBuilder = new ModificationQueryBuilder(command); // loop through all the tables in the schema and let them prepare for insert foreach (var table in schema.Tables) table.ToInsertStatement(context, queryBuilder, properties); // finish the complete insert statement queryBuilder.AppendQuery("SELECT @ScopeIdentity"); // set the command text command.CommandText = queryBuilder.ToStatement(); }
/// <summary> /// Initializes the given <paramref name="column"/>. /// </summary> /// <param name="context">The <see cref="IMansionContext"/>.</param> /// <param name="column">The <see cref="PropertyColumn"/> which to initialze.</param> /// <param name="properties">The properties.</param> /// <exception cref="ArgumentNullException">Thrown if one of the parameters is null.</exception> protected static void Initialize(IMansionContext context, PropertyColumn column, IPropertyBag properties) { // validate arguments if (context == null) throw new ArgumentNullException("context"); if (column == null) throw new ArgumentNullException("column"); if (properties == null) throw new ArgumentNullException("properties"); // get the allow null flag column.AllowNullValue = properties.Get(context, "allowNullValue", false); // check if there is an expression string expressionString; if (properties.TryGet(context, "expression", out expressionString)) { var expressionService = context.Nucleus.ResolveSingle<IExpressionScriptService>(); column.HasExpression = true; column.Expression = expressionService.Parse(context, new LiteralResource(expressionString)); } // get the default value string defaultValue; if (properties.TryGet(context, "defaultValue", out defaultValue)) { var expressionService = context.Nucleus.ResolveSingle<IExpressionScriptService>(); var defaultValueExpression = expressionService.Parse(context, new LiteralResource(defaultValue)); column.DefaultValue = defaultValueExpression.Execute<object>(context); column.HasDefaultValue = true; } }
/// <summary> /// /// </summary> /// <param name="context"></param> /// <param name="queryBuilder"></param> /// <param name="properties"></param> protected override void DoToInsertStatement(IMansionContext context, ModificationQueryBuilder queryBuilder, IPropertyBag properties) { // allow identity insert on special cases, most likely used when fixing the repository integrity if (!properties.Get(context, "_allowIdenityInsert", false)) return; queryBuilder.PrependQuery("SET IDENTITY_INSERT [dbo].[Nodes] ON;"); // get the value of the column var value = properties.Get<object>(context, PropertyName); // add the parameter var parameterName = queryBuilder.AddParameter(ColumnName, value); // set the column value queryBuilder.AddColumnValue(ColumnName, parameterName); queryBuilder.AppendQuery("SET IDENTITY_INSERT [dbo].[Nodes] OFF;"); }
public virtual void DefineOwnProperty(Descriptor currentDescriptor) { string key = currentDescriptor.Name; Descriptor desc; if (properties.TryGet(key, out desc) && desc.Owner == this) { // updating an existing property switch (desc.DescriptorType) { case DescriptorType.Value: switch (currentDescriptor.DescriptorType) { case DescriptorType.Value: properties.Get(key).Set(this, currentDescriptor.Get(this)); break; case DescriptorType.Accessor: properties.Delete(key); properties.Put(key, currentDescriptor); break; case DescriptorType.Clr: throw new NotSupportedException(); default: break; } break; case DescriptorType.Accessor: PropertyDescriptor propDesc = (PropertyDescriptor)desc; if (currentDescriptor.DescriptorType == DescriptorType.Accessor) { propDesc.GetFunction = ((PropertyDescriptor)currentDescriptor).GetFunction ?? propDesc.GetFunction; propDesc.SetFunction = ((PropertyDescriptor)currentDescriptor).SetFunction ?? propDesc.SetFunction; } else { propDesc.Set(this, currentDescriptor.Get(this)); } break; default: break; } } else { // add a new property if (desc != null) { desc.Owner.RedefineProperty(desc.Name); // if we have a cached property } properties.Put(key, currentDescriptor); m_length++; } }
/// <summary> /// Gets an <see cref="IScenario"/> from a given NUnit property bad. /// </summary> /// <returns>The scenario.</returns> /// <param name="properties">Properties.</param> public static IScenario GetScenario(IPropertyBag properties) { if (properties.ContainsKey(ScreenplayScenarioKey)) { return((IScenario)properties.Get(ScreenplayScenarioKey)); } return(null); }
public T Get <T>(string name) { object result; if (_properties.TryGetValue(GetKey <T>(name), out result)) { return((T)result); } return(_parent == null ? default(T) : _parent.Get <T>(name)); }
/// <summary> /// Transforms the given <paramref name="source"/> into an ElasticSearch document. /// </summary> /// <param name="context">the <see cref="IMansionContext"/>.</param> /// <param name="source">The <see cref="IPropertyBag"/> which to transform.</param> /// <param name="document">The document to which to write the mapped value.</param> /// <returns>Returns the resulting document.</returns> /// <exception cref="ArgumentNullException">Thrown if one of the parameters is null.</exception> protected override void DoTransform(IMansionContext context, IPropertyBag source, Dictionary<string, object> document) { // get the property value var raw = source.Get(context, Field, string.Empty) ?? string.Empty; // split on comma, trim all values, remove empty entries var values = raw.Split(new[] {','}).Select(x => Normalize(context, x.Trim()).ToString()).Where(x => !string.IsNullOrEmpty(x)).ToArray(); // write the values to the document document.Add(Field, values); }
/// <summary> /// /// </summary> /// <param name="context"></param> /// <param name="queryBuilder"></param> /// <param name="properties"></param> protected override void DoToInsertStatement(IMansionContext context, ModificationQueryBuilder queryBuilder, IPropertyBag properties) { // build the select max order + 1 query only for none root nodes var newPointer = properties.Get<NodePointer>(context, "_newPointer"); queryBuilder.PrependQuery("DECLARE @order int = 1"); if (newPointer.Depth > 1) queryBuilder.PrependQuery(string.Format("SET @order = (SELECT ISNULL(MAX([order]) + 1, 1) FROM [Nodes] WHERE [parentId] = {0})", queryBuilder.AddParameter("parentId", newPointer.Parent.Id, DbType.Int32))); // add the column queryBuilder.AddColumnValue(PropertyName, "@order"); }
/// <summary> /// /// </summary> /// <param name="context"></param> /// <param name="queryBuilder"></param> /// <param name="properties"></param> protected override void DoToInsertStatement(IMansionContext context, ModificationQueryBuilder queryBuilder, IPropertyBag properties) { var newPointer = properties.Get<NodePointer>(context, "_newPointer"); queryBuilder.AddColumnValue("name", newPointer.Name.Trim(), DbType.String); queryBuilder.AddColumnValue("type", newPointer.Type.Trim(), DbType.String); queryBuilder.AddColumnValue("depth", newPointer.Depth, DbType.Int32); queryBuilder.AddColumnValue("parentId", newPointer.HasParent ? (object) newPointer.Parent.Id : null, DbType.Int32); queryBuilder.AddColumnValue("parentPointer", newPointer.HasParent ? newPointer.Parent.PointerString + NodePointer.PointerSeparator : null, DbType.String); queryBuilder.AddColumnValue("parentPath", newPointer.HasParent ? newPointer.Parent.PathString + NodePointer.PathSeparator : null, DbType.String); queryBuilder.AddColumnValue("parentStructure", newPointer.HasParent ? newPointer.Parent.StructureString + NodePointer.StructureSeparator : null, DbType.String); }
/// <summary> /// Renders a cell of this column. /// </summary> /// <param name="context">The <see cref="IMansionWebContext"/>.</param> /// <param name="templateService">The <see cref="ITemplateService"/>.</param> /// <param name="dataset">The <see cref="Dataset"/> rendered in this column.</param> /// <param name="row">The being rendered.</param> protected override void DoRenderCell(IMansionWebContext context, ITemplateService templateService, Dataset dataset, IPropertyBag row) { // create the cell properties var cellProperties = new PropertyBag { {"value", row.Get<object>(context, propertyName, null)} }; // render the cell using (context.Stack.Push("CellProperties", cellProperties)) templateService.Render(context, "GridControlPropertyColumnContent").Dispose(); }
public Jint.Native.Descriptor Get(string name) { if (lastAccessed != null && lastAccessed.Name == name) { return(lastAccessed); } Descriptor descriptor = bag.Get(name); if (descriptor != null) { lastAccessed = descriptor; } return(descriptor); }
public void DefineOwnProperty(string key, Descriptor currentDescriptor) { Descriptor desc; if (properties.TryGet(key, out desc)) { switch (desc.DescriptorType) { case DescriptorType.Value: switch (currentDescriptor.DescriptorType) { case DescriptorType.Value: properties.Get(key).Set(this, currentDescriptor.Get(this)); break; case DescriptorType.Accessor: properties.Delete(key); properties.Put(key, currentDescriptor); break; case DescriptorType.Clr: throw new NotSupportedException(); default: break; } break; case DescriptorType.Accessor: PropertyDescriptor propDesc = (PropertyDescriptor)desc; if (currentDescriptor.DescriptorType == DescriptorType.Accessor) { propDesc.GetFunction = ((PropertyDescriptor)currentDescriptor).GetFunction ?? propDesc.GetFunction; propDesc.SetFunction = ((PropertyDescriptor)currentDescriptor).SetFunction ?? propDesc.SetFunction; } else { propDesc.Set(this, currentDescriptor.Get(this)); } break; default: break; } } else { properties.Put(key, currentDescriptor); } }
public static T GetValue <T>(this IPropertyBag properties, string key) where T : class { _dict.Clear(); foreach (var propeprtyBagKey in properties.Keys) { _dict[propeprtyBagKey] = properties.Get(propeprtyBagKey); } object obj; if (_dict != null && _dict.TryGetValue(key, out obj) && _dict.Count > 0) { return(_dict[key] as T); } return(null); }
/// <summary> /// This method is called just before a node is updated by the repository. /// </summary> /// <param name="context">The <see cref="IMansionContext"/>.</param> /// <param name="record"> </param> /// <param name="properties">The updated properties of the node.</param> protected override void DoBeforeUpdate(IMansionContext context, Record record, IPropertyBag properties) { base.DoBeforeUpdate(context, record, properties); // check if the identifier was updated string identifier; if (!properties.TryGet(context, "identifier", out identifier)) return; identifier = identifier.Trim().ToLower(); properties.Set("identifier", identifier); // only update the name with the identifier if the previous name was also derived from the identifier if (record.Get(context, "name", string.Empty).Equals(record.Get(context, "identifier", string.Empty))) { var name = properties.Get(context, "name", identifier).Trim().ToLower(); properties.Set("name", name); } }
/// <summary> /// Prepares an insert query. /// </summary> /// <param name="context"></param> /// <param name="connection">The connection.</param> /// <param name="transaction">The transaction.</param> /// <param name="properties"></param> /// <returns></returns> public void Prepare(IMansionContext context, SqlConnection connection, SqlTransaction transaction, IPropertyBag properties) { // validate arguments if (connection == null) throw new ArgumentNullException("connection"); if (transaction == null) throw new ArgumentNullException("transaction"); if (properties == null) throw new ArgumentNullException("properties"); // get the values var typeName = properties.Get<string>(context, "type", null); if (string.IsNullOrWhiteSpace(typeName)) throw new InvalidOperationException("A record must have a type"); // retrieve the type var type = typeService.Load(context, typeName); // get the schema of the root type var schema = Resolver.Resolve(context, type); // set the full text property SqlServerUtilities.PopulateFullTextColumn(context, type, properties, properties); // create the commands command = connection.CreateCommand(); command.CommandType = CommandType.Text; command.Transaction = transaction; // prepare the query var queryBuilder = new ModificationQueryBuilder(command); // loop through all the tables in the schema and let them prepare for insert foreach (var table in schema.Tables) table.ToInsertStatement(context, queryBuilder, properties); // finish the complete insert statement queryBuilder.AppendQuery("SELECT @ScopeIdentity"); // set the command text command.CommandText = queryBuilder.ToStatement(); }
/// <summary> /// Removes a tag name from the <paramref name="properties"/>. /// </summary> /// <param name="context">The <see cref="IMansionContext"/>.</param> /// <param name="properties">The properties containing the current tag names.</param> /// <param name="tagName">The name of the tag which to remove.</param> public static void RemoveTagName(IMansionContext context, IPropertyBag properties, string tagName) { // validate arguments if (context == null) throw new ArgumentNullException("context"); if (properties == null) throw new ArgumentNullException("properties"); tagName = Normalize(tagName); if (string.IsNullOrEmpty(tagName)) throw new ArgumentNullException("tagName"); // get the current tag names var tagNames = properties.Get(context, "tags", string.Empty).Split(new[] {','}).Select(Normalize).Distinct().ToList(); // remove the tag tagNames.Remove(tagName); // set the new tag names properties.Set("tags", string.Join(", ", tagNames)); }
/// <summary> /// Renders the specified <paramref name="blockProperties"/> to the output pipe. /// </summary> /// <param name="context">The <see cref="IMansionContext"/>.</param> /// <param name="blockProperties">The <see cref="IPropertyBag"/> of the block which to render.</param> /// <param name="targetField">The name of the field to which to render.</param> protected override void DoRender(IMansionContext context, IPropertyBag blockProperties, string targetField) { // first retrieve the block node to display Guid displayedBlockGuid; if (!blockProperties.TryGet(context, "blockGuid", out displayedBlockGuid)) throw new InvalidOperationException("Block guid not found for shared block display"); var displayedBlockNode = context.Repository.RetrieveSingleNode(context, new PropertyBag { {"guid", displayedBlockGuid} }); if (displayedBlockNode == null) throw new InvalidOperationException(string.Format("Could not find block with guid '{0}'", displayedBlockGuid)); // second, merge the two block properties together var mergedBlockProperties = new PropertyBag(); mergedBlockProperties.Merge(blockProperties); mergedBlockProperties.Merge(displayedBlockNode); mergedBlockProperties.Set("id", blockProperties.Get<int>(context, "id")); // finally re-render the combined block using the portal service PortalService.RenderBlock(context, mergedBlockProperties, targetField); }
/// <summary> /// </summary> /// <param name="context"></param> /// <param name="dataspace"></param> /// <returns></returns> public string Evaluate(IMansionContext context, IPropertyBag dataspace) { // validate arguments if (context == null) throw new ArgumentNullException("context"); if (dataspace == null) throw new ArgumentNullException("dataspace"); // write the dataspace out to JSon array var buffer = new StringBuilder(); using (var textWriter = new StringWriter(buffer)) using (var jsonWriter = new JsonTextWriter(textWriter)) { jsonWriter.WriteStartArray(); // loop over the values in the dataspace foreach (var property in dataspace.Where(x => x.Value != null)) { // get the type var propertyType = property.Value.GetType(); // if this type has no serializer, convert it to string first var value = property.Value; if (!Serializer.Converters.Any(candidate => candidate.CanConvert(propertyType))) value = dataspace.Get<string>(context, property.Key); // write the value jsonWriter.WriteValue(value); } jsonWriter.WriteEndArray(); } // return the content of the buffer. return buffer.ToString(); }
/// <summary> /// This method is called just after a node is updated by the repository. /// </summary> /// <param name="context">The <see cref="IMansionContext"/>.</param> /// <param name="node">The modified node.</param> /// <param name="modifiedProperties">The properties which were set to the updated <paramref name="node"/>.</param> protected override void DoAfterUpdate(IMansionContext context, Node node, IPropertyBag modifiedProperties) { // loop over all the updated properties to find those who start with _propagate foreach (var propagatePropertyName in modifiedProperties.Names.Where(x => x.StartsWith(PropagatePrefix, StringComparison.OrdinalIgnoreCase))) { // get the name of the property being propagated var propagatedPropertyName = propagatePropertyName.Substring(PropagatePrefix.Length); // get the propagated property value var propagatedPropertyValue = modifiedProperties.Get<object>(context, propagatedPropertyName); // retrieve all the children nodes and update them all foreach (var childNode in context.Repository.Retrieve(context, new PropertyBag { {"parentSource", node}, {"depth", "any"} }).Nodes) { context.Repository.Update(context, childNode, new PropertyBag { {propagatedPropertyName, propagatedPropertyValue} }); } } }
/// <summary> /// /// </summary> /// <param name="context"></param> /// <param name="queryBuilder"></param> /// <param name="properties"></param> protected override void DoToInsertStatement(IMansionContext context, ModificationQueryBuilder queryBuilder, IPropertyBag properties) { // get the value of the column var value = GetValue(context, properties.Get<object>(context, PropertyName)); // add the parameter var parameterName = queryBuilder.AddParameter(ColumnName, value); // set the column value queryBuilder.AddColumnValue(ColumnName, parameterName); }
/// <summary> /// Authenticates using ID. /// </summary> /// <param name="context"></param> /// <param name="parameters"></param> /// <returns></returns> private AuthenticationResult AuthenticateWithId(IMansionContext context, IPropertyBag parameters) { // get the credentials var userId = parameters.Get<int>(context, "userId"); // perform a query var userNode = context.Repository.RetrieveSingleNode(context, new PropertyBag { {"baseType", "User"}, {"id", userId}, {"status", "any"}, {"bypassAuthorization", true}, {"cache", false}, {StorageOnlyQueryComponent.PropertyKey, true} }); if (userNode == null) { return AuthenticationResult.Failed(new PropertyBag { {AuthenticationResult.ReasonPropertyName, AuthenticationResult.InvalidCredentialsReason} }); } // create and return the user state return AuthenticationResult.Success(CreateUserState(context, userNode), new PropertyBag()); }
/// <summary> /// Get the first property with the given <paramref name="key"/>, if it can be found, otherwise /// returns null. /// </summary> public object Get(string key) { return(_source.Get(key)); }
/// <summary> /// Send a report email /// </summary> /// <param name="context"></param> /// <param name="jobNode"></param> /// <param name="taskDescriptor"></param> /// <param name="task"></param> /// <param name="taskOutput"></param> /// <param name="exception"></param> private static void SendErrorReportEmail(IMansionContext context, IPropertyBag jobNode, Type taskDescriptor, Task task, StringBuilder taskOutput, Exception exception = null) { var reportEmailFrom = jobNode.Get<string>(context, "reportEmailFrom", null); if (reportEmailFrom.IsNullOrWhiteSpace()) return; var reportEmailTo = jobNode.Get<string>(context, "reportEmailTo", null); if (reportEmailTo.IsNullOrWhiteSpace()) return; var mailService = context.Nucleus.ResolveSingle<IMailService>(); using (var message = mailService.CreateMessage()) { message.To.Add(reportEmailTo); message.From = new MailAddress(reportEmailFrom); message.Subject = String.Format("Job '{0}' failed while executing task '{1}'", jobNode.Get<string>(context, "name"), taskDescriptor.Name); message.Body = (exception != null) ? String.Format("The following exception occurred while executing task '{0}': [{1}] {2}", taskDescriptor.Name, exception.GetType().Name, exception.Message) : String.Format("The task '{0}' failed and gave the following output: {1}", taskDescriptor.Name, taskOutput); task.EnrichErrorReportEmail(message, exception); mailService.Send(context, message); } }
/// <summary> /// Transforms the given <paramref name="source"/> into an ElasticSearch document. /// </summary> /// <param name="context">the <see cref="IMansionContext"/>.</param> /// <param name="source">The <see cref="IPropertyBag"/> which to transform.</param> /// <param name="document">The document to which to write the mapped value.</param> /// <returns>Returns the resulting document.</returns> /// <exception cref="ArgumentNullException">Thrown if one of the parameters is null.</exception> protected override void DoTransform(IMansionContext context, IPropertyBag source, Dictionary<string, object> document) { // just map the value to the document document.Add(Field, Normalize(context, source.Get<object>(context, Field))); }
internal static Scope CreateScope(ITest currentTest, Type targetType) { MethodInfo testMethod = currentTest.Method.MethodInfo; object[] testMethodArguments = currentTest.Arguments; IPropertyBag testMethodProperties = currentTest.Properties; if (testMethod == null) { return(null); } string testFramework = "NUnit " + targetType?.Assembly?.GetName().Version; string testSuite = testMethod.DeclaringType?.FullName; string testName = testMethod.Name; string skipReason = null; Scope scope = Common.TestTracer.StartActive("nunit.test", serviceName: Common.TestTracer.DefaultServiceName); Span span = scope.Span; span.Type = SpanTypes.Test; span.SetTraceSamplingPriority(SamplingPriority.AutoKeep); span.ResourceName = $"{testSuite}.{testName}"; span.SetTag(Tags.Origin, TestTags.CIAppTestOriginName); span.SetTag(TestTags.Suite, testSuite); span.SetTag(TestTags.Name, testName); span.SetTag(TestTags.Framework, testFramework); span.SetTag(TestTags.Type, TestTags.TypeTest); CIEnvironmentValues.DecorateSpan(span); var framework = FrameworkDescription.Instance; span.SetTag(CommonTags.RuntimeName, framework.Name); span.SetTag(CommonTags.RuntimeVersion, framework.ProductVersion); span.SetTag(CommonTags.RuntimeArchitecture, framework.ProcessArchitecture); span.SetTag(CommonTags.OSArchitecture, framework.OSArchitecture); span.SetTag(CommonTags.OSPlatform, framework.OSPlatform); span.SetTag(CommonTags.OSVersion, Environment.OSVersion.VersionString); // Get test parameters ParameterInfo[] methodParameters = testMethod.GetParameters(); if (methodParameters?.Length > 0) { TestParameters testParameters = new TestParameters(); testParameters.Metadata = new Dictionary <string, object>(); testParameters.Arguments = new Dictionary <string, object>(); testParameters.Metadata[TestTags.MetadataTestName] = currentTest.Name; for (int i = 0; i < methodParameters.Length; i++) { if (testMethodArguments != null && i < testMethodArguments.Length) { testParameters.Arguments[methodParameters[i].Name] = testMethodArguments[i]?.ToString() ?? "(null)"; } else { testParameters.Arguments[methodParameters[i].Name] = "(default)"; } } span.SetTag(TestTags.Parameters, testParameters.ToJSON()); } // Get traits if (testMethodProperties != null) { Dictionary <string, List <string> > traits = new Dictionary <string, List <string> >(); skipReason = (string)testMethodProperties.Get("_SKIPREASON"); foreach (var key in testMethodProperties.Keys) { if (key == "_SKIPREASON" || key == "_JOINTYPE") { continue; } IList value = testMethodProperties[key]; if (value != null) { List <string> lstValues = new List <string>(); foreach (object valObj in value) { if (valObj is null) { continue; } lstValues.Add(valObj.ToString()); } traits[key] = lstValues; } else { traits[key] = null; } } if (traits.Count > 0) { span.SetTag(TestTags.Traits, Datadog.Trace.Vendors.Newtonsoft.Json.JsonConvert.SerializeObject(traits)); } } if (skipReason != null) { FinishSkippedScope(scope, skipReason); scope = null; } span.ResetStartTime(); return(scope); }
/// <summary> /// Interprets the input.. /// </summary> /// <param name="context">The <see cref="IMansionContext"/>.</param> /// <param name="input">The input which to interpret.</param> /// <returns>Returns the interpreted result.</returns> protected override IResourcePath DoInterpret(IMansionContext context, IPropertyBag input) { // get the path var type = input.Get<ITypeDefinition>(context, "type"); if (type == null) throw new InvalidOperationException("The type must be specified"); var extension = input.Get(context, "extension", string.Empty).TrimStart('.'); if (string.IsNullOrEmpty(extension)) throw new InvalidOperationException("The extension must be specified"); var overridable = input.Get(context, "overridable", true); // return the resource path return new TypeResourcePath(type.Hierarchy.Select(x => x.Name), extension, overridable); }
/// <summary> /// /// </summary> /// <param name="context"></param> /// <param name="queryBuilder"></param> /// <param name="record"> </param> /// <param name="modifiedProperties"></param> protected override void DoToUpdateStatement(IMansionContext context, ModificationQueryBuilder queryBuilder, Record record, IPropertyBag modifiedProperties) { // allow update of relational column on special cases, most likely used when fixing the repository integrity if (modifiedProperties.Get(context, "_allowRelationPropertiesUpdate", false)) { string name; if (modifiedProperties.TryGet(context, "name", out name)) queryBuilder.AddColumnValue("name", name, DbType.String); string type; if (modifiedProperties.TryGet(context, "type", out type)) queryBuilder.AddColumnValue("type", type, DbType.String); int depth; if (modifiedProperties.TryGet(context, "depth", out depth)) queryBuilder.AddColumnValue("depth", depth, DbType.Int32); int parentId; if (modifiedProperties.TryGet(context, "parentId", out parentId)) queryBuilder.AddColumnValue("parentId", parentId, DbType.Int32); string parentPointer; if (modifiedProperties.TryGet(context, "parentPointer", out parentPointer)) queryBuilder.AddColumnValue("parentPointer", parentPointer, DbType.String); string parentPath; if (modifiedProperties.TryGet(context, "parentPath", out parentPath)) queryBuilder.AddColumnValue("parentPath", parentPath, DbType.String); string parentStructure; if (modifiedProperties.TryGet(context, "parentStructure", out parentStructure)) queryBuilder.AddColumnValue("parentStructure", parentStructure, DbType.String); return; } // make sure the relational intgrety is not comprimised if (modifiedProperties.Names.Intersect(ReservedPropertyName, StringComparer.OrdinalIgnoreCase).Any()) throw new InvalidOperationException("The relational properties can not be changed"); // get the pointer NodePointer pointer; if (!record.TryGet(context, "pointer", out pointer)) throw new InvalidOperationException("Could not update this record because it did not contain a pointer"); // add the id an pointer parameters var idParameterName = queryBuilder.AddParameter("id", pointer.Id, DbType.Int32); var pointerParameterName = queryBuilder.AddParameter("pointer", pointer.PointerString + "-%", DbType.String); // check if the name changed string newName; if (modifiedProperties.TryGetAndRemove(context, "name", out newName)) { newName = newName.Trim(); if (string.IsNullOrEmpty(newName)) throw new InvalidOperationException("Can not update column name with empty string"); if (newName.Contains(NodePointer.PathSeparator)) throw new InvalidOperationException(string.Format("Name '{0}' contains invalid characters", newName)); if (!pointer.Name.Equals(newName)) { // add the name column modification queryBuilder.AddColumnValue("name", newName, DbType.String); // update the paths var oldPathLengthParameterName = queryBuilder.AddParameter("oldPathLength", pointer.PathString.Length + 1, DbType.String); var newPathParameterName = queryBuilder.AddParameter("newPath", NodePointer.Rename(pointer, newName).PathString + NodePointer.PathSeparator, DbType.String); queryBuilder.AppendQuery(string.Format(@" UPDATE [Nodes] SET [parentPath] = {0} + RIGHT( [parentPath], LEN( [parentPath] ) - {1} ) WHERE ( [parentId] = {2} OR [parentPointer] LIKE {3} )", newPathParameterName, oldPathLengthParameterName, idParameterName, pointerParameterName)); } } // check if the type changed string newType; if (modifiedProperties.TryGetAndRemove(context, "type", out newType)) { newType = newType.Trim(); if (string.IsNullOrEmpty(newType)) throw new InvalidOperationException("Can not update column type with empty string"); if (newType.Contains(NodePointer.StructureSeparator)) throw new InvalidOperationException(string.Format("Type '{0}' contains invalid characters", newType)); if (!string.IsNullOrEmpty(newType) && !pointer.Type.Equals(newType, StringComparison.OrdinalIgnoreCase)) { // add the name column modification queryBuilder.AddColumnValue("type", newType, DbType.String); // update the structures var newStructureParameterName = queryBuilder.AddParameter("newStructure", NodePointer.ChangeType(pointer, newType).StructureString + NodePointer.StructureSeparator, DbType.String); var oldStructureLengthParameterName = queryBuilder.AddParameter("oldStructureLength", pointer.StructureString.Length + 1, DbType.Int32); queryBuilder.AppendQuery(string.Format("UPDATE [Nodes] SET [parentStructure] = {0} + RIGHT( [parentStructure], LEN( [parentStructure] ) - {1} ) WHERE ( [parentId] = {2} OR [parentPointer] LIKE {3} )", newStructureParameterName, oldStructureLengthParameterName, idParameterName, pointerParameterName)); } } }
/// <summary> /// Authenticates using username/password. /// </summary> /// <param name="context"></param> /// <param name="parameters"></param> /// <returns></returns> private AuthenticationResult AuthenticateWithUsernamePassword(IMansionContext context, IPropertyBag parameters) { // get the credentials var username = parameters.Get(context, "username", string.Empty); if (string.IsNullOrEmpty(username)) { return AuthenticationResult.Failed(new PropertyBag { {AuthenticationResult.ReasonPropertyName, AuthenticationResult.NoUsernameSpecifiedReason} }); } var password = parameters.Get(context, "password", string.Empty); if (string.IsNullOrEmpty(password)) { return AuthenticationResult.Failed(new PropertyBag { {AuthenticationResult.ReasonPropertyName, AuthenticationResult.NoPasswordSpecifiedReason} }); } // perform a query var userNode = context.Repository.RetrieveSingleNode(context, new PropertyBag { {"baseType", "User"}, {"login", username}, {"password", password}, {"status", "any"}, {"bypassAuthorization", true}, {"cache", false}, {StorageOnlyQueryComponent.PropertyKey, true} }); if (userNode == null) { return AuthenticationResult.Failed(new PropertyBag { {AuthenticationResult.ReasonPropertyName, AuthenticationResult.InvalidCredentialsReason} }); } // check against unpublished users if (userNode.Status != NodeStatus.Published) { return AuthenticationResult.Failed(new PropertyBag { {AuthenticationResult.ReasonPropertyName, AuthenticationResult.AccounDeactivatedReason} }); } // create and return the user state return AuthenticationResult.Success(CreateUserState(context, userNode), new PropertyBag()); }
/// <summary> /// This method is called just before a node is created by the repository. /// </summary> /// <param name="context">The <see cref="IMansionContext"/>.</param> /// <param name="parent">The parent node to which the new child will be added.</param> /// <param name="newProperties">The new properties of the node.</param> protected override void DoBeforeCreate(IMansionContext context, Node parent, IPropertyBag newProperties) { // make sure the name is normalized newProperties.Set("name", TagUtilities.Normalize(newProperties.Get(context, "name", string.Empty))); }
internal static Scope CreateScope <TContext>(TContext executionContext, Type targetType) where TContext : ITestExecutionContext { ITest currentTest = executionContext.CurrentTest; MethodInfo testMethod = currentTest.Method.MethodInfo; object[] testMethodArguments = currentTest.Arguments; IPropertyBag testMethodProperties = currentTest.Properties; if (testMethod == null) { return(null); } string testFramework = "NUnit " + targetType?.Assembly?.GetName().Version; string testSuite = testMethod.DeclaringType?.FullName; string testName = testMethod.Name; string skipReason = null; Tracer tracer = Tracer.Instance; Scope scope = tracer.StartActive("nunit.test"); Span span = scope.Span; span.Type = SpanTypes.Test; span.SetTraceSamplingPriority(SamplingPriority.AutoKeep); span.ResourceName = $"{testSuite}.{testName}"; span.SetTag(TestTags.Suite, testSuite); span.SetTag(TestTags.Name, testName); span.SetTag(TestTags.Framework, testFramework); span.SetTag(TestTags.Type, TestTags.TypeTest); CIEnvironmentValues.DecorateSpan(span); var framework = FrameworkDescription.Instance; span.SetTag(CommonTags.RuntimeName, framework.Name); span.SetTag(CommonTags.RuntimeOSArchitecture, framework.OSArchitecture); span.SetTag(CommonTags.RuntimeOSPlatform, framework.OSPlatform); span.SetTag(CommonTags.RuntimeProcessArchitecture, framework.ProcessArchitecture); span.SetTag(CommonTags.RuntimeVersion, framework.ProductVersion); // Get test parameters ParameterInfo[] methodParameters = testMethod.GetParameters(); if (methodParameters?.Length > 0) { for (int i = 0; i < methodParameters.Length; i++) { if (testMethodArguments != null && i < testMethodArguments.Length) { span.SetTag($"{TestTags.Arguments}.{methodParameters[i].Name}", testMethodArguments[i]?.ToString() ?? "(null)"); } else { span.SetTag($"{TestTags.Arguments}.{methodParameters[i].Name}", "(default)"); } } } // Get traits if (testMethodProperties != null) { skipReason = (string)testMethodProperties.Get("_SKIPREASON"); foreach (var key in testMethodProperties.Keys) { if (key == "_SKIPREASON") { continue; } IList value = testMethodProperties[key]; if (value != null) { List <string> lstValues = new List <string>(); foreach (object valObj in value) { if (valObj is null) { continue; } lstValues.Add(valObj.ToString()); } span.SetTag($"{TestTags.Traits}.{key}", string.Join(", ", lstValues)); } else { span.SetTag($"{TestTags.Traits}.{key}", "(null)"); } } } if (skipReason != null) { span.SetTag(TestTags.Status, TestTags.StatusSkip); span.SetTag(TestTags.SkipReason, skipReason); span.Finish(TimeSpan.Zero); scope.Dispose(); scope = null; } span.ResetStartTime(); return(scope); }
/// <summary> /// Gets a <see cref="Dataset"/> containing all the columns available for the specified type. /// </summary> /// <param name="context">The request context.</param> /// <param name="attributes">The attributes of this tag.</param> /// <returns>Returns the result.</returns> protected override Dataset Get(IMansionContext context, IPropertyBag attributes) { return portalService.GetColumnDataset(context, attributes.Get<ITypeDefinition>(context, "type")); }
internal static Scope CreateScope(ITest currentTest, Type targetType) { MethodInfo testMethod = currentTest.Method.MethodInfo; object[] testMethodArguments = currentTest.Arguments; IPropertyBag testMethodProperties = currentTest.Properties; if (testMethod == null) { return(null); } string testFramework = "NUnit"; string fullName = currentTest.FullName; string composedTestName = currentTest.Name; string testName = testMethod.Name; string testSuite = testMethod.DeclaringType?.FullName; string testBundle = testMethod.DeclaringType?.Assembly?.GetName().Name; // Extract the test suite from the full name to support custom fixture parameters and test declared in base classes. if (fullName.EndsWith("." + composedTestName)) { testSuite = fullName.Substring(0, fullName.Length - (composedTestName.Length + 1)); } string skipReason = null; Scope scope = Tracer.Instance.StartActiveInternal("nunit.test"); Span span = scope.Span; span.Type = SpanTypes.Test; span.SetTraceSamplingPriority(SamplingPriorityValues.AutoKeep); span.ResourceName = $"{testSuite}.{testName}"; span.SetTag(Tags.Origin, TestTags.CIAppTestOriginName); span.SetTag(Tags.Language, TracerConstants.Language); span.SetTag(TestTags.Bundle, testBundle); span.SetTag(TestTags.Suite, testSuite); span.SetTag(TestTags.Name, testName); span.SetTag(TestTags.Framework, testFramework); span.SetTag(TestTags.FrameworkVersion, targetType.Assembly?.GetName().Version.ToString()); span.SetTag(TestTags.Type, TestTags.TypeTest); CIEnvironmentValues.Instance.DecorateSpan(span); var framework = FrameworkDescription.Instance; span.SetTag(CommonTags.LibraryVersion, TracerConstants.AssemblyVersion); span.SetTag(CommonTags.RuntimeName, framework.Name); span.SetTag(CommonTags.RuntimeVersion, framework.ProductVersion); span.SetTag(CommonTags.RuntimeArchitecture, framework.ProcessArchitecture); span.SetTag(CommonTags.OSArchitecture, framework.OSArchitecture); span.SetTag(CommonTags.OSPlatform, framework.OSPlatform); span.SetTag(CommonTags.OSVersion, Environment.OSVersion.VersionString); // Get test parameters ParameterInfo[] methodParameters = testMethod.GetParameters(); if (methodParameters?.Length > 0) { TestParameters testParameters = new TestParameters(); testParameters.Metadata = new Dictionary <string, object>(); testParameters.Arguments = new Dictionary <string, object>(); testParameters.Metadata[TestTags.MetadataTestName] = currentTest.Name; for (int i = 0; i < methodParameters.Length; i++) { if (testMethodArguments != null && i < testMethodArguments.Length) { testParameters.Arguments[methodParameters[i].Name] = Common.GetParametersValueData(testMethodArguments[i]); } else { testParameters.Arguments[methodParameters[i].Name] = "(default)"; } } span.SetTag(TestTags.Parameters, testParameters.ToJSON()); } // Get traits if (testMethodProperties != null) { Dictionary <string, List <string> > traits = new Dictionary <string, List <string> >(); skipReason = (string)testMethodProperties.Get("_SKIPREASON"); foreach (var key in testMethodProperties.Keys) { if (key == "_SKIPREASON" || key == "_JOINTYPE") { continue; } IList value = testMethodProperties[key]; if (value != null) { List <string> lstValues = new List <string>(); foreach (object valObj in value) { if (valObj is null) { continue; } lstValues.Add(valObj.ToString()); } traits[key] = lstValues; } else { traits[key] = null; } } if (traits.Count > 0) { span.SetTag(TestTags.Traits, Vendors.Newtonsoft.Json.JsonConvert.SerializeObject(traits)); } } if (skipReason != null) { FinishSkippedScope(scope, skipReason); scope = null; } span.ResetStartTime(); Tracer.Instance.TracerManager.Telemetry.IntegrationGeneratedSpan(IntegrationId); return(scope); }
/// <summary> /// Parses the <paramref name="properties"/> into a <see cref="IResourcePath"/>. /// </summary> /// <param name="context">The <see cref="IMansionContext"/>.</param> /// <param name="properties">The properties which to parse.</param> /// <returns>Returns the parsed <see cref="IResourcePath"/>.</returns> public IResourcePath ParsePath(IMansionContext context, IPropertyBag properties) { // validate arguments if (context == null) throw new ArgumentNullException("context"); if (properties == null) throw new ArgumentNullException("properties"); // get the resource base path var categoryBasePath = properties.Get(context, "category", "Temp"); // check if it is an existing resource string relativePath; if (properties.TryGet(context, "relativePath", out relativePath)) return new ContentResourcePath(relativePath); // check if it is a new file name string fileName; if (properties.TryGet(context, "fileName", out fileName)) { // get the current date var today = DateTime.Today; // get the file base name and extension var fileBaseName = Path.GetFileNameWithoutExtension(fileName); var fileExtension = Path.GetExtension(fileName); // make sure the file name is unique var index = 0; while (File.Exists(ResourceUtils.Combine(physicalBasePath, relativeBasePath, categoryBasePath, today.Year.ToString(CultureInfo.InvariantCulture), today.Month.ToString(CultureInfo.InvariantCulture), fileBaseName + index + fileExtension))) index++; // create the resource path return new ContentResourcePath(ResourceUtils.Combine(categoryBasePath, today.Year.ToString(CultureInfo.InvariantCulture), today.Month.ToString(CultureInfo.InvariantCulture), fileBaseName + index + fileExtension)); } // unkonwn type throw new InvalidOperationException("Could not identify resource path"); }
/// <summary> /// Get the first property with the given <paramref name="key"/>, if it can be found, otherwise /// returns null. /// </summary> public object Get(string key) => _source.Get(key);