Esempio n. 1
0
 protected void SetEntityValue(result_entities entity, attribute attribute, string value)
 {
     switch (attribute.value_type)
     {
         case "float":
             entity.value_float = float.Parse(value);
             break;
         case "int":
             entity.value_int = int.Parse(value);
             break;
         case "short_text":
             entity.value_short_text = value;
             break;
         case "text":
             entity.value_text = value;
             break;
         case "date_time":
             entity.value_date_time = DateTime.Parse(value);
             break;
         case "binary":
             break;
         default:
             entity.value_text = value;
             break;
     }
 }
Esempio n. 2
0
 public result_entities AddGVF(result_entities entity, List<result_entities> pragmaEntities, List<result_entities> featureEntities)
 {
     entities.result_entities.Add(entity);
     entities.result_entities.AddRange(pragmaEntities);
     entities.result_entities.AddRange(featureEntities);
     entities.SaveChanges();
     return entity;
 }
Esempio n. 3
0
        public result_entities AddPhenotype(result_files resultFile, patient patient, attribute attribute, DateTime? resultedOn)
        {
            result_entities rootEntity = new result_entities()
            {
                patient_id = patient.id,
                result_file_id = resultFile.id,
                attribute_id = attribute.id,
            };

            result_entities resultedOnEntity = new result_entities()
            {
                patient_id = patient.id,
                result_file_id = resultFile.id,
                attribute_id = GetAttribute(null, null, "Resulted on", null).id,
                parent = rootEntity,
                value_date_time = resultedOn
            };

            entities.result_entities.AddRange(new[] { rootEntity, resultedOnEntity });
            entities.SaveChanges();
            return rootEntity;
        }
Esempio n. 4
0
        public override void LoadData(string filePath)
        {
            string[] data = File.ReadAllLines(filePath);
            List<Pragma> pragmas = new List<Pragma>();
            List<string> comments = new List<string>();
            List<Feature> features = new List<Feature>();
            foreach (var row in data)
            {
                switch (GVFParserHelper.GetRowType(row))
                {
                    case GVFParserHelper.RowType.Pragma:
                        {
                            pragmas.Add(pragmaParser.Parse(row));
                            break;
                        }
                    case GVFParserHelper.RowType.Comment:
                        {
                            comments.Add(row.Trim(CommentTrimChars));
                            break;
                        }
                    case GVFParserHelper.RowType.Data:
                        {
                            features.Add(GVFParserHelper.ParseFeature(row));
                            break;
                        }
                }
            }

            var source = sourceRepo.AddSource("GVF", "GVF file");
            var file = AddResultFile(filePath, source);
            patient patient = null;
            //string genomeBuild = null;
            //DateTime? resultDate = null;

            // Process the file-level pragmas
            result_entities rootEntity = new result_entities()
            {
                attribute_id = EntityRepository.GetAttribute(null, null, "Genomic Variant Format result", null).id,
                result_file_id = file.id
            };

            var pragmaEntities = new List<result_entities>();
            foreach (var pragma in pragmas)
            {
                if (pragma.Name == "individual-id")
                {
                    var mrnParts = pragma.Tags.FirstOrDefault(x => x.Name == "Dbxref").Value.Split(':');
                    patient = patientRepo.AddPatient(mrnParts[1], mrnParts[0],
                        pragma.Tags.FirstOrDefault(x => x.Name == "First_name").Value,
                        pragma.Tags.FirstOrDefault(x => x.Name == "Last_name").Value,
                        DateTime.Parse(pragma.Tags.FirstOrDefault(x => x.Name == "DOB").Value));
                }
                //else if (pragma.Name == "phenotype-description")
                //{
                //    var phenotype = phenotypeRepo.GetPhenotypeByExternalId(CreatePhenotype(pragma));
                //}
                //else if (pragma.Name == "genome-build")
                //{
                //    genomeBuild = pragma.Value;
                //}
                else if (pragma.Name == "file-date")
                {
                    pragmaEntities.Add(new result_entities()
                    {
                        attribute_id = EntityRepository.GetAttribute(null, null, "Resulted on", null).id,
                        result_file_id = file.id,
                        value_date_time = DateTime.Parse(pragma.Value),
                        parent = rootEntity
                    });
                }
                else
                {
                    var pragmaEntity = new result_entities()
                    {
                        attribute_id = EntityRepository.GetAttribute(pragma.Name, "GVF", null, null).id,
                        result_file_id = file.id,
                        parent = rootEntity
                    };
                    pragmaEntities.Add(pragmaEntity);

                    if (pragma.Tags.Count > 0)
                    {
                        foreach (var tag in pragma.Tags)
                        {
                            var attribute = EntityRepository.GetAttribute(tag.Name, "GVF", tag.Name, null);
                            var tagEntity = new result_entities()
                            {
                                attribute_id = attribute.id,
                                result_file_id = file.id,
                                parent = pragmaEntity,
                            };
                            SetEntityValue(tagEntity, attribute, tag.Value);
                            pragmaEntities.Add(tagEntity);
                        }
                    }
                    else
                    {
                        pragmaEntity.value_short_text = pragma.Value;
                        //collectionInformationList.Add(AddPragmaInformation(string.Format("GVF:{0}", pragma.Name), pragma.Value));
                    }
                }
            }

            // Convert all comments into individual variant information entries
            foreach (var comment in comments)
            {
                pragmaEntities.Add(new result_entities()
                {
                    attribute_id = EntityRepository.GetAttribute("Comment", "GVF", "Comment", null).id,
                    result_file_id = file.id,
                    parent = rootEntity,
                    value_text = comment
                });
            }

            rootEntity.patient_id = patient.id;
            pragmaEntities.ForEach(x => x.patient_id = patient.id);

            var featureEntities = new List<result_entities>();
            foreach (var feature in features)
            {
                var gvfEntity = new result_entities()
                {
                    attribute_id = EntityRepository.GetAttribute(null, null, "Genomic Variant Format feature", null).id,
                    patient_id = patient.id,
                    result_file_id = file.id,
                    parent = rootEntity
                };
                featureEntities.Add(gvfEntity);

                featureEntities.Add(new result_entities()
                {
                    attribute_id = EntityRepository.GetAttribute("Chromosome", "GVF", null, null).id,
                    patient_id = patient.id,
                    result_file_id = file.id,
                    parent = gvfEntity,
                    value_short_text = feature.Chromosome
                });

                featureEntities.Add(AddFeatureAttribute("Source", patient.id, file.id, gvfEntity, feature.Source));
                featureEntities.Add(AddFeatureAttribute("Type", patient.id, file.id, gvfEntity, feature.Type));
                featureEntities.Add(AddFeatureAttribute("Start position", patient.id, file.id, gvfEntity, feature.StartPosition.ToString()));
                featureEntities.Add(AddFeatureAttribute("End position", patient.id, file.id, gvfEntity, feature.EndPosition.ToString()));
                featureEntities.Add(AddFeatureAttribute("Score", patient.id, file.id, gvfEntity, feature.Score));
                featureEntities.Add(AddFeatureAttribute("Strand", patient.id, file.id, gvfEntity, feature.Strand));
                featureEntities.Add(AddFeatureAttribute("Phase", patient.id, file.id, gvfEntity, feature.Phase));

                foreach (var attr in feature.Attributes.Where(x => x.Name != "ID" && x.Name != "Variant_seq").ToArray())
                {

                    featureEntities.Add(AddFeatureAttribute(attr.Name, patient.id, file.id, gvfEntity, attr.Value));
                }

                var variantEntity = new result_entities()
                {
                    attribute_id = EntityRepository.GetAttribute(feature.Attributes.FirstOrDefault(x => x.Name == "ID").Value, "dbSNP", null, null).id,
                    patient_id = patient.id,
                    result_file_id = file.id,
                    parent = gvfEntity
                };
                featureEntities.Add(variantEntity);

                var alleles = feature.Attributes.FirstOrDefault(x => x.Name == "Variant_seq").Value.Split(new[] { ',' });
                foreach (var allele in alleles)
                {
                    featureEntities.Add(AddFeatureAttribute("SNP allele", patient.id, file.id, variantEntity, allele));
                }
            }

            entityRepo.AddGVF(rootEntity, pragmaEntities, featureEntities);
        }
Esempio n. 5
0
 private result_entities AddFeatureAttribute(string attributeCode, int patientId, int fileId, result_entities parent, string value)
 {
     var attribute = EntityRepository.GetAttribute(attributeCode, "GVF", attributeCode, null);
     var entity = new result_entities()
     {
         attribute_id = attribute.id,
         patient_id = patientId,
         result_file_id = fileId,
         parent = parent,
     };
     SetEntityValue(entity, attribute, value);
     return entity;
 }
Esempio n. 6
0
        public override void LoadData(string filePath)
        {
            var vcfParser = new VCFParser(filePath);
            var header = vcfParser.Header;
            var patient = new patient();

            var source = sourceRepo.AddSource("VCF", "VCF file");
            var file = AddResultFile(filePath, source);

            // Process the file-level pragmas
            result_entities rootEntity = new result_entities()
            {
                attribute_id = EntityRepository.GetAttribute(null, null, "Variant Call Format result", null).id,
                result_file_id = file.id
            };

            // We pull out all of the metadata from the header (all lines) and write them as information
            // lines associated with this result.
            var headerEntities = new List<result_entities>();
            foreach (var headerItem in header.MetaDataInInputOrder)
            {
                if (headerItem.Key == "individual-id")
                {
                    var individualParts = headerItem.Value.Replace("<", "").Replace(">", "").Split(new char[] { ',' });
                    var individualData = individualParts.Select(x => x.Split(new char[] { '=' })).ToArray();
                    var mrnParts = individualData.FirstOrDefault(x => x[0] == "Dbxref")[1].Split(':');
                    patient = patientRepo.AddPatient(mrnParts[1], mrnParts[0],
                        individualData.FirstOrDefault(x => x[0] == "First_name")[1],
                        individualData.FirstOrDefault(x => x[0] == "Last_name")[1],
                        DateTime.Parse(individualData.FirstOrDefault(x => x[0] == "DOB")[1]));
                }
                else if (headerItem.Key == "fileDate")
                {
                    DateTime resultDate = DateTime.ParseExact(headerItem.Value, "yyyyMMdd", CultureInfo.InvariantCulture, DateTimeStyles.None);
                    headerEntities.Add(CreateEntityAttribute("Resulted on", 0, file.id, rootEntity, resultDate.ToShortDateString()));
                }
                else if (headerItem.GetType() == typeof(VCFInfoHeaderLine))
                {
                    var info = headerItem as VCFInfoHeaderLine;
                    var infoEntity = CreateEntityAttribute("INFO", 0, file.id, rootEntity, null);
                    headerEntities.Add(infoEntity);
                    headerEntities.Add(CreateEntityAttribute("ID", 0, file.id, infoEntity, info.ID));
                    headerEntities.Add(CreateEntityAttribute("Number", 0, file.id, infoEntity, info.CountType.ToString()));
                    headerEntities.Add(CreateEntityAttribute("Type", 0, file.id, infoEntity, info.Type.ToString()));
                    headerEntities.Add(CreateEntityAttribute("Description", 0, file.id, infoEntity, info.Description));
                }
                else if (headerItem.GetType() == typeof(VCFFilterHeaderLine))
                {
                    var filter = headerItem as VCFFilterHeaderLine;
                    var filterEntity = CreateEntityAttribute("FILTER", 0, file.id, rootEntity, null);
                    headerEntities.Add(filterEntity);
                    foreach (var field in filter.GenericFields())
                    {
                        headerEntities.Add(CreateEntityAttribute(field.Key, 0, file.id, filterEntity, field.Value));
                    }
                }
                else if (headerItem.GetType() == typeof(VCFFormatHeaderLine))
                {
                    var format = headerItem as VCFFormatHeaderLine;
                    var formatEntity = CreateEntityAttribute("FORMAT", 0, file.id, rootEntity, null);
                    headerEntities.Add(formatEntity);
                    headerEntities.Add(CreateEntityAttribute("ID", 0, file.id, formatEntity, format.ID));
                    headerEntities.Add(CreateEntityAttribute("Number", 0, file.id, formatEntity, format.CountType.ToString()));
                    headerEntities.Add(CreateEntityAttribute("Type", 0, file.id, formatEntity, format.Type.ToString()));
                    headerEntities.Add(CreateEntityAttribute("Description", 0, file.id, formatEntity, format.Description));
                }
                else
                {
                    var headerEntity = CreateEntityAttribute(headerItem.Key, 0, file.id, rootEntity, headerItem.Value);
                    headerEntities.Add(headerEntity);
                }
            }

            rootEntity.patient_id = patient.id;
            headerEntities.ForEach(x => x.patient_id = patient.id);

            var variantEntities = new List<result_entities>();
            while (vcfParser.MoveNext())
            {
                var current = vcfParser.Current;
                result_entities variantEntity = new result_entities()
                {
                    attribute_id = EntityRepository.GetAttribute(null, null, "Variant Call Format variant", null).id,
                    result_file_id = file.id,
                    patient_id = patient.id,
                    parent = rootEntity
                };
                variantEntities.Add(variantEntity);

                result_entities snpEntity = new result_entities()
                {
                    attribute_id = EntityRepository.GetAttribute(current.ID, "dbSNP", null, null).id,
                    result_file_id = file.id,
                    patient_id = patient.id,
                    parent = variantEntity
                };
                variantEntities.Add(snpEntity);

                SetVariantValues(current, patient.id, file.id, snpEntity, variantEntities);

                variantEntities.Add(CreateEntityAttribute("Chromosome", patient.id, file.id, variantEntity, current.Chr));
                variantEntities.Add(CreateEntityAttribute("Start position", patient.id, file.id, variantEntity, current.Start.ToString()));
                variantEntities.Add(CreateEntityAttribute("End position", patient.id, file.id, variantEntity, current.End.ToString()));
                variantEntities.Add(CreateEntityAttribute("Reference base", patient.id, file.id, variantEntity, current.Reference.BaseString));
                variantEntities.Add(CreateEntityAttribute("Quality", patient.id, file.id, variantEntity, current.PhredScaledQual.ToString()));
                foreach (var attr in current.Attributes)
                {
                    variantEntities.Add(CreateEntityAttribute(string.Format("INFO:{0}", attr.Key), patient.id, file.id, variantEntity, attr.Value.ToString()));
                }

                if (current.FiltersMaybeNull != null)
                {
                    foreach (var filter in current.FiltersMaybeNull)
                    {
                        variantEntities.Add(CreateEntityAttribute(string.Format("FILTER:{0}", filter), patient.id, file.id, variantEntity, string.Empty));
                    }
                }

                //foreach (var genotype in current.Genotypes)
                //{
                //    attributeList.Add(AddVariantInformation("VCF:Genotype", genotype.ToMHGRString()));
                //}

                //attributeList.Add(AddVariantInformation("VCF:Quality", current.PhredScaledQual.ToString()));
                //attributeList.Add(AddVariantInformation("VCF:Filter", string.Join(",", current.Filters.ToArray())));
                //featureInformationList.Add(patientVariant, attributeList);
            }

            entityRepo.AddVCF(rootEntity, headerEntities, variantEntities);
        }
Esempio n. 7
0
 private void SetVariantValues(VariantContext context, int patientId, int fileId, result_entities parent, List<result_entities> variantEntities)
 {
     if (context.Genotypes.Count > 0)
     {
         var alleles = context.Genotypes[0].Alleles;
         foreach (var allele in alleles)
         {
             variantEntities.Add(new result_entities()
             {
                 patient_id = patientId,
                 result_file_id = fileId,
                 attribute_id = EntityRepository.GetAttribute(null, null, "SNP allele", null).id,
                 parent = parent,
                 value_short_text = allele.DisplayString
             });
         }
     }
 }
Esempio n. 8
0
        public result_entities[] AddSnps(result_files resultFile, patient patient, DateTime? resultedOn, List<SnpResult> snps)
        {
            var results = new List<result_entities>();
            var snpAlleleAttributeId = GetAttribute(null, null, "SNP allele", null).id;
            var referenceBaseAttributeId = GetAttribute(null, null, "Reference base", null).id;
            var resultedOnAttributeId = GetAttribute(null, null, "Resulted on", null).id;
            foreach (var snp in snps)
            {
                var entityParts = new List<result_entities>();
                result_entities rootEntity = new result_entities()
                {
                    patient_id = patient.id,
                    result_file_id = resultFile.id,
                    attribute_id = GetAttribute(snp.RSID, "dbSNP", snp.RSID, snp.RSID).id,
                };

                result_entities resultedOnEntity = new result_entities()
                {
                    patient_id = patient.id,
                    result_file_id = resultFile.id,
                    attribute_id = resultedOnAttributeId,
                    parent = rootEntity,
                    value_date_time = resultedOn
                };

                result_entities referenceBaseEntity = new result_entities()
                {
                    patient_id = patient.id,
                    result_file_id = resultFile.id,
                    attribute_id = referenceBaseAttributeId,
                    parent = rootEntity,
                    value_short_text = snp.ReferenceBase
                };

                result_entities allele1Entity = new result_entities()
                {
                    patient_id = patient.id,
                    result_file_id = resultFile.id,
                    attribute_id = snpAlleleAttributeId,
                    parent = rootEntity,
                    value_short_text = snp.Genotype[0].ToString()
                };

                result_entities allele2Entity = new result_entities()
                {
                    patient_id = patient.id,
                    result_file_id = resultFile.id,
                    attribute_id = snpAlleleAttributeId,
                    parent = rootEntity,
                    value_short_text = snp.Genotype[1].ToString()
                };

                entities.result_entities.AddRange(new[] { rootEntity, resultedOnEntity, referenceBaseEntity, allele1Entity, allele2Entity });
                results.Add(rootEntity);
            }

            entities.SaveChanges();
            return results.ToArray();
        }
Esempio n. 9
0
 public result_entities AddVCF(result_entities entity, List<result_entities> headerEntities, List<result_entities> variantEntities)
 {
     entities.result_entities.Add(entity);
     entities.result_entities.AddRange(headerEntities);
     entities.result_entities.AddRange(variantEntities);
     entities.SaveChanges();
     return entity;
 }
Esempio n. 10
0
        public result_entities[] AddStarVariants(patient patient, result_files resultFile, DateTime resultedOn, List<StarVariantResult> stars)
        {
            var results = new List<result_entities>();
            foreach (var star in stars)
            {
                var entityParts = new List<result_entities>();
                result_entities rootEntity = new result_entities()
                {
                    patient_id = patient.id,
                    result_file_id = resultFile.id,
                    attribute_id = GetAttribute(star.Gene, "HGNC", star.Gene, star.Gene).id
                };
                entityParts.Add(rootEntity);

                result_entities resultedOnEntity = new result_entities()
                {
                    patient_id = patient.id,
                    result_file_id = resultFile.id,
                    attribute_id = GetAttribute(null, null, "Resulted on", null).id,
                    parent = rootEntity,
                    value_date_time = resultedOn
                };
                entityParts.Add(resultedOnEntity);

                string[] splitStars = star.Result.Split(new string[] { "*" }, StringSplitOptions.RemoveEmptyEntries);
                foreach (var value in splitStars)
                {
                    result_entities alleleEntity = new result_entities()
                    {
                        patient_id = patient.id,
                        result_file_id = resultFile.id,
                        attribute_id = GetAttribute(null, null, "Star allele", null).id,
                        parent = rootEntity,
                        value_short_text = value
                    };
                    entityParts.Add(alleleEntity);
                }

                entities.result_entities.AddRange(entityParts);
                results.Add(rootEntity);
            }

            entities.SaveChanges();
            return results.ToArray();
        }
Esempio n. 11
0
        private string FormatResultEntityValue(result_entities entity)
        {
            if (entity == null)
            {
                return string.Empty;
            }

            if (entity.value_date_time.HasValue)
            {
                return entity.value_date_time.Value.ToShortDateString();
            }
            else if (entity.value_float.HasValue)
            {
                return entity.value_float.ToString();
            }
            else if (entity.value_int.HasValue)
            {
                return entity.value_int.ToString();
            }
            else if (!string.IsNullOrEmpty(entity.value_short_text))
            {
                return entity.value_short_text;
            }
            else if (!string.IsNullOrEmpty(entity.value_text))
            {
                return entity.value_text;
            }

            return string.Empty;
        }