/// <summary> /// Create a device entity /// </summary> public AmiCollection GetDeviceEntities(Expression <Func <DeviceEntity, bool> > expression) { return(this.Client.Get <AmiCollection>("DeviceEntity", QueryExpressionBuilder.BuildQuery(expression).ToArray())); }
/// <summary> /// Retrieves a specified user. /// </summary> /// <param name="query">The query expression to use to find the user.</param> /// <returns>Returns a collection of users which match the specified query parameters.</returns> public AmiCollection GetUsers(Expression <Func <SecurityUser, bool> > query) { return(this.Client.Get <AmiCollection>("SecurityUser", QueryExpressionBuilder.BuildQuery(query).ToArray())); }
/// <summary> /// Retrieves an audit /// </summary> /// <param name="expression">The query to filter audits on</param> public AuditData GetAudits(Expression <Func <AuditData, bool> > expression) { return(this.Client.Get <AuditData>($"Audit", QueryExpressionBuilder.BuildQuery(expression).ToArray())); }
/// <summary> /// Gets the code systems. /// </summary> /// <param name="query">The query.</param> /// <returns>Returns a list of code systems.</returns> public AmiCollection GetCodeSystems(Expression <Func <CodeSystem, bool> > query) { return(this.Client.Get <AmiCollection>("CodeSystem", QueryExpressionBuilder.BuildQuery(query).ToArray())); }
/// <summary> /// Gets the extension types. /// </summary> /// <param name="expression">The expression.</param> /// <returns>Returns a list of extension types.</returns> public AmiCollection GetExtensionTypes(Expression <Func <ExtensionType, bool> > expression) { return(this.Client.Get <AmiCollection>("ExtensionType", QueryExpressionBuilder.BuildQuery(expression).ToArray())); }
/// <summary> /// Create a query /// </summary> public SqlStatement CreateQuery <TModel>(Expression <Func <TModel, bool> > predicate) { var nvc = QueryExpressionBuilder.BuildQuery(predicate, true); return(CreateQuery <TModel>(nvc)); }
/// <summary> /// Gets a list of alerts. /// </summary> /// <param name="query">The query expression to use to find the alerts.</param> /// <returns>Returns a collection of alerts which match the specified criteria.</returns> public AmiCollection <AlertMessageInfo> GetAlerts(Expression <Func <AlertMessage, bool> > query) { return(this.Client.Get <AmiCollection <AlertMessageInfo> >("alert", QueryExpressionBuilder.BuildQuery(query).ToArray())); }
/// <summary> /// Retrieves the specified role from the AMI /// </summary> public AmiCollection FindRole(Expression <Func <SecurityRole, bool> > query) { return(this.Client.Get <AmiCollection>("SecurityRole", QueryExpressionBuilder.BuildQuery(query).ToArray())); }
/// <summary> /// Gets a list of alerts. /// </summary> /// <param name="query">The query expression to use to find the alerts.</param> /// <returns>Returns a collection of alerts which match the specified criteria.</returns> public AmiCollection GetMailMessages(Expression <Func <MailMessage, bool> > query) { return(this.Client.Get <AmiCollection>("MailMessage", QueryExpressionBuilder.BuildQuery(query).ToArray())); }
/// <summary> /// Find the specified audits with the specified query /// </summary> public IEnumerable <AuditData> Find(Expression <Func <AuditData, bool> > query, int offset, int?count, out int totalResults, params ModelSort <AuditData>[] orderBy) { // Convert query to easier format and map common parameters var inQuery = QueryExpressionBuilder.BuildQuery(query); var outQuery = new NameValueCollection(); var termService = ApplicationServiceContext.Current.GetService <IAuditTermLookupService>(); // Map query foreach (var kv in inQuery) { object valueList = kv.Value; if (!(valueList is IList)) { valueList = new List <Object>() { valueList } } ; // Iterate and add values foreach (var val in (valueList as IList).OfType <String>()) { switch (kv.Key) { case "action": { var code = new CodeValue <AtnaApi.Model.ActionType>( (AtnaApi.Model.ActionType)Enum.Parse(typeof(AtnaApi.Model.ActionType), val) ); outQuery.Add("action", termService.GetKey(code.Code, code.CodeSystem, "ActionType").ToString()); } break; case "correlationId": outQuery.Add("correlationToken", val); break; case "event": { var code = new CodeValue <AtnaApi.Model.EventIdentifierType>( (AtnaApi.Model.EventIdentifierType)Enum.Parse(typeof(AtnaApi.Model.EventIdentifierType), val) ); outQuery.Add("eventId", termService.GetKey(code.Code, code.CodeSystem, "EventIdentifierType").ToString()); break; } case "type.code": outQuery.Add("eventType.mnemonic", val); break; case "type.codeSystem": outQuery.Add("eventType.domain", val); break; case "outcome": { var code = new CodeValue <AtnaApi.Model.OutcomeIndicator>( (AtnaApi.Model.OutcomeIndicator)Enum.Parse(typeof(AtnaApi.Model.OutcomeIndicator), val) ); outQuery.Add("outcome", termService.GetKey(code.Code, code.CodeSystem, "OutcomeIndicator").ToString()); break; } case "timestamp": outQuery.Add("eventTime", val); break; default: throw new InvalidOperationException($"Cannot map {kv.Key} as this property is unkown in SanteGuard"); } } } var newQuery = QueryExpressionParser.BuildLinqExpression <Audit>(outQuery); return(ApplicationServiceContext.Current.GetService <IRepositoryService <Audit> >().Find(newQuery, offset, count, out totalResults) .Select(o => o.ToAuditData())); }
/// <summary> /// Subscription is executing /// </summary> private void AdtPatientPassthroughInterceptor_Executing(object sender, QueryRequestEventArgs <IdentifiedData> e) { e.Cancel = true; // Now we want to load the subscription var subscriptionDefinitionQuery = QueryExpressionParser.BuildLinqExpression <SubscriptionDefinition>(new NameValueCollection(QueryExpressionBuilder.BuildQuery(e.Query).ToArray())); var subscriptionDefinition = ApplicationServiceContext.Current.GetService <IRepositoryService <SubscriptionDefinition> >().Find(subscriptionDefinitionQuery, 0, 1, out int tr, null).FirstOrDefault(); // Get the HL7 definition var hl7Def = subscriptionDefinition.ServerDefinitions.FirstOrDefault(o => o.InvariantName == "hl7"); if (hl7Def == null) { throw new InvalidOperationException("Subscription does not contian a definition for 'hl7' query"); } // Get the parameters from the rest operation context NameValueCollection filter = e.QueryTag, subscription = NameValueCollection.ParseQueryString(hl7Def.Definition), queryFilter = new NameValueCollection(); foreach (var itm in subscription) { queryFilter.Add(itm.Key, itm.Value.Select(o => { if (o.StartsWith("$") && o.EndsWith("$")) { return(filter["_" + o.Substring(1, o.Length - 2)][0]); } else { return(o); } }).ToList()); } // Original has modified on? if (filter.ContainsKey("modifiedOn")) { queryFilter.Add("modifiedOn", filter["modifiedOn"]); } e.Results = this.SendQuery(queryFilter, e.Count ?? 25, out tr); e.TotalResults = tr; }
/// <summary> /// Retrieves a specified role. /// </summary> /// <param name="query">The query expression to use to find the role.</param> /// <returns>Returns a collection of roles which match the specified query parameters.</returns> public AmiCollection <SecurityRoleInfo> GetRoles(Expression <Func <SecurityRole, bool> > query) { return(this.Client.Get <AmiCollection <SecurityRoleInfo> >("role", QueryExpressionBuilder.BuildQuery(query).ToArray())); }
/// <summary> /// Retrieves a specified policy. /// </summary> /// <param name="query">The query expression to use to find the policy.</param> /// <returns>Returns a collection of policies which match the specified query parameters.</returns> public AmiCollection <SecurityPolicyInfo> GetPolicies(Expression <Func <SecurityPolicy, bool> > query) { return(this.Client.Get <AmiCollection <SecurityPolicyInfo> >("policy", QueryExpressionBuilder.BuildQuery(query).ToArray())); }
/// <summary> /// Gets a list applications for a specific query. /// </summary> /// <returns>Returns a list of application which match the specific query.</returns> public AmiCollection <SecurityApplicationInfo> GetApplications(Expression <Func <SecurityApplicationInfo, bool> > query) { return(this.Client.Get <AmiCollection <SecurityApplicationInfo> >("application", QueryExpressionBuilder.BuildQuery(query).ToArray())); }
/// <summary> /// Register subscription /// </summary> public PubSubSubscriptionDefinition RegisterSubscription <TModel>(string name, string description, PubSubEventType events, Expression <Func <TModel, bool> > filter, Guid channelId, string supportAddress = null, DateTimeOffset?notBefore = null, DateTimeOffset?notAfter = null) { var filterHdsi = QueryExpressionBuilder.BuildQuery(filter); return(this.RegisterSubscription(typeof(TModel), name, description, events, new NameValueCollection(filterHdsi.ToArray()).ToString(), channelId, supportAddress, notBefore, notAfter)); }
/// <summary> /// Gets a list of assigning authorities. /// </summary> /// <param name="query">The query expression to use to find the assigning authorities.</param> /// <returns>Returns a collection of assigning authorities which match the specified criteria.</returns> public AmiCollection GetAssigningAuthorities(Expression <Func <AssigningAuthority, bool> > query) { return(this.Client.Get <AmiCollection>("AssigningAuthority", QueryExpressionBuilder.BuildQuery(query).ToArray())); }
/// <summary> /// Query function returning results and count control /// </summary> private IEnumerable <TData> Query(System.Linq.Expressions.Expression <Func <TData, bool> > query, int offset, int?count, out int totalResults, Guid queryId, bool countResults, bool fastQuery, IEnumerable <String> expandProperties = null) { if (query == null) { throw new ArgumentNullException(nameof(query)); } DataQueryPreEventArgs <TData> preArgs = new DataQueryPreEventArgs <TData>(query, offset, count); this.Querying?.Invoke(this, preArgs); if (preArgs.Cancel) { this.m_tracer.TraceWarning("Pre-Event handler indicates abort query {0}", query); totalResults = preArgs.TotalResults; return(preArgs.Results); } #if PERFMON Stopwatch sw = new Stopwatch(); sw.Start(); #endif // Query object using (var context = this.CreateReadonlyConnection()) try { IEnumerable <TData> results = null; using (context.LockConnection()) { this.m_tracer.TraceVerbose("QUERY {0}", query); if (fastQuery) { context.DelayLoadMode = LoadState.PartialLoad; } else { context.DelayLoadMode = LoadState.FullLoad; } if (expandProperties != null) { context.LoadAssociations = expandProperties.ToArray(); } results = this.Query(context, query, offset, count ?? -1, out totalResults, queryId, countResults); } var postData = new DataQueryResultEventArgs <TData>(query, results, offset, count, totalResults); this.Queried?.Invoke(this, postData); totalResults = postData.TotalResults; // Remove from the cache foreach (var itm in context.CacheOnCommit.AsParallel()) { ApplicationContext.Current.GetService <IDataCachingService>()?.Add(itm); } return(postData.Results); } catch (NotSupportedException e) { this.m_tracer.TraceVerbose("Cannot perform LINQ query, switching to stored query sqp_{0}", typeof(TData).Name, e); // Build dictionary var httpValues = QueryExpressionBuilder.BuildQuery <TData>(query, true); var filter = new Dictionary <String, Object>(); foreach (var f in httpValues) { object existing = null; if (filter.TryGetValue(f.Key, out existing)) { if (!(existing is IList)) { existing = new List <Object>() { existing }; filter[f.Key] = existing; } (existing as IList).Add(f.Value); } else { filter.Add(f.Key, f.Value); } } // Query return(this.Query(String.Format("sqp_{0}", typeof(TData).Name), filter, offset, count, out totalResults, queryId)); } catch (Exception e) { this.m_tracer.TraceError("Error : {0}", e); throw; } #if PERFMON finally { sw.Stop(); ApplicationContext.Current.PerformanceLog(typeof(TData).Name, nameof(Query), query.ToString(), sw.Elapsed); } #endif }
/// <summary> /// Gets a list of certificate signing requests. /// </summary> /// <param name="query">The query expression to use to find the certificate signing requests.</param> /// <returns>Returns a collection of certificate signing requests which match the specified query.</returns> public AmiCollection GetCertificateSigningRequests(Expression <Func <SubmissionInfo, bool> > query) { return(this.Client.Get <AmiCollection>("Csr", QueryExpressionBuilder.BuildQuery(query).ToArray())); }
/// <summary> /// Create a query /// </summary> public SqlStatement CreateQuery <TModel>(Expression <Func <TModel, bool> > predicate, params ColumnMapping[] selector) { var nvc = QueryExpressionBuilder.BuildQuery(predicate, true); return(CreateQuery <TModel>(nvc, selector)); }
/// <summary> /// Query the server endpoint for BIS metadata /// </summary> public IEnumerable <TBisDefinition> Query <TBisDefinition>(Expression <Func <TBisDefinition, bool> > filter, int offset, int?count) where TBisDefinition : BiDefinition { try { var rootAtt = typeof(TBisDefinition).GetTypeInfo().GetCustomAttribute <XmlRootAttribute>(); using (var client = this.GetRestClient()) return(client.Get <BiDefinitionCollection>($"{rootAtt.ElementName}", QueryExpressionBuilder.BuildQuery(filter).ToArray())?.Items.OfType <TBisDefinition>().ToList()); } catch (Exception e) { this.m_tracer.TraceError("Error querying BIS definition with query {0}: {1}", filter, e); throw new Exception($"Error executing BIS query {filter}", e); } }