public async Task <IEnumerable <ClientStage> > Extract(Guid?htsClientId = null)
        {
            //_clientStageRepository.Clear();

            var subscriber = await _subscriberSystemRepository.GetDefaultAsync();

            if (null == subscriber)
            {
                throw new Exception("Default EMR NOT SET");
            }

            var practices = _practiceRepository.GetAllDefault().ToList();

            var clients = new List <ClientStage>();

            var persons = _personRepository.GetAllClients();

            foreach (var person in persons)
            {
                var client   = ClientStage.Create(person, subscriber);
                var practice = practices.FirstOrDefault(x => x.Id == client.PracticeId);

                if (null != practice)
                {
                    client.SiteCode = practice.Code;
                }

                clients.Add(client);
            }
            return(clients.Where(x => !x.ClientId.IsNullOrEmpty()));
        }
Example #2
0
 public IActionResult GetFacilities()
 {
     try
     {
         var practice = _practiceRepository.GetAllDefault();
         return(Ok(practice));
     }
     catch (Exception e)
     {
         Log.Debug($"{e}");
         return(StatusCode(500, $"{e.Message}"));
     }
 }
        public async Task <IEnumerable <IndexClientMessage> > Load(Guid?htsClientId = null, params LoadAction[] actions)
        {
            var messages = new List <IndexClientMessage>();

            if (!actions.Any())
            {
                actions = new[] { LoadAction.All }
            }
            ;

            var facs = _practiceRepository.GetAllDefault().ToList();

            //  Set Facility
            var facility = facs.FirstOrDefault(x => x.IsDefault);

            if (null == facility)
            {
                throw new Exception($"Default Faciltity Not found");
            }

            //      MESSAGE_HEADER

            var facilityCode = facility.Code;
            var header       = MESSAGE_HEADER.Create(facilityCode);

            //      NEWCLIENT

            var stagedIndexClients = _clientStageRepository.GetIndexClients();

            if (!htsClientId.IsNullOrEmpty())
            {
                stagedIndexClients = stagedIndexClients.Where(x => x.ClientId == htsClientId);
            }

            foreach (var stagedClient in stagedIndexClients)
            {
                header.UpdateMfl(stagedClient.SiteCode);

                #region PATIENT_IDENTIFICATION

                var pid = PATIENT_IDENTIFICATION.Create(stagedClient);

                #endregion

                ENCOUNTERS encounter = null;
                if (!actions.Contains(LoadAction.RegistrationOnly))
                {
                    var pretests = _clientPretestStageRepository.GetByClientId(stagedClient.ClientId).ToList();

                    //    PRETEST AND TESTING

                    if (pretests.Any())
                    {
                        var lastPretest = pretests.OrderByDescending(x => x.EncounterDate).FirstOrDefault();

                        foreach (var pretest in pretests)
                        {
                            var pretestEncounter =
                                await CreatePretestEncounters(header, pid, stagedClient, pretest, actions);

                            messages.Add(pretestEncounter);
                        }

                        if (null != lastPretest)
                        {
                            var nonPretest =
                                await CreateNonPretestEncounters(header, pid, stagedClient, lastPretest, actions);

                            if (null != nonPretest)
                            {
                                messages.Add(nonPretest);
                            }
                        }
                    }
                    else
                    {
                        var registration = CreateRegistration(header, pid, stagedClient, encounter);
                        messages.Add(registration);
                    }
                }
                else
                {
                    messages.Add(new IndexClientMessage(header,
                                                        new List <NEWCLIENT> {
                        NEWCLIENT.Create(pid, encounter)
                    }, stagedClient.ClientId));
                }
            }

            return(messages);
        }