public override List <dynamic> Execute(List <SynapseSearchTerm> synapseSearchTerms)
        {
            var baseQuery = (from person in this.dbContext.entitystorematerialised_CorePerson
                             join personId in this.dbContext.entitystorematerialised_CorePersonidentifier on
                             person.PersonId equals personId.PersonId
                             join personAddress in this.dbContext.entitystorematerialised_CorePersonaddress1 on
                             person.PersonId equals personAddress.PersonId into pa
                             from address in pa.DefaultIfEmpty()
                             join personContact in this.dbContext.entitystorematerialised_CorePersoncontactinfo1 on
                             person.PersonId equals personContact.PersonId into pc
                             from contact in pc.DefaultIfEmpty()
                             join personNextOfKin in this.dbContext.entitystorematerialised_CoreNextofkin1 on
                             person.PersonId equals personNextOfKin.PersonId into pn
                             from nextOfKin in pn.DefaultIfEmpty()
                             select new
            {
                personData = person,
                personIdData = personId,
                personAddressData = address,
                personContactData = contact,
                personNextOfKinData = nextOfKin
            });

            var searchOp = new GenericSearchOpProcessor();

            var withSearchClause = searchOp.Apply(baseQuery, synapseSearchTerms);

#if DEBUG
            var stringQuery = withSearchClause.ToSql();
#endif
            var matPersons = withSearchClause
                             .OrderByDescending((entity) => entity.personData.Createdtimestamp)
                             .Select(entity => new
            {
                person           = entity.personData,
                patientIdentifer = entity.personIdData,
                personAddress    = entity.personAddressData,
                personContact    = entity.personContactData,
                personNextOfKin  = entity.personNextOfKinData
            })
                             .ToList();

            if (matPersons.IsCollectionValid())
            {
                var persons            = matPersons.Select(m => m.person).ToList();
                var patientIdentifiers = matPersons.Select(m => m.patientIdentifer).ToList();
                var personAddresses    = matPersons.Select(m => m.personAddress).ToList();
                var personContacts     = matPersons.Select(m => m.personContact).ToList();
                var personNextOfKins   = matPersons.Select(m => m.personNextOfKin).ToList();

                return(new List <dynamic> {
                    persons, patientIdentifiers, personAddresses, personContacts, personNextOfKins
                });
            }

            return(null);
        }
        public override List <dynamic> Execute(List <SynapseSearchTerm> synapseSearchTerms)
        {
            var baseQuery = (from result in this.dbContext.entitystorematerialised_CoreResult1
                             join person in this.dbContext.entitystorematerialised_CorePerson on
                             result.PersonId equals person.PersonId
                             join personIden in this.dbContext.entitystorematerialised_CorePersonidentifier on
                             person.PersonId equals personIden.PersonId
                             join resultOrder in this.dbContext.entitystorematerialised_CoreOrder1 on
                             result.OrderId equals resultOrder.OrderId into orderTemp
                             from order in orderTemp.DefaultIfEmpty()
                             select new
            {
                resultData = result,
                personData = person,
                personIdData = personIden,
                orderData = order
            });

            var searchOp = new GenericSearchOpProcessor();

            var withSearchClause = searchOp.Apply(baseQuery, synapseSearchTerms);

            var matResults = withSearchClause
                             .OrderByDescending((entity) => entity.resultData.Createdtimestamp)
                             .Select(entity => new
            {
                result           = entity.resultData,
                patientIdentifer = entity.personIdData
            })
                             .ToList();

            if (matResults.IsCollectionValid())
            {
                var results           = matResults.Select(m => m.result).ToList();
                var patientIdentifier = matResults.Select(m => m.patientIdentifer).FirstOrDefault();

                return(new List <dynamic> {
                    results, patientIdentifier
                });
            }

            return(null);
        }
        public override List <dynamic> Execute(List <SynapseSearchTerm> synapseSearchTerms)
        {
            var baseQuery = (from encounter in this.dbContext.entitystorematerialised_CoreEncounter
                             join person in this.dbContext.entitystorematerialised_CorePerson on
                             encounter.PersonId equals person.PersonId
                             join personId in this.dbContext.entitystorematerialised_CorePersonidentifier on
                             person.PersonId equals personId.PersonId
                             select new
            {
                encounterData = encounter,
                personData = person,
                personIdData = personId
            });

            var searchOp = new GenericSearchOpProcessor();

            var withSearchClause = searchOp.Apply(baseQuery, synapseSearchTerms);

#if DEBUG
            var stringQuery = withSearchClause.ToSql();
#endif
            var matEncounters = withSearchClause
                                .OrderByDescending((entity) => entity.encounterData.Createdtimestamp)
                                .Select(entity => new
            {
                encounter        = entity.encounterData,
                patientIdentifer = entity.personIdData
            })
                                .ToList();

            if (matEncounters.IsCollectionValid())
            {
                var encounters        = matEncounters.Select(m => m.encounter).ToList(); // make sure this is the root entity
                var patientIdentifier = matEncounters.Select(m => m.patientIdentifer).FirstOrDefault();

                return(new List <dynamic> {
                    encounters, patientIdentifier
                });
            }

            return(null);
        }