The element repository.
Inheritance: IElementRepository
        /// <summary>
        /// Creates literature sequence in database.
        /// </summary>
        /// <param name="commonSequence">
        /// The common sequence.
        /// </param>
        /// <param name="sequenceStream">
        /// The sequence stream.
        /// </param>
        /// <param name="language">
        /// The language id.
        /// </param>
        /// <param name="original">
        /// The original.
        /// </param>
        /// <param name="translator">
        /// The translator id.
        /// </param>
        /// <param name="dropPunctuation">
        /// Flag indicating if punctuation should be removed from text.
        /// </param>
        public void Create(CommonSequence commonSequence, Stream sequenceStream, Language language, bool original, Translator translator, bool dropPunctuation = false)
        {
            string    stringSequence = FileHelper.ReadSequenceFromStream(sequenceStream);
            BaseChain chain;

            if (commonSequence.Notation == Notation.Letters)
            {
                stringSequence = stringSequence.ToUpper();
                if (dropPunctuation)
                {
                    stringSequence = new string(stringSequence.Where(c => !char.IsPunctuation(c)).ToArray());
                }
                chain = new BaseChain(stringSequence);
            }
            else
            {
                // file always contains empty string at the end
                // TODO: rewrite this, add empty string check at the end or write a normal trim
                string[] text = stringSequence.Split(new[] { '\n', '\r', ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
                chain = new BaseChain(text.Select(e => (ValueString)e).Cast <IBaseObject>().ToList());
            }

            MatterRepository.CreateOrExtractExistingMatterForSequence(commonSequence);

            long[] alphabet = ElementRepository.ToDbElements(chain.Alphabet, commonSequence.Notation, true);
            Create(commonSequence, original, language, translator, alphabet, chain.Building);
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="SequenceTransformerController"/> class.
 /// </summary>
 public SequenceTransformerController()
 {
     db = new LibiadaWebEntities();
     dnaSequenceRepository = new DnaSequenceRepository(db);
     commonSequenceRepository = new CommonSequenceRepository(db);
     elementRepository = new ElementRepository(db);
 }
Example #3
0
        /// <summary>
        /// Saves measures to db.
        /// </summary>
        /// <param name="measure">
        /// The measure.
        /// </param>
        /// <returns>
        /// The <see cref="long"/>.
        /// </returns>
        public long CreateMeasure(Measure measure)
        {
            var measureChain = new BaseChain(measure.NoteList.Cast <IBaseObject>().ToList());

            long[] notes = new ElementRepository(db).GetOrCreateNotesInDb(measureChain.Alphabet);

            string localMeasureHash = measure.GetHashCode().ToString();
            var    dbMeasures       = db.Measure.Where(m => m.Value == localMeasureHash).ToList();

            if (dbMeasures.Count > 0)
            {
                foreach (var dbMeasure in dbMeasures)
                {
                    long[] dbAlphabet = db.GetMeasureAlphabet(dbMeasure.Id);
                    if (notes.SequenceEqual(dbAlphabet))
                    {
                        int[] dbBuilding = db.GetMeasureBuilding(dbMeasure.Id);
                        if (measureChain.Building.SequenceEqual(dbBuilding))
                        {
                            if (measure.Attributes.Key.Fifths != dbMeasure.Fifths ||
                                measure.Attributes.Size.BeatBase != dbMeasure.Beatbase ||
                                measure.Attributes.Size.Beats != dbMeasure.Beats)
                            {
                                throw new Exception("Found in db measure is not equal to local measure.");
                            }

                            return(dbMeasure.Id);
                        }
                    }
                }
            }

            return(Create(measure, notes, measureChain.Building));
        }
Example #4
0
        /// <summary>
        /// Saves Fmotifs to db.
        /// </summary>
        /// <param name="fmotif">
        /// The Fmotif.
        /// </param>
        /// <returns>
        /// The <see cref="long"/>.
        /// </returns>
        public long CreateFmotif(Fmotif fmotif)
        {
            var fmotifChain = new BaseChain(fmotif.NoteList.Cast <IBaseObject>().ToList());

            long[] notes = new ElementRepository(db).GetOrCreateNotesInDb(fmotifChain.Alphabet);

            var localFmotifHash = fmotif.GetHashCode().ToString();
            var dbFmotifs       = db.Fmotif.Where(f => f.Value == localFmotifHash).ToList();

            if (dbFmotifs.Count > 0)
            {
                foreach (var dbFmotif in dbFmotifs)
                {
                    long[] dbAlphabet = db.GetFmotifAlphabet(dbFmotif.Id);
                    if (notes.SequenceEqual(dbAlphabet))
                    {
                        int[] dbBuilding = db.GetFmotifBuilding(dbFmotif.Id);
                        if (fmotifChain.Building.SequenceEqual(dbBuilding))
                        {
                            if (fmotif.Type != dbFmotif.FmotifType)
                            {
                                throw new Exception("Found in db fmotif is not equal to local fmotif.");
                            }

                            return(dbFmotif.Id);
                        }
                    }
                }
            }

            return(Create(fmotif, notes, fmotifChain.Building));
        }
Example #5
0
        /// <summary>
        /// Create data sequence and matter.
        /// </summary>
        /// <param name="sequence">
        /// The common sequence.
        /// </param>
        /// <param name="sequenceStream">
        /// The sequence stream.
        /// </param>
        /// <param name="precision">
        /// Precision of data sequence.
        /// </param>
        public void Create(CommonSequence sequence, Stream sequenceStream, int precision)
        {
            string stringSequence = FileHelper.ReadSequenceFromStream(sequenceStream);

            string[] text = stringSequence.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);

            string[] cleanedSequence = text.Where(t => !t.Equals("\"volume\"") && !string.IsNullOrEmpty(t) && !string.IsNullOrWhiteSpace(t)).ToArray();

            var elements = new List <IBaseObject>(cleanedSequence.Length);

            for (int i = 0; i < cleanedSequence.Length; i++)
            {
                string element = cleanedSequence[i];
                if (element.Substring(element.Length - 2, 2).Equals(".0"))
                {
                    cleanedSequence[i] = cleanedSequence[i].Substring(0, cleanedSequence[i].Length - 2);
                }

                int intElement = int.Parse(cleanedSequence[i]);
                int multiplier = (int)Math.Pow(10, precision);
                intElement /= multiplier;
                intElement *= multiplier;

                elements.Add(new ValueInt(intElement));
            }

            var chain = new BaseChain(elements);

            MatterRepository.CreateOrExtractExistingMatterForSequence(sequence);

            long[] alphabet = ElementRepository.ToDbElements(chain.Alphabet, sequence.Notation, true);
            Create(sequence, alphabet, chain.Building);
        }
        /// <summary>
        /// The create.
        /// </summary>
        /// <param name="sequence">
        /// The sequence.
        /// </param>
        /// <param name="sequenceStream">
        /// The sequence stream.
        /// </param>
        /// <exception cref="Exception">
        /// Thrown if congeneric tracks count not equals 1 (track is not monophonic).
        /// </exception>
        public void Create(CommonSequence sequence, Stream sequenceStream)
        {
            string stringSequence = FileHelper.ReadSequenceFromStream(sequenceStream);
            var    doc            = new XmlDocument();

            doc.LoadXml(stringSequence);

            var parser = new MusicXmlParser();

            parser.Execute(doc);
            ScoreTrack tempTrack = parser.ScoreModel;

            if (tempTrack.CongenericScoreTracks.Count != 1)
            {
                throw new Exception("Track contains more then one or zero congeneric score tracks (parts).");
            }

            MatterRepository.CreateOrExtractExistingMatterForSequence(sequence);

            BaseChain notesSequence = ConvertCongenericScoreTrackToNotesBaseChain(tempTrack.CongenericScoreTracks[0]);

            long[] notesAlphabet = ElementRepository.GetOrCreateNotesInDb(notesSequence.Alphabet);
            sequence.Notation = Notation.Notes;
            Create(sequence, notesAlphabet, notesSequence.Building);

            BaseChain measuresSequence = ConvertCongenericScoreTrackToMeasuresBaseChain(tempTrack.CongenericScoreTracks[0]);

            long[] measuresAlphabet = MeasureRepository.GetOrCreateMeasuresInDb(measuresSequence.Alphabet);
            sequence.Notation = Notation.Measures;
            sequence.Id       = default;
            Create(sequence, measuresAlphabet, measuresSequence.Building);

            sequence.Notation = Notation.FormalMotifs;
            var pauseTreatments = EnumExtensions.ToArray <PauseTreatment>().Where(pt => pt != PauseTreatment.NotApplicable);

            foreach (PauseTreatment pauseTreatment in pauseTreatments)
            {
                BaseChain fmotifsSequence = ConvertCongenericScoreTrackToFormalMotifsBaseChain(tempTrack.CongenericScoreTracks[0], pauseTreatment, false);
                long[]    fmotifsAlphabet = FmotifRepository.GetOrCreateFmotifsInDb(fmotifsSequence.Alphabet);
                sequence.Id = default;
                Create(sequence, fmotifsAlphabet, fmotifsSequence.Building, pauseTreatment, false);

                fmotifsSequence = ConvertCongenericScoreTrackToFormalMotifsBaseChain(tempTrack.CongenericScoreTracks[0], pauseTreatment, true);
                fmotifsAlphabet = FmotifRepository.GetOrCreateFmotifsInDb(fmotifsSequence.Alphabet);
                sequence.Id     = default;
                Create(sequence, fmotifsAlphabet, fmotifsSequence.Building, pauseTreatment, true);
            }
        }
        /// <summary>
        /// The create DNA sequence.
        /// </summary>
        /// <param name="sequence">
        /// The common sequence.
        /// </param>
        /// <param name="fastaSequence">
        /// Sequence as <see cref="ISequence"/>>.
        /// </param>
        /// <param name="partial">
        /// The partial.
        /// </param>
        /// <exception cref="Exception">
        /// Thrown if at least one element of new sequence is missing in db
        /// or if sequence is empty or invalid.
        /// </exception>
        public void Create(CommonSequence sequence, ISequence fastaSequence, bool partial)
        {
            if (fastaSequence.ID.Contains("Resource temporarily unavailable"))
            {
                throw new Exception("Sequence is empty or invalid (probably ncbi is not responding).");
            }

            string stringSequence = fastaSequence.ConvertToString().ToUpper();

            var chain = new BaseChain(stringSequence);

            if (!ElementRepository.ElementsInDb(chain.Alphabet, sequence.Notation))
            {
                throw new Exception("At least one element of new sequence is invalid (not A, C, T, G or U).");
            }

            MatterRepository.CreateOrExtractExistingMatterForSequence(sequence);

            long[] alphabet = ElementRepository.ToDbElements(chain.Alphabet, sequence.Notation, false);
            Create(sequence, partial, alphabet, chain.Building);
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="SequenceElementsController"/> class.
 /// </summary>
 public SequenceElementsController()
 {
     db = new LibiadaWebEntities();
     elementRepository = new ElementRepository(db);
     sequenceRepository = new CommonSequenceRepository(db);
 }
Example #9
0
 /// <summary>
 /// The get elements.
 /// </summary>
 /// <param name="sequenceId">
 /// The sequence id.
 /// </param>
 /// <returns>
 /// The <see cref="List{element}"/>.
 /// </returns>
 public List <Element> GetElements(long sequenceId)
 {
     long[] elementIds = Db.GetAlphabetElementIds(sequenceId);
     return(ElementRepository.GetElements(elementIds));
 }
Example #10
0
 /// <summary>
 /// The get alphabet.
 /// </summary>
 /// <param name="sequenceId">
 /// The sequence id.
 /// </param>
 /// <returns>
 /// The <see cref="Alphabet"/>.
 /// </returns>
 private Alphabet GetAlphabet(long sequenceId)
 {
     long[] elements = Db.GetAlphabetElementIds(sequenceId);
     return(ElementRepository.ToLibiadaAlphabet(elements));
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="SequenceImporter"/> class.
 /// </summary>
 /// <param name="db">
 /// The db.
 /// </param>
 protected SequenceImporter(LibiadaWebEntities db)
 {
     Db = db;
     MatterRepository = new MatterRepository(db);
     ElementRepository = new ElementRepository(db);
 }
Example #12
0
 /// <summary>
 /// Initializes a new instance of the <see cref="SequenceImporter"/> class.
 /// </summary>
 /// <param name="db">
 /// The db.
 /// </param>
 protected SequenceImporter(LibiadaWebEntities db)
 {
     Db = db;
     MatterRepository  = new MatterRepository(db);
     ElementRepository = new ElementRepository(db);
 }