/// <summary> /// Adds new task to db and tasks list. /// </summary> /// <param name="action"> /// The action. /// </param> /// <param name="taskType"> /// The task Type. /// </param> public long CreateTask(Func <Dictionary <string, string> > action, TaskType taskType) { CalculationTask databaseTask; Task task; using (var db = new LibiadaWebEntities()) { databaseTask = new CalculationTask { Created = DateTime.Now, Description = taskType.GetDisplayValue(), Status = TaskState.InQueue, UserId = AccountHelper.GetUserId(), TaskType = taskType }; db.CalculationTask.Add(databaseTask); db.SaveChanges(); } lock (tasks) { task = new Task(databaseTask.Id, action, databaseTask.UserId, taskType); lock (task) { tasks.Add(task); signalrHub.Send(TaskEvent.AddTask, task.TaskData); } } ManageTasks(); return(task.TaskData.Id); }
/// <summary> /// TExtracts alphabet elements ids for given sequence. /// </summary> /// <param name="db"> /// Database connection. /// </param> /// <param name="sequenceId"> /// The sequence id. /// </param> /// <returns> /// The <see cref="long[]"/>. /// </returns> public static long[] GetAlphabetElementIds(this LibiadaWebEntities db, long sequenceId) { var dbConnection = (NpgsqlConnection)db.Database.Connection; const string Query = "SELECT alphabet FROM chain WHERE id = @id"; var id = new NpgsqlParameter <long>("id", NpgsqlDbType.Bigint) { TypedValue = sequenceId }; long[] result; dbConnection.Open(); using (var command = new NpgsqlCommand(Query, dbConnection)) { command.Parameters.Add(id); using (NpgsqlDataReader reader = command.ExecuteReader()) { if (!reader.Read()) { dbConnection.Close(); throw new ArgumentException($"sequence id {sequenceId} does not exist", nameof(sequenceId)); } result = (long[])reader[0]; } } dbConnection.Close(); return(result); }
/// <summary> /// Initializes a new instance of the <see cref="LocalCalculationController"/> class. /// </summary> public LocalCalculationController() : base("Local calculation") { db = new LibiadaWebEntities(); commonSequenceRepository = new CommonSequenceRepository(db); characteristicTypeLinkRepository = new CharacteristicTypeLinkRepository(db); }
/// <summary> /// Finds user by it's id. /// </summary> /// <param name="id"> /// The user id. /// </param> /// <returns> /// The <see cref="Models.Account.ApplicationUser"/>. /// </returns> private static AspNetUser GetUserById(int id) { using (var db = new LibiadaWebEntities()) { return(db.AspNetUsers.Find(id)); } }
/// <summary> /// Send push notification to subscribers. /// </summary> /// <param name="userId"> /// User id for sending the push notification. /// </param> /// <param name="data"> /// Data dictionary containing push notification elements. /// </param> public static void Send(int userId, Dictionary <string, string> data) { using (var db = new LibiadaWebEntities()) { var subscribers = db.AspNetPushNotificationSubscribers.Where(s => s.UserId == userId); if (subscribers.Count() != 0) { foreach (var subscriber in subscribers) { var endpoint = subscriber.Endpoint; var p256dh = subscriber.P256dh; var auth = subscriber.Auth; var payload = JsonConvert.SerializeObject(data); var subscription = new PushSubscription(endpoint, p256dh, auth); var options = new Dictionary <string, object>(); options["TTL"] = 3600; var publicKey = ConfigurationManager.AppSettings["PublicVapidKey"]; var privateKey = ConfigurationManager.AppSettings["PrivateVapidKey"]; options["vapidDetails"] = new VapidDetails(subject, publicKey, privateKey); var webPushClient = new WebPushClient(); try { webPushClient.SendNotification(subscription, payload, options); } catch (WebPushException exception) { Debug.WriteLine("Http STATUS code: {0}", exception.StatusCode); } } } } }
/// <summary> /// Deletes the task by id. /// </summary> /// <param name="id"> /// The task id. /// </param> public void DeleteTask(long id) { lock (tasks) { Task task = tasks.Single(t => t.TaskData.Id == id); if (task.TaskData.UserId == AccountHelper.GetUserId() || AccountHelper.IsAdmin()) { lock (task) { if ((task.SystemTask != null) && (!task.SystemTask.IsCompleted)) { CancellationTokenSource cancellationTokenSource = task.CancellationTokenSource; cancellationTokenSource.Cancel(); cancellationTokenSource.Dispose(); } tasks.Remove(task); using (var db = new LibiadaWebEntities()) { CalculationTask databaseTask = db.CalculationTask.Find(id); db.CalculationTask.Remove(databaseTask); db.SaveChanges(); } signalrHub.Send(TaskEvent.DeleteTask, task.TaskData); } } } }
public ActionResult Index(long matterId) { return Action(() => { string matterName; Subsequence[] sequenceSubsequences; using (var db = new LibiadaWebEntities()) { long parentSequenceId = db.DnaSequence.Single(d => d.MatterId == matterId).Id; DnaSequence parentSequence = db.DnaSequence.Single(c => c.Id == parentSequenceId); var features = NcbiHelper.GetFeatures(parentSequence.RemoteId); using (var subsequenceImporter = new SubsequenceImporter(features, parentSequenceId)) { subsequenceImporter.CreateSubsequences(); } matterName = db.Matter.Single(m => m.Id == matterId).Name; sequenceSubsequences = db.Subsequence.Where(s => s.SequenceId == parentSequenceId) .Include(s => s.Position) .Include(s => s.Feature) .Include(s => s.SequenceAttribute) .ToArray(); } return new Dictionary<string, object> { { "matterName", matterName }, { "genes", sequenceSubsequences } }; }); }
/// <summary> /// Initializes a new instance of the <see cref="SequenceTransformerController"/> class. /// </summary> public SequenceTransformerController() { db = new LibiadaWebEntities(); dnaSequenceRepository = new GeneticSequenceRepository(db); commonSequenceRepository = new CommonSequenceRepository(db); elementRepository = new ElementRepository(db); }
/// <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); }
/// <summary> /// Deletes the task by id. /// </summary> /// <param name="id"> /// The task id. /// </param> public void DeleteTask(long id) { lock (tasks) { Task task = tasks.Single(t => t.TaskData.Id == id); if (task.TaskData.UserId == AccountHelper.GetUserId() || AccountHelper.IsAdmin()) { lock (task) { if (task.Thread != null && task.Thread.IsAlive) { task.Thread.Abort(); } tasks.Remove(task); using (var db = new LibiadaWebEntities()) { CalculationTask databaseTask = db.CalculationTask.Find(id); db.CalculationTask.Remove(databaseTask); db.SaveChanges(); } signalrHub.Send(TaskEvent.DeleteTask, task.TaskData); } } } }
/// <summary> /// The edit. /// </summary> /// <param name="id"> /// The id. /// </param> /// <returns> /// The <see cref="System.Threading.Tasks.Task"/>. /// </returns> public async Task <ActionResult> Edit(long?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } using (var db = new LibiadaWebEntities()) { Matter matter = await db.Matter.FindAsync(id); if (matter == null) { return(HttpNotFound()); } var groups = EnumExtensions.ToArray <Group>().ToSelectListWithNature(); var sequenceTypes = EnumExtensions.ToArray <SequenceType>().ToSelectListWithNature(); var natures = EnumHelper.GetSelectList(typeof(Nature), matter.Nature); var data = new Dictionary <string, object> { { "natures", natures }, { "groups", groups }, { "sequenceTypes", sequenceTypes }, { "matter", new StringedMatter(matter, db.CommonSequence.Count(c => c.MatterId == matter.Id)) } }; ViewBag.data = JsonConvert.SerializeObject(data); return(View(matter)); } }
/// <summary> /// The edit. /// </summary> /// <param name="id"> /// The id. /// </param> /// <returns> /// The <see cref="Task"/>. /// </returns> public async Task <ActionResult> Edit(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } SequenceGroup sequenceGroup = await db.SequenceGroup.FindAsync(id); if (sequenceGroup == null) { return(HttpNotFound()); } using (var db = new LibiadaWebEntities()) { var viewDataHelper = new ViewDataHelper(db); var viewData = viewDataHelper.FillViewData(1, int.MaxValue); var matterRepository = new MatterRepository(db); var matterIds = sequenceGroup.Matters.Select(m => m.Id); bool Selected(Matter m) => matterIds.Contains(m.Id); viewData["matters"] = matterRepository.GetMatterSelectList(db.Matter, Selected); viewData["sequenceGroupTypes"] = EnumExtensions.ToArray <SequenceGroupType>().ToSelectListWithNature(); ViewBag.data = JsonConvert.SerializeObject(viewData); } return(View(sequenceGroup)); }
/// <summary> /// The edit. /// </summary> /// <param name="id"> /// The id. /// </param> /// <returns> /// The <see cref="System.Threading.Tasks.Task"/>. /// </returns> public ActionResult Edit(long?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } using (var db = new LibiadaWebEntities()) { Matter matter = db.Matter.Include(m => m.Multisequence).SingleOrDefault(m => m.Id == id); if (matter == null) { return(HttpNotFound()); } var data = new Dictionary <string, object> { { "natures", EnumHelper.GetSelectList(typeof(Nature), matter.Nature) }, { "groups", EnumExtensions.ToArray <Group>().ToSelectListWithNature() }, { "sequenceTypes", EnumExtensions.ToArray <SequenceType>().ToSelectListWithNature() }, { "sequencesCount", db.CommonSequence.Count(c => c.MatterId == matter.Id) }, { "matter", matter }, { "multisequences", db.Multisequence.ToList() }, { "nature", ((byte)matter.Nature).ToString() }, { "group", ((byte)matter.Group).ToString() }, { "sequenceType", ((byte)matter.SequenceType).ToString() } }; ViewBag.data = JsonConvert.SerializeObject(data, new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore }); return(View(matter)); } }
public async Task <ActionResult> Edit( [Bind(Include = "Id,Name,Nature,Description,Group,SequenceType,MultisequenceId,MultisequenceNumber,CollectionCountry,CollectionDate")] Matter matter) { using (var db = new LibiadaWebEntities()) { if (ModelState.IsValid) { db.Entry(matter).State = EntityState.Modified; await db.SaveChangesAsync(); return(RedirectToAction("Index")); } var data = new Dictionary <string, object> { { "natures", EnumHelper.GetSelectList(typeof(Nature), matter.Nature) }, { "groups", EnumExtensions.ToArray <Group>().ToSelectListWithNature() }, { "sequenceTypes", EnumExtensions.ToArray <SequenceType>().ToSelectListWithNature() }, { "sequencesCount", db.CommonSequence.Count(c => c.MatterId == matter.Id) }, { "matter", matter }, { "multisequences", db.Multisequence.ToList() }, { "nature", ((byte)matter.Nature).ToString() }, { "group", ((byte)matter.Group).ToString() }, { "sequenceType", ((byte)matter.SequenceType).ToString() } }; ViewBag.data = JsonConvert.SerializeObject(data); return(View(matter)); } }
/// <summary> /// Initializes a new instance of the <see cref="SubsequencesSimilarityController"/> class. /// </summary> public SubsequencesSimilarityController() : base(TaskType.SubsequencesSimilarity) { db = new LibiadaWebEntities(); subsequenceExtractor = new SubsequenceExtractor(db); characteristicTypeLinkRepository = FullCharacteristicRepository.Instance; sequenceAttributeRepository = new SequenceAttributeRepository(db); }
/// <summary> /// The index. /// </summary> /// <returns> /// The <see cref="ActionResult"/>. /// </returns> public ActionResult Index() { var db = new LibiadaWebEntities(); var viewDataHelper = new ViewDataHelper(db); Func<CharacteristicType, bool> filter; if (UserHelper.IsAdmin()) { filter = c => c.FullSequenceApplicable; } else { filter = c => c.FullSequenceApplicable && Aliases.UserAvailableCharacteristics.Contains((Aliases.CharacteristicType)c.Id); } var data = new Dictionary<string, object> { { "characteristicTypes", viewDataHelper.GetCharacteristicTypes(filter) } }; var transformationLinks = new[] { Link.Start, Link.End, Link.CycleStart, Link.CycleEnd }; transformationLinks = transformationLinks.OrderBy(n => (int)n).ToArray(); data.Add("transformationLinks", transformationLinks.ToSelectList()); var operations = new List<SelectListItem> { new SelectListItem { Text = "Dissimilar", Value = 1.ToString() }, new SelectListItem { Text = "Higher order", Value = 2.ToString() } }; data.Add("operations", operations); ViewBag.data = JsonConvert.SerializeObject(data); return View(); }
public ActionResult Index(long[] matterIds) { return(CreateTask(() => { string[] matterNames; var results = new string[matterIds.Length]; var statuses = new string[matterIds.Length]; using (var db = new LibiadaWebEntities()) { matterNames = db.Matter .Where(m => matterIds.Contains(m.Id)) .OrderBy(m => m.Id) .Select(m => m.Name) .ToArray(); var parentSequences = db.DnaSequence .Where(c => matterIds.Contains(c.MatterId)) .OrderBy(c => c.MatterId) .ToArray(); for (int i = 0; i < parentSequences.Length; i++) { try { DnaSequence parentSequence = parentSequences[i]; using (var subsequenceImporter = new SubsequenceImporter(parentSequence)) { subsequenceImporter.CreateSubsequences(); } int featuresCount = db.Subsequence.Count(s => s.SequenceId == parentSequence.Id && s.Feature != Feature.NonCodingSequence); int nonCodingCount = db.Subsequence.Count(s => s.SequenceId == parentSequence.Id && s.Feature == Feature.NonCodingSequence); statuses[i] = "Success"; results[i] = $"Successfully imported {featuresCount} features and {nonCodingCount} non coding subsequences"; } catch (Exception exception) { statuses[i] = "Error"; results[i] = exception.Message; while (exception.InnerException != null) { results[i] += $" {exception.InnerException.Message}"; exception = exception.InnerException; } } } } return new Dictionary <string, object> { { "matterNames", matterNames }, { "results", results }, { "status", statuses } }; })); }
public ActionResult Index( long matterId, short characteristicLinkId, Notation notation, int step, int initialLength, string accuracy) { return(CreateTask(() => { string characteristicName; string matterName; double[] characteristics; Chain sequence; IFullCalculator calculator; Link link; using (var db = new LibiadaWebEntities()) { var commonSequenceRepository = new CommonSequenceRepository(db); matterName = Cache.GetInstance().Matters.Single(m => matterId == m.Id).Name; var sequenceId = db.CommonSequence.Single(c => matterId == c.MatterId && c.Notation == notation).Id; sequence = commonSequenceRepository.GetLibiadaChain(sequenceId); var characteristicTypeLinkRepository = FullCharacteristicRepository.Instance; characteristicName = characteristicTypeLinkRepository.GetCharacteristicName(characteristicLinkId, notation); FullCharacteristic characteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkId); calculator = FullCalculatorsFactory.CreateCalculator(characteristic); link = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkId); } // characteristics = SequencesCharacteristicsCalculator.Calculate( new[] { sequenceId }, characteristicLinkId); AverageRemoteness averageRemotenessCalc = new AverageRemoteness(); double averageRemoteness = averageRemotenessCalc.Calculate(sequence, Link.Start); Alphabet alphabet = sequence.Alphabet; var doubleAccuracy = double.Parse(accuracy); List <SequencePredictionData> sequencePredictionResult; Chain chain; (sequencePredictionResult, chain) = Predict(averageRemotenessCalc, sequence, initialLength, alphabet, averageRemoteness, doubleAccuracy); var matching = FindPercentageOfMatching(sequence, chain, initialLength) * 100; var result = new Dictionary <string, object> { { "result", sequencePredictionResult }, { "matterName", matterName }, { "matching", matching } }; return new Dictionary <string, string> { { "data", JsonConvert.SerializeObject(result) } }; })); }
/// <summary> /// The index. /// </summary> /// <returns> /// The <see cref="System.Threading.Tasks.Task"/>. /// </returns> public async Task <ActionResult> Index() { using (var db = new LibiadaWebEntities()) { var musicSequence = db.MusicSequence.Where(m => m.Notation == Notation.FormalMotifs).Include(m => m.Matter); return(View(await musicSequence.ToListAsync())); } }
/// <summary> /// Initializes a new instance of the <see cref="SubsequencesSimilarityController"/> class. /// </summary> public SubsequencesSimilarityController() : base("Subsequences similarity") { db = new LibiadaWebEntities(); subsequenceExtractor = new SubsequenceExtractor(db); characteristicTypeLinkRepository = new CharacteristicTypeLinkRepository(db); sequenceAttributeRepository = new SequenceAttributeRepository(db); }
/// <summary> /// The index. /// </summary> /// <returns> /// The <see cref="ActionResult"/>. /// </returns> public ActionResult Index() { using (var db = new LibiadaWebEntities()) { ViewBag.matterId = new SelectList(Cache.GetInstance().Matters.ToArray(), "id", "name"); return(View()); } }
/// <summary> /// Initializes a new instance of the <see cref="SequencesAlignmentController"/> class. /// </summary> public SequencesAlignmentController() : base("Sequences alignment") { db = new LibiadaWebEntities(); subsequenceExtractor = new SubsequenceExtractor(db); characteristicTypeLinkRepository = new CharacteristicTypeLinkRepository(db); featureRepository = new FeatureRepository(db); }
/// <summary> /// Retrieves attributes values of given subsequences from database. /// </summary> /// <param name="subsequenceIds"> /// Ids of subsequences which attributes values are to be retrieved. /// </param> /// <returns> /// Dictionary containing subsequences ids as keys and attributes values as values. /// </returns> private Dictionary <long, AttributeValue[]> GetSubsequencesAttributesValues(long[] subsequenceIds) { using (var db = new LibiadaWebEntities()) { var sequenceAttributeRepository = new SequenceAttributeRepository(db); return(sequenceAttributeRepository.GetAttributes(subsequenceIds)); } }
/// <summary> /// The index. /// </summary> /// <returns> /// The <see cref="System.Threading.Tasks.Task"/>. /// </returns> public async Task <ActionResult> Index() { using (var db = new LibiadaWebEntities()) { var commonSequence = db.CommonSequence.Include(c => c.Matter); return(View(await commonSequence.ToListAsync())); } }
/// <summary> /// Calculation method. /// </summary> /// <param name="chainCharacteristicsIds"> /// Dictionary with chain ids as a key /// and characteristicLink ids array as value. /// </param> /// <returns> /// The <see cref="T:double[][]"/>. /// </returns> public static Dictionary <long, Dictionary <short, double> > Calculate(Dictionary <long, short[]> chainCharacteristicsIds) { var newCharacteristics = new List <CharacteristicValue>(); var allCharacteristics = new Dictionary <long, Dictionary <short, double> >(); using (var db = new LibiadaWebEntities()) { short[] characteristicLinkIds = chainCharacteristicsIds.SelectMany(c => c.Value).Distinct().ToArray(); var characteristicTypeLinkRepository = FullCharacteristicRepository.Instance; var calculators = new Dictionary <short, LinkedFullCalculator>(); foreach (short characteristicLinkId in characteristicLinkIds) { Link link = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkId); FullCharacteristic characteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkId); calculators.Add(characteristicLinkId, new LinkedFullCalculator(characteristic, link)); } var commonSequenceRepository = new CommonSequenceRepository(db); long[] sequenceIds = chainCharacteristicsIds.Keys.ToArray(); foreach (long sequenceId in sequenceIds) { short[] sequenceCharacteristicLinkIds = chainCharacteristicsIds[sequenceId]; Dictionary <short, double> characteristics = db.CharacteristicValue .Where(c => sequenceId == c.SequenceId && sequenceCharacteristicLinkIds.Contains(c.CharacteristicLinkId)) .ToDictionary(ct => ct.CharacteristicLinkId, ct => ct.Value); allCharacteristics.Add(sequenceId, characteristics); if (characteristics.Count < sequenceCharacteristicLinkIds.Length) { Chain sequence = commonSequenceRepository.GetLibiadaChain(sequenceId); foreach (short sequenceCharacteristicLinkId in sequenceCharacteristicLinkIds) { if (!characteristics.ContainsKey(sequenceCharacteristicLinkId)) { LinkedFullCalculator calculator = calculators[sequenceCharacteristicLinkId]; double characteristicValue = calculator.Calculate(sequence); var characteristic = new CharacteristicValue { SequenceId = sequenceId, CharacteristicLinkId = sequenceCharacteristicLinkId, Value = characteristicValue }; characteristics.Add(sequenceCharacteristicLinkId, characteristicValue); newCharacteristics.Add(characteristic); } } } } var characteristicRepository = new CharacteristicRepository(db); characteristicRepository.TrySaveCharacteristicsToDatabase(newCharacteristics); return(allCharacteristics); } }
/// <summary> /// Initializes a new instance of the <see cref="ViewDataHelper"/> class. /// </summary> /// <param name="db"> /// The db. /// </param> public ViewDataHelper(LibiadaWebEntities db) { this.db = db; matterRepository = new MatterRepository(db); notationRepository = new NotationRepository(db); featureRepository = new FeatureRepository(db); characteristicTypeLinkRepository = new CharacteristicTypeLinkRepository(db); remoteDbRepository = new RemoteDbRepository(db); }
/// <summary> /// Initializes a new instance of the <see cref="SequencesMattersController"/> class. /// </summary> protected SequencesMattersController() : base("Sequence upload") { Db = new LibiadaWebEntities(); dnaSequenceRepository = new DnaSequenceRepository(Db); literatureSequenceRepository = new LiteratureSequenceRepository(Db); musicSequenceRepository = new MusicSequenceRepository(Db); dataSequenceRepository = new DataSequenceRepository(Db); }
/// <summary> /// The create. /// </summary> /// <returns> /// The <see cref="ActionResult"/>. /// </returns> public ActionResult Create() { using (var db = new LibiadaWebEntities()) { var viewDataHelper = new ViewDataHelper(db); ViewBag.data = JsonConvert.SerializeObject(viewDataHelper.FillMatterCreationViewData()); } return(View()); }
/// <summary> /// The index. /// </summary> /// <returns> /// The <see cref="ActionResult"/>. /// </returns> public ActionResult Index() { using (var db = new LibiadaWebEntities()) { var viewDataHelper = new ViewDataHelper(db); Dictionary <string, object> viewData = viewDataHelper.GetCharacteristicsData(CharacteristicCategory.Full); ViewBag.data = JsonConvert.SerializeObject(viewData); return(View()); } }
/// <summary> /// The index. /// </summary> /// <returns> /// The <see cref="ActionResult"/>. /// </returns> public ActionResult Index() { using (var db = new LibiadaWebEntities()) { var viewDataHelper = new ViewDataHelper(db); ViewBag.data = JsonConvert.SerializeObject(viewDataHelper.FillSubsequencesViewData(1, int.MaxValue, "Calculate")); } return(View()); }
/// <summary> /// The index. /// </summary> /// <returns> /// The <see cref="ActionResult"/>. /// </returns> public ActionResult Index() { using (var db = new LibiadaWebEntities()) { var viewDataHelper = new ViewDataHelper(db); ViewBag.data = JsonConvert.SerializeObject(viewDataHelper.FillSubsequencesViewData(1, int.MaxValue, "Calculate")); } return View(); }
/// <summary> /// Extracts sequence length from database. /// </summary> /// <param name="db"> /// The db. /// </param> /// <param name="sequenceId"> /// The sequence id. /// </param> /// <returns> /// The <see cref="int"/>. /// </returns> public static int GetSequenceLength(this LibiadaWebEntities db, long sequenceId) { const string Query = "SELECT cardinality(building) FROM chain WHERE id = @id"; var id = new NpgsqlParameter <long>("id", NpgsqlDbType.Bigint) { TypedValue = sequenceId }; return(db.Database.SqlQuery <int>(Query, id).First()); }
/// <summary> /// The index. /// </summary> /// <returns> /// The <see cref="ActionResult"/>. /// </returns> public ActionResult Index() { using (var db = new LibiadaWebEntities()) { var viewDataHelper = new ViewDataHelper(db); var viewData = viewDataHelper.FillViewData(CharacteristicCategory.Full, 1, int.MaxValue, "Calculate"); ViewBag.data = JsonConvert.SerializeObject(viewData); return(View()); } }
/// <summary> /// Initializes a new instance of the <see cref="SequenceMixerController"/> class. /// </summary> public SequenceMixerController() { db = new LibiadaWebEntities(); sequenceRepository = new CommonSequenceRepository(db); dnaSequenceRepository = new GeneticSequenceRepository(db); musicSequenceRepository = new MusicSequenceRepository(db); literatureSequenceRepository = new LiteratureSequenceRepository(db); dataSequenceRepository = new DataSequenceRepository(db); elementRepository = new ElementRepository(db); }
/// <summary> /// Calculation method. /// </summary> /// <param name="chains"> /// The chains. /// </param> /// <param name="calculators"> /// The calculators. /// </param> /// <param name="links"> /// The links. /// </param> /// <param name="characteristicTypeLinkIds"> /// The characteristic type link ids. /// </param> /// <returns> /// The <see cref="T:double[][]"/>. /// </returns> public static double[][] Calculate(Chain[][] chains, IFullCalculator[] calculators, Link[] links, int[] characteristicTypeLinkIds) { var newCharacteristics = new List<Characteristic>(); var characteristics = new double[chains.Length][]; var sequenceIds = chains.SelectMany(c => c).Select(c => c.Id).Distinct(); Dictionary<long, Dictionary<int, double>> dbCharacteristics; using (var db = new LibiadaWebEntities()) { dbCharacteristics = db.Characteristic .Where(c => characteristicTypeLinkIds.Contains(c.CharacteristicTypeLinkId) && sequenceIds.Contains(c.SequenceId)) .ToArray() .GroupBy(c => c.SequenceId) .ToDictionary(c => c.Key, c => c.ToDictionary(ct => ct.CharacteristicTypeLinkId, ct => ct.Value)); } for (int i = 0; i < chains.Length; i++) { characteristics[i] = new double[calculators.Length]; for (int j = 0; j < calculators.Length; j++) { long sequenceId = chains[i][j].Id; chains[i][j].FillIntervalManagers(); Dictionary<int, double> sequenceDbCharacteristics; if (!dbCharacteristics.TryGetValue(sequenceId, out sequenceDbCharacteristics)) { sequenceDbCharacteristics = new Dictionary<int, double>(); } if (!sequenceDbCharacteristics.TryGetValue(characteristicTypeLinkIds[j], out characteristics[i][j])) { characteristics[i][j] = calculators[j].Calculate(chains[i][j], links[j]); var currentCharacteristic = new Characteristic { SequenceId = sequenceId, CharacteristicTypeLinkId = characteristicTypeLinkIds[j], Value = characteristics[i][j] }; newCharacteristics.Add(currentCharacteristic); } } } // trying to save calculated characteristics to database using (var db = new LibiadaWebEntities()) { var characteristicRepository = new CharacteristicRepository(db); characteristicRepository.TrySaveCharacteristicsToDatabase(newCharacteristics); } return characteristics; }
/// <summary> /// The get subsequence characteristic. /// </summary> /// <param name="subsequenceId"> /// The subsequence id. /// </param> /// <param name="characteristicLinkId"> /// The characteristic type link id. /// </param> /// <param name="windowSize"> /// The window size. /// </param> /// <param name="step"> /// The step. /// </param> /// <returns> /// The <see cref="string"/>. /// </returns> public string GetSubsequenceCharacteristic( long subsequenceId, short characteristicLinkId, int windowSize, int step) { Chain chain; IFullCalculator calculator; Link link; using (var db = new LibiadaWebEntities()) { var characteristicTypeLinkRepository = FullCharacteristicRepository.Instance; FullCharacteristic characteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkId); calculator = FullCalculatorsFactory.CreateCalculator(characteristic); link = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkId); var subsequenceExtractor = new SubsequenceExtractor(db); Subsequence subsequence = db.Subsequence.Single(s => s.Id == subsequenceId); chain = subsequenceExtractor.GetSubsequenceSequence(subsequence); } CutRule cutRule = new SimpleCutRule(chain.Length, step, windowSize); CutRuleIterator iterator = cutRule.GetIterator(); var fragments = new List <Chain>(); while (iterator.Next()) { int start = iterator.GetStartPosition(); int end = iterator.GetEndPosition(); var fragment = new List <IBaseObject>(); for (int k = 0; start + k < end; k++) { fragment.Add(chain[start + k]); } fragments.Add(new Chain(fragment)); } var characteristics = new double[fragments.Count]; for (int k = 0; k < fragments.Count; k++) { characteristics[k] = calculator.Calculate(fragments[k], link); } return(JsonConvert.SerializeObject(characteristics)); }
/// <summary> /// Calculation method. /// </summary> /// <param name="chainIds"> /// The chains ids. /// </param> /// <param name="characteristicLinkIds"> /// The characteristic type link ids. /// </param> /// <param name="rotate"> /// The rotate flag. /// </param> /// <param name="complementary"> /// The complementary flag. /// </param> /// <param name="rotationLength"> /// The rotation length. /// </param> /// <returns> /// The <see cref="T:double[][]"/>. /// </returns> public static double[][] Calculate(long[][] chainIds, short[] characteristicLinkIds, bool rotate, bool complementary, uint?rotationLength) { var links = new Link[characteristicLinkIds.Length]; var calculators = new IFullCalculator[characteristicLinkIds.Length]; var characteristics = new double[chainIds.Length][]; long[] sequenceIds = chainIds.SelectMany(c => c).Distinct().ToArray(); var sequences = new Dictionary <long, Chain>(); using (var db = new LibiadaWebEntities()) { var commonSequenceRepository = new CommonSequenceRepository(db); for (int i = 0; i < sequenceIds.Length; i++) { sequences.Add(sequenceIds[i], commonSequenceRepository.GetLibiadaChain(sequenceIds[i])); } var characteristicTypeLinkRepository = FullCharacteristicRepository.Instance; for (int k = 0; k < characteristicLinkIds.Length; k++) { links[k] = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkIds[k]); FullCharacteristic characteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkIds[k]); calculators[k] = FullCalculatorsFactory.CreateCalculator(characteristic); } } for (int i = 0; i < chainIds.Length; i++) { characteristics[i] = new double[calculators.Length]; for (int j = 0; j < calculators.Length; j++) { long sequenceId = chainIds[i][j]; var sequence = (Chain)sequences[sequenceId].Clone(); if (complementary) { var sourceSequence = new Sequence(Alphabets.DNA, sequence.ToString()); ISequence complementarySequence = sourceSequence.GetReverseComplementedSequence(); sequence = new Chain(complementarySequence.ConvertToString()); } if (rotate) { int[] building = sequence.Building.Rotate(rotationLength ?? 0); List <IBaseObject> newSequence = building.Select(t => new ValueInt(t)).ToList <IBaseObject>(); sequence = new Chain(newSequence); } characteristics[i][j] = calculators[j].Calculate(sequence, links[j]); } } return(characteristics); }
/// <summary> /// The create. /// </summary> /// <returns> /// The <see cref="ActionResult"/>. /// </returns> public ActionResult Create() { using (var db = new LibiadaWebEntities()) { var viewDataHelper = new ViewDataHelper(db); var viewData = viewDataHelper.FillViewData(1, int.MaxValue); viewData["sequenceGroupTypes"] = EnumExtensions.ToArray <SequenceGroupType>().ToSelectListWithNature(); ViewBag.data = JsonConvert.SerializeObject(viewData); return(View()); } }
public void Create(ImageSequence sequence, LibiadaWebEntities db) { if (sequence.Id == default) { sequence.Id = db.GetNewElementId(); } var parameters = new List <NpgsqlParameter> { new NpgsqlParameter <long>("id", NpgsqlDbType.Bigint) { TypedValue = sequence.Id }, new NpgsqlParameter <byte>("notation", NpgsqlDbType.Smallint) { TypedValue = (byte)sequence.Notation }, new NpgsqlParameter <long>("matter_id", NpgsqlDbType.Bigint) { TypedValue = sequence.MatterId }, new NpgsqlParameter <byte[]>("image_transformations", NpgsqlDbType.Array | NpgsqlDbType.Smallint) { TypedValue = Array.Empty <byte>() }, new NpgsqlParameter <byte[]>("matrix_transformations", NpgsqlDbType.Array | NpgsqlDbType.Smallint) { TypedValue = Array.Empty <byte>() }, new NpgsqlParameter <byte>("order_extractor", NpgsqlDbType.Smallint) { TypedValue = (byte)sequence.OrderExtractor }, }; const string Query = @"INSERT INTO image_sequence ( id, notation, matter_id, image_transformations, matrix_transformations, order_extractor ) VALUES ( @id, @notation, @matter_id, @image_transformations, @matrix_transformations, @order_extractor );"; db.ExecuteCommand(Query, parameters.ToArray()); }
/// <summary> /// Removes not finished and not started tasks from database /// on task manager initialization. /// </summary> private void RemoveGarbageFromDb() { using (var db = new LibiadaWebEntities()) { var tasksToDelete = db.CalculationTask .Where(t => t.Status != TaskState.Completed && t.Status != TaskState.Error) .ToArray(); db.CalculationTask.RemoveRange(tasksToDelete); db.SaveChanges(); } }
public ActionResult Index(long[] matterIds) { return Action(() => { string[] matterNames; string[] results = new string[matterIds.Length]; string[] statuses = new string[matterIds.Length]; using (var db = new LibiadaWebEntities()) { matterNames = db.Matter.Where(m => matterIds.Contains(m.Id)).OrderBy(m => m.Id).Select(m => m.Name).ToArray(); var parentSequences = db.DnaSequence.Where(c => matterIds.Contains(c.MatterId)).OrderBy(c => c.MatterId); long[] parentSequenceIds = parentSequences.Select(c => c.Id).ToArray(); string[] parentRemoteIds = parentSequences.Select(c => c.RemoteId).ToArray(); var features = NcbiHelper.GetFeatures(parentRemoteIds); for (int i = 0; i < matterIds.Length; i++) { try { var parentSequenceId = parentSequenceIds[i]; using (var subsequenceImporter = new SubsequenceImporter(features[i], parentSequenceId)) { subsequenceImporter.CreateSubsequences(); } var nonCodingCount = db.Subsequence.Count(s => s.SequenceId == parentSequenceId && s.FeatureId == Aliases.Feature.NonCodingSequence); var featuresCount = db.Subsequence.Count(s => s.SequenceId == parentSequenceId && s.FeatureId != Aliases.Feature.NonCodingSequence); statuses[i] = "Success"; results[i] = "Successfully imported " + featuresCount + " features and " + nonCodingCount + " non coding subsequences"; } catch (Exception exception) { statuses[i] = "Error"; results[i] = exception.Message; if (exception.InnerException != null) { results[i] += " " + exception.InnerException.Message; } } } } return new Dictionary<string, object> { { "matterNames", matterNames }, { "results", results }, { "status", statuses } }; }); }
/// <summary> /// The index. /// </summary> /// <returns> /// The <see cref="ActionResult"/>. /// </returns> public ActionResult Index() { var db = new LibiadaWebEntities(); var genesSequenceIds = db.Subsequence.Select(s => s.SequenceId).Distinct(); var matterIds = db.DnaSequence.Include(c => c.Matter).Where(c => !string.IsNullOrEmpty(c.RemoteId) && !genesSequenceIds.Contains(c.Id) && (c.Matter.SequenceType == SequenceType.CompleteGenome || c.Matter.SequenceType == SequenceType.MitochondrionGenome || c.Matter.SequenceType == SequenceType.Plasmid)).Select(c => c.MatterId).ToList(); var viewDataHelper = new ViewDataHelper(db); var data = viewDataHelper.GetMattersData(1, 1, m => matterIds.Contains(m.Id), "Import"); data.Add("nature", (byte)Nature.Genetic); ViewBag.data = JsonConvert.SerializeObject(data); return View(); }
/// <summary> /// The index. /// </summary> /// <returns> /// The <see cref="ActionResult"/>. /// </returns> public ActionResult Index() { var db = new LibiadaWebEntities(); var viewDataHelper = new ViewDataHelper(db); Func<CharacteristicType, bool> filter; if (UserHelper.IsAdmin()) { filter = c => c.FullSequenceApplicable; } else { filter = c => c.FullSequenceApplicable && Aliases.UserAvailableCharacteristics.Contains((Aliases.CharacteristicType)c.Id); } ViewBag.data = JsonConvert.SerializeObject(viewDataHelper.FillViewData(filter, 1, int.MaxValue, "Calculate")); return View(); }
/// <summary> /// The execute custom sql command with parameters. /// </summary> /// <param name="db"> /// The db. /// </param> /// <param name="query"> /// The query. /// </param> /// <param name="parameters"> /// The parameters. /// </param> public static void ExecuteCommand(LibiadaWebEntities db, string query, object[] parameters) { db.Database.ExecuteSqlCommand(query, parameters); }
/// <summary> /// Initializes a new instance of the <see cref="ElementRepository"/> class. /// </summary> /// <param name="db"> /// The db. /// </param> public ElementRepository(LibiadaWebEntities db) { this.db = db; }
/// <summary> /// Gets building of sequence by id.. /// </summary> /// <param name="db"> /// Database connection. /// </param> /// <param name="sequenceId"> /// The sequence id. /// </param> /// <returns> /// The <see cref="T:int[]"/>. /// </returns> public static int[] GetBuilding(LibiadaWebEntities db, long sequenceId) { const string Query = "SELECT unnest(building) FROM chain WHERE id = @id"; return db.Database.SqlQuery<int>(Query, new NpgsqlParameter("@id", sequenceId)).ToArray(); }
/// <summary> /// Initializes a new instance of the <see cref="SequenceAttributeRepository"/> class. /// </summary> /// <param name="db"> /// The db. /// </param> public SequenceAttributeRepository(LibiadaWebEntities db) { this.db = db; attributeRepository = new AttributeRepository(); }
public ActionResult Index(long[] matterIds, int characteristicTypeLinkId, int[] characteristicTypeLinkIds, int[] featureIds) { return Action(() => { var matterNames = new string[matterIds.Length]; var remoteIds = new string[matterIds.Length]; var subsequencesCharacteristicsNames = new string[characteristicTypeLinkIds.Length]; var calculators = new IFullCalculator[characteristicTypeLinkIds.Length]; var links = new Link[characteristicTypeLinkIds.Length]; var subsequencesCharacteristicsList = new SelectListItem[characteristicTypeLinkIds.Length]; var attributeValues = new List<AttributeValue>(); IEnumerable<SelectListItem> featuresSelectList; Chain[] chains; long[] parentSequenceIds; string sequenceCharacteristicName; IFullCalculator calculator; Link link; using (var db = new LibiadaWebEntities()) { var featureRepository = new FeatureRepository(db); featuresSelectList = featureRepository.GetFeaturesById(featureIds).Select(f => new SelectListItem { Value = f.Id.ToString(), Text = f.Name, Selected = true }); var parentSequences = db.DnaSequence.Include(s => s.Matter) .Where(s => s.NotationId == Aliases.Notation.Nucleotide && matterIds.Contains(s.MatterId)) .Select(s => new { s.Id, MatterName = s.Matter.Name, s.RemoteId }) .ToDictionary(s => s.Id); parentSequenceIds = parentSequences.Keys.ToArray(); for (int n = 0; n < parentSequenceIds.Length; n++) { matterNames[n] = parentSequences[parentSequenceIds[n]].MatterName; remoteIds[n] = parentSequences[parentSequenceIds[n]].RemoteId; } var commonSequenceRepository = new CommonSequenceRepository(db); chains = commonSequenceRepository.GetNucleotideChains(matterIds); var characteristicTypeLinkRepository = new CharacteristicTypeLinkRepository(db); sequenceCharacteristicName = characteristicTypeLinkRepository.GetCharacteristicName(characteristicTypeLinkId); calculator = CalculatorsFactory.CreateFullCalculator(characteristicTypeLinkRepository.GetCharacteristicType(characteristicTypeLinkId).ClassName); link = characteristicTypeLinkRepository.GetLibiadaLink(characteristicTypeLinkId); for (int k = 0; k < characteristicTypeLinkIds.Length; k++) { links[k] = characteristicTypeLinkRepository.GetLibiadaLink(characteristicTypeLinkIds[k]); string className = characteristicTypeLinkRepository.GetCharacteristicType(characteristicTypeLinkIds[k]).ClassName; calculators[k] = CalculatorsFactory.CreateFullCalculator(className); subsequencesCharacteristicsNames[k] = characteristicTypeLinkRepository.GetCharacteristicName(characteristicTypeLinkIds[k]); subsequencesCharacteristicsList[k] = new SelectListItem { Value = k.ToString(), Text = subsequencesCharacteristicsNames[k], Selected = false }; } } var characteristics = SequencesCharacteristicsCalculator.Calculate(chains, calculator, link, characteristicTypeLinkId); var sequenceData = new SequenceData[parentSequenceIds.Length]; for (int i = 0; i < parentSequenceIds.Length; i++) { // all subsequence calculations var subsequencesData = SubsequencesCharacteristicsCalculator.CalculateSubsequencesCharacteristics( characteristicTypeLinkIds, featureIds, parentSequenceIds[i], calculators, links, attributeValues); sequenceData[i] = new SequenceData(matterIds[i], matterNames[i], remoteIds[i], characteristics[i], subsequencesData); } // sorting organisms by their characteristic sequenceData = sequenceData.OrderBy(r => r.Characteristic).ToArray(); var resultData = new Dictionary<string, object> { { "result", sequenceData }, { "subsequencesCharacteristicsNames", subsequencesCharacteristicsNames }, { "subsequencesCharacteristicsList", subsequencesCharacteristicsList }, { "sequenceCharacteristicName", sequenceCharacteristicName }, { "features", featuresSelectList.ToDictionary(f => f.Value) }, { "attributes", EnumExtensions.ToArray<Attribute>().ToDictionary(a => (byte)a, a => a.GetDisplayValue()) }, { "attributeValues", attributeValues.Select(sa => new { attribute = sa.AttributeId, value = sa.Value }) } }; return new Dictionary<string, object> { { "data", JsonConvert.SerializeObject(resultData) } }; }); }
/// <summary> /// Initializes a new instance of the <see cref="MatterRepository"/> class. /// </summary> /// <param name="db"> /// The db. /// </param> public MatterRepository(LibiadaWebEntities db) { this.db = db; }
/// <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); }
/// <summary> /// Initializes a new instance of the <see cref="BuildingsSimilarityController"/> class. /// </summary> public BuildingsSimilarityController() : base("Buildings comparison") { db = new LibiadaWebEntities(); sequenceRepository = new CommonSequenceRepository(db); }
/// <summary> /// Initializes a new instance of the <see cref="CharacteristicTypeLinkRepository"/> class. /// </summary> /// <param name="db"> /// The db. /// </param> public CharacteristicTypeLinkRepository(LibiadaWebEntities db) { characteristicTypeLinks = db.CharacteristicTypeLink.Include(ctl => ctl.CharacteristicType).Include(ctl => ctl.Link).ToList(); notations = db.Notation.ToList(); }
/// <summary> /// Initializes a new instance of the <see cref="DataSequenceRepository"/> class. /// </summary> /// <param name="db"> /// The db. /// </param> public DataSequenceRepository(LibiadaWebEntities db) : base(db) { }
public ActionResult Index( int[] transformationLinkIds, int[] transformationIds, int iterationsCount, int[] characteristicTypeLinkIds, string[] customSequences, bool localFile, HttpPostedFileBase[] file) { return Action(() => { var db = new LibiadaWebEntities(); var characteristicTypeLinkRepository = new CharacteristicTypeLinkRepository(db); int sequencesCount = localFile ? Request.Files.Count : customSequences.Length; var sequences = new string[sequencesCount]; var names = new string[sequencesCount]; for (int i = 0; i < sequencesCount; i++) { if (localFile) { var sequenceStream = FileHelper.GetFileStream(file[i]); var fastaSequence = NcbiHelper.GetFastaSequence(sequenceStream); sequences[i] = fastaSequence.ConvertToString(); names[i] = fastaSequence.ID; } else { sequences[i] = customSequences[i]; names[i] = "Custom sequence " + (i + 1) + ". Length: " + customSequences[i].Length; } } var characteristics = new double[sequences.Length, characteristicTypeLinkIds.Length]; for (int j = 0; j < sequences.Length; j++) { for (int k = 0; k < characteristicTypeLinkIds.Length; k++) { var sequence = new Chain(sequences[j]); for (int l = 0; l < iterationsCount; l++) { for (int w = 0; w < transformationIds.Length; w++) { if (transformationIds[w] == 1) { sequence = DissimilarChainFactory.Create(sequence); } else { sequence = HighOrderFactory.Create(sequence, (Link)transformationLinkIds[w]); } } } var link = characteristicTypeLinkRepository.GetLibiadaLink(characteristicTypeLinkIds[k]); string className = characteristicTypeLinkRepository.GetCharacteristicType(characteristicTypeLinkIds[k]).ClassName; var calculator = CalculatorsFactory.CreateFullCalculator(className); characteristics[j, k] = calculator.Calculate(sequence, link); } } var characteristicNames = characteristicTypeLinkIds.Select(c => characteristicTypeLinkRepository.GetCharacteristicName(c)).ToArray(); var characteristicsList = new SelectListItem[characteristicTypeLinkIds.Length]; for (int i = 0; i < characteristicNames.Length; i++) { characteristicsList[i] = new SelectListItem { Value = i.ToString(), Text = characteristicNames[i], Selected = false }; } var transformations = new Dictionary<int, string>(); for (int i = 0; i < transformationIds.Length; i++) { var link = ((Link)transformationLinkIds[i]).GetDisplayValue(); transformations.Add(i, transformationIds[i] == 1 ? "dissimilar" : "higher order " + link); } var result = new Dictionary<string, object> { { "characteristics", characteristics }, { "characteristicNames", characteristicNames }, { "characteristicsList", characteristicsList }, { "transformationsList", transformations }, { "iterationsCount", iterationsCount } }; return new Dictionary<string, object> { { "data", JsonConvert.SerializeObject(result) } }; }); }
/// <summary> /// Calculation method. /// </summary> /// <param name="chains"> /// The chains. /// </param> /// <param name="calculator"> /// The calculator. /// </param> /// <param name="link"> /// The link. /// </param> /// <param name="characteristicTypeLinkId"> /// The characteristic type link id. /// </param> /// <returns> /// The <see cref="T:double[]"/>. /// </returns> public static double[] Calculate(Chain[] chains, IFullCalculator calculator, Link link, int characteristicTypeLinkId) { var newCharacteristics = new List<Characteristic>(); var characteristics = new double[chains.Length]; var sequenceIds = chains.Select(c => c.Id); Dictionary<long, double> dbCharacteristics; using (var db = new LibiadaWebEntities()) { dbCharacteristics = db.Characteristic .Where(c => characteristicTypeLinkId == c.CharacteristicTypeLinkId && sequenceIds.Contains(c.SequenceId)) .ToArray() .GroupBy(c => c.SequenceId) .ToDictionary(c => c.Key, c => c.Single().Value); } for (int i = 0; i < chains.Length; i++) { chains[i].FillIntervalManagers(); long sequenceId = chains[i].Id; if (!dbCharacteristics.TryGetValue(sequenceId, out characteristics[i])) { characteristics[i] = calculator.Calculate(chains[i], link); var currentCharacteristic = new Characteristic { SequenceId = sequenceId, CharacteristicTypeLinkId = characteristicTypeLinkId, Value = characteristics[i] }; newCharacteristics.Add(currentCharacteristic); } } // trying to save calculated characteristics to database using (var db = new LibiadaWebEntities()) { var characteristicRepository = new CharacteristicRepository(db); characteristicRepository.TrySaveCharacteristicsToDatabase(newCharacteristics); } return characteristics; }
/// <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); }
public ActionResult Index( long[] matterIds, int[] characteristicTypeLinkIds, int[] notationIds, int[] languageIds, int?[] translatorIds, bool rotate, bool complementary, uint? rotationLength) { return Action(() => { var sequencesCharacteristics = new SequenceCharacteristics[matterIds.Length]; var characteristicNames = new string[characteristicTypeLinkIds.Length]; var characteristicsList = new SelectListItem[characteristicTypeLinkIds.Length]; var links = new Link[characteristicTypeLinkIds.Length]; var calculators = new IFullCalculator[characteristicTypeLinkIds.Length]; Dictionary<long, string> mattersNames; double[][] characteristics; Chain[][] chains; using (var db = new LibiadaWebEntities()) { mattersNames = db.Matter.Where(m => matterIds.Contains(m.Id)).ToDictionary(m => m.Id, m => m.Name); var commonSequenceRepository = new CommonSequenceRepository(db); chains = commonSequenceRepository.GetChains(matterIds, notationIds, languageIds, translatorIds); var characteristicTypeLinkRepository = new CharacteristicTypeLinkRepository(db); for (int k = 0; k < characteristicTypeLinkIds.Length; k++) { links[k] = characteristicTypeLinkRepository.GetLibiadaLink(characteristicTypeLinkIds[k]); string className = characteristicTypeLinkRepository.GetCharacteristicType(characteristicTypeLinkIds[k]).ClassName; calculators[k] = CalculatorsFactory.CreateFullCalculator(className); characteristicNames[k] = characteristicTypeLinkRepository.GetCharacteristicName(characteristicTypeLinkIds[k], notationIds[k]); characteristicsList[k] = new SelectListItem { Value = k.ToString(), Text = characteristicNames[k], Selected = false }; } } if (!rotate && !complementary) { characteristics = SequencesCharacteristicsCalculator.Calculate(chains, calculators, links, characteristicTypeLinkIds); } else { characteristics = SequencesCharacteristicsCalculator.Calculate(chains, calculators, links, rotate, complementary, rotationLength); } for (int i = 0; i < matterIds.Length; i++) { sequencesCharacteristics[i] = new SequenceCharacteristics { MatterName = mattersNames[matterIds[i]], Characteristics = characteristics[i] }; } var result = new Dictionary<string, object> { { "characteristics", sequencesCharacteristics }, { "characteristicNames", characteristicNames }, { "characteristicsList", characteristicsList } }; return new Dictionary<string, object> { { "data", JsonConvert.SerializeObject(result) } }; }); }
/// <summary> /// Initializes a new instance of the <see cref="OrderTransformerController"/> class. /// </summary> public OrderTransformerController() : base("Order transformation") { db = new LibiadaWebEntities(); commonSequenceRepository = new CommonSequenceRepository(db); }
public ActionResult Index( long[] matterIds, int characteristicTypeLinkId, int[] featureIds, string maxPercentageDifference, double characteristicValueFrom, double characteristicValueTo) { return Action(() => { Dictionary<int, string> features; var attributeValues = new List<AttributeValue>(); var characteristics = new SubsequenceData[matterIds.Length][]; string characteristicName; long[] parentSequenceIds; var matterNames = new string[matterIds.Length]; IFullCalculator calculator; Link link; int mattersCount = matterIds.Length; int[] subsequencesCount = new int[mattersCount]; using (var db = new LibiadaWebEntities()) { var featureRepository = new FeatureRepository(db); features = featureRepository.Features.ToDictionary(f => f.Id, f => f.Name); var parentSequences = db.DnaSequence.Include(s => s.Matter) .Where(s => s.NotationId == Aliases.Notation.Nucleotide && matterIds.Contains(s.MatterId)) .Select(s => new { s.Id, MatterName = s.Matter.Name }) .ToDictionary(s => s.Id); parentSequenceIds = parentSequences.Keys.ToArray(); for (int n = 0; n < parentSequenceIds.Length; n++) { matterNames[n] = parentSequences[parentSequenceIds[n]].MatterName; } var characteristicTypeLinkRepository = new CharacteristicTypeLinkRepository(db); characteristicName = characteristicTypeLinkRepository.GetCharacteristicName(characteristicTypeLinkId); string className = characteristicTypeLinkRepository.GetCharacteristicType(characteristicTypeLinkId).ClassName; calculator = CalculatorsFactory.CreateFullCalculator(className); link = characteristicTypeLinkRepository.GetLibiadaLink(characteristicTypeLinkId); } // cycle through matters; first level of characteristics array for (int i = 0; i < parentSequenceIds.Length; i++) { var subsequencesData = SubsequencesCharacteristicsCalculator.CalculateSubsequencesCharacteristics( new[] { characteristicTypeLinkId }, featureIds, parentSequenceIds[i], new[] { calculator }, new[] { link }, attributeValues); subsequencesCount[i] = subsequencesData.Length; subsequencesData = subsequencesData.Where(c => (characteristicValueFrom == 0 && characteristicValueTo == 0) || (c.CharacteristicsValues[0] >= characteristicValueFrom && c.CharacteristicsValues[0] <= characteristicValueTo)). OrderBy(c => c.CharacteristicsValues[0]).ToArray(); characteristics[i] = subsequencesData; } double decimalDifference = double.Parse(maxPercentageDifference, CultureInfo.InvariantCulture) / 100; var similarities = new object[mattersCount, mattersCount]; var equalElements = new List<SubsequenceComparisonData>(); int comparisonNumber = 0; for (int i = 0; i < characteristics.Length; i++) { for (int j = 0; j < characteristics.Length; j++) { comparisonNumber++; double similarSequencesCharacteristicValueFirst = 0; var similarSequencesCharacteristicValueSecond = new Dictionary<int, double>(); double similarFirstSequencesCharacteristicValue = 0; double similarSecondSequencesCharacteristicValue = 0; int secondArrayStartPosition = 0; double differenceSum = 0; int equalElementsCountFromFirst = 0; var equalElementsCountFromSecond = new Dictionary<int, int>(); bool equalFound = false; int equalPairsCount = 0; for (int k = 0; k < characteristics[i].Length; k++) { double first = characteristics[i][k].CharacteristicsValues[0]; for (int l = secondArrayStartPosition; l < characteristics[j].Length; l++) { double second = characteristics[j][l].CharacteristicsValues[0]; double difference = calculateAverageDifference(first, second); bool nextElementInSecondArrayIsEqual = false; if (l < characteristics[j].Length - 1) { nextElementInSecondArrayIsEqual = calculateAverageDifference(second, characteristics[j][l + 1].CharacteristicsValues[0]) <= decimalDifference; } if (difference <= decimalDifference) { equalFound = true; equalPairsCount++; if (!equalElementsCountFromSecond.ContainsKey(l)) { equalElementsCountFromSecond.Add(l, 1); differenceSum += difference; } if (!similarSequencesCharacteristicValueSecond.ContainsKey(l)) { similarSequencesCharacteristicValueSecond.Add(l, second); } if (i != j) { equalElements.Add(new SubsequenceComparisonData { Difference = difference, FirstMatterId = i, SecondMatterId = j, FirstSubsequenceId = k, SecondSubsequenceId = l, }); } similarFirstSequencesCharacteristicValue += first; similarSecondSequencesCharacteristicValue += second; if (!nextElementInSecondArrayIsEqual) { break; } } else if (second < first) { secondArrayStartPosition++; } } if (equalFound) { equalElementsCountFromFirst++; similarSequencesCharacteristicValueFirst += first; } } double differenceSecondFinal = equalElementsCountFromSecond.Sum(s => s.Value); double differenceFinal = equalElementsCountFromFirst < differenceSecondFinal ? equalElementsCountFromFirst * 2d : differenceSecondFinal * 2d; double formula1 = differenceFinal / (subsequencesCount[i] + subsequencesCount[j]); double formula2 = 0; if (equalPairsCount != 0 && formula1 != 0) { formula2 = (differenceSum / equalPairsCount) / formula1; } double similarSequencesCharacteristicValueSecondFinal = similarSequencesCharacteristicValueSecond.Sum(s => s.Value); double similarSequencesCharacteristicValue = similarSequencesCharacteristicValueFirst < similarSequencesCharacteristicValueSecondFinal ? similarSequencesCharacteristicValueFirst * 2d : similarSequencesCharacteristicValueSecondFinal * 2d; double formula3 = similarSequencesCharacteristicValue * 100d / (characteristics[i].Sum(c => c.CharacteristicsValues[0]) + characteristics[j].Sum(c => c.CharacteristicsValues[0])); similarities[i, j] = new { formula1 = Math.Round(formula1 * 100d, 3), formula2 = Math.Round(formula2, 3), formula3 = Math.Round(formula3, 3) }; } } var result = new Dictionary<string, object> { { "mattersNames", matterNames }, { "characteristicName", characteristicName }, { "similarities", similarities }, { "characteristics", characteristics }, { "equalElements", equalElements.OrderBy(e => e.Difference).ToList() }, { "features", features }, { "attributeValues", attributeValues.Select(sa => new { attribute = sa.AttributeId, value = sa.Value }) }, { "attributes", EnumExtensions.ToArray<LibiadaWeb.Attribute>().ToDictionary(a => (byte)a, a => a.GetDisplayValue()) } }; return new Dictionary<string, object> { { "data", JsonConvert.SerializeObject(result) } }; }); }
public ActionResult Index(string[] accessions, bool importGenes) { return Action(() => { var matterNames = new string[accessions.Length]; var savedMatterNames = new string[accessions.Length]; var results = new string[accessions.Length]; var statuses = new string[accessions.Length]; using (var db = new LibiadaWebEntities()) { var existingAccessions = db.DnaSequence.Select(d => d.RemoteId).Distinct().ToArray(); var dnaSequenceRepository = new DnaSequenceRepository(db); var bioSequences = NcbiHelper.GetGenBankSequences(accessions); for (int i = 0; i < accessions.Length; i++) { string accession = accessions[i]; matterNames[i] = accession; if (existingAccessions.Contains(accession) || existingAccessions.Contains(accession + ".1")) { results[i] = "Sequence already exists"; statuses[i] = "Exist"; continue; } try { var metadata = NcbiHelper.GetMetadata(bioSequences[i]); if (existingAccessions.Contains(metadata.Version.CompoundAccession)) { results[i] = "Sequence already exists"; statuses[i] = "Exist"; continue; } savedMatterNames[i] = NcbiHelper.ExtractSequenceName(metadata) + " | " + metadata.Version.CompoundAccession; matterNames[i] = "Common name=" + metadata.Source.CommonName + ", Species=" + metadata.Source.Organism.Species + ", Definition=" + metadata.Definition + ", Saved matter name=" + savedMatterNames[i]; var matter = new Matter { Name = savedMatterNames[i], Nature = Nature.Genetic, Group = GroupRepository.ExtractSequenceGroup(savedMatterNames[i]), SequenceType = SequenceTypeRepsitory.ExtractSequenceGroup(savedMatterNames[i]) }; var sequence = new CommonSequence { Matter = matter, NotationId = Aliases.Notation.Nucleotide, RemoteDbId = Aliases.RemoteDb.RemoteDbNcbi, RemoteId = metadata.Version.CompoundAccession }; dnaSequenceRepository.Create(sequence, bioSequences[i], metadata.Definition.ToLower().Contains("partial")); if (importGenes) { try { using (var subsequenceImporter = new SubsequenceImporter(metadata.Features.All, sequence.Id)) { subsequenceImporter.CreateSubsequences(); } var nonCodingCount = db.Subsequence.Count(s => s.SequenceId == sequence.Id && s.FeatureId == Aliases.Feature.NonCodingSequence); var featuresCount = db.Subsequence.Count(s => s.SequenceId == sequence.Id && s.FeatureId != Aliases.Feature.NonCodingSequence); statuses[i] = "Success"; results[i] = "Successfully imported sequence and " + featuresCount + " features and " + nonCodingCount + " non coding subsequences"; } catch (Exception exception) { results[i] = "successfully imported sequence but failed to import genes: " + exception.Message; statuses[i] = "Error"; if (exception.InnerException != null) { results[i] += " " + exception.InnerException.Message; } } } else { results[i] = "successfully imported sequence"; statuses[i] = "Success"; } } catch (Exception exception) { results[i] = "Error:" + exception.Message + (exception.InnerException == null ? string.Empty : exception.InnerException.Message); statuses[i] = "Error"; } } // removing matters for whitch adding of sequence failed var orphanMatters = db.Matter.Include(m => m.Sequence).Where(m => savedMatterNames.Contains(m.Name) && m.Sequence.Count == 0).ToArray(); if (orphanMatters.Length > 0) { db.Matter.RemoveRange(orphanMatters); db.SaveChanges(); } } return new Dictionary<string, object> { { "matterNames", matterNames }, { "results", results }, { "status", statuses } }; }); }