public ActionResult Index(
string searchQuery,
bool importGenes,
bool importPartial,
bool filterMinLength,
int minLength,
bool filterMaxLength,
int maxLength)
{
return(CreateTask(() =>
{
string searchResults;
string[] accessions;
List <NuccoreObject> nuccoreObjects;
if (filterMinLength)
{
searchResults = filterMaxLength ?
NcbiHelper.FormatNcbiSearchTerm(searchQuery, minLength, maxLength: maxLength) :
NcbiHelper.FormatNcbiSearchTerm(searchQuery, minLength);
}
else
{
searchResults = filterMaxLength ?
NcbiHelper.FormatNcbiSearchTerm(searchQuery, minLength: 1, maxLength: maxLength) :
NcbiHelper.FormatNcbiSearchTerm(searchQuery);
}
nuccoreObjects = NcbiHelper.ExecuteESummaryRequest(searchResults, importPartial);
accessions = nuccoreObjects.Select(no => no.AccessionVersion.Split('.')[0]).Distinct().ToArray();
var importResults = new List <MatterImportResult>(accessions.Length);
using (var db = new LibiadaWebEntities())
{
var matterRepository = new MatterRepository(db);
var dnaSequenceRepository = new GeneticSequenceRepository(db);
var(existingAccessions, accessionsToImport) = dnaSequenceRepository.SplitAccessionsIntoExistingAndNotImported(accessions);
importResults.AddRange(existingAccessions.ConvertAll(existingAccession => new MatterImportResult
{
MatterName = existingAccession,
Result = "Sequence already exists",
Status = "Exists"
}));
foreach (string accession in accessionsToImport)
{
var importResult = new MatterImportResult()
{
MatterName = accession
};
try
{
ISequence bioSequence = NcbiHelper.DownloadGenBankSequence(accession);
GenBankMetadata metadata = NcbiHelper.GetMetadata(bioSequence);
importResult.MatterName = metadata.Version.CompoundAccession;
Matter matter = matterRepository.CreateMatterFromGenBankMetadata(metadata);
importResult.SequenceType = matter.SequenceType.GetDisplayValue();
importResult.Group = matter.Group.GetDisplayValue();
importResult.MatterName = matter.Name;
importResult.AllNames = $"Common name = {metadata.Source.CommonName}, "
+ $"Species = {metadata.Source.Organism.Species}, "
+ $"Definition = {metadata.Definition}, "
+ $"Saved matter name = {importResult.MatterName}";
var sequence = new CommonSequence
{
Matter = matter,
Notation = Notation.Nucleotides,
RemoteDb = RemoteDb.GenBank,
RemoteId = metadata.Version.CompoundAccession
};
bool partial = metadata.Definition.ToLower().Contains("partial");
dnaSequenceRepository.Create(sequence, bioSequence, partial);
(importResult.Result, importResult.Status) = importGenes ?
ImportFeatures(metadata, sequence) :
("Successfully imported sequence", "Success");
}
catch (Exception exception)
{
importResult.Status = "Error";
importResult.Result = $"Error: {exception.Message}";
while (exception.InnerException != null)
{
exception = exception.InnerException;
importResult.Result += $" {exception.Message}";
}
foreach (var dbEntityEntry in db.ChangeTracker.Entries())
{
if (dbEntityEntry.Entity != null)
{
dbEntityEntry.State = EntityState.Detached;
}
}
}
finally
{
importResults.Add(importResult);
}
}
string[] names = importResults.Select(r => r.MatterName).ToArray();
// removing matters for which adding of sequence failed
Matter[] orphanMatters = db.Matter
.Include(m => m.Sequence)
.Where(m => names.Contains(m.Name) && m.Sequence.Count == 0)
.ToArray();
if (orphanMatters.Length > 0)
{
db.Matter.RemoveRange(orphanMatters);
db.SaveChanges();
}
}
var result = new Dictionary <string, object> {
{ "result", importResults }
};
return new Dictionary <string, string> {
{ "data", JsonConvert.SerializeObject(result) }
};
}));
}
public ActionResult Index(Notation notation, bool dropPunctuation)
{
return(CreateTask(() =>
{
var importResults = new List <MatterImportResult>();
using (var db = new LibiadaWebEntities())
{
Matter[] matters = db.Matter.Where(m => m.Nature == Nature.Literature).ToArray();
for (int i = 0; i < Request.Files.Count; i++)
{
string sequenceName = Request.Files[i].FileName.Substring(0, Request.Files[i].FileName.LastIndexOf('.'));
var importResult = new MatterImportResult()
{
MatterName = sequenceName
};
try
{
var sequence = new CommonSequence
{
Notation = notation
};
if (matters.Any(m => m.Name == sequenceName))
{
sequence.MatterId = matters.Single(m => m.Name == sequenceName).Id;
importResult.Result = "Successfully imported poem for existing matter";
}
else
{
sequence.Matter = new Matter
{
Name = sequenceName,
Group = Group.ClassicalLiterature,
Nature = Nature.Literature,
SequenceType = SequenceType.CompleteText
};
importResult.Result = "Successfully imported poem and created matter";
}
var repository = new LiteratureSequenceRepository(db);
repository.Create(sequence, Request.Files[i].InputStream, Language.Russian, true, Translator.NoneOrManual, dropPunctuation);
importResult.Status = "Success";
importResults.Add(importResult);
}
catch (Exception exception)
{
importResult.Result = $"Failed to import poem: {exception.Message}";
while (exception.InnerException != null)
{
importResult.Result += $" {exception.InnerException.Message}";
exception = exception.InnerException;
}
importResult.Status = "Error";
importResults.Add(importResult);
}
}
var data = new Dictionary <string, object> {
{ "result", importResults }
};
return new Dictionary <string, object>
{
{ "data", JsonConvert.SerializeObject(data) }
};
}
}));
}
public ActionResult Index(long[] matterIds)
{
return(CreateTask(() =>
{
string[] matterNames;
var importResults = new List <MatterImportResult>(matterIds.Length);
using (var db = new LibiadaWebEntities())
{
matterNames = Cache.GetInstance().Matters
.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++)
{
var importResult = new MatterImportResult()
{
MatterName = matterNames[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);
importResult.Status = "Success";
importResult.Result = $"Successfully imported {featuresCount} features and {nonCodingCount} non coding subsequences";
importResults.Add(importResult);
}
catch (Exception exception)
{
importResult.Status = "Error";
importResult.Result = exception.Message;
while (exception.InnerException != null)
{
importResult.Result += $" {exception.InnerException.Message}";
exception = exception.InnerException;
}
importResults.Add(importResult);
}
}
}
var result = new Dictionary <string, object> {
{ "result", importResults }
};
return new Dictionary <string, string> {
{ "data", JsonConvert.SerializeObject(result) }
};
}));
}
public ActionResult Index(HttpPostedFileBase[] files)
{
return(CreateTask(() =>
{
var importResults = new List <MatterImportResult>();
using (var db = new LibiadaWebEntities())
{
Matter[] matters = Cache.GetInstance().Matters.Where(m => m.Nature == Nature.Music).ToArray();
for (int i = 0; i < Request.Files.Count; i++)
{
string sequenceName = Request.Files[i].FileName.Substring(0, Request.Files[i].FileName.LastIndexOf('.'));
var importResult = new MatterImportResult()
{
MatterName = sequenceName
};
try
{
var sequence = new CommonSequence();
if (matters.Any(m => m.Name == sequenceName))
{
sequence.MatterId = matters.Single(m => m.Name == sequenceName).Id;
importResult.Result = "Successfully imported music for existing matter";
}
else
{
sequence.Matter = new Matter
{
Name = sequenceName,
Group = Group.ClassicalMusic,
Nature = Nature.Music,
SequenceType = SequenceType.CompleteMusicalComposition
};
importResult.Result = "Successfully imported music and created matter";
}
var repository = new MusicSequenceRepository(db);
repository.Create(sequence, Request.Files[i].InputStream);
importResult.Status = "Success";
importResults.Add(importResult);
}
catch (Exception exception)
{
importResult.Result = $"Failed to import music: {exception.Message}";
while (exception.InnerException != null)
{
importResult.Result += $" {exception.InnerException.Message}";
exception = exception.InnerException;
}
importResult.Status = "Error";
importResults.Add(importResult);
}
}
var result = new Dictionary <string, object> {
{ "result", importResults }
};
return new Dictionary <string, string> {
{ "data", JsonConvert.SerializeObject(result) }
};
}
}));
}
public ActionResult Index(HttpPostedFileBase[] files)
{
return(CreateTask(() =>
{
var importResults = new List <MatterImportResult>();
using (var db = new LibiadaWebEntities())
{
Matter[] matters = db.Matter.Where(m => m.Nature == Nature.Image).ToArray();
var matterRepository = new MatterRepository(db);
for (int i = 0; i < Request.Files.Count; i++)
{
var file = Request.Files[i];
string sequenceName = file?.FileName.Substring(0, file.FileName.LastIndexOf('.'));
var importResult = new MatterImportResult()
{
MatterName = sequenceName
};
try
{
if (file == null)
{
throw new FileNotFoundException($"No image file is provided. Iteration: {i}");
}
if (matters.Any(m => m.Name == sequenceName))
{
importResult.Result = "Image already exists";
continue;
}
int fileSize = file.ContentLength;
var fileBytes = new byte[fileSize];
file.InputStream.Read(fileBytes, 0, fileSize);
var matter = new Matter
{
Name = sequenceName,
Group = Group.Picture,
Nature = Nature.Image,
Source = fileBytes,
SequenceType = SequenceType.CompleteImage
};
matterRepository.SaveToDatabase(matter);
importResult.Result = "Successfully imported image and created matter";
importResult.Status = "Success";
importResults.Add(importResult);
}
catch (Exception exception)
{
importResult.Result = $"Failed to import image: {exception.Message}";
while (exception.InnerException != null)
{
importResult.Result += $" {exception.InnerException.Message}";
exception = exception.InnerException;
}
importResult.Status = "Error";
importResults.Add(importResult);
}
}
var result = new Dictionary <string, object> {
{ "result", importResults }
};
return new Dictionary <string, string> {
{ "data", JsonConvert.SerializeObject(result) }
};
}
}));
}
