public async Task <ActionResult <Primer> > PostPrimer(Primer primer)
{
_context.Primer.Add(primer);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetPrimer", new { id = primer.Id }, primer));
}
public Primer FindPrime(Primer p)
{
bool isPrime = false;
uint primeCandidate = p.StartNumber;
do
{
primeCandidate += 1;
if (primeCandidate % 2 != 0)
{
uint primeDetector = 0;
for (uint i = 3; i <= Math.Sqrt(primeCandidate); i += 2)
{
if (primeCandidate % i == 0)
{
primeDetector++;
}
}
if (primeDetector == 0)
{
isPrime = true;
}
}
} while (isPrime == false);
p.PrimeNumber = primeCandidate;
return(p);
}
public async Task <IActionResult> PutPrimer(int id, Primer primer)
{
if (id != primer.Id)
{
return(BadRequest());
}
_context.Entry(primer).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PrimerExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
//============================================================================*
// ResolveIdentities()
//============================================================================*
public bool ResolveIdentities(cDataFiles Datafiles)
{
bool fChanged = false;
foreach (cPrimer Primer in this)
{
fChanged = Primer.ResolveIdentities(Datafiles) ? true : fChanged;
}
return(fChanged);
}
public ActionResult Create([Bind(Include = "Id,Name,PrimerTypeId,ManufacturerId,Notes")] Primer modEntity)
{
if (ModelState.IsValid)
{
this.service.Add(modEntity);
return(RedirectToAction("Index"));
}
ViewBag.ManufacturerId = new SelectList(this.manufacturers, "Id", "Name", modEntity.ManufacturerId);
ViewBag.PrimerTypeId = new SelectList(this.primerTypes, "Id", "Abbreviation", modEntity.PrimerTypeId);
return(View(modEntity));
}
public ActionResult NextPrime(PrimeSearchTool number)
{
if (ModelState.IsValid)
{
var primeFinder = new PrimeFinder();
var primer = new Primer();
primer.StartNumber = number.FirstNumber.Value;
primer = primeFinder.FindPrime(primer);
number.NextPrime = primer.PrimeNumber;
return(View("NextPrime", number));
}
return(View("NextPrime", number));
}
protected override void SetSyllable()
{
var first = Primer.GetConsonant(SelectionMode.All);
var second = Primer.GetConsonant(SelectionMode.All);
while (first == second)
{
second = Primer.GetConsonant(SelectionMode.All);
}
var last = Primer.GetVowel(SelectionMode.Popular);
SelectedItem = $"{first}{second}{last}";
}
private void AddPrimer()
{
if (frmPrimer.IsOpen)
{
System.Windows.MessageBox.Show("An instance of the add primer window is currently open.");
return;
}
_SelectedPrimer = new Primer();
_frmPrimer = new frmPrimer();
_frmPrimer.DataContext = this;
_frmPrimer.ResizeMode = System.Windows.ResizeMode.NoResize;
_frmPrimer.Show();
}
//============================================================================*
// Export()
//============================================================================*
public void Export(cRWXMLDocument XMLDocument, XmlElement XMLParentElement, bool fIncludeTransactions = true)
{
if (Count > 0)
{
XmlElement XMLElement = XMLDocument.CreateElement(ExportName);
XMLParentElement.AppendChild(XMLElement);
foreach (cPrimer Primer in this)
{
Primer.Export(XMLDocument, XMLElement, false, fIncludeTransactions);
}
}
}
//============================================================================*
// ProcessPrimers()
//============================================================================*
public void ProcessPrimers()
{
m_nNumBadPrimers = 0;
foreach (cPrimer Primer in m_DataFiles.PrimerList)
{
if (!Primer.Validate())
{
m_nNumBadPrimers++;
}
ProcessTransactionList(Primer);
}
}
private static void SplitWordLists(string dictionary = "REVERSE.TXT")
{
var reader = File.OpenText(dictionary);
var words = new List <List <string> >();
words.Add(new List <string>());
words.Add(new List <string>());
words.Add(new List <string>());
words.Add(new List <string>());
var word = reader.ReadLine();
while (word != null)
{
word = word.Trim();
if (word.IndexOf('-') == -1)
{
var syllablesCount = Primer.GetSyllablesCount(word);
if (word.Length > 2 && syllablesCount > 0 && syllablesCount < 5)
{
var separ = Primer.setProb(word);
Debug.Assert(separ.Replace("-", string.Empty).Length == word.Length);
words[syllablesCount - 1].Add(separ);
}
}
word = reader.ReadLine();
}
reader.Close();
for (int index = 0; index < words.Count; index++)
{
var list = words[index];
var fileName = (index + 1) + ".txt";
if (File.Exists(fileName))
{
File.Delete(fileName);
}
if (list.Count > 0)
{
File.WriteAllLines(fileName, list);
}
}
}
public override ActionResult Index(int?id)
{
var entityViews = new List <PrimerViewModel>();
using (var localService = this.service as IPrimerService)
{
foreach (PrimerView viewEntity in localService.GetPrimerViews().OrderBy(ev => ev.PrimerTypeName).ThenBy(ev => ev.PrimerFullName))
{
var entityView = new PrimerViewModel();
var entity = new Primer {
Id = viewEntity.Id, Name = viewEntity.Name, PrimerTypeId = viewEntity.PrimerTypeId, ManufacturerId = viewEntity.ManufacturerId, Notes = viewEntity.Notes
};
entityView.Entity = entity;
entityView.EntityView = viewEntity;
entityViews.Add(entityView);
}
}
return(View(entityViews));
}
public void Setup()
{
Primer = new Primer();
Random = new Random();
}
public MainWindow()
{
InitializeComponent();
DataContext = new Primer();
}
public void AdvanceStage(IRepositoryFactory repositoryFactory, Barcode barcode, UserJob userJob)
{
// barcode is complete and cannot be advanced
if (barcode.Stage.IsComplete)
{
return;
}
var jobType = userJob.JobType;
var stage = barcode.Stage;
var plate = barcode.UserJobPlate;
// by default only insert one new barcode
var subPlates = 1;
// jobs with large plate, gets broken down to 4 barcodes
if (_largeplateJobs.Contains(jobType.Id) && userJob.PlateType == PlateTypes.ThreeEightyFour && stage.Order == 2)
{
subPlates = 4;
}
Primer primer1 = barcode.Primer;
Primer primer2 = null;
var directional = false;
// if it's directional, you need a forward and back for each sub plate to generate
if (_directionalJobs.Contains(jobType.Id))
{
// bacterial clone, 2nd stage, take the direction
if (jobType.Id == (int)JobTypeIds.BacterialClone && stage.Order == 3 && userJob.UserJobBacterialClone.SequenceDirection == SequenceDirection.Backward)
{
directional = true;
primer1 = userJob.UserJobBacterialClone.Primer1;
primer2 = userJob.UserJobBacterialClone.Primer2;
}
// frankly, I think this was old code that isn't used any more
// pcr and purified dna take the direction at 1st stage
if ((jobType.Id == (int)JobTypeIds.PCRProduct || jobType.Id == (int)JobTypeIds.PurifiedDna) && stage.Order == 2 && userJob.UserJobDna.SequenceDirection == SequenceDirection.Backward)
{
directional = true;
primer1 = userJob.UserJobDna.Primer1;
primer2 = userJob.UserJobDna.Primer2;
}
}
// load the next stage
var nextStage = jobType.Stages.First(a => a.Order == stage.Order + 1);
for (var i = 0; i < subPlates; i++)
{
// write the first plate
var newBarcode1 = new Barcode()
{
SourceBarcode = barcode, Stage = nextStage, Primer = primer1, SubPlateId = i + 1
};
plate.AddBarcode(newBarcode1);
if (directional)
{
var newBarcode2 = new Barcode()
{
SourceBarcode = barcode, Stage = nextStage, Primer = primer2, SubPlateId = i + 1
};
plate.AddBarcode(newBarcode2);
}
}
barcode.Done = true;
repositoryFactory.UserJobPlateRepository.EnsurePersistent(plate);
userJob.LastUpdate = DateTime.Now;
repositoryFactory.UserJobRepository.EnsurePersistent(userJob);
}
public void Init()
{
Primer = new Primer();
}
