private async void PushDataRelations()
        {
            bool        completed                    = true;
            bool        completedRelations           = true;
            List <Guid> clientRelationsIds           = new List <Guid>();
            List <Guid> clientNoRelationsIds         = new List <Guid>();
            List <ClientToDeleteDTO> clientIdsDelete = new List <ClientToDeleteDTO>();
            int n = 0;

            #region Initialize

            InitSend();

            var practice = await GetPractice();

            if (null == practice)
            {
                return;
            }

            bool serverOnline = await CheckConnection();

            if (!serverOnline)
            {
                return;
            }

            var practicses = _practiceSetupService.GetAll();

            #endregion

            #region LoadIds

            _clientReaderService.ResetState();

            var allClientsIds = _clientReaderService.LoadClientIds(AppPracticeId);
            clientNoRelationsIds = allClientsIds;
            var totalCount = allClientsIds.Count;

            var clientIdsWithRelations = _clientReaderService.LoadClientIdsWithRelations(AppPracticeId);
            clientRelationsIds = clientIdsWithRelations.Select(x => x.IndexId).ToList();
            if (clientRelationsIds.Any())
            {
                _relsIds.AddRange(clientIdsWithRelations.Select(x => x.IndexId));
                _relsIds.AddRange(clientIdsWithRelations.SelectMany(x => x.SecondaryIds));
            }

            if (_relsIds.Any())
            {
                clientNoRelationsIds = allClientsIds.Where(x => !_relsIds.Contains(x)).ToList();
            }
            #endregion

            #region CLIENTSONLY

            foreach (var id in clientNoRelationsIds)
            {
                var clientToDeleteDto = new ClientToDeleteDTO();
                n++;

                #region LoadClients

                Client client = null;
                try
                {
                    client = _clientReaderService.LoadClient(id);
                }
                catch (Exception e)
                {
                }

                #endregion

                #region SendClients

                if (null != client)
                {
                    var clientInfo = new SyncClientDTO(client);

                    clientInfo.PracticeCode = GetCode(clientInfo.PracticeId, practicses);

                    CurrentStatus = showPerc("Clients", n, totalCount);

                    bool status      = false;
                    bool isCompleted = client.CanBeSynced();

                    try
                    {
                        if (isCompleted)
                        {
                            status = await _clientSyncService.AttempSendClients(Address, clientInfo);
                        }
                        else
                        {
                        }
                    }
                    catch (Exception e)
                    {
                    }

                    if (status)
                    {
                        clientToDeleteDto = new ClientToDeleteDTO(client.Id, client.PersonId);
                    }
                    else
                    {
                        completed = false;
                    }
                }
                #endregion

                #region DeleteClients
                if (!clientToDeleteDto.NotSent)
                {
                    List <Encounter> encounters = new List <Encounter>();
                    try
                    {
                        encounters = _clientReaderService.LoadEncounters(id);
                    }
                    catch (Exception e)
                    {
                    }

                    if (null != encounters && encounters.Count > 0)
                    {
                        var  syncEncounters = SyncClientEncounterDTO.Create(encounters, client);
                        bool status         = false;
                        try
                        {
                            status = await _clientSyncService.AttempSendClientEncounters(Address, syncEncounters);
                        }
                        catch (Exception e)
                        {
                        }

                        if (status)
                        {
                            foreach (var encounter in encounters)
                            {
                                clientToDeleteDto.AddEnounter(new EnconterToDeleteDTO(encounter.Id,
                                                                                      encounter.EncounterType));
                            }
                        }
                        else
                        {
                            completed = false;
                        }
                    }

                    clientIdsDelete.Add(clientToDeleteDto);


                    foreach (var toDeleteDto in clientIdsDelete)
                    {
                        //TODO: ALLOW DELETE []
                        if (deleteOnPush)
                        {
                            try
                            {
                                _clientReaderService.Purge(toDeleteDto);
                            }
                            catch (Exception e)
                            {
                            }
                        }
                    }
                }
                #endregion
            }

            #endregion

            #region CLIENTRELATIONS

            foreach (var id in clientRelationsIds)
            {
                var clientToDeleteDto = new ClientToDeleteDTO();
                n++;

                Client        client         = null;
                List <Client> clientContacts = new List <Client>();
                int           contactCount   = 0;

                #region LoadClientWithRelations

                try
                {
                    client = _clientReaderService.LoadClient(id);
                    var contact = clientIdsWithRelations.FirstOrDefault(x => x.IndexId == id);
                    contactCount = contact.SecondaryIds.Count;
                    if (null != contact && client.CanBeSynced())
                    {
                        foreach (var secondaryId in contact.SecondaryIds)
                        {
                            var clientContact = _clientReaderService.LoadClientContact(secondaryId);
                            if (null != clientContact)
                            {
                                clientContacts.Add(clientContact);
                            }
                        }
                    }
                }
                catch (Exception e)
                {
                }

                #endregion

                #region SendClientWithRelations

                if (null != client)
                {
                    var clientInfo = new SyncClientDTO(client);

                    clientInfo.PracticeCode = GetCode(clientInfo.PracticeId, practicses);

                    CurrentStatus = showPerc("Clients", n, totalCount);

                    bool status = false;

                    try
                    {
                        if (client.CanBeSynced())
                        {
                            var contactsCannotBeSynced =
                                clientContacts.Any() && clientContacts.Any(x => !x.CanBeSynced());

                            if (!contactsCannotBeSynced)
                            {
                                status = await _clientSyncService.AttempSendClients(Address, clientInfo);

                                foreach (var clientContact in clientContacts)
                                {
                                    var clientConactInfo = new SyncClientDTO(clientContact);
                                    clientConactInfo.PracticeCode =
                                        GetCode(clientConactInfo.PracticeId, practicses);

                                    n++;
                                    CurrentStatus = showPerc("Clients", n, totalCount);
                                    status        = await _clientSyncService.AttempSendClients(Address, clientConactInfo);
                                }
                            }
                            else
                            {
                                CurrentStatus = showPerc("Clients", n + contactCount, totalCount);
                            }
                        }
                        else
                        {
                            CurrentStatus = showPerc("Clients", n + contactCount, totalCount);
                        }
                    }
                    catch (Exception e)
                    {
                    }

                    if (status)
                    {
                        clientToDeleteDto = new ClientToDeleteDTO(client.Id, client.PersonId);
                    }
                    else
                    {
                        completedRelations = false;
                    }
                }

                #endregion

                #region DeleteSentClientWithRelations

                if (!clientToDeleteDto.NotSent)
                {
                    List <Encounter> encounters        = new List <Encounter>();
                    List <Encounter> contactEncounters = new List <Encounter>();
                    try
                    {
                        encounters = _clientReaderService.LoadEncounters(id);

                        var contact = clientIdsWithRelations.FirstOrDefault(x => x.IndexId == id);
                        foreach (var sid in contact.SecondaryIds)
                        {
                            var cencounters = _clientReaderService.LoadEncounters(sid);
                            encounters.AddRange(cencounters);
                        }
                    }
                    catch (Exception e)
                    {
                    }

                    if (null != encounters && encounters.Count > 0)
                    {
                        var  syncEncounters = SyncClientEncounterDTO.Create(encounters, client);
                        bool status         = false;
                        try
                        {
                            status = await _clientSyncService.AttempSendClientEncounters(Address, syncEncounters);
                        }
                        catch (Exception e)
                        {
                        }

                        if (status)
                        {
                            foreach (var encounter in encounters)
                            {
                                clientToDeleteDto.AddEnounter(new EnconterToDeleteDTO(encounter.Id,
                                                                                      encounter.EncounterType));
                            }
                        }
                        else
                        {
                            completedRelations = false;
                        }
                    }

                    clientIdsDelete.Add(clientToDeleteDto);
                    foreach (var ct in clientContacts)
                    {
                        clientIdsDelete.Add(new ClientToDeleteDTO(ct.Id, ct.PersonId));
                    }



                    foreach (var toDeleteDto in clientIdsDelete)
                    {
                        //TODO: ALLOW DELETE []
                        if (deleteOnPush)
                        {
                            try
                            {
                                _clientReaderService.Purge(toDeleteDto);
                                _sentIds.Add(toDeleteDto.Id);
                            }
                            catch (Exception e)
                            {
                            }
                        }
                    }
                }

                #endregion
            }

            #endregion

            CurrentStatusTotal  = $"Total Clients {totalCount}";
            CurrentStatusSent   = $"Total Sent {clientIdsDelete.Count}";
            CurrentStatusFailed = $"Total Failed {totalCount - clientIdsDelete.Count}";
            var messageVerdict = $"Check and resolve any Incomplete records and review server logs";

            if (completed && completedRelations)
            {
                if (totalCount > clientIdsDelete.Count)
                {
                    CurrentStatusSummary = messageVerdict;
                }

                _dialogService.ShowToast("process completed");
            }
            else
            {
                CurrentStatusSummary = messageVerdict;
                _dialogService.ShowToast("process completed");
            }

            IsBusy = false;
        }
Esempio n. 2
0
        private async void PushData()
        {
            IsBusy = true;

            CurrentStatus = $"connecting...";
            var practice = await _activationService.GetLocal(Address);

            if (null != practice)
            {
                bool completed = true;

                try
                {
                    var response = await _activationService.AttempCheckVersion(Address);

                    if (string.IsNullOrWhiteSpace(response))
                    {
                        _dialogService.Alert($"you are using an old version of LiveHAPI");
                        IsBusy        = false;
                        CurrentStatus = $"send failed! updated LiveHAPI ";
                        return;
                    }

                    int.TryParse(response, out var version);

                    if (version != _hapiVersion)
                    {
                        _dialogService.Alert($"you are using an old version of LiveHAPI");
                        IsBusy        = false;
                        CurrentStatus = $"send failed! update LiveHAPI to v{_hapiVersion}";
                        return;
                    }

                    var pracs = _practiceSetupService.GetAll();
                    await _activationService.AttemptEnrollPractice(Address, pracs);
                }
                catch (Exception e)
                {
                    _dialogService.Alert($"connetion Error {e.Message}");
                    IsBusy = false;
                    return;
                }



                var ids   = _clientReaderService.LoadClientIds();
                var count = ids.Count;
                int n     = 0;

                var clientIdsDelete  = new List <ClientToDeleteDTO>();
                var encountersDelete = new List <EnconterToDeleteDTO>();

                var practicses = _practiceSetupService.GetAll();

                foreach (var id in ids)
                {
                    var clientToDeleteDto = new ClientToDeleteDTO();
                    n++;

                    var client = _clientReaderService.LoadClient(id);


                    if (null != client)
                    {
                        var clientInfo = new SyncClientDTO(client);

                        clientInfo.PracticeCode = GetCode(clientInfo.PracticeId, practicses);

                        CurrentStatus = showPerc("Clients", n, count);

                        var status = await _clientSyncService.AttempSendClients(Address, clientInfo);

                        if (status)
                        {
                            clientToDeleteDto = new ClientToDeleteDTO(client.Id, client.PersonId);
                        }
                        else
                        {
                            completed = false;
                        }
                    }

                    if (!clientToDeleteDto.NotSent)
                    {
                        var encounters = _clientReaderService.LoadEncounters(id);
                        if (null != encounters && encounters.Count > 0)
                        {
                            var syncEncounters = SyncClientEncounterDTO.Create(encounters, client);
                            var status         = await _clientSyncService.AttempSendClientEncounters(Address, syncEncounters);

                            if (status)
                            {
                                foreach (var encounter in encounters)
                                {
                                    clientToDeleteDto.AddEnounter(new EnconterToDeleteDTO(encounter.Id,
                                                                                          encounter.EncounterType));
                                }
                            }
                            else
                            {
                                completed = false;
                            }
                        }

                        var shrs = _clientReaderService.LoadPSmartStores(id);

                        if (null != shrs && shrs.Count > 0)
                        {
                            await _clientSyncService.SendClientShrs(Address, shrs);
                        }

                        clientIdsDelete.Add(clientToDeleteDto);
                        foreach (var toDeleteDto in clientIdsDelete)
                        {
                            //TODO: ALLOW DELETE []
                            if (deleteOnPush)
                            {
                                _clientReaderService.Purge(toDeleteDto);
                            }
                        }
                    }
                }

                //  send

                CurrentStatus = $"done! sent {clientIdsDelete.Count} of {count} ";

                if (completed)
                {
                    _dialogService.ShowToast("completed successfully");
                }
                else
                {
                    CurrentStatus = $"{CurrentStatus} with some Errors, Please check server logs";
                    _dialogService.Alert("send completed with errors");
                }
            }
            else
            {
                IsBusy        = false;
                CurrentStatus = $"connection failed !!";

                _dialogService.Alert("Could not connect to server");
            }

            IsBusy = false;
        }