public async Task <ActionResult <Symptom> > PostSymptom(Symptom symptom)
{
_context.Symptoms.Add(symptom);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetSymptom), new { id = symptom.Id }, symptom));
}
private IEnumerator ApplyTreatment(Symptom symptom)
{
Debug.Log("treating: " + symptom.name + " - " + symptom.cure.GetComponent <Item>().duration);
treating = true;
yield return(new WaitForSeconds(symptom.cure.GetComponent <Item>().duration));
score += symptom.points;
symptoms.Remove(symptom);
Debug.Log("Treatment for " + symptom.name + " over");
treating = false;
switch (symptom.cure.GetComponent <Item>().itemName)
{
case "ice":
symptoms.Add(GameObject.FindObjectOfType <DataBank>().GetSymptom("wet"));
AddTime(5);
break;
case "needle and thread":
symptoms.Add(GameObject.FindObjectOfType <DataBank>().GetSymptom("injured paw"));
AddTime(3 + 5);
break;
}
}
public async Task <DiseaseDTO> AddAsync(DiseaseDTO dto)
{
var disease = DiseaseDTO.CreateFromDTO(dto);
await _uow.Diseases.AddAsync(disease);
if (dto.Symptoms.Any())
{
foreach (var dtoSymptom in dto.Symptoms)
{
var symptom = await _uow.Symptoms.FindAsync(dtoSymptom.SymptomId);
if (symptom == null)
{
symptom = new Symptom()
{
SymptomName = dtoSymptom.SymptomName
};
await _uow.Symptoms.AddAsync(symptom);
}
await _uow.DiseaseSymptoms.AddAsync(new DiseaseSymptom()
{
Disease = disease, Symptom = symptom
});
}
}
await _uow.SaveChangesAsync();
return(DiseaseDTO.CreateFromDomain(disease));
}
public IHttpActionResult PutSymptom(int id, Symptom symptom)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != symptom.Symp_ID)
{
return(BadRequest());
}
db.Entry(symptom).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!SymptomExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public void SymptomManager_DeleteSymptom()
{
SymptomManager m = new SymptomManager(new TreeMonDbContext(connectionKey));
Symptom s = new Symptom()
{
AccountId = "a",
Name = "DELETERECORD",
CreatedBy = "TESTUSER",
DateCreated = DateTime.UtcNow,
};
m.Insert(s);
//Test the delete flag
Assert.IsTrue(m.DeleteSymptom(s) > 0);
m.GetSymptom("DELETERECORD");
Symptom d = m.GetSymptom("DELETERECORD");
Assert.IsNotNull(d);
Assert.IsTrue(d.Deleted == true);
Assert.IsTrue(m.DeleteSymptom(s, true) > 0);
d = m.GetSymptom("DELETERECORD");
Assert.IsNull(d);
}
public async Task <Symptom> CreateAsync(Symptom createModel)
{
var symptom = (await _context.Symptoms.AddAsync(createModel)).Entity;
await _context.SaveChangesAsync();
return(symptom);
}
public ServiceResult Insert(INode n, bool validateFirst = true)
{
if (!this.DataAccessAuthorized(n, "POST", false))
{
return(ServiceResponse.Error("You are not authorized this action."));
}
n.Initialize(this._requestingUser.UUID, this._requestingUser.AccountUUID, this._requestingUser.RoleWeight);
var s = (Symptom)n;
using (var context = new TreeMonDbContext(this._connectionKey))
{
if (validateFirst)
{
Symptom dbU = context.GetAll <Symptom>().FirstOrDefault(wu => wu.Name.EqualsIgnoreCase(s.Name) && wu.AccountUUID == s.AccountUUID);
if (dbU != null)
{
return(ServiceResponse.Error("Symptom already exists."));
}
}
if (context.Insert <Symptom>(s))
{
return(ServiceResponse.OK("", s));
}
}
return(ServiceResponse.Error("An error occurred inserting Symptom " + s.Name));
}
public void AddSymptom(Symptom symptom)
{
if (alive && symptom != null)
{
symptoms.Add(symptom);
}
}
public void Delete(Symptom entity)
{
if (AuthorizedUsers["Delete"].SingleOrDefault(x => x == Role) != null)
{
SymptomController.Delete(entity);
}
}
public async Task <RedirectResult> AddReport(int IdAppointment, [Bind(Exclude = "Date")] DoctorReport report, List <string> symptoms, List <string> complaints, List <string> complaints2, List <string> analyses)
{
report.Complaints = Symptom.GetSymptomsString(complaints);
report.Complaints2 = Symptom.GetSymptomsString(complaints2);
report.Analyses = Symptom.GetSymptomsString(analyses);
report.IdSymptoms = Symptom.GetSymptomsString(symptoms);
report.Date = DateTime.Now;
using (var transaction = db.Database.BeginTransaction())
{
try
{
Appointment appointment = await db.Appointments.FindAsync(IdAppointment);
db.Appointments.Remove(appointment);
db.DoctorReports.Add(report);
await db.SaveChangesAsync();
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
}
}
return(Redirect("/Cabinet"));
}
public async Task <Symptom> AddSymptomAsync(Symptom symptom)
{
_db.Symptoms.Add(symptom);
await _db.SaveChangesAsync();
return(symptom);
}
public void Api_SymptomController_UpdateSymptom()
{
TreeMonDbContext context = new TreeMonDbContext(connectionKey);
Symptom mdl = new Symptom();
mdl.AccountUUID = SystemFlag.Default.Account;
mdl.Name = Guid.NewGuid().ToString("N");
mdl.UUID = Guid.NewGuid().ToString("N");
mdl.DateCreated = DateTime.Now;
Assert.IsTrue(context.Insert <Symptom>(mdl));
mdl = context.GetAll <Symptom>().Where(w => w.Name == mdl.Name).FirstOrDefault();
Symptom pv = new Symptom();
pv.Id = mdl.Id;
pv.UUID = mdl.UUID;
pv.AccountUUID = mdl.AccountUUID;
pv.Name = mdl.Name;
pv.DateCreated = DateTime.Now;
//~~~ Updatable fields ~~~
string postData = JsonConvert.SerializeObject(pv);
Task.Run(async() =>
{
ServiceResult res = await TestHelper.SentHttpRequest("POST", "api/Symptoms/Update", postData, _ownerAuthToken);
Assert.IsNotNull(res);
Assert.AreEqual(res.Code, 200);
Symptom dbSymptom = context.GetAll <Symptom>().Where(w => w.Name == mdl.Name).FirstOrDefault();
Assert.IsNotNull(dbSymptom);
}).GetAwaiter().GetResult();
}
public void GeneratePerks(out Symptom[] symptoms, out Transmission[] transmissions)
{
symptoms = new Symptom[SymptomsMaxLevel];
transmissions = new Transmission[TransmissionMaxLevel];
int pog = 500;
while (CanUsePoints() && pog != 0)
{
int typ = Random.Range(0, 2);
int subtype;
switch (typ)
{
case 0:
subtype = Random.Range(0, SymptomsSize / SymptomsMaxLevel);
if (symptoms[subtype] == null)
{
symptoms[subtype] = SymptomsPerks[subtype][0].Clone();
UsedPoints++;
//Debug.Log("Added " + symptoms[subtype].Name + " Points used: " + UsedPoints);
}
else
{
if (symptoms[subtype].PerkLevel < SymptomsMaxLevel)
{
symptoms[subtype].EvolvePerk(SymptomsPerks[subtype][symptoms[subtype].PerkLevel]);
UsedPoints++;
//Debug.Log("Added " + symptoms[subtype].Name + " Points used: " + UsedPoints);
}
}
break;
case 1:
subtype = Random.Range(0, TransmissionSize / TransmissionMaxLevel);
if (transmissions[subtype] == null)
{
transmissions[subtype] = TransmissionPerks[subtype][0].Clone();
UsedPoints++;
//Debug.Log("Added " + transmissions[subtype].Name + " Points used: " + UsedPoints);
}
else
{
if (transmissions[subtype].PerkLevel < TransmissionMaxLevel)
{
transmissions[subtype].EvolvePerk(TransmissionPerks[subtype][transmissions[subtype].PerkLevel]);
UsedPoints++;
//Debug.Log("Added " + transmissions[subtype].Name + " Points used: " + UsedPoints);
}
}
break;
default:
break;
}
pog--;
}
}
private async Task AddDiseaseFromString(string line)
{
if (line != null)
{
var values = line.Split(", ");
var disease = new Disease()
{
DiseaseName = values[0]
};
await _uow.Diseases.AddAsync(disease);
foreach (var name in values.Skip(1))
{
var symptom = await _uow.Symptoms.FindByNameAsync(name);
if (symptom == null)
{
symptom = new Symptom()
{
SymptomName = name
};
await _uow.Symptoms.AddAsync(symptom);
}
await _uow.DiseaseSymptoms.AddAsync(new DiseaseSymptom()
{
Disease = disease, Symptom = symptom
});
}
}
await _uow.SaveChangesAsync();
}
public override void EvolvePerk(Perk PerkEvolved)
{
base.EvolvePerk(PerkEvolved);
Symptom sym = PerkEvolved as Symptom;
LethalityRate = sym.LethalityRate;
}
public ServiceResult Update(Symptom s)
{
if (s == null)
{
return(ServiceResponse.Error("Invalid Symptom sent to server."));
}
SymptomManager symptomManager = new SymptomManager(Globals.DBConnectionKey, Request.Headers?.Authorization?.Parameter);
var dbS = (Symptom)symptomManager.GetBy(s.UUID);
if (dbS == null)
{
return(ServiceResponse.Error("Symptom was not found."));
}
if (dbS.DateCreated == DateTime.MinValue)
{
dbS.DateCreated = DateTime.UtcNow;
}
dbS.Deleted = s.Deleted;
dbS.Name = s.Name;
dbS.Status = s.Status;
dbS.SortOrder = s.SortOrder;
return(symptomManager.Update(dbS));
}
public async Task <string> MakeAnAppointment(Appointment busyTime, DateTime selectedDate, TimeSpan receptionTime, List <string> symptoms)
{
busyTime.PredictedDiagnoses = PredicateDiagnoses(symptoms);
busyTime.IdSymptoms = Symptom.GetSymptomsString(symptoms);
busyTime.EndTime = busyTime.StartTime + receptionTime;
busyTime.Day = new DateTime(DateTime.Now.Year, selectedDate.Month, selectedDate.Day);
List <Appointment> checkTime = db.Appointments.Where(bt => bt.IdDoctor == busyTime.IdDoctor && bt.StartTime == busyTime.StartTime && bt.Day == busyTime.Day).ToList();
if (checkTime.Count > 0)
{
return("<h3>Время приёма уже занято! Выберите другое время!</h3>");
}
List <Appointment> apps = db.Appointments.Where(app => app.IdPatient == busyTime.IdPatient && app.Day == busyTime.Day && !((app.StartTime < busyTime.StartTime && app.EndTime <= busyTime.StartTime) || (app.StartTime >= busyTime.EndTime && app.EndTime > busyTime.EndTime))).ToList <Appointment>();
if (apps.Count != 0)
{
return("<h3>Извините, но на это время вы записаны к другому врачу!</h3>");
}
db.Appointments.Add(busyTime);
await db.SaveChangesAsync();
User patient = await db.Patients.FindAsync(busyTime.IdPatient);
User doctor = await db.Doctors.FindAsync(busyTime.IdDoctor);
MailSender sender = new MailSender(patient.Email);
sender.SendMessageForMakeAppointment(doctor, selectedDate, busyTime.StartTime, MailSender.UserType.Patient, Url.Action("Doctor", "Home", new { id = busyTime.IdDoctor }, Request.Url.Scheme));
sender.Recipient = doctor.Email;
sender.SendMessageForMakeAppointment(patient, selectedDate, busyTime.StartTime, MailSender.UserType.Doctor);
return($"<h3>Запись была осуществлена успешно!</h3><br/><a href={Url.Action("Index","Cabinet")}>В личный кабинет</a>");
}
public async Task <Symptom> UpdateSymptomAsync(Symptom symptom)
{
_db.Entry(symptom).State = EntityState.Modified;
await _db.SaveChangesAsync();
return(symptom);
}
public async Task <IActionResult> PutSymptom(int id, Symptom symptom)
{
if (id != symptom.Id)
{
return(BadRequest());
}
_context.Entry(symptom).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SymptomExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private double ConditionedSymptomsRefusal(Disease disease, string symptoms)
{
string[] uniqueSymptoms = symptoms.Split(";");
double symptomsProbability = 1d;
foreach (string symptom in uniqueSymptoms)
{
if (symptom.Equals(""))
{
continue;
}
Symptom symptomX = _context.Symptoms.Where(sym => sym.SymptomName.Equals(symptom)).First();
SymptomDisease symptomDisease = _context.SymptomDiseases.Where(symDis => symDis.DiseaseID.Equals(disease.Id) && symDis.SymptomID.Equals(symptomX.Id)).FirstOrDefault();
if (symptomDisease != null)
{
symptomsProbability *= (symptomX.OccurenceProbability - symptomDisease.OccurenceProbability * disease.GeneralProbability) / (1d - DiseaseGeneralProbability(disease));
}
else
{
symptomsProbability *= 0.98d;
}
}
return(symptomsProbability);
}
public Symptom AddRoot(Symptom symptom)
{
if(symptom == null) {
throw new WebFaultException(HttpStatusCode.BadRequest);
}
return _storage.CreateNode(symptom.Name, null);
}
/// <summary>
/// This method is used to transform a Symptom object to SymptomDTO object
/// </summary>
/// <param name="symptom">Symptom which we wish to transform</param>
/// <returns>SymptomDTO which was transformed from input</returns>
public static SymptomDTO Transform(Symptom symptom)
{
return(new SymptomDTO()
{
name = symptom.Name
});
}
public void Edit(Symptom entity)
{
if (AuthorizedUsers["Edit"].SingleOrDefault(x => x == Role) != null)
{
SymptomController.Edit(entity);
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Body,WellBeing,ChestPain,SymptomList,RecordDate")] Symptom symptom)
{
if (id != symptom.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(symptom);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SymptomExists(symptom.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(symptom));
}
public async Task <Symptom> UpdateAsync(Symptom updateModel)
{
var symptom = _context.Symptoms.Update(updateModel).Entity;
await _context.SaveChangesAsync();
return(symptom);
}
public override ErrorList Validate()
{
var result = new ErrorList();
result.AddRange(base.Validate());
if (ReactionDateElement != null)
{
result.AddRange(ReactionDateElement.Validate());
}
if (Subject != null)
{
result.AddRange(Subject.Validate());
}
if (DidNotOccurFlagElement != null)
{
result.AddRange(DidNotOccurFlagElement.Validate());
}
if (Recorder != null)
{
result.AddRange(Recorder.Validate());
}
if (Symptom != null)
{
Symptom.ForEach(elem => result.AddRange(elem.Validate()));
}
if (Exposure != null)
{
Exposure.ForEach(elem => result.AddRange(elem.Validate()));
}
return(result);
}
public void Core_MakeAllPills()
{
var dMock = new Mock <IDevice>();
var rMock = new Mock <IRepository>();
rMock.Setup(x => x.GetAll <Symptom>()).Returns(() =>
{
var s1 = new Symptom()
{
Name = "S1"
};
s1.Wirkstoffe.Add(new Wirkstoff()
{
Name = "W1"
});
s1.Wirkstoffe.Add(new Wirkstoff()
{
Name = "W2"
});
// var s2 = new Symptom() { Name = "S2" };
// s2.Wirkstoffe.Add(new Wirkstoff() { Name = "W3" });
// s2.Wirkstoffe.Add(new Wirkstoff() { Name = "W4" });
return(new[] { s1, s1, s1 });
});
Core core = new Core(dMock.Object, rMock.Object);
core.MakeAllPills();
dMock.Verify(x => x.Machzeug(It.IsAny <IEnumerable <Wirkstoff> >()), Times.Exactly(3));
}
public async Task <Symptom> AddAsync(Symptom symptom)
{
await _context.Symptoms.AddAsync(symptom);
await _context.SaveChangesAsync();
return(symptom);
}
public ActionResult DeleteConfirmed(string id)
{
Symptom symptom = db.Symptoms.Find(id);
db.Symptoms.Remove(symptom);
db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// This method is used to create a new SymptomsInDiseases from symptom and a disease
/// </summary>
/// <param name="symptom">Symptom which we will use to create a response</param>
/// <param name="disease">Disease which we will use to create a response</param>
/// <returns>SymptomsInDiseases which is made by two given inputs</returns>
public SymptomsInDiseases createNew(Symptom symptom, Disease disease)
{
return(new SymptomsInDiseases()
{
Symptom = symptom,
Disease = disease
});
}
public HttpResponseMessage<Symptom> AddRoot(Symptom symptom)
{
if (symptom == null) {
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
var newSymptom = _storage.CreateNode(symptom.Name, null);
return BuildCreateMessage(newSymptom);
}
public SymptomDTO Transform(Symptom s)
{
return(new SymptomDTO
{
Id = s.Id,
Name = s.Name,
});
}
public Symptom AddChild(string nodeId, Symptom child)
{
Int32 id;
if (child == null || !Int32.TryParse(nodeId, out id)) {
throw new WebFaultException(HttpStatusCode.BadRequest);
}
var parent = _storage.GetNode(id);
return _storage.CreateNode(child.Name, parent);
}
public HttpResponseMessage<Symptom> AddChild(Int32 nodeId, Symptom child)
{
var parent = _storage.GetNode(nodeId);
if (parent == null) {
throw new HttpResponseException(HttpStatusCode.NotFound);
}
var newSymptom = _storage.CreateNode(child.Name, parent);
return BuildCreateMessage(newSymptom);
}
private HandbookSymptomListItem AddButton(Symptom symptom){
GameObject handbookSymptomListItem = (GameObject)Instantiate (HandbookSymptomListItemPrefab);
HandbookSymptomListItem handbookSymptom = handbookSymptomListItem.GetComponent<HandbookSymptomListItem> ();
handbookSymptom.Symptom = symptom;
handbookSymptom.HandbookManager = this;
handbookSymptomListItem.transform.SetParent (transform);
handbookSymptomListItem.transform.localPosition = new Vector3(0, 0, 0);
handbookSymptomListItem.transform.localScale = new Vector3 (1f, 1f, 1f);
handbookSymptomListItem.transform.localRotation = new Quaternion();
return handbookSymptom;
}
public void Seed(DiagnoseMeDbContext context)
{
if (context.Symptoms.Any())
{
return;
}
var symptomsNamesAsString = @"главоболие; виене на свят; разстройство на съня; мозъчна тромбоза с парализа на определена група мускули; смущения в говора;
влошаване на страничното периферно зрение; нарастване на размера на черепа; нарастване на носа; нарастване на ушните миди; нарастване на езика; задебеляване на устните;
бяла коса; розово-бяла кожа която не потъмнява от слънцето; сини или червени ириси на очите;
кихане; течащ или запушен нос; сърбежи на очите и кожата;
повръщане; висока температура; болки в корема; повръщане на кръв; тежка диария; настинка; пъпки; язва;
суха кашлица; кихане; хрема; болки в гърлото; температура;
болки във венците; кървене на венците;
чувство на умора; повишена температура; болка в мускулите и ставите; главоболие и възпалено гърло; повръщане; диария; болки в корема;
тремор в покой(най-често по пръстите на ръцете); ригор; ступор; когнитивни дефицити; депресия; деменция;
синузит; главоболие;
кашлица с оскъдни жилави белезникави храчки; кръвохрачене; задух при усилие и в покой; болки и бодежи в гръдния кош; туберкулоза; белодробно сърце; дихателна и сърдечна недостатъчност с прогресиращ ход;
повишена функция на щитовидната жлеза; неправилно хранене (особено в детската възраст);
влажна кашлица; температура; втрисане; недостиг на въздух; остра или пронизваща болка в гърдите при дълбоко поемане на въздух и повишена дихателна честота;
зачервяване и оток на ушната мида; обилно отделяне на рядка ушна кал; сърбеж; дразнене; чувство за наличие на чуждо тяло в ухото; слаби болки; намаляване на слуха;
втрисане с изпотяване и рязко влошаване на общото състояние; нарастваща слабост; загуба на апетит; хеморагична диатеза – епистаксис; гингиворагии; подкожни кръвоизливи; генитални кръвоизливи;
слабост; отпадналост; дискомфорт; слаба концентрация; диспнея (затруднено дишане);
болка в долния десен край на корема; ускорен пулс; повишена телесна температура (до 38°С); гадене; повръщане;
болки в колената; подуване; зачервяване на лакътя или коляното; затопляне на мястото; ограничаване на движенията; усещане за триене;
отпадналост; лесна уморяемост; главоболие; намален мускулен тонус; отслабени сухожилни рефлекси; двойно виждане (диплопия); фотофобия; разширяване на зениците; нистагъм; страбизъм; диспнея (затруднено дишане); неподвижност на мекото небце; дисфагия (затруднено преглъщане); пресипване на гласа (афония); липса на гълтателен рефлекс;
бяло течение; кръвотечение; болки в половите органи; горещина и отичане на половите органи;
слепване между гланса и препуциума; подуване при уриниране;
голяма чувствителност; спазъм при който съвкуплението става невъзможно; остра болка; треперене; сърцебиене;
тъпи болки в таза ирадииращи към ануса, тестисите или вътрешната част на бедрата; проблеми с ерекцията; парене и болка при уриниране и еякулация";
var symptomsNamesAsList = new HashSet<string>(
symptomsNamesAsString
.Split(';')
.Select(x => x.Trim())
.ToList());
foreach (var symptomName in symptomsNamesAsList)
{
var symptom = context.Symptoms.SingleOrDefault(x => x.Name == symptomName);
if (symptom == null)
{
symptom = new Symptom { Name = symptomName, Diseases = null };
context.Symptoms.AddOrUpdate(x => x.Name, symptom);
context.SaveChanges();
}
}
}
private HttpResponseMessage<Symptom> BuildCreateMessage(Symptom s)
{
var response = new HttpResponseMessage<Symptom>(s, HttpStatusCode.Created);
string relativeUri = Url.Route("DefaultAPI", new { nodeId = s.ID });
Uri baseUri = new Uri(String.Format("{0}://{1}", Request.RequestUri.Scheme, Request.RequestUri.Authority));
response.Headers.Location = new Uri(baseUri, relativeUri);
return response;
}
internal IList<Allergy> toAllergiesFromXmlNode(XmlNode node)
{
IList<Allergy> allergies = new List<Allergy>();
int total = verifyTopLevelNode(node);
if (total == 0)
{
return allergies;
}
XmlNodeList allergyNodes = node.SelectNodes("/allergy");
if (allergyNodes == null || allergyNodes.Count == 0)
{
return allergies;
}
foreach (XmlNode allergyNode in allergyNodes)
{
Allergy allergy = new Allergy();
XmlNodeList drugClassesNodes = allergyNode.SelectNodes("drugClasses/drugClass");
if (drugClassesNodes != null && drugClassesNodes.Count > 0)
{
allergy.DrugClasses = new StringDictionary();
foreach (XmlNode drugClassNode in drugClassesNodes)
{
string vuid = XmlUtils.getXmlAttributeValue(drugClassNode, "/", "vuid");
string name = XmlUtils.getXmlAttributeValue(drugClassNode, "/", "name");
if (!String.IsNullOrEmpty(vuid))
{
allergy.DrugClasses.Add(vuid, name);
}
}
}
XmlNodeList drugIngredientsNodes = allergyNode.SelectNodes("drugIngredients/drugIngredient");
if (drugIngredientsNodes != null && drugIngredientsNodes.Count > 0)
{
allergy.DrugIngredients = new StringDictionary();
foreach (XmlNode drugIngredientNode in drugIngredientsNodes)
{
string vuid = XmlUtils.getXmlAttributeValue(drugIngredientNode, "/", "vuid");
string name = XmlUtils.getXmlAttributeValue(drugIngredientNode, "/", "name");
if (!String.IsNullOrEmpty(vuid))
{
allergy.DrugIngredients.Add(vuid, name);
}
}
}
XmlNodeList reactionsNodes = allergyNode.SelectNodes("reactions/reaction");
if (reactionsNodes != null && reactionsNodes.Count > 0)
{
allergy.Reactions = new List<Symptom>();
foreach (XmlNode reactionNode in reactionsNodes)
{
Symptom symptom = new Symptom();
symptom.Name = XmlUtils.getXmlAttributeValue(reactionNode, "/", "name");
symptom.Id = XmlUtils.getXmlAttributeValue(reactionNode, "/", "vuid");
allergy.Reactions.Add(symptom);
}
}
allergy.Timestamp = XmlUtils.getXmlAttributeValue(allergyNode, "entered", "value");
allergy.AllergenId = XmlUtils.getXmlAttributeValue(allergyNode, "id", "value");
allergy.AllergenName = XmlUtils.getXmlAttributeValue(allergyNode, "name", "value");
allergy.AllergenType = XmlUtils.getXmlAttributeValue(allergyNode, "type", "name");
allergy.Comment = XmlUtils.getXmlAttributeValue(allergyNode, "assessment", "value");
allergy.Facility = new SiteId(XmlUtils.getXmlAttributeValue(allergyNode, "facility", "code"), XmlUtils.getXmlAttributeValue(allergyNode, "facility", "name"));
allergies.Add(allergy);
}
return allergies;
}
public void SeedDisease(DiagnoseMeDbContext context, DiseaseSeedModel model)
{
var symptomsNames = new HashSet<string>(model.Symptoms.Split(';').Select(x => x.Trim()).ToList());
// Build the Symptoms
var symptoms = new HashSet<Symptom>();
foreach (var symptomName in symptomsNames)
{
var symptom = this.ExtractedSymptoms.SingleOrDefault(x => x.Name == symptomName);
// If symptom not found in our list => get it from database
if (symptom == null)
{
symptom = context.Symptoms.SingleOrDefault(x => x.Name == symptomName);
// If symptom not found in db => create and insert it
if (symptom == null)
{
symptom = new Symptom() { Name = symptomName };
context.Symptoms.AddOrUpdate(x => x.Name, symptom);
}
this.ExtractedSymptoms.Add(symptom);
}
symptoms.Add(symptom);
}
// Build the Disease
var disease = new Disease()
{
Name = model.Name,
Description = model.Description,
Occurrence = model.Occurrence,
Target = model.Target,
Symptoms = symptoms
};
context.Diseases.AddOrUpdate(x => x.Name, disease);
context.SaveChanges();
}
protected void getSymptomSummary()
{
DateTime from;
DateTime to = DateTime.Now;
String from_date_string = from_date.Text;
if (String.IsNullOrEmpty(from_date_string))
from = DateTime.Now.AddDays(-14);
else
from = DateTime.Parse(from_date_string + " 00:00:01 AM");
HealthRecordSearcher searcher = PersonInfo.SelectedRecord.CreateSearcher();
HealthRecordFilter filter = new HealthRecordFilter(Condition.TypeId);
filter.CreatedDateMax = to;
filter.CreatedDateMin = from;
searcher.Filters.Add(filter);
HealthRecordItemCollection items = searcher.GetMatchingItems()[0];
foreach (Condition condition in items)
{
if (isSymptom(condition))
{
Symptom symptom = new Symptom();
symptom.SymptomName = condition.Name.Text;
symptom.SymptomValue = Convert.ToInt32(condition.Status.Text);
symptom.When = DateTime.Parse(condition.OnsetDate.ToString());
if (symptom.When >= from)
symptoms.Add(symptom);
}
}
symptoms.Sort(delegate(Symptom p1, Symptom p2) { return p1.When.CompareTo(p2.When); });
}
