/// <summary> /// Determines whether the network is available. /// </summary> /// <returns>Returns true if the network is available.</returns> public bool IsAvailable() { try { //var restClient = ApplicationContext.Current.GetRestClient("imsi"); var networkInformationService = ApplicationContext.Current.GetService <INetworkInformationService>(); if (networkInformationService.IsNetworkAvailable) { ImsiServiceClient client = this.GetServiceClient(); //new ImsiServiceClient(restClient); client.Client.Credentials = new NullCredentials(); client.Client.Description.Endpoint[0].Timeout = 10000; return(this.IsValidVersion(client) && client.Ping()); } else { return(false); } } catch (Exception e) { this.m_tracer.TraceError($"Unable to determine network state: {e}"); return(false); } }
/// <summary> /// Gets a specified model. /// </summary> /// <typeparam name="TModel">The type of model data to retrieve.</typeparam> /// <param name="key">The key of the model.</param> /// <param name="versionKey">The version key of the model.</param> /// <param name="options">The integrations query options.</param> /// <returns>Returns a model.</returns> public TModel Get <TModel>(Guid key, Guid?versionKey, IntegrationQueryOptions options = null) where TModel : IdentifiedData { try { ImsiServiceClient client = this.GetServiceClient(); //new ImsiServiceClient(ApplicationContext.Current.GetRestClient("imsi")); client.Client.Requesting += IntegrationQueryOptions.CreateRequestingHandler(options); client.Client.Responding += (o, e) => this.Responding?.Invoke(o, e); client.Client.Credentials = this.GetCredentials(client.Client); if (client.Client.Credentials == null) { return(null); } this.m_tracer.TraceVerbose("Performing IMSI GET ({0}):{1}v{2}", typeof(TModel).FullName, key, versionKey); var retVal = client.Get <TModel>(key, versionKey); if (retVal is Bundle) { (retVal as Bundle)?.Reconstitute(); return((retVal as Bundle).Entry as TModel); } else { return(retVal as TModel); } } catch (TargetInvocationException e) { throw Activator.CreateInstance(e.InnerException.GetType(), "Error performing action", e) as Exception; } }
/// <summary> /// Converts an <see cref="EditConceptModel"/> instance to a <see cref="Concept"/> instance. /// </summary> /// <param name="imsiServiceClient">The ImsiServiceClient instance.</param> /// <param name="concept">The concept.</param> /// <returns>Returns the converted concept instance.</returns> public Concept ToEditConceptModel(ImsiServiceClient imsiServiceClient, Concept concept) { concept.CreationTime = DateTimeOffset.Now; concept.VersionKey = null; if (!string.Equals(this.ConceptClass, concept.ClassKey.ToString())) { concept.Class = new ConceptClass { Key = Guid.Parse(this.ConceptClass) }; } concept.Mnemonic = this.Mnemonic; if (string.IsNullOrWhiteSpace(AddReferenceTerm) || string.IsNullOrWhiteSpace(RelationshipType)) { return(concept); } Guid id, relationshipKey; if (Guid.TryParse(AddReferenceTerm, out id) && Guid.TryParse(RelationshipType, out relationshipKey)) { var term = imsiServiceClient.Get <ReferenceTerm>(id, null) as ReferenceTerm; if (term != null) { concept.ReferenceTerms.Add(new ConceptReferenceTerm(term.Key, relationshipKey)); } } return(concept); }
/// <summary> /// Finds the specified model /// </summary> public Bundle Find <TModel>(Expression <Func <TModel, bool> > predicate, int offset, int?count, IntegrationQueryOptions options = null) where TModel : IdentifiedData { try { ImsiServiceClient client = this.GetServiceClient(); client.Client.Requesting += IntegrationQueryOptions.CreateRequestingHandler(options); client.Client.Responding += (o, e) => this.Responding?.Invoke(o, e); client.Client.Credentials = this.GetCredentials(client.Client); if (client.Client.Credentials == null) { return(null); } if (options?.Timeout.HasValue == true) { client.Client.Description.Endpoint[0].Timeout = options.Timeout.Value; } this.m_tracer.TraceVerbose("Performing IMSI query ({0}):{1}", typeof(TModel).FullName, predicate); var retVal = client.Query <TModel>(predicate, offset, count, queryId: options?.QueryId); //retVal?.Reconstitute(); return(retVal); } catch (TargetInvocationException e) { throw Activator.CreateInstance(e.InnerException.GetType(), "Error performing action", e) as Exception; } }
/// <summary> /// Inserts specified data. /// </summary> /// <param name="data">The data to be inserted.</param> public void Insert(IdentifiedData data) { try { if (!(data is Bundle || data is Entity || data is Act)) { return; } if (data is Bundle) { data.Key = null; } ImsiServiceClient client = this.GetServiceClient(); //new ImsiServiceClient(ApplicationContext.Current.GetRestClient("imsi")); client.Client.Credentials = this.GetCredentials(client.Client); client.Client.Responding += (o, e) => this.Responding?.Invoke(o, e); if (client.Client.Credentials == null) { return; } // Special case = Batch submit of data with an entry point var submission = (data as Bundle)?.Entry ?? data; client.Client.Requesting += (o, e) => { var bund = e.Body as Bundle; if (!(bund?.Entry is UserEntity)) // not submitting a user entity so we only submit ACT { bund?.Item.RemoveAll(i => !(i is Act || i is Person && !(i is UserEntity))); // || i is EntityRelationship)); } if (bund != null) { bund.Key = Guid.NewGuid(); e.Cancel = bund.Item.Count == 0; } }; // Create method var method = typeof(ImsiServiceClient).GetRuntimeMethods().FirstOrDefault(o => o.Name == "Create" && o.GetParameters().Length == 1); method = method.MakeGenericMethod(new Type[] { submission.GetType() }); this.m_tracer.TraceVerbose("Performing IMSI INSERT {0}", submission); var iver = method.Invoke(client, new object[] { submission }) as IVersionedEntity; if (iver != null) { this.UpdateToServerCopy(iver); } } catch (TargetInvocationException e) { throw Activator.CreateInstance(e.InnerException.GetType(), "Error performing action", e.InnerException) as Exception; } }
public GenericImsiPersister() { this.m_client = new ImsiServiceClient(ApplicationContext.Current.GetRestClient("imsi")); this.m_client.Client.Requesting += (o, e) => { e.Query.Add("_expand", new List <String>() { "typeConcept", "address.use", "name.use" }); }; }
/// <summary> /// Get service client /// </summary> private ImsiServiceClient GetServiceClient() { var retVal = new ImsiServiceClient(ApplicationContext.Current.GetRestClient("imsi")); retVal.Client.Accept = "application/xml"; retVal.Client.Requesting += (o, e) => { if (AuthenticationContext.CurrentUIContext.Principal != AuthenticationContext.AnonymousPrincipal && AuthenticationContext.CurrentUIContext.Principal != AuthenticationContext.Current.Principal) { e.AdditionalHeaders["X-OpenIZ-OnBehalfOf"] = AuthenticationContext.CurrentUIContext.Principal.Identity.Name; } }; return(retVal); }
/// <summary> /// Called when the action is executing. /// </summary> /// <param name="filterContext">The filter context of the action executing.</param> protected override void OnActionExecuting(ActionExecutingContext filterContext) { var amiRestClient = new RestClientService(Constants.Ami) { Accept = Constants.ApplicationXml, Credentials = new AmiCredentials(this.User, HttpContext.Request) }; this.AmiClient = new AmiServiceClient(amiRestClient); var imsiRestClient = new RestClientService(Constants.Imsi) { Accept = Constants.ApplicationXml, Credentials = new ImsCredentials(this.User, HttpContext.Request) }; this.ImsiClient = new ImsiServiceClient(imsiRestClient); base.OnActionExecuting(filterContext); }
/// <summary> /// Obsoletes specified data. /// </summary> /// <param name="data">The data to be obsoleted.</param> public void Obsolete(IdentifiedData data, bool unsafeObsolete = false) { try { if (!(data is Bundle || data is Entity || data is Act || data is EntityRelationship)) // || data is EntityRelationship)) { return; } ImsiServiceClient client = this.GetServiceClient(); //new ImsiServiceClient(ApplicationContext.Current.GetRestClient("imsi")); client.Client.Credentials = this.GetCredentials(client.Client); client.Client.Responding += (o, e) => this.Responding?.Invoke(o, e); if (client.Client.Credentials == null) { return; } // Force an update if (unsafeObsolete) { client.Client.Requesting += (o, e) => e.AdditionalHeaders["X-OpenIZ-Unsafe"] = "true"; } else { client.Client.Requesting += (o, e) => e.AdditionalHeaders["If-Match"] = data.Tag; } var method = typeof(ImsiServiceClient).GetRuntimeMethods().FirstOrDefault(o => o.Name == "Obsolete" && o.GetParameters().Length == 1); method = method.MakeGenericMethod(new Type[] { data.GetType() }); this.m_tracer.TraceVerbose("Performing IMSI OBSOLETE {0}", data); var iver = method.Invoke(client, new object[] { data }) as IVersionedEntity; if (iver != null) { this.UpdateToServerCopy(iver); } } catch (TargetInvocationException e) { throw Activator.CreateInstance(e.InnerException.GetType(), "Error performing action", e) as Exception; } }
/// <summary> /// Throws an exception if the specified service client has the invalid version /// </summary> private bool IsValidVersion(ImsiServiceClient client) { var expectedVersion = typeof(IdentifiedData).GetTypeInfo().Assembly.GetName().Version; if (this.m_options == null) { this.m_options = client.Options(); } if (this.m_options == null) { return(false); } var version = new Version(this.m_options.InterfaceVersion); // Major version must match & minor version must match. Example: // Server Client Result // 0.6.14.* 0.6.14.* Compatible // 0.7.0.* 0.6.14.* Not compatible (server newer) // 0.7.0.* 0.9.0.0 Compatible (client newer) // 0.8.0.* 1.0.0.0 Not compatible (major version mis-match) this.m_tracer.TraceVerbose("IMSI server indicates version {0}", this.m_options.InterfaceVersion); return(version < expectedVersion); }
/// <summary> /// Initializes a new instance of the <see cref="EntityRelationshipService" /> class. /// </summary> /// <param name="client">The client.</param> /// <param name="conceptService">The concept service.</param> public EntityRelationshipService(ImsiServiceClient client, IConceptService conceptService, IEntityService entityService) : base(client) { this.conceptService = conceptService; this.entityService = entityService; }
/// <summary> /// Initializes a new instance of the <see cref="ImsiServerInformationService"/> class. /// </summary> /// <param name="client">The client.</param> public ImsiServerInformationService(ImsiServiceClient client) : base(client) { }
/// <summary> /// Initializes a new instance of the <see cref="PlaceConceptService"/> class. /// </summary> /// <param name="client">The client.</param> /// <param name="conceptService">The concept service.</param> public PlaceConceptService(ImsiServiceClient client, IConceptService conceptService) : base(client) { this.conceptService = conceptService; }
/// <summary> /// Initializes a new instance of the <see cref="MaterialConceptService"/> class. /// </summary> /// <param name="client">The client.</param> /// <param name="cacheService">The cache service.</param> /// <param name="conceptService">The concept service.</param> public MaterialConceptService(ImsiServiceClient client, ICacheService cacheService, IConceptService conceptService) : base(client) { this.cacheService = cacheService; this.conceptService = conceptService; }
/// <summary> /// Updates specified data. /// </summary> /// <param name="data">The data to be updated.</param> public void Update(IdentifiedData data, bool unsafeUpdate = false) { try { // HACK if (!(data is Bundle || data is Entity || data is Act || data is Patch)) { return; } if (data is Patch && !typeof(Entity).GetTypeInfo().IsAssignableFrom((data as Patch).AppliesTo.Type.GetTypeInfo()) && !typeof(Act).GetTypeInfo().IsAssignableFrom((data as Patch).AppliesTo.Type.GetTypeInfo())) { return; } ImsiServiceClient client = this.GetServiceClient(); //new ImsiServiceClient(ApplicationContext.Current.GetRestClient("imsi")); client.Client.Credentials = this.GetCredentials(client.Client); client.Client.Responding += (o, e) => this.Responding?.Invoke(o, e); if (client.Client.Credentials == null) { return; } // Force an update if (unsafeUpdate) { client.Client.Requesting += (o, e) => e.AdditionalHeaders["X-Patch-Force"] = "true"; } // Special case = Batch submit of data with an entry point var submission = (data as Bundle)?.Entry ?? data; // Assign a uuid for this submission if (data is Bundle && data.Key == null) { data.Key = Guid.NewGuid(); } if (submission is Patch) { var patch = submission as Patch; // Patch for update on times (obsolete, creation time, etc. always fail so lets remove them) patch.Operation.RemoveAll(o => o.OperationType == PatchOperationType.Test && this.m_removePatchTest.Contains(o.Path)); this.m_tracer.TraceVerbose("Performing IMSI UPDATE (PATCH) {0}", patch); var existingKey = patch.AppliesTo.Key; // Get the object and then update var idp = typeof(IDataPersistenceService <>).MakeGenericType(patch.AppliesTo.Type); var idpService = ApplicationContext.Current.GetService(idp); var getMethod = idp.GetRuntimeMethod("Get", new Type[] { typeof(Guid) }); var existing = getMethod.Invoke(idpService, new object[] { existingKey }) as IdentifiedData; Guid newUuid = Guid.Empty; try { newUuid = client.Patch(patch); // Update the server version key if (existing is IVersionedEntity && (existing as IVersionedEntity)?.VersionKey != newUuid) { this.m_tracer.TraceVerbose("Patch successful - VersionId of {0} to {1}", existing, newUuid); (existing as IVersionedEntity).VersionKey = newUuid; var updateMethod = idp.GetRuntimeMethod("Update", new Type[] { getMethod.ReturnType }); updateMethod.Invoke(idpService, new object[] { existing }); } } catch (WebException e) { switch ((e.Response as HttpWebResponse).StatusCode) { case HttpStatusCode.Conflict: // Try to resolve the conflict in an automated way this.m_tracer.TraceWarning("Will attempt to force PATCH {0}", patch); // Condition 1: Can we apply the patch without causing any issues (ignoring version) client.Client.Requesting += (o, evt) => { evt.AdditionalHeaders["X-Patch-Force"] = "true"; }; // Configuration dictates only safe patch if (ApplicationContext.Current.Configuration.GetSection <SynchronizationConfigurationSection>().SafePatchOnly) { // First, let's grab the item var serverCopy = this.Get(patch.AppliesTo.Type, patch.AppliesTo.Key.Value, null); if (ApplicationContext.Current.GetService <IPatchService>().Test(patch, serverCopy)) { newUuid = client.Patch(patch); } else { // There are no intersections of properties between the object we have and the server copy var serverDiff = ApplicationContext.Current.GetService <IPatchService>().Diff(existing, serverCopy); if (!serverDiff.Operation.Any(sd => patch.Operation.Any(po => po.Path == sd.Path && sd.OperationType != PatchOperationType.Test))) { newUuid = client.Patch(patch); } else { throw; } } } else /// unsafe patch ... meh { newUuid = client.Patch(patch); } break; case HttpStatusCode.NotFound: // We tried to update something that doesn't exist on the server? That's odd this.m_tracer.TraceWarning("Server reported patch target doesn't exist! {0}", patch); var svcType = typeof(IDataPersistenceService <>).MakeGenericType(patch.AppliesTo.Type); var persistenceService = ApplicationContext.Current.GetService(svcType) as IDataPersistenceService; var localObject = persistenceService.Get(patch.AppliesTo.Key.Value); // Re-queue for create // First, we have to remove the "replaces version" key as it doesn't make much sense if (localObject is IVersionedEntity) { (localObject as IVersionedEntity).PreviousVersionKey = null; } this.Insert(Bundle.CreateBundle(localObject as IdentifiedData)); break; } } // Update the server version key if (existing is IVersionedEntity && (existing as IVersionedEntity)?.VersionKey != newUuid) { this.m_tracer.TraceVerbose("Patch successful - VersionId of {0} to {1}", existing, newUuid); (existing as IVersionedEntity).VersionKey = newUuid; var updateMethod = idp.GetRuntimeMethod("Update", new Type[] { getMethod.ReturnType }); updateMethod.Invoke(idpService, new object[] { existing }); } } else // regular update { // Force an update if (!unsafeUpdate) { client.Client.Requesting += (o, e) => e.AdditionalHeaders["If-Match"] = data.Tag; } client.Client.Requesting += (o, e) => (e.Body as Bundle)?.Item.RemoveAll(i => !(i is Act || i is Patient || i is Provider || i is UserEntity)); // || i is EntityRelationship)); var method = typeof(ImsiServiceClient).GetRuntimeMethods().FirstOrDefault(o => o.Name == "Update" && o.GetParameters().Length == 1); method = method.MakeGenericMethod(new Type[] { submission.GetType() }); this.m_tracer.TraceVerbose("Performing IMSI UPDATE (FULL) {0}", data); var iver = method.Invoke(client, new object[] { submission }) as IVersionedEntity; if (iver != null) { this.UpdateToServerCopy(iver); } } } catch (TargetInvocationException e) { throw Activator.CreateInstance(e.InnerException.GetType(), "Error performing action", e) as Exception; } }
/// <summary> /// Initializes a new instance of the <see cref="ConceptService" /> class. /// </summary> /// <param name="client">The client.</param> /// <param name="cacheService">The cache service.</param> public ConceptService(ImsiServiceClient client, ICacheService cacheService) : base(client) { this.cacheService = cacheService; }
/// <summary> /// Initializes a new instance of the <see cref="EntityService" /> class. /// </summary> /// <param name="client">The client.</param> /// <param name="conceptService">The concept service.</param> /// <param name="coreAuditService">The core audit service.</param> /// <param name="entityAuditService">The entity audit service.</param> public EntityService(ImsiServiceClient client, IConceptService conceptService, ICoreAuditService coreAuditService, IEntityAuditService entityAuditService) : base(client) { this.conceptService = conceptService; this.coreAuditService = coreAuditService; this.entityAuditService = entityAuditService; }
/// <summary> /// Initializes a new instance of the <see cref="ImsiServiceBase"/> class. /// </summary> /// <param name="client">The client.</param> protected ImsiServiceBase(ImsiServiceClient client) { this.Client = client; }
/// <summary> /// Initializes a new instance of the <see cref="UserService"/> class. /// </summary> /// <param name="client">The client.</param> public UserService(ImsiServiceClient client) : base(client) { }