public AllergyData InitializeAllergy(PostInitializeAllergyRequest request)
{
try
{
AllergyData result = null;
IRestClient client = new JsonServiceClient();
//[Route("/{Version}/{ContractNumber}/Allergy/Initialize", "POST")]
var url = Common.Helper.BuildURL(string.Format("{0}/{1}/{2}/{3}/Allergy/Initialize",
DDAllergyUrl,
"NG",
request.Version,
request.ContractNumber), request.UserId);
PutInitializeAllergyDataResponse dataDomainResponse = client.Put <PutInitializeAllergyDataResponse>(url, new PutInitializeAllergyDataRequest
{
Context = "NG",
ContractNumber = request.ContractNumber,
AllergyName = request.AllergyName,
UserId = request.UserId,
Version = request.Version
} as object);
if (dataDomainResponse != null)
{
result = dataDomainResponse.AllergyData;
}
return(result);
}
catch (WebServiceException ex)
{
throw new WebServiceException("AD:InitializeAllergy()::" + ex.Message, ex.InnerException);
}
}
public void UpdateAllergy_Test()
{
AllergyData data = new AllergyData
{
DeleteFlag = false,
Id = "5453cea0d433232a387d51b9",
Name = "allergyName",
TypeIds = new List <string> {
"5447d6ddfe7a59146485b512", "5446db5efe7a591e74013b6b", "5446db5efe7a591e74013b6c"
},
Version = 1.0
};
PutAllergyDataRequest request = new PutAllergyDataRequest
{
Context = context,
ContractNumber = contractNumber,
AllergyData = data,
UserId = userId,
Version = version
};
AllergyData aData = cm.UpdateAllergy(request);
Assert.IsTrue(aData.Name == data.Name);
}
private static void updateAllergyData(AllergyData allergyData, AllergyData existingAllergyData)
{
if (allergyData.UserName != null)
{
existingAllergyData.UserName = allergyData.UserName;
}
if (allergyData.Allergy1 != null)
{
existingAllergyData.Allergy1 = allergyData.Allergy1;
}
if (allergyData.Allergy2 != null)
{
existingAllergyData.Allergy2 = allergyData.Allergy2;
}
if (allergyData.Allergy3 != null)
{
existingAllergyData.Allergy3 = allergyData.Allergy3;
}
if (allergyData.Allergy4 != null)
{
existingAllergyData.Allergy4 = allergyData.Allergy4;
}
if (allergyData.Allergy5 != null)
{
existingAllergyData.Allergy5 = allergyData.Allergy5;
}
}
public async Task <IActionResult> PutAllergyData(String userId, AllergyData allergyData)
{
if (!userId.Equals(allergyData.UserId))
{
return(BadRequest());
}
_context.Entry(allergyData).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AllergyDataExists(userId))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <AllergyData> > PostAllergyData(AllergyData allergyData)
{
_context.AllergyData.Add(allergyData);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetAllergyData", new { userId = allergyData.UserId }, allergyData));
}
public object Initialize(object newEntity)
{
PutInitializeAllergyDataRequest request = (PutInitializeAllergyDataRequest)newEntity;
AllergyData data = null;
try
{
MEAllergy meA = new MEAllergy(this.UserId)
{
Name = request.AllergyName,
TTLDate = System.DateTime.UtcNow.AddDays(_initializeDays),
DeleteFlag = false
};
using (AllergyMongoContext ctx = new AllergyMongoContext(ContractDBName))
{
ctx.Allergies.Collection.Insert(meA);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.Allergy.ToString(),
meA.Id.ToString(),
DataAuditType.Insert,
request.ContractNumber);
data = new AllergyData
{
Id = meA.Id.ToString(),
Name = meA.Name.ToUpper()
};
}
return(data);
}
catch (Exception) { throw; }
}
public void UpdateAllergy_Test()
{
AllergyData data = new AllergyData
{
DeleteFlag = false,
Id = "5453cea0d433232a387d51b9",
Name = "testing",
TypeIds = new List <string> {
"5447d6ddfe7a59146485b512", "5446db5efe7a591e74013b6b", "5446db5efe7a591e74013b6c"
},
Version = 1.0
};
PutAllergyDataRequest request = new PutAllergyDataRequest
{
Context = context,
ContractNumber = contractNumber,
AllergyData = data,
UserId = userId,
Version = version
};
//[Route("/{Context}/{Version}/{ContractNumber}/Allergy/Update", "PUT")]
PutAllergyDataResponse response = client.Put <PutAllergyDataResponse>(
string.Format("{0}/{1}/{2}/{3}/Allergy/Update", url, context, version, contractNumber), request);
Assert.IsNotNull(response);
}
public object Update(object entity)
{
PutAllergyDataRequest pa = (PutAllergyDataRequest)entity;
AllergyData pt = pa.AllergyData;
MEAllergy meA = new MEAllergy(pa.UserId);
meA.DeleteFlag = pt.DeleteFlag;
meA.CodingSystemCode = pt.CodingSystemCode;
meA.Name = pt.Name;
return(true);
}
public void SetAllergyData(AllergyData allergyData)
{
allergyData.AllergyRecordStamp = $"{DateTime.Now}";
var recordToUpdate = _context.AllergyDatas.Where(s => s.Id == 1).First();
recordToUpdate.PollenToday = allergyData.PollenToday;
recordToUpdate.PollenTomorrow = allergyData.PollenTomorrow;
recordToUpdate.PollenYesterday = allergyData.PollenYesterday;
recordToUpdate.AllergyRecordStamp = allergyData.AllergyRecordStamp;
// _context.AllergyDatas.Add(allergyData);
_context.SaveChanges();
}
public object Update(object entity)
{
bool result = false;
PutAllergyDataRequest pa = (PutAllergyDataRequest)entity;
AllergyData pt = pa.AllergyData;
try
{
using (AllergyMongoContext ctx = new AllergyMongoContext(ContractDBName))
{
var q = MB.Query <MEAllergy> .EQ(b => b.Id, ObjectId.Parse(pt.Id));
var uv = new List <MB.UpdateBuilder>();
uv.Add(MB.Update.Set(MEAllergy.UpdatedByProperty, ObjectId.Parse(this.UserId)));
uv.Add(MB.Update.Set(MEAllergy.VersionProperty, pa.Version));
uv.Add(MB.Update.Set(MEAllergy.LastUpdatedOnProperty, System.DateTime.UtcNow));
if (pt.TypeIds != null && pt.TypeIds.Count > 0)
{
uv.Add(MB.Update.SetWrapped <List <ObjectId> >(MEAllergy.TypeIdsProperty, Helper.ConvertToObjectIdList(pt.TypeIds)));
}
else
{
uv.Add(MB.Update.Set(MEAllergy.TypeIdsProperty, BsonNull.Value));
}
uv.Add(MB.Update.Set(MEAllergy.DeleteFlagProperty, pt.DeleteFlag));
DataAuditType type;
if (pt.DeleteFlag)
{
uv.Add(MB.Update.Set(MEAllergy.TTLDateProperty, System.DateTime.UtcNow.AddDays(_expireDays)));
type = DataAuditType.Delete;
}
else
{
uv.Add(MB.Update.Set(MEAllergy.TTLDateProperty, BsonNull.Value));
type = DataAuditType.Update;
}
IMongoUpdate update = MB.Update.Combine(uv);
ctx.Allergies.Collection.Update(q, update);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.Allergy.ToString(),
pt.Id,
type,
pa.ContractNumber);
result = true;
}
return(result as object);
}
catch (Exception) { throw; }
}
public void isAllergicTo(string prodname)
{
//Arrange
AllergiesValues allergies = new AllergiesValues();
Dictionary <string, int> Result;
AllergyData data = new AllergyData();
prodname = "eggs";
//Act
data.isAllergyTo(prodname);
//Assert
}
public DTO.Allergy InitializeAllergy(PostInitializeAllergyRequest request)
{
DTO.Allergy allergy = null;
try
{
AllergyData data = EndpointUtil.InitializeAllergy(request);
if (data != null)
{
allergy = Mapper.Map <DTO.Allergy>(data);
}
return(allergy);
}
catch (Exception ex) { throw ex; }
}
public void InitializeAllergy_Test()
{
PutInitializeAllergyDataRequest request = new PutInitializeAllergyDataRequest
{
Context = context,
ContractNumber = contractNumber,
UserId = userId,
Version = version,
AllergyName = "allergyName"
};
AllergyData response = cm.InitializeAllergy(request);
Assert.IsTrue(request.AllergyName == response.Name);
}
public DTO.AllergyData UpdateAllergy(DTO.PutAllergyDataRequest request)
{
AllergyData result = null;
var repo = StubRepositoryFactory.GetAllergyRepository(request, RepositoryType.Allergy);
if (request.AllergyData != null)
{
bool status = (bool)repo.Update(request);
if (status)
{
result = (AllergyData)repo.FindByID(request.AllergyData.Id);
}
}
return(result);
}
public void FindAllergy(int score)
{
//Arrange
AllergiesValues allergies = new AllergiesValues();
Dictionary <string, int> Result;
AllergyData data = new AllergyData();
score = 34;
//Act
data.FindPersonAllergy(score);
//Result = allergies.AllergyChart();
//Assert
}
public object Initialize(object newEntity)
{
PutInitializeAllergyDataRequest request = (PutInitializeAllergyDataRequest)newEntity;
AllergyData data = null;
MEAllergy meA = new MEAllergy(this.UserId)
{
Name = request.AllergyName,
TTLDate = System.DateTime.UtcNow.AddDays(1),
DeleteFlag = false
};
data = new AllergyData
{
Id = meA.Id.ToString(),
Name = meA.Name
};
return(data);
}
public AllergyData UpdateAllergy(PutAllergyDataRequest request)
{
try
{
AllergyData result = null;
var repo = AllergyRepositoryFactory.GetAllergyRepository(request, RepositoryType.Allergy);
if (request.AllergyData != null)
{
bool status = (bool)repo.Update(request);
if (status)
{
result = (AllergyData)repo.FindByID(request.AllergyData.Id);
}
}
return(result);
}
catch (Exception ex) { throw ex; }
}
public List <String> getAllergies(String userId)
{
var db = _allergyContext;
AllergyData allergyData = db.AllergyData.Find(userId);
if (allergyData == null)
{
return(new List <String>());
//:TODO throw an exception
}
List <String> allergyList = new List <String>();
allergyList.Add(allergyData.Allergy1);
allergyList.Add(allergyData.Allergy2);
allergyList.Add(allergyData.Allergy3);
allergyList.Add(allergyData.Allergy4);
allergyList.Add(allergyData.Allergy5);
return(allergyList);
}
public object FindByID(string entityID)
{
AllergyData data = null;
try
{
using (AllergyMongoContext ctx = new AllergyMongoContext(ContractDBName))
{
List <IMongoQuery> queries = new List <IMongoQuery>();
queries.Add(Query.EQ(MEAllergy.IdProperty, ObjectId.Parse(entityID)));
IMongoQuery mQuery = Query.And(queries);
MEAllergy meA = ctx.Allergies.Collection.Find(mQuery).FirstOrDefault();
if (meA != null)
{
data = AutoMapper.Mapper.Map <AllergyData>(meA);
}
}
return(data);
}
catch (Exception) { throw; }
}
public List <PatientAllergy> UpdatePatientAllergies(PostPatientAllergiesRequest request)
{
List <PatientAllergy> patientAllergies = null;
try
{
// Update Allergy collection for any newly initialized allergies & then register in search index.
if (request.PatientAllergies != null && request.PatientAllergies.Count > 0)
{
request.PatientAllergies.ForEach(p =>
{
if (p.IsNewAllergy)
{
PostAllergyRequest req = new PostAllergyRequest
{
Allergy = new DTO.Allergy {
Id = p.AllergyId, TypeIds = p.AllergyTypeIds, Name = p.AllergyName
},
ContractNumber = request.ContractNumber,
UserId = request.UserId,
Version = request.Version
};
AllergyData allergyData = EndpointUtil.UpdateAllergy(req);
DTO.Allergy newAllergy = Mapper.Map <DTO.Allergy>(allergyData);
// Register newly initialized allergies in search index.
SearchManager.RegisterAllergyDocumentInSearchIndex(newAllergy, req.ContractNumber, request);
}
});
}
List <PatientAllergyData> data = EndpointUtil.UpdatePatientAllergies(request);
if (data != null && data.Count > 0)
{
patientAllergies = new List <PatientAllergy>();
data.ForEach(a => patientAllergies.Add(Mapper.Map <PatientAllergy>(a)));
}
return(patientAllergies);
}
catch (Exception ex) { throw ex; }
}
public async Task <IActionResult> UpdateAllergyData(AllergyData allergyData)
{
if (allergyData.UserId == null)
{
return(BadRequest("Error : user id mandatory"));
}
var existingAllergyData = await _context.AllergyData.FindAsync(allergyData.UserId);
if (existingAllergyData == null)
{
return(BadRequest("Error : No user found with the user id used"));
}
updateAllergyData(allergyData, existingAllergyData);
_context.Entry(existingAllergyData).State = EntityState.Modified;
_context.Entry(existingAllergyData).Property(x => x.Id).IsModified = false;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AllergyDataExists(allergyData.UserId))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok(existingAllergyData));
}
public void OnGet()
{
AllergyDatas = _db.AllergyDatas.OrderByDescending(s => s.Id).FirstOrDefault();
}
public ActionResult <AllergyData> SetAllergyData(AllergyData allergyData)
{
_repository.SetAllergyData(allergyData);
_repository.SaveChanges();
return(Ok());
}
