private static IEnumerable <IEdmModel> BuildAnnotations(IEdmModel model) { IEdmEntityContainer edmEntityContainer = ExtensionMethods.EntityContainers(model).SingleOrDefault((IEdmEntityContainer ec) => ec.Name == "TenantReportingWebService"); EdmModel edmModel = new EdmModel(); edmModel.AddReferencedModel(model); ReportingSchema reportingSchema = ReportingService.GetReportingSchema(); foreach (IEntity entity in reportingSchema.Entities.Values) { IEdmEntitySet edmEntitySet = edmEntityContainer.FindEntitySet(entity.Name); if (edmEntitySet != null) { ReportingService.AddAnnotation(edmModel, edmEntitySet, "ReportTitle", entity.Annotation.ReportTitle); if (entity.Annotation.Xaxis != null) { string value = string.Join(",", entity.Annotation.Xaxis); if (!string.IsNullOrEmpty(value)) { ReportingService.AddAnnotation(edmModel, edmEntitySet, "X-Axis", value); } } ReportingService.AddAnnotation(edmModel, edmEntitySet, "Y-Axis", string.Join(",", entity.Annotation.Yaxis)); } } return(new IEdmModel[] { edmModel }); }
private Dictionary <string, ReportingSchema.ReportPropertyCmdletParamMapping[]> LoadRbacMapping(SafeXmlDocument doc) { Dictionary <string, ReportingSchema.ReportPropertyCmdletParamMapping[]> result; using (XmlNodeList xmlNodeList = doc.SelectNodes("/Configuration/CmdletParameterMappings/CmdletParameterMapping")) { Dictionary <string, ReportingSchema.ReportPropertyCmdletParamMapping[]> dictionary = new Dictionary <string, ReportingSchema.ReportPropertyCmdletParamMapping[]>(xmlNodeList.Count); foreach (object obj in xmlNodeList) { XmlNode xmlNode = (XmlNode)obj; using (XmlNodeList xmlNodeList2 = xmlNode.SelectNodes("Cmdlet")) { using (XmlNodeList xmlNodeList3 = xmlNode.SelectNodes("Mappings/Mapping")) { ReportingSchema.CheckCondition(xmlNodeList2.Count == 1, "There must be one and only one Cmdlet node under Rbac node."); string key = xmlNodeList2[0].Attributes["Name"].Value.Trim(); ReportingSchema.CheckCondition(!dictionary.ContainsKey(key), "There shouldn't be duplicate Cmdlet under Rbac node."); ReportingSchema.CheckCondition(xmlNodeList3.Count > 0, "The mapping shouldn't be empty."); ReportingSchema.ReportPropertyCmdletParamMapping[] array = new ReportingSchema.ReportPropertyCmdletParamMapping[xmlNodeList3.Count]; int num = 0; foreach (object obj2 in xmlNodeList3) { XmlNode xmlNode2 = (XmlNode)obj2; array[num++] = new ReportingSchema.ReportPropertyCmdletParamMapping(xmlNode2.Attributes["CmdletParameter"].Value.Trim(), xmlNode2.Attributes["ReportObjectProperty"].Value.Trim()); } dictionary.Add(key, array); } } } result = dictionary; } return(result); }
private static ReportingSchema GetReportingSchema() { HttpContext httpContext = HttpContext.Current; string currentReportingVersion = ReportingVersion.GetCurrentReportingVersion(httpContext); return(ReportingSchema.GetReportingSchema(currentReportingVersion)); }
private void LoadEntityNodes(SafeXmlDocument doc, Dictionary <string, ReportingSchema.ReportPropertyCmdletParamMapping[]> reportPropertyCmdletParamMapping) { using (XmlNodeList xmlNodeList = doc.SelectNodes("/Configuration/Reports/Report")) { HashSet <string> hashSet = new HashSet <string>(StringComparer.InvariantCultureIgnoreCase); foreach (object obj in xmlNodeList) { XmlNode xmlNode = (XmlNode)obj; ReportingSchema.CheckCondition(!string.IsNullOrWhiteSpace(xmlNode.Attributes["Name"].Value) && !string.IsNullOrWhiteSpace(xmlNode.Attributes["Snapin"].Value) && !string.IsNullOrWhiteSpace(xmlNode.Attributes["Cmdlet"].Value), string.Format("Attributes {0}, {1}, {2} of entity should not be empty.", "Name", "Cmdlet", "Snapin")); hashSet.Add(xmlNode.Attributes["Snapin"].Value.Trim()); } using (IPSCommandResolver ipscommandResolver = DependencyFactory.CreatePSCommandResolver(hashSet)) { foreach (object obj2 in xmlNodeList) { XmlNode xmlNode2 = (XmlNode)obj2; string text = xmlNode2.Attributes["Name"].Value.Trim(); string text2 = xmlNode2.Attributes["Cmdlet"].Value.Trim(); string snapinName = xmlNode2.Attributes["Snapin"].Value.Trim(); ReportingSchema.CheckCondition(!this.entities.ContainsKey(text), "Duplicate entity in the config file"); Dictionary <string, string> dictionary = null; using (XmlNodeList xmlNodeList2 = xmlNode2.SelectNodes("CmdletParameters/CmdletParameter")) { if (xmlNodeList2.Count > 0) { dictionary = new Dictionary <string, string>(xmlNodeList2.Count); foreach (object obj3 in xmlNodeList2) { XmlNode xmlNode3 = (XmlNode)obj3; ReportingSchema.CheckCondition(!string.IsNullOrWhiteSpace(xmlNode3.Attributes["Name"].Value) && !string.IsNullOrWhiteSpace(xmlNode3.Attributes["Value"].Value), "cmdlet parameter name and value should not be empty."); string key = xmlNode3.Attributes["Name"].Value.Trim(); string value = xmlNode3.Attributes["Value"].Value.Trim(); dictionary.Add(key, value); } } } Dictionary <string, List <string> > dictionary2 = null; if (reportPropertyCmdletParamMapping.ContainsKey(text2)) { dictionary2 = new Dictionary <string, List <string> >(reportPropertyCmdletParamMapping[text2].Length); foreach (ReportingSchema.ReportPropertyCmdletParamMapping reportPropertyCmdletParamMapping2 in reportPropertyCmdletParamMapping[text2]) { if (!dictionary2.ContainsKey(reportPropertyCmdletParamMapping2.ReportObjectProperty)) { dictionary2.Add(reportPropertyCmdletParamMapping2.ReportObjectProperty, new List <string>()); } dictionary2[reportPropertyCmdletParamMapping2.ReportObjectProperty].Add(reportPropertyCmdletParamMapping2.CmdletParameter); } } XmlNode annotationNode = ReportingSchema.SelectSingleNode(xmlNode2, "Annotation"); IReportAnnotation annotation = DependencyFactory.CreateReportAnnotation(annotationNode); IEntity entity = DependencyFactory.CreateEntity(text, new TaskInvocationInfo(text2, snapinName, dictionary), dictionary2, annotation); entity.Initialize(ipscommandResolver); this.entities.Add(text, entity); } } } }
private IDataServiceQueryProvider GetQueryProvider(IDataServiceMetadataProvider metadata) { if (this.queryProvider == null) { ReportingSchema reportingSchema = ReportingService.GetReportingSchema(); this.queryProvider = new ReportingQueryProvider(metadata, reportingSchema); } return(this.queryProvider); }
public static IReportAnnotation Load(XmlNode annotationNode) { ReportAnnotation reportAnnotation = new ReportAnnotation(); reportAnnotation.reportTitle = ReportAnnotation.GetStringInfo(ReportingSchema.SelectSingleNode(annotationNode, "ReportTitle")); ReportingSchema.CheckCondition(reportAnnotation.reportTitle != null && !string.IsNullOrEmpty(reportAnnotation.reportTitle.StringId), "Report title isn't present."); reportAnnotation.xaxises = ReportAnnotation.LoadSeries(annotationNode, "XAxis"); reportAnnotation.yaxises = ReportAnnotation.LoadSeries(annotationNode, "YAxis"); ReportingSchema.CheckCondition(reportAnnotation.yaxises != null && reportAnnotation.yaxises.Count > 0, "Report Y-Axis doesn't present."); return(reportAnnotation); }
public static ReportingSchema GetCurrentReportingSchema(HttpContext httpContext) { ReportingSchema schema = null; ElapsedTimeWatcher.Watch(RequestStatistics.RequestStatItem.GetReportingSchemaLatency, delegate { string currentReportingVersion = ReportingVersion.GetCurrentReportingVersion(httpContext); schema = ReportingSchema.GetReportingSchema(currentReportingVersion); }); return(schema); }
public static XmlNode SelectSingleNode(XmlNode node, string xpath) { XmlNode result; using (XmlNodeList xmlNodeList = node.SelectNodes(xpath)) { ReportingSchema.CheckCondition(xmlNodeList.Count == 1, string.Format("expect only one {0}.", xpath)); result = xmlNodeList[0]; } return(result); }
private IDataServiceMetadataProvider GetMetadataProvider() { this.metadataProvider = (ReportingMetadataProvider)HttpRuntime.Cache[this.GetCacheKey()]; if (this.metadataProvider != null) { return(this.metadataProvider); } ReportingSchema reportingSchema = ReportingService.GetReportingSchema(); this.metadataProvider = new ReportingMetadataProvider(reportingSchema); HttpRuntime.Cache.Insert(this.GetCacheKey(), this.metadataProvider, null, (DateTime)ExDateTime.UtcNow.Add(ReportingService.MetadataProviderCacheMaxAge), Cache.NoSlidingExpiration, CacheItemPriority.High, null); return(this.metadataProvider); }
private ResourceType GenerateComplexTypeSchema(Type clrType, ResourceTypeKind resourceTypeKind) { if (this.complexTypeResourceTypes.ContainsKey(clrType.FullName)) { return(this.complexTypeResourceTypes[clrType.FullName]); } ResourceType resourceType = new ResourceType(clrType, resourceTypeKind, null, "TenantReporting", clrType.Name, false); foreach (PropertyInfo propertyInfo in clrType.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy)) { Type type = propertyInfo.PropertyType; Type type2; if (ReportingSchema.IsNullableType(type, out type2)) { type = type2; } ResourcePropertyKind resourcePropertyKind = 1; ResourceType resourceType2 = ResourceType.GetPrimitiveResourceType(type); if (resourceType2 == null) { if (type.IsEnum || type.IsValueType) { throw new NotSupportedException("struct and enum are not supported. For struct, try to change it to class. For enum, try to change it to integer or string."); } if (type.Equals(clrType)) { resourceType2 = resourceType; } else { resourceType2 = this.GenerateComplexTypeSchema(type, 1); } resourcePropertyKind = 4; } resourceType.AddProperty(new ResourceProperty(propertyInfo.Name, resourcePropertyKind, resourceType2)); } if (resourceTypeKind == 1) { this.complexTypeResourceTypes.Add(clrType.FullName, resourceType); } return(resourceType); }
public static ReportingSchema GetReportingSchema(string version) { ReportingSchema schema = null; ElapsedTimeWatcher.Watch(RequestStatistics.RequestStatItem.GetReportingSchemaLatency, delegate { if (!ReportingSchema.SchemaDictionary.TryGetValue(version, out schema)) { lock (ReportingSchema.SyncRoot) { if (!ReportingSchema.SchemaDictionary.TryGetValue(version, out schema)) { schema = new ReportingSchema(version); ReportingSchema.SchemaDictionary[version] = schema; } } } }); return(schema); }
private void BuildResourceType(IEntity entity, ResourceType resourceType, Dictionary <string, ResourceType> complexTypeResourceTypes) { if (ResourceType.GetPrimitiveResourceType(entity.ClrType) == null) { foreach (PropertyInfo propertyInfo in entity.ClrType.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy)) { if (entity.ReportPropertyCmdletParamsMap == null || !entity.ReportPropertyCmdletParamsMap.ContainsKey(propertyInfo.Name) || this.IsEntityPropertyVisibleForCurrentUser(entity, propertyInfo.Name)) { Type type = propertyInfo.PropertyType; Type type2; if (ReportingSchema.IsNullableType(type, out type2)) { type = type2; } ResourcePropertyKind resourcePropertyKind = 1; ResourceType resourceType2 = ResourceType.GetPrimitiveResourceType(type); if (resourceType2 == null) { if (type.IsEnum || type.IsValueType) { throw new NotSupportedException("struct and enum are not supported. For struct, try to change it to class. For enum, try to change it to integer or string."); } if (type.Equals(entity.ClrType)) { resourceType2 = resourceType; } else { resourceType2 = complexTypeResourceTypes[type.FullName]; } resourcePropertyKind = 4; } resourceType.AddProperty(new ResourceProperty(propertyInfo.Name, resourcePropertyKind | (entity.KeyMembers.Contains(propertyInfo.Name) ? 2 : 0), resourceType2)); } } } resourceType.SetReadOnly(); }
public ReportingQueryProvider(IDataServiceMetadataProvider metadataProvider, ReportingSchema schema) { this.metadataProvider = metadataProvider; this.schema = schema; this.dataSource = DependencyFactory.CreateReportingDataSource(RbacPrincipal.Current); }
private RbacPrincipal CreateRbacPrincipal(IIdentity identity, string tenantDomain, string cacheKey, HttpContext httpContext) { ExTraceGlobals.ReportingWebServiceTracer.TraceDebug <string, string, string>((long)this.GetHashCode(), "[RbacPrincipalManager::CreateRbacPrincipal] Create RbacPrincipal. Identity: {0}; tenantDomain: {1}; cacheKey: '{2}'", identity.GetSafeName(true), tenantDomain ?? string.Empty, cacheKey); ExchangeRunspaceConfigurationSettings rbacSettings = null; ElapsedTimeWatcher.Watch(RequestStatistics.RequestStatItem.NewExchangeRunspaceConfigurationSettingsLatency, delegate { rbacSettings = new ExchangeRunspaceConfigurationSettings(ExchangeRunspaceConfigurationSettings.ExchangeApplication.ReportingWebService, tenantDomain, ExchangeRunspaceConfigurationSettings.SerializationLevel.None); }); ReportingSchema schema = ReportingSchema.GetCurrentReportingSchema(httpContext); try { RequestStatistics requestStatistics = HttpContext.Current.Items[RequestStatistics.RequestStatsKey] as RequestStatistics; if (requestStatistics != null) { requestStatistics.AddExtendedStatisticsDataPoint("AuthType", identity.AuthenticationType); } using (new AverageTimePerfCounter(RwsPerfCounters.AverageRbacPrincipalCreation, RwsPerfCounters.AverageRbacPrincipalCreationBase, true)) { RwsExchangeRunspaceConfiguration rbacConfiguration = null; ElapsedTimeWatcher.Watch(RequestStatistics.RequestStatItem.NewRwsExchangeRunspaceConfigurationLatency, delegate { rbacConfiguration = RwsExchangeRunspaceConfiguration.NewInstance(identity, rbacSettings, schema.CmdletFilter, this.GetSnapinSet()); }); RbacPrincipal rbacPrincipal = null; ElapsedTimeWatcher.Watch(RequestStatistics.RequestStatItem.NewRbacPrincipalLatency, delegate { rbacPrincipal = new RbacPrincipal(rbacConfiguration, cacheKey); }); return(rbacPrincipal); } } catch (CmdletAccessDeniedException ex) { HttpRuntime.Cache.Remove(cacheKey); ExTraceGlobals.ReportingWebServiceTracer.TraceError <CmdletAccessDeniedException>((long)this.GetHashCode(), "[RbacPrincipalManager::CreateRbacPrincipal] CmdletAccessDeniedException: {0}", ex); ServiceDiagnostics.ThrowError(ReportingErrorCode.ErrorTenantNotInOrgScope, Strings.ErrorTenantNotInOrgScope(tenantDomain), ex); } catch (CannotResolveTenantNameException ex2) { HttpRuntime.Cache.Remove(cacheKey); ExTraceGlobals.ReportingWebServiceTracer.TraceError <CannotResolveTenantNameException>((long)this.GetHashCode(), "[RbacPrincipalManager::CreateRbacPrincipal] CannotResolveTenantNameException: {0}", ex2); ServiceDiagnostics.ThrowError(ReportingErrorCode.ErrorTenantNotResolved, Strings.ErrorTenantNotResolved(tenantDomain), ex2); } catch (ADTransientException ex3) { HttpRuntime.Cache.Remove(cacheKey); ExTraceGlobals.ReportingWebServiceTracer.TraceError <ADTransientException>((long)this.GetHashCode(), "[RbacPrincipalManager::CreateRbacPrincipal] ADTransientException: {0}", ex3); ServiceDiagnostics.ThrowError(ReportingErrorCode.ADTransientError, Strings.ADTransientError, ex3); } catch (DataSourceOperationException ex4) { HttpRuntime.Cache.Remove(cacheKey); ExTraceGlobals.ReportingWebServiceTracer.TraceError <DataSourceOperationException>((long)this.GetHashCode(), "[RbacPrincipalManager::CreateRbacPrincipal] DataSourceOperationException: {0}", ex4); ServiceDiagnostics.ThrowError(ReportingErrorCode.ADOperationError, Strings.ADOperationError, ex4); } catch (TimeoutException ex5) { HttpRuntime.Cache.Remove(cacheKey); ExTraceGlobals.ReportingWebServiceTracer.TraceError <TimeoutException>((long)this.GetHashCode(), "[RbacPrincipalManager::CreateRbacPrincipal] TimeoutException: {0}", ex5); ServiceDiagnostics.ThrowError(ReportingErrorCode.CreateRunspaceConfigTimeoutError, Strings.CreateRunspaceConfigTimeoutError, ex5); } catch (Exception ex6) { HttpRuntime.Cache.Remove(cacheKey); ExTraceGlobals.ReportingWebServiceTracer.TraceError <Exception>((long)this.GetHashCode(), "[RbacPrincipalManager::CreateRbacPrincipal] Exception: {0}", ex6); ServiceDiagnostics.ThrowError(ReportingErrorCode.UnknownError, Strings.UnknownError, ex6); } return(null); }
public ReportingMetadataProvider(ReportingSchema schema) { this.metadata = new Metadata(RbacPrincipal.Current, schema.Entities.Values, schema.ComplexTypeResourceTypes); }