public void should_Write_Clients()
        {
            var clientsResponses = _clientMessageWriter.Write().Result.ToList();

            foreach (var message in _clientMessageWriter.Messages)
            {
                Assert.False(string.IsNullOrWhiteSpace(message));
            }

            var stagedIndexClients = _clientStageRepository.GetIndexClients();

            Assert.False(stagedIndexClients.Any());
            if (_clientMessageWriter.Errors.Any())
            {
                foreach (var e in _clientMessageWriter.Errors)
                {
                    Console.WriteLine(e.Message);

                    Console.WriteLine(new string('*', 40));
                }
            }

            foreach (var message in _clientMessageWriter.Messages)
            {
                Console.WriteLine(message);
                Console.WriteLine(new string('|', 40));
            }

            Assert.True(clientsResponses.Any());
            foreach (var response in clientsResponses)
            {
                Console.WriteLine(response);
            }
        }
        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);
        }