public IEnumerable<IWebElement> FindByPartialId(string id, Scope scope) { id = "_" + id; var xpath = String.Format(".//*[substring(@id, string-length(@id) - {0} + 1, string-length(@id)) = {1}]", id.Length, xPath.Literal(id)); return Find(By.XPath(xpath),scope); }
private ExpansionContext(Stack<MethodBase> stack, Scope scope, NameGenerator names, IEnumerable<KeyValuePair<Sym, Expression>> env) { Stack = stack; Scope = scope; Names = names; Env = env.ToDictionary(); }
private object InvokeTarget(Scope scope) { if (scope == _optimizedContext.GlobalScope && !_optimizedContext.LanguageContext.EnableTracing) { EnsureCompiled(); Exception e = PythonOps.SaveCurrentException(); var funcCode = EnsureFunctionCode(_optimizedTarget, false, true); PushFrame(_optimizedContext, funcCode); try { if (Ast.CompilerContext.SourceUnit.Kind == SourceCodeKind.Expression) { return OptimizedEvalWrapper(funcCode); } return _optimizedTarget(funcCode); } finally { PythonOps.RestoreCurrentException(e); PopFrame(); } } // if we're running against a different scope or we need tracing then re-compile the code. if (_unoptimizedCode == null) { // TODO: Copy instead of mutate ((PythonCompilerOptions)Ast.CompilerContext.Options).Optimized = false; Interlocked.CompareExchange( ref _unoptimizedCode, Ast.MakeLookupCode().ToScriptCode(), null ); } // This is a brand new ScriptCode which also handles all appropriate ScriptCode // things such as pushing a function code or updating the stack trace for // exec/eval code. Therefore we don't need to do any of that here. return _unoptimizedCode.Run(scope); }
// copy constructor // ================ // private Scope(Scope other) : this(new List<Utils.StoreEntry>(other.locals), other.esp_pos, new List<Utils.StoreEntry>(other.globals), other.func, new List<Utils.StoreEntry>(other.typedefs), new List<Utils.StoreEntry>(other.enums)) {}
public GeneratedCodeVisitor(SourceWriter source, Dictionary<string, object> globalSymbols, NullBehaviour nullBehaviour) { _nullBehaviour = nullBehaviour; _source = source; _scope = new Scope(new Scope(null) { Variables = globalSymbols }); }
public void Execute(Machine machine, Stack<object> stack, Scope scope, Instruction instr) { int length = (int)machine.TakeByte(); string name = machine.TakeBytes(length * sizeof(char)).AsString(); scope.GetFunction(name).Call(machine); }
protected override Scope GetScope(IClaimsPrincipal principal, RequestSecurityToken request) { Scope scope = new Scope(request.AppliesTo.Uri.AbsoluteUri, SecurityTokenServiceConfiguration.SigningCredentials); string encryptingCertificateName = WebConfigurationManager.AppSettings[ApplicationSettingsNames.EncryptingCertificateName]; if (!string.IsNullOrEmpty(encryptingCertificateName)) { scope.EncryptingCredentials = new X509EncryptingCredentials(CertificateUtilities.GetCertificate(StoreName.My, StoreLocation.LocalMachine, encryptingCertificateName)); } else { scope.TokenEncryptionRequired = false; } if (!string.IsNullOrEmpty(request.ReplyTo)) { scope.ReplyToAddress = request.ReplyTo; } else { scope.ReplyToAddress = scope.AppliesToAddress; } return scope; }
public void Test() { var scope = new Scope(); scope.Element<Custom>(new CustomSurrogate()); scope.Element<Item>() .Elements() .Add(x => x.Name) .Add(x => x.Custom) .Add(x => x.Value) .End(); var obj = new Item { Name = "item", Value = "test", Custom = new Custom { InnerXml = "<test></test>" } }; var xml = scope.ToXmlString(obj); var obj2 = new Item(); scope.ReadXmlString(xml, obj2); Assert.AreEqual(obj.Name, obj2.Name); Assert.AreEqual(obj.Value, obj2.Value); Assert.AreEqual(obj.Custom.InnerXml, obj2.Custom.InnerXml); }
public string GetProperty(string strPropertyName, string strFormat, System.Globalization.CultureInfo formatProvider, Entities.Users.UserInfo AccessingUser, Scope AccessLevel, ref bool PropertyNotFound) { CultureInfo ci = formatProvider; if (strPropertyName.ToLower() == CultureDropDownTypes.EnglishName.ToString().ToLowerInvariant()) { return PropertyAccess.PropertyAccess.FormatString(CultureInfo.CurrentCulture.TextInfo.ToTitleCase(ci.EnglishName), strFormat); } else if (strPropertyName.ToLower() == CultureDropDownTypes.Lcid.ToString().ToLowerInvariant()) { return ci.LCID.ToString(); } else if (strPropertyName.ToLower() == CultureDropDownTypes.Name.ToString().ToLowerInvariant()) { return PropertyAccess.PropertyAccess.FormatString(ci.Name, strFormat); } else if (strPropertyName.ToLower() == CultureDropDownTypes.NativeName.ToString().ToLowerInvariant()) { return PropertyAccess.PropertyAccess.FormatString(CultureInfo.CurrentCulture.TextInfo.ToTitleCase(ci.NativeName), strFormat); } else if (strPropertyName.ToLower() == CultureDropDownTypes.TwoLetterIsoCode.ToString().ToLowerInvariant()) { return PropertyAccess.PropertyAccess.FormatString(ci.TwoLetterISOLanguageName, strFormat); } else if (strPropertyName.ToLower() == CultureDropDownTypes.ThreeLetterIsoCode.ToString().ToLowerInvariant()) { return PropertyAccess.PropertyAccess.FormatString(ci.ThreeLetterISOLanguageName, strFormat); } else if (strPropertyName.ToLower() == CultureDropDownTypes.DisplayName.ToString().ToLowerInvariant()) { return PropertyAccess.PropertyAccess.FormatString(ci.DisplayName, strFormat); } PropertyNotFound = true; return string.Empty; }
public DeclareVariableNode(String type, String name, SGLNode expression, Scope scope) { this.type = type; this.name = name; this.expression = expression; this.scope = scope; }
public string GetProperty(string propertyName, string format, CultureInfo formatProvider, UserInfo AccessingUser, Scope CurrentScope, ref bool PropertyNotFound) { switch (propertyName.ToLowerInvariant()) { case "url": return NewUrl(objParent.Language); case "flagsrc": return "/" + objParent.Language + ".gif"; case "selected": return (objParent.Language == CultureInfo.CurrentCulture.Name).ToString(); case "label": return Localization.GetString("Label", objParent.resourceFile); case "i": return Globals.ResolveUrl("~/images/Flags"); case "p": return Globals.ResolveUrl(PathUtils.Instance.RemoveTrailingSlash(objPortal.HomeDirectory)); case "s": return Globals.ResolveUrl(PathUtils.Instance.RemoveTrailingSlash(objPortal.ActiveTab.SkinPath)); case "g": return Globals.ResolveUrl("~/portals/" + Globals.glbHostSkinFolder); default: PropertyNotFound = true; return string.Empty; } }
public string GetProperty(string strPropertyName, string strFormat, System.Globalization.CultureInfo formatProvider, Entities.Users.UserInfo AccessingUser, Scope AccessLevel, ref bool PropertyNotFound) { if (dr == null) return string.Empty; object valueObject = dr[strPropertyName]; string OutputFormat = strFormat; if (string.IsNullOrEmpty(strFormat)) OutputFormat = "g"; if (valueObject != null) { switch (valueObject.GetType().Name) { case "String": return PropertyAccess.PropertyAccess.FormatString(Convert.ToString(valueObject), strFormat); case "Boolean": return (PropertyAccess.PropertyAccess.Boolean2LocalizedYesNo(Convert.ToBoolean(valueObject), formatProvider)); case "DateTime": case "Double": case "Single": case "Int32": case "Int64": return (((IFormattable)valueObject).ToString(OutputFormat, formatProvider)); default: return PropertyAccess.PropertyAccess.FormatString(valueObject.ToString(), strFormat); } } else { PropertyNotFound = true; return string.Empty; } }
public override void ExitInnerBlock( Command command, Thread thread, Scope scope ) { if ( new TLBit( command.ParamExpression.Evaluate( scope ) ).Value ) thread.EnterBlock( command.InnerBlock ); else thread.Advance(); }
public string GetProperty(string propertyName, string format, CultureInfo formatProvider, UserInfo AccessingUser, Scope AccessLevel, ref bool PropertyNotFound) { TimeZoneInfo userTimeZone = AccessingUser.Profile.PreferredTimeZone; switch (propertyName.ToLower()) { case "current": if (format == string.Empty) { format = "D"; } return TimeZoneInfo.ConvertTime(DateTime.Now, userTimeZone).ToString(format, formatProvider); case "now": if (format == string.Empty) { format = "g"; } return TimeZoneInfo.ConvertTime(DateTime.Now, userTimeZone).ToString(format, formatProvider); case "system": if (format == String.Empty) { format = "g"; } return DateTime.Now.ToString(format, formatProvider); case "utc": if (format == String.Empty) { format = "g"; } return DateTime.Now.ToUniversalTime().ToString(format, formatProvider); default: PropertyNotFound = true; return string.Empty; } }
private IWebElement FindButtonByText(string locator, Scope scope) { return elementFinder.Find(By.TagName("button"), scope).FirstOrDefault(e => textMatcher.TextMatches(e, locator)) ?? elementFinder.Find(By.ClassName("button"), scope).FirstOrDefault(e => textMatcher.TextMatches(e, locator)) ?? elementFinder.Find(By.XPath(".//*[@role = 'button']"), scope).FirstOrDefault(e => textMatcher.TextMatches(e, locator)); }
private static SyntaxNode Repository(SyntaxNode node, Scope scope) { //Hubo problemas con el templatecito bonito, //Roslyn espera que tu reemplaces una clase con otra //Por tanto hay que escupir la clase nada mas y annadir //la interfaz al scope var repository = node as ClassDeclarationSyntax; if (repository == null) throw new InvalidOperationException(); //Vamos a suponer que quieres cambiar los metodos para que sean UnitOfWork //solo un ejemplo. var typeName = repository.Identifier.ToString(); var className = typeName + "Repository"; var interfaceName = "I" + typeName + "Repository"; var methods = repository .DescendantNodes() .OfType<MethodDeclarationSyntax>(); var @interface = repoInterface.Get<InterfaceDeclarationSyntax>(interfaceName) .AddMembers(methods .Select(method => CSharp.MethodDeclaration(method.ReturnType, method.Identifier) .WithParameterList(method.ParameterList) .WithSemicolonToken(Roslyn.semicolon)) .ToArray()); scope.AddType(@interface); return repoClass.Get<ClassDeclarationSyntax>(className, typeName, interfaceName) .AddMembers(methods.ToArray()); }
public Scope(BodyType bodyType, Scope parent, ReadOnlyArray<string> parameters) { _bodyType = bodyType; Parent = parent; _parameters = parameters; _rootScope = parent != null ? parent._rootScope : this; }
public static void __init__(Scope/*!*/ scope, string name, string documentation) { scope.SetName(Symbols.Name, name); if (documentation != null) { scope.SetName(Symbols.Doc, documentation); } }
/// <summary>Assigns all needed attributes to the tag</summary> /// <returns>This instance downcasted to base class</returns> public virtual IndexedTag attr( string abbr = null, string axis = null, string headers = null, Scope? scope = null, int? rowspan = null, int? colspan = null, string id = null, string @class = null, string style = null, string title = null, LangCode lang = null, string xmllang = null, Dir? dir = null, string onclick = null, string ondblclick = null, string onmousedown = null, string onmouseup = null, string onmouseover = null, string onmousemove = null, string onmouseout = null, string onkeypress = null, string onkeydown = null, string onkeyup = null, Align? align = null, char? @char = null, Length charoff = null, Valign? valign = null ) { Abbr = abbr; Axis = axis; Headers = headers; Scope = scope; RowSpan = rowspan; ColSpan = colspan; Id = id; Class = @class; Style = style; Title = title; Lang = lang; XmlLang = xmllang; Dir = dir; OnClick = onclick; OnDblClick = ondblclick; OnMouseDown = onmousedown; OnMouseUp = onmouseup; OnMouseOver = onmouseover; OnMouseMove = onmousemove; OnMouseOut = onmouseout; OnKeyPress = onkeypress; OnKeyDown = onkeydown; OnKeyUp = onkeyup; Align = align; Char = @char; CharOff = charoff; Valign = valign; return this; }
private IncludeToken(Token parent, Scope scope, Span span, PreprocessorToken prepToken, string fileName, bool searchFileDir) : base(parent, scope, span) { _prepToken = prepToken; _fileName = fileName; _searchFileDir = searchFileDir; }
public GeneratedCodeVisitor(SourceBuilder output, Dictionary<string, object> globalSymbols, NullBehaviour nullBehaviour) { _nullBehaviour = nullBehaviour; _source = output; _scope = new Scope(new Scope(null) { Variables = globalSymbols }); }
private static SyntaxNode ProcessContract(SyntaxNode node, Scope scope, SyntacticalExtension<SyntaxNode> extension) { if (extension.Kind == ExtensionKind.Code) { var block = extension.Body as BlockSyntax; Debug.Assert(block != null); List<StatementSyntax> checks = new List<StatementSyntax>(); foreach (var st in block.Statements) { var stExpression = st as ExpressionStatementSyntax; if (stExpression == null) { scope.AddError("contract01", "contracts only support boolean expressions", st); continue; } var contractCheck = ContractCheck .ReplaceNodes(ContractCheck .DescendantNodes() .OfType<ExpressionSyntax>() .Where(expr => expr.ToString() == "__condition"), (oldNode, newNode) => stExpression.Expression); checks.Add(contractCheck); } return CSharp.Block(checks); } scope.AddError("contract02", "contract cannot return a value", node); return node; }
public NativeCallContext(NativeMethod source, IElfObject @this, params IElfObject[] args) { Stack = new Stack<IElfObject>(); var callScope = new Scope(); callScope.Add("@this", @this); source.FuncDef.Args.Zip(args, callScope.Add); Scopes = new Stack<Scope>(); Scopes.Push(callScope); Source = source; if (source.FuncDef.Args.Count() != args.Length) { throw new UnexpectedElfRuntimeException(@this.VM, String.Format( "Fatal error invoking native call '{0}({1})' with args '{2}'. Reason: args count mismatch.", Source.Name, Source.FuncDef.Args.StringJoin(), args.StringJoin())); } CurrentEvi = 0; PrevEvi = -1; if (source.Body.IsNullOrEmpty()) { throw new UnexpectedElfRuntimeException(@this.VM, String.Format( "Fatal error invoking native call '{0}'. Reason: empty method body.", Source.Name)); } }
/// <summary> /// Creates a <see cref="SetRequestMessage"/> with all contents. /// </summary> /// <param name="requestId">The request id.</param> /// <param name="version">Protocol version</param> /// <param name="community">Community name</param> /// <param name="variables">Variables</param> public SetRequestMessage(int requestId, VersionCode version, OctetString community, IList<Variable> variables) { if (variables == null) { throw new ArgumentNullException("variables"); } if (community == null) { throw new ArgumentNullException("community"); } if (version == VersionCode.V3) { throw new ArgumentException("only v1 and v2c are supported", "version"); } Version = version; Header = Header.Empty; Parameters = SecurityParameters.Create(community); var pdu = new SetRequestPdu( requestId, variables); Scope = new Scope(pdu); Privacy = DefaultPrivacyProvider.DefaultPair; _bytes = this.PackMessage(null).ToBytes(); }
public void Execute(Machine machine, Stack<object> stack, Scope scope, Instruction instr) { int length; string name; switch (instr) { default: throw new VMException("Something just went horribly wrong. Variable instructlet is not supposed to receive {0}", instr.ToString()); case Instruction.SetVar: length = (int)machine.TakeByte(); name = machine.TakeBytes(length).AsString(); machine.ExecuteNextInstructlet(); scope.SetVariable(name, stack.Pop()); break; case Instruction.GetVar: length = (int)machine.TakeByte(); name = machine.TakeBytes((int)length).AsString(); stack.Push(scope.GetVariable(name)); break; } }
public override void Execute( Command command, Thread thread, Scope scope ) { TLSub sub = scope[ command.Identifier ] as TLSub; command.InnerBlock = sub.Block; thread.EnterBlock( command.InnerBlock, true, new Scope( sub.Scope ) ); }
public async void ProvisionAccessTokenAsync_AssertionTokenIsSigned() { var claims = new List<Claim>{ new Claim( Constants.Claims.ISSUER, TestData.ISSUER ), new Claim( Constants.Claims.TENANT_ID, TestData.TENANT_ID.ToString() ), new Claim( Constants.Claims.USER_ID, TestData.USER ) }; var scopes = new Scope[] { }; await m_accessTokenProvider .ProvisionAccessTokenAsync( claims, scopes ) .SafeAsync(); var publicKeys = ( await m_publicKeyDataProvider.GetAllAsync().SafeAsync() ).ToList(); string expectedKeyId = publicKeys.First().Id.ToString(); string actualKeyId = m_actualAssertion.Header.SigningKeyIdentifier[ 0 ].Id; Assert.AreEqual( 1, publicKeys.Count ); Assert.AreEqual( expectedKeyId, actualKeyId ); AssertClaimEquals( m_actualAssertion, Constants.Claims.ISSUER, TestData.ISSUER ); AssertClaimEquals( m_actualAssertion, Constants.Claims.TENANT_ID, TestData.TENANT_ID.ToString() ); AssertClaimEquals( m_actualAssertion, Constants.Claims.USER_ID, TestData.USER ); }
private object Run(Scope/*!*/ scope, bool bindGlobals) { RubyScope localScope; RubyContext context = (RubyContext)LanguageContext; switch (_kind) { case TopScopeFactoryKind.Hosted: localScope = RubyTopLevelScope.CreateHostedTopLevelScope(scope, context, bindGlobals); break; case TopScopeFactoryKind.Main: localScope = RubyTopLevelScope.CreateTopLevelScope(scope, context, true); break; case TopScopeFactoryKind.File: localScope = RubyTopLevelScope.CreateTopLevelScope(scope, context, false); break; case TopScopeFactoryKind.WrappedFile: localScope = RubyTopLevelScope.CreateWrappedTopLevelScope(scope, context); break; default: throw Assert.Unreachable; } return Target(localScope, localScope.SelfObject); }
/// <summary> /// Authentication request class to setup a request for the AuthenticationUtility.Authenticate method. /// </summary> /// <param name="scope">The required scope to receive information for. /// Regarding to the Google's documentation, the scope has to begin with openid and then include profile or email or both. /// For details see https://developers.google.com/accounts/docs/OpenIDConnect#scope-param /// </param> public AuthenticationRequest(Scope scope) { Scope = scope; }
public GreaterThan(Scope scope) : base(scope, ">", "cmpq\t%rax,%rcx\nmovq\t$0,%rax\nsetg\t%al") { }
public RegisterFactoryAttribute(Type factoryType, Scope factoryScope = Scope.InstancePerResolution, Scope factoryTargetScope = Scope.InstancePerResolution) { FactoryType = factoryType; FactoryScope = factoryScope; FactoryTargetScope = factoryTargetScope; }
protected override string ProcessToken(IsInRoleDto model, UserInfo accessingUser, Scope accessLevel) { var userInfo = UserController.Instance.GetCurrentUserInfo(); var isInRole = userInfo.IsInRole(model.Name); var asString = isInRole ? Boolean.TrueString : Boolean.FalseString; return(asString); }
public override Func <Scope, object> ToResolver(Scope topScope) { return(s => new SqlConnection(topScope.GetInstance <SqlServerSettings>().ConnectionString)); }
public string GetProperty(string propertyName, string format, CultureInfo formatProvider, UserInfo accessingUser, Scope accessLevel, ref bool propertyNotFound) { string OutputFormat = string.Empty; if (format == string.Empty) { OutputFormat = "g"; } else { OutputFormat = format; } string propName = propertyName.ToLowerInvariant(); switch (propName) { case "roleid": return(PropertyAccess.FormatString(this.RoleID.ToString(), format)); case "groupid": return(PropertyAccess.FormatString(this.RoleID.ToString(), format)); case "status": return(PropertyAccess.FormatString(this.Status.ToString(), format)); case "groupname": return(PropertyAccess.FormatString(this.RoleName, format)); case "rolename": return(PropertyAccess.FormatString(this.RoleName, format)); case "groupdescription": return(PropertyAccess.FormatString(this.Description, format)); case "description": return(PropertyAccess.FormatString(this.Description, format)); case "usercount": return(PropertyAccess.FormatString(this.UserCount.ToString(), format)); case "street": return(PropertyAccess.FormatString(this.GetString("Street", string.Empty), format)); case "city": return(PropertyAccess.FormatString(this.GetString("City", string.Empty), format)); case "region": return(PropertyAccess.FormatString(this.GetString("Region", string.Empty), format)); case "country": return(PropertyAccess.FormatString(this.GetString("Country", string.Empty), format)); case "postalcode": return(PropertyAccess.FormatString(this.GetString("PostalCode", string.Empty), format)); case "website": return(PropertyAccess.FormatString(this.GetString("Website", string.Empty), format)); case "datecreated": return(PropertyAccess.FormatString(this.CreatedOnDate.ToString(), format)); case "photourl": return(PropertyAccess.FormatString(this.FormatUrl(this.PhotoURL), format)); case "stat_status": return(PropertyAccess.FormatString(this.GetString("stat_status", string.Empty), format)); case "stat_photo": return(PropertyAccess.FormatString(this.GetString("stat_photo", string.Empty), format)); case "stat_file": return(PropertyAccess.FormatString(this.GetString("stat_file", string.Empty), format)); case "url": return(PropertyAccess.FormatString(this.FormatUrl(this.GetString("URL", string.Empty)), format)); case "issystemrole": return(PropertyAccess.Boolean2LocalizedYesNo(this.IsSystemRole, formatProvider)); case "grouptype": return(this.IsPublic ? "Public.Text" : "Private.Text"); case "groupcreatorname": return(PropertyAccess.FormatString(this.GetString("GroupCreatorName", string.Empty), format)); default: if (this.Settings.ContainsKey(propertyName)) { return(PropertyAccess.FormatString(this.GetString(propertyName, string.Empty), format)); } propertyNotFound = true; return(string.Empty); } }
public Task <Dictionary <string, object> > ProcessAsync(IntrospectionRequestValidationResult validationResult, Scope scope) { _logger.LogTrace("Creating introspection response"); var response = new Dictionary <string, object>(); if (validationResult.IsActive == false) { _logger.LogDebug("Creating introspection response for inactive token."); response.Add("active", false); return(Task.FromResult(response)); } if (scope.AllowUnrestrictedIntrospection) { _logger.LogDebug("Creating unrestricted introspection response for active token."); response = validationResult.Claims.ToClaimsDictionary(); response.Add("active", true); } else { _logger.LogDebug("Creating restricted introspection response for active token."); response = validationResult.Claims.Where(c => c.Type != JwtClaimTypes.Scope).ToClaimsDictionary(); response.Add("active", true); response.Add("scope", new[] { scope.Name }); } return(Task.FromResult(response)); }
public WebHostBuilderWrapper([NotNull] IWebHostBuilder webHostBuilder, Scope scope) { _webHostBuilderImplementation = webHostBuilder ?? throw new ArgumentNullException(nameof(webHostBuilder)); _scope = scope; }
public ParsedField(Scope scope, string type, string name) { Scope = scope; Type = new ParsedType(type); Name = name; }
/// <summary> /// Initializes a new instance of the <see cref="TokenReplace"/> class. /// creates a new TokenReplace object for custom context. /// </summary> /// <param name="accessLevel">Security level granted by the calling object.</param> /// <param name="moduleID">ID of the current module.</param> public TokenReplace(Scope accessLevel, int moduleID) : this(accessLevel, null, null, null, moduleID) { }
protected override ClaimsIdentity GetOutputClaimsIdentity(ClaimsPrincipal principal, RequestSecurityToken request, Scope scope) { if (principal == null) { throw new InvalidRequestException("The caller's principal is null."); } ClaimsIdentity outputIdentity = (ClaimsIdentity)principal.Identity; //outputIdentity.AddClaim(new Claim(ClaimTypes.Email, "*****@*****.**")); //outputIdentity.AddClaim(new Claim(ClaimTypes.Surname, "Adams")); //outputIdentity.AddClaim(new Claim(ClaimTypes.Name, "Terry")); //outputIdentity.AddClaim(new Claim(ClaimTypes.Role, "developer")); //outputIdentity.AddClaim(new Claim("http://schemas.xmlsoap.org/claims/Group", "Sales")); //outputIdentity.AddClaim(new Claim("http://schemas.xmlsoap.org/claims/Group", "Marketing")); // return (ClaimsIdentity)principal.Identity; return(outputIdentity); }
public string GetProperty(string propertyName, string format, CultureInfo formatProvider, UserInfo accessingUser, Scope currentScope, ref bool propertyNotFound) { string outputFormat = string.Empty; if (format == string.Empty) { outputFormat = "g"; } if (currentScope == Scope.NoSettings) { propertyNotFound = true; return(PropertyAccess.ContentLocked); } propertyNotFound = true; string result = string.Empty; bool isPublic = true; switch (propertyName.ToLowerInvariant()) { case "portalid": propertyNotFound = false; result = this.PortalID.ToString(outputFormat, formatProvider); break; case "displayportalid": propertyNotFound = false; result = this.OwnerPortalID.ToString(outputFormat, formatProvider); break; case "tabid": propertyNotFound = false; result = this.TabID.ToString(outputFormat, formatProvider); break; case "tabmoduleid": propertyNotFound = false; result = this.TabModuleID.ToString(outputFormat, formatProvider); break; case "moduleid": propertyNotFound = false; result = this.ModuleID.ToString(outputFormat, formatProvider); break; case "moduledefid": isPublic = false; propertyNotFound = false; result = this.ModuleDefID.ToString(outputFormat, formatProvider); break; case "moduleorder": isPublic = false; propertyNotFound = false; result = this.ModuleOrder.ToString(outputFormat, formatProvider); break; case "panename": propertyNotFound = false; result = PropertyAccess.FormatString(this.PaneName, format); break; case "moduletitle": propertyNotFound = false; result = PropertyAccess.FormatString(this.ModuleTitle, format); break; case "cachetime": isPublic = false; propertyNotFound = false; result = this.CacheTime.ToString(outputFormat, formatProvider); break; case "cachemethod": isPublic = false; propertyNotFound = false; result = PropertyAccess.FormatString(this.CacheMethod, format); break; case "alignment": propertyNotFound = false; result = PropertyAccess.FormatString(this.Alignment, format); break; case "color": propertyNotFound = false; result = PropertyAccess.FormatString(this.Color, format); break; case "border": propertyNotFound = false; result = PropertyAccess.FormatString(this.Border, format); break; case "iconfile": propertyNotFound = false; result = PropertyAccess.FormatString(this.IconFile, format); break; case "alltabs": isPublic = false; propertyNotFound = false; result = PropertyAccess.Boolean2LocalizedYesNo(this.AllTabs, formatProvider); break; case "isdeleted": isPublic = false; propertyNotFound = false; result = PropertyAccess.Boolean2LocalizedYesNo(this.IsDeleted, formatProvider); break; case "header": propertyNotFound = false; result = PropertyAccess.FormatString(this.Header, format); break; case "footer": propertyNotFound = false; result = PropertyAccess.FormatString(this.Footer, format); break; case "startdate": isPublic = false; propertyNotFound = false; result = this.StartDate.ToString(outputFormat, formatProvider); break; case "enddate": isPublic = false; propertyNotFound = false; result = this.EndDate.ToString(outputFormat, formatProvider); break; case "containersrc": isPublic = false; propertyNotFound = false; result = PropertyAccess.FormatString(this.ContainerSrc, format); break; case "displaytitle": isPublic = false; propertyNotFound = false; result = PropertyAccess.Boolean2LocalizedYesNo(this.DisplayTitle, formatProvider); break; case "displayprint": isPublic = false; propertyNotFound = false; result = PropertyAccess.Boolean2LocalizedYesNo(this.DisplayPrint, formatProvider); break; case "displaysyndicate": isPublic = false; propertyNotFound = false; result = PropertyAccess.Boolean2LocalizedYesNo(this.DisplaySyndicate, formatProvider); break; case "iswebslice": isPublic = false; propertyNotFound = false; result = PropertyAccess.Boolean2LocalizedYesNo(this.IsWebSlice, formatProvider); break; case "webslicetitle": isPublic = false; propertyNotFound = false; result = PropertyAccess.FormatString(this.WebSliceTitle, format); break; case "websliceexpirydate": isPublic = false; propertyNotFound = false; result = this.WebSliceExpiryDate.ToString(outputFormat, formatProvider); break; case "webslicettl": isPublic = false; propertyNotFound = false; result = this.WebSliceTTL.ToString(outputFormat, formatProvider); break; case "inheritviewpermissions": isPublic = false; propertyNotFound = false; result = PropertyAccess.Boolean2LocalizedYesNo(this.InheritViewPermissions, formatProvider); break; case "isshareable": isPublic = false; propertyNotFound = false; result = PropertyAccess.Boolean2LocalizedYesNo(this.IsShareable, formatProvider); break; case "isshareableviewonly": isPublic = false; propertyNotFound = false; result = PropertyAccess.Boolean2LocalizedYesNo(this.IsShareableViewOnly, formatProvider); break; case "desktopmoduleid": isPublic = false; propertyNotFound = false; result = this.DesktopModuleID.ToString(outputFormat, formatProvider); break; case "friendlyname": propertyNotFound = false; result = PropertyAccess.FormatString(this.DesktopModule.FriendlyName, format); break; case "foldername": propertyNotFound = false; result = PropertyAccess.FormatString(this.DesktopModule.FolderName, format); break; case "description": propertyNotFound = false; result = PropertyAccess.FormatString(this.DesktopModule.Description, format); break; case "version": propertyNotFound = false; result = PropertyAccess.FormatString(this.DesktopModule.Version, format); break; case "ispremium": isPublic = false; propertyNotFound = false; result = PropertyAccess.Boolean2LocalizedYesNo(this.DesktopModule.IsPremium, formatProvider); break; case "isadmin": isPublic = false; propertyNotFound = false; result = PropertyAccess.Boolean2LocalizedYesNo(this.DesktopModule.IsAdmin, formatProvider); break; case "businesscontrollerclass": propertyNotFound = false; result = PropertyAccess.FormatString(this.DesktopModule.BusinessControllerClass, format); break; case "modulename": propertyNotFound = false; result = PropertyAccess.FormatString(this.DesktopModule.ModuleName, format); break; case "supportedfeatures": isPublic = false; propertyNotFound = false; result = this.DesktopModule.SupportedFeatures.ToString(outputFormat, formatProvider); break; case "compatibleversions": isPublic = false; propertyNotFound = false; result = PropertyAccess.FormatString(this.DesktopModule.CompatibleVersions, format); break; case "dependencies": isPublic = false; propertyNotFound = false; result = PropertyAccess.FormatString(this.DesktopModule.Dependencies, format); break; case "permissions": isPublic = false; propertyNotFound = false; result = PropertyAccess.FormatString(this.DesktopModule.Permissions, format); break; case "defaultcachetime": isPublic = false; propertyNotFound = false; result = this.ModuleDefinition.DefaultCacheTime.ToString(outputFormat, formatProvider); break; case "modulecontrolid": isPublic = false; propertyNotFound = false; result = this.ModuleControlId.ToString(outputFormat, formatProvider); break; case "controlsrc": isPublic = false; propertyNotFound = false; result = PropertyAccess.FormatString(this.ModuleControl.ControlSrc, format); break; case "controltitle": propertyNotFound = false; result = PropertyAccess.FormatString(this.ModuleControl.ControlTitle, format); break; case "helpurl": propertyNotFound = false; result = PropertyAccess.FormatString(this.ModuleControl.HelpURL, format); break; case "supportspartialrendering": propertyNotFound = false; result = PropertyAccess.Boolean2LocalizedYesNo(this.ModuleControl.SupportsPartialRendering, formatProvider); break; case "containerpath": isPublic = false; propertyNotFound = false; result = PropertyAccess.FormatString(this.ContainerPath, format); break; case "panemoduleindex": isPublic = false; propertyNotFound = false; result = this.PaneModuleIndex.ToString(outputFormat, formatProvider); break; case "panemodulecount": isPublic = false; propertyNotFound = false; result = this.PaneModuleCount.ToString(outputFormat, formatProvider); break; case "isdefaultmodule": isPublic = false; propertyNotFound = false; result = PropertyAccess.Boolean2LocalizedYesNo(this.IsDefaultModule, formatProvider); break; case "allmodules": isPublic = false; propertyNotFound = false; result = PropertyAccess.Boolean2LocalizedYesNo(this.AllModules, formatProvider); break; case "isportable": isPublic = false; propertyNotFound = false; result = PropertyAccess.Boolean2LocalizedYesNo(this.DesktopModule.IsPortable, formatProvider); break; case "issearchable": isPublic = false; propertyNotFound = false; result = PropertyAccess.Boolean2LocalizedYesNo(this.DesktopModule.IsSearchable, formatProvider); break; case "isupgradeable": isPublic = false; propertyNotFound = false; result = PropertyAccess.Boolean2LocalizedYesNo(this.DesktopModule.IsUpgradeable, formatProvider); break; case "adminpage": isPublic = false; propertyNotFound = false; result = PropertyAccess.FormatString(this.DesktopModule.AdminPage, format); break; case "hostpage": isPublic = false; propertyNotFound = false; result = PropertyAccess.FormatString(this.DesktopModule.HostPage, format); break; } if (!isPublic && currentScope != Scope.Debug) { propertyNotFound = true; result = PropertyAccess.ContentLocked; } return(result); }
/// <summary> /// Initializes a new instance of the <see cref="TokenReplace"/> class. /// creates a new TokenReplace object for custom context. /// </summary> /// <param name="accessLevel">Security level granted by the calling object.</param> /// <param name="language">Locale to be used for formatting etc.</param> /// <param name="portalSettings">PortalSettings to be used.</param> /// <param name="user">user, for which the properties shall be returned.</param> public TokenReplace(Scope accessLevel, string language, PortalSettings portalSettings, UserInfo user) : this(accessLevel, language, portalSettings, user, Null.NullInteger) { }
/// <summary> /// Initializes a new <see cref="Type"/>. /// </summary> /// <param name="definedScope">The <see cref="Scope"/> this type defines associated members in.</param> public Type(Scope definedScope) { DefinedScope = definedScope; }
/// <summary> /// Initializes a new instance of the <see cref="TokenReplace"/> class. /// creates a new TokenReplace object for custom context. /// </summary> /// <param name="accessLevel">Security level granted by the calling object.</param> public TokenReplace(Scope accessLevel) : this(accessLevel, null, null, null, Null.NullInteger) { }
/// <summary> /// Creates a new instance of a user-defined function. /// </summary> /// <param name="prototype"> The next object in the prototype chain. </param> /// <param name="name"> The name of the function. </param> /// <param name="argumentNames"> The names of the arguments. </param> /// <param name="parentScope"> The scope at the point the function is declared. </param> /// <param name="bodyText"> The source code for the function body. </param> /// <param name="generatedMethod"> A delegate which represents the body of the function plus any dependencies. </param> /// <param name="strictMode"> <c>true</c> if the function body is strict mode; <c>false</c> otherwise. </param> /// <remarks> This is used by functions declared in JavaScript code (including getters and setters). </remarks> public UserDefinedFunction(ObjectInstance prototype, string name, IList <string> argumentNames, Scope parentScope, string bodyText, GeneratedMethod generatedMethod, bool strictMode) : base(prototype) { this.ArgumentsText = string.Join(", ", argumentNames); this.ArgumentNames = argumentNames; this.BodyText = bodyText; this.generatedMethod = generatedMethod; this.body = (FunctionDelegate)this.generatedMethod.GeneratedDelegate; this.ParentScope = parentScope; this.StrictMode = strictMode; InitProperties(name, argumentNames.Count); }
public override object Resolve(Scope scope) { Func <T> func = scope.GetInstance <T>; return(func); }
/// <summary> /// Registering an application /// </summary> /// <param name="instance">Instance to connect</param> /// <param name="appName">Name of your application</param> /// <param name="scope">The rights needed by your application</param> /// <param name="website">URL to the homepage of your app</param> /// <returns></returns> public static async Task <AppRegistration> CreateApp(string instance, string appName, Scope scope, string website = null, string redirectUri = null) { var data = new List <KeyValuePair <string, string> >() { new KeyValuePair <string, string>("client_name", appName), new KeyValuePair <string, string>("scopes", GetScopeParam(scope)), }; if (string.IsNullOrEmpty(redirectUri)) { data.Add(new KeyValuePair <string, string>("redirect_uris", "urn:ietf:wg:oauth:2.0:oob")); } else { data.Add(new KeyValuePair <string, string>("redirect_uris", redirectUri)); } if (!string.IsNullOrEmpty(website)) { data.Add(new KeyValuePair <string, string>("website", website)); } string url = $"https://{instance}/api/v1/apps"; var client = new HttpClient(); var content = new FormUrlEncodedContent(data); var response = await client.PostAsync(url, content); var responseJson = await response.Content.ReadAsStringAsync(); var appRegistration = JsonConvert.DeserializeObject <AppRegistration>(responseJson); appRegistration.Instance = instance; appRegistration.Scope = scope; return(appRegistration); }
public static Scope CreateDbCommandScope(Tracer tracer, IDbCommand command) { if (!tracer.Settings.IsIntegrationEnabled(AdoNetConstants.IntegrationId)) { // integration disabled, don't create a scope, skip this trace return(null); } var commandType = command.GetType(); if (tracer.Settings.AdoNetExcludedTypes.Count > 0 && tracer.Settings.AdoNetExcludedTypes.Contains(commandType.FullName)) { // AdoNet type disabled, don't create a scope, skip this trace return(null); } Scope scope = null; try { string dbType = GetDbType(commandType.Namespace, commandType.Name); if (dbType == null) { // don't create a scope, skip this trace return(null); } Span parent = tracer.ActiveScope?.Span; if (parent != null && parent.Type == SpanTypes.Sql && parent.GetTag(Tags.DbType) == dbType && parent.ResourceName == command.CommandText) { // we are already instrumenting this, // don't instrument nested methods that belong to the same stacktrace // e.g. ExecuteReader() -> ExecuteReader(commandBehavior) return(null); } string serviceName = tracer.Settings.GetServiceName(tracer, dbType); string operationName = $"{dbType}.query"; var tags = new SqlTags(); scope = tracer.StartActiveWithTags(operationName, tags: tags, serviceName: serviceName); var span = scope.Span; tags.DbType = dbType; span.AddTagsFromDbCommand(command); tags.SetAnalyticsSampleRate(AdoNetConstants.IntegrationId, tracer.Settings, enabledWithGlobalSetting: false); } catch (Exception ex) { Log.Error(ex, "Error creating or populating scope."); } return(scope); }
internal static IValue Compare(List <IValue> list, Scope scope) { IValue first = list.First(); return(first.MetaType.Compare.Invoke(list, scope).First()); }
/// <summary> /// Creates a new instance of a user-defined function. /// </summary> /// <param name="prototype"> The next object in the prototype chain. </param> /// <param name="name"> The name of the function. </param> /// <param name="argumentNames"> The names of the arguments. </param> /// <param name="parentScope"> The scope at the point the function is declared. </param> /// <param name="bodyText"> The source code for the function body. </param> /// <param name="body"> A delegate which represents the body of the function. </param> /// <param name="strictMode"> <c>true</c> if the function body is strict mode; <c>false</c> otherwise. </param> /// <remarks> This is used by <c>arguments</c>. </remarks> internal UserDefinedFunction(ObjectInstance prototype, string name, IList <string> argumentNames, Scope parentScope, string bodyText, FunctionDelegate body, bool strictMode) : base(prototype) { this.ArgumentsText = string.Join(", ", argumentNames); this.ArgumentNames = argumentNames; this.BodyText = bodyText; this.generatedMethod = new GeneratedMethod(body, null); this.body = body; this.ParentScope = parentScope; this.StrictMode = strictMode; InitProperties(name, argumentNames.Count); }
public static EngineResult Evaluate(IfStatement conditional, Scope scope) => Evaluate(conditional.Predicate, NullArgument.It, scope) ? Evaluate(conditional.ThenStatement, scope) : conditional.ElseStatement != null?Evaluate(conditional.ElseStatement, scope) : null;
/** **************************************************************************************** * Searches value in the actual scope. While not found, moves walk state to next outer * and continues there. * @return The next object found in the current or any next outer scope. ******************************************************************************************/ public T Walk() { while (walking) { switch (actScope) { case Scope.ThreadInner: { // initialize if (walkNextThreadIdx == -2) { walkNextThreadIdx = -1; if (threadInnerStore.Count != 0) { walkThreadValues = null; threadInnerStore.TryGetValue(scopeInfo.GetThread(), out walkThreadValues); if (walkThreadValues != null) { walkNextThreadIdx = walkThreadValues.Count; } } } // return next inner thread object (walkNext keeps being ThreadInner) if (walkNextThreadIdx > 0) { walkNextThreadIdx--; return(walkThreadValues[walkNextThreadIdx]); } // next scope is Method actScope = Scope.Method; // if we have a valid 'local object' return this first if (walkLocalObject != null) { return(walkLocalObject); } } break; case Scope.Path: case Scope.Filename: case Scope.Method: { if (lazyLanguageNode) { getPathMapNode(false); } while (actPathMapNode != null) { T actValue = actPathMapNode.Value; actPathMapNode = actPathMapNode.Parent; if (actValue != null) { return(actValue); } } actScope = Scope.ThreadOuter; walkNextThreadIdx = -2; } break; case Scope.ThreadOuter: { // initialize if (walkNextThreadIdx == -2) { if (threadOuterStore.Count != 0) { walkThreadValues = null; threadOuterStore.TryGetValue(scopeInfo.GetThread(), out walkThreadValues); if (walkThreadValues != null) { walkNextThreadIdx = walkThreadValues.Count; } } } // return next outer thread object (walkNext keeps being ThreadOuter) if (walkNextThreadIdx > 0) { walkNextThreadIdx--; return(walkThreadValues[walkNextThreadIdx]); } // next scope is Global actScope = Scope.Global; } break; case Scope.Global: { walking = false; return(globalStore); } } } return(default(T)); }
public override Operand Eval(Scope scope) => this;
public string GetProperty(string propertyName, string format, System.Globalization.CultureInfo formatProvider, Entities.Users.UserInfo accessingUser, Scope accessLevel, ref bool propertyNotFound) { string OutputFormat = string.Empty; if (format == string.Empty) { OutputFormat = "g"; } else { OutputFormat = format; } propertyName = propertyName.ToLowerInvariant(); switch (propertyName) { case "journalid": return(PropertyAccess.FormatString(JournalId.ToString(), format)); case "journaltypeid": return(PropertyAccess.FormatString(JournalTypeId.ToString(), format)); case "profileid": return(PropertyAccess.FormatString(ProfileId.ToString(), format)); case "socialgroupid": return(PropertyAccess.FormatString(SocialGroupId.ToString(), format)); case "datecreated": return(PropertyAccess.FormatString(DateCreated.ToString(), format)); case "title": return(PropertyAccess.FormatString(Title, format)); case "summary": return(PropertyAccess.FormatString(Summary, format)); case "body": return(PropertyAccess.FormatString(Body, format)); case "timeframe": return(PropertyAccess.FormatString(TimeFrame, format)); case "isdeleted": return(IsDeleted.ToString()); } propertyNotFound = true; return(string.Empty); }
public override object Resolve(Scope scope) { return(new SqlConnection(scope.GetInstance <SqlServerSettings>().ConnectionString)); }
public Factorial() { var ifBlockScope = Scope.CreateAndBuild(new List <IsStatic> { }); var elseBlock = Scope.CreateAndBuild(new List <IsStatic> { }); var inputKey = new NameKey("input"); var input = MemberDefinition.CreateAndBuild(inputKey, new NumberType(), Access.ReadWrite); var facKey = new NameKey("fac"); var fac = MemberDefinition.CreateAndBuild(facKey, MethodType.CreateAndBuild(new NumberType(), new NumberType()), Access.ReadWrite); var methodScope = Scope.CreateAndBuild(new List <IsStatic> { new IsStatic(input, false) }); RootScope = Model.Instantiated.RootScope.CreateAndBuild( Scope.CreateAndBuild( new List <IsStatic> { new IsStatic(MemberDefinition.CreateAndBuild(facKey, MethodType.CreateAndBuild( new NumberType(), new NumberType()), Access.ReadWrite), false) }), new [] { AssignOperation.CreateAndBuild( MethodDefinition.CreateAndBuild( new NumberType(), input, methodScope, new ICodeElement[] { ElseOperation.CreateAndBuild( IfOperation.CreateAndBuild( LessThanOperation.CreateAndBuild( MemberReference.CreateAndBuild(input), ConstantNumber.CreateAndBuild(2)), BlockDefinition.CreateAndBuild( ifBlockScope, new ICodeElement[] { ReturnOperation.CreateAndBuild( ConstantNumber.CreateAndBuild(1)) }, Array.Empty <ICodeElement>())), BlockDefinition.CreateAndBuild( elseBlock, new ICodeElement[] { ReturnOperation.CreateAndBuild( MultiplyOperation.CreateAndBuild( NextCallOperation.CreateAndBuild( SubtractOperation.CreateAndBuild( MemberReference.CreateAndBuild(input), ConstantNumber.CreateAndBuild(1)), MemberReference.CreateAndBuild(fac)), MemberReference.CreateAndBuild(input))) }, Array.Empty <ICodeElement>())) }, Array.Empty <ICodeElement>()), MemberReference.CreateAndBuild(fac) ) }, EntryPointDefinition.CreateAndBuild(new EmptyType(), MemberDefinition.CreateAndBuild(new NameKey("input"), new NumberType(), Access.ReadWrite), Scope.CreateAndBuild(Array.Empty <IsStatic>()), Array.Empty <ICodeElement>(), Array.Empty <ICodeElement>()) ); }
/// <summary> /// Connects the specified scope. /// </summary> internal void Connect(Scope scope) { this.scope = scope; AttachEvents(); }
private static Scope CreateScope(RequestContext requestContext) { var requestMessage = requestContext?.RequestMessage; if (requestMessage == null) { return(null); } var tracer = Tracer.Instance; if (!tracer.Settings.IsIntegrationEnabled(IntegrationName)) { // integration disabled, don't create a scope, skip this trace return(null); } Scope scope = null; try { SpanContext propagatedContext = null; string host = null; string httpMethod = null; if (requestMessage.Properties.TryGetValue("httpRequest", out var httpRequestProperty) && httpRequestProperty is HttpRequestMessageProperty httpRequestMessageProperty) { // we're using an http transport host = httpRequestMessageProperty.Headers[HttpRequestHeader.Host]; httpMethod = httpRequestMessageProperty.Method?.ToUpperInvariant(); // try to extract propagated context values from http headers if (tracer.ActiveScope == null) { try { var headers = httpRequestMessageProperty.Headers.Wrap(); propagatedContext = tracer.Propagator.Extract(headers); } catch (Exception ex) { Log.Error(ex, "Error extracting propagated HTTP headers."); } } } var operationNameSuffix = requestMessage.Headers.Action ?? requestMessage.Headers.To?.LocalPath; var operationName = !string.IsNullOrEmpty(operationNameSuffix) ? "wcf.request " + operationNameSuffix : "wcf.request"; scope = tracer.StartActive(operationName, propagatedContext); var span = scope.Span; span.DecorateWebServerSpan( resourceName: null, httpMethod, host, httpUrl: requestMessage.Headers.To?.AbsoluteUri); // set analytics sample rate if enabled var analyticsSampleRate = tracer.Settings.GetIntegrationAnalyticsSampleRate(IntegrationName, enabledWithGlobalSetting: true); span.SetMetric(Tags.Analytics, analyticsSampleRate); } catch (Exception ex) { Log.Error(ex, "Error creating or populating scope."); } // always returns the scope, even if it's null return(scope); }
protected override IClaimsIdentity GetOutputClaimsIdentity(IClaimsPrincipal principal, RequestSecurityToken request, Scope scope) { if (null == principal) { throw new ArgumentNullException("principal"); } var outputIdentity = new ClaimsIdentity(); var userName = principal.Identity.Name; using (var db = new StsContext()) { var webUser = db.WebUsers.Single(w => w.Username == userName); foreach (var requestClaim in request.Claims) { var value = GetValueForClaimRequest(requestClaim, webUser); if (value != null) { outputIdentity.Claims.Add(new Claim(requestClaim.ClaimType, value)); } } if (outputIdentity.Claims.All(c => c.ClaimType != Security.ClaimTypes.Name)) { outputIdentity.Claims.Add(new Claim(Security.ClaimTypes.Name, webUser.Username)); } if (outputIdentity.Claims.All(c => c.ClaimType != Security.ClaimTypes.Role)) { outputIdentity.Claims.Add(new Claim(Security.ClaimTypes.Role, webUser.Role)); } } return outputIdentity; }
protected override IClaimsIdentity GetOutputClaimsIdentity(IClaimsPrincipal principal, RequestSecurityToken request, Scope scope) { var outputIdentity = new ClaimsIdentity(); if (null == principal) { throw new InvalidRequestException("The caller's principal is null."); } switch (principal.Identity.Name.ToUpperInvariant()) { // In a production environment, all the information that will be added // as claims should be read from the authenticated Windows Principal. // The following lines are hardcoded because windows integrated // authentication is disabled. case "ADATUM\\JOHNDOE": outputIdentity.Claims.AddRange(new List<Claim> { new Claim(System.IdentityModel.Claims.ClaimTypes.Name, "ADATUM\\johndoe"), new Claim(AllOrganizations.ClaimTypes.Group, Adatum.Groups.DomainUsers), new Claim(AllOrganizations.ClaimTypes.Group, Adatum.Groups.MarketingManagers) }); break; } return outputIdentity; }