func (s *ServerSuite) TestNewRecordMatchDedupRequest(c *C) {
// Insert a record match system interface to the DB
r := ptm_models.InsertResourceFromFile(database, "RecordMatchSystemInterface", "../fixtures/record-match-sys-if-01.json")
recMatchSysIface := r.(*ptm_models.RecordMatchSystemInterface)
c.Assert(*recMatchSysIface, NotNil)
// Insert a record set to the DB
r = ptm_models.InsertResourceFromFile(database, "RecordSet", "../fixtures/record-set-01.json")
masterRecSet := r.(*ptm_models.RecordSet)
c.Assert(*masterRecSet, NotNil)
// Insert a corresponding record match run to the DB
recMatchRun := &ptm_models.RecordMatchRun{}
ptm_models.LoadResourceFromFile("../fixtures/record-match-run-post-01.json", recMatchRun)
recMatchRun.MasterRecordSetID = masterRecSet.ID
recMatchRun.RecordMatchSystemInterfaceID = recMatchSysIface.ID
// Build a record match run
// construct a record match request
req, err := newRecordMatchRequest("http://localhost/fhir", recMatchRun, database)
c.Assert(err, IsNil)
buf, _ := req.Message.MarshalJSON()
logger.Log.WithFields(
logrus.Fields{"method": "TestNewRecordMatchDedupRequest",
"request": string(buf)}).Info("")
c.Assert(req, NotNil)
c.Assert(req.Message.Type, Equals, "message")
c.Assert(len(req.Message.Entry), Equals, 2) //MsgHdr + Param`
}
// SetAnswerKey associates a specified Record Set with a FHIR Bundle that
// contains a set of expected record matches (i.e., answer key for the record set)
// The uploaded file is expected to be a FHIR Bundle of type, document,
// in JSON representation.
func (rc *ResourceController) SetAnswerKey(ctx *gin.Context) {
recordSetId, err := toBsonObjectID(ctx.PostForm("recordSetId"))
// Ensure the referenced Record Set exists
resource, err := rc.LoadResource("RecordSet", recordSetId)
if err != nil {
ctx.AbortWithError(http.StatusNotFound, err)
return
}
recordSet := resource.(*ptm_models.RecordSet)
// extract the answer key from the posted form
file, _, err := ctx.Request.FormFile("answerKey")
if err != nil {
ctx.AbortWithError(http.StatusBadRequest, err)
return
}
// write uploaded content to a temp file
tmpfile, err := ioutil.TempFile(os.TempDir(), "ptmatch-")
defer os.Remove(tmpfile.Name())
_, err = io.Copy(tmpfile, file)
ptm_models.LoadResourceFromFile(tmpfile.Name(), &recordSet.AnswerKey)
if isValidAnswerKey(recordSet.AnswerKey) {
c := rc.Database().C(ptm_models.GetCollectionName("RecordSet"))
err = c.Update(bson.M{"_id": recordSetId}, recordSet)
if err != nil {
ctx.AbortWithError(http.StatusInternalServerError, err)
return
}
resource, err = rc.LoadResource("RecordSet", recordSetId)
if err != nil {
ctx.AbortWithError(http.StatusInternalServerError, err)
return
}
recordSet = resource.(*ptm_models.RecordSet)
logger.Log.WithFields(
logrus.Fields{"updated recordset": recordSet}).Info("SetAnswerKey")
ctx.JSON(http.StatusOK, recordSet)
} else {
ctx.AbortWithStatus(http.StatusBadRequest)
}
}
// TestNewMessageHeader tests that a MessageHeader for a record-match
// request is constructed from information in a RecordMatchRun object.
func (s *ServerSuite) TestNewMessageHeader(c *C) {
// Insert a record match system interface to the DB
r := ptm_models.InsertResourceFromFile(database, "RecordMatchSystemInterface", "../fixtures/record-match-sys-if-01.json")
recMatchSysIface := r.(*ptm_models.RecordMatchSystemInterface)
c.Assert(*recMatchSysIface, NotNil)
recMatchRun := &ptm_models.RecordMatchRun{}
ptm_models.LoadResourceFromFile("../fixtures/record-match-run-post-01.json", recMatchRun)
recMatchRun.RecordMatchSystemInterfaceID = recMatchSysIface.ID
// Build a record match run
// construct a record match request
src := "http://replace.me/with/selurl/global"
msgHdr, _ := newMessageHeader(src, recMatchRun, database)
c.Assert(msgHdr, NotNil)
c.Assert(msgHdr.Source.Endpoint, Equals, src)
c.Assert(msgHdr.Event.Code, Equals, "record-match")
}
func (s *ServerSuite) TestRecordMatchRunResponse(c *C) {
var r interface{}
// Insert a record match run object to the DB
// r := ptm_models.InsertResourceFromFile(Database(), "RecordMatchRun", "../fixtures/record-match-run-01.json")
recMatchRun := &ptm_models.RecordMatchRun{}
ptm_models.LoadResourceFromFile("../fixtures/record-match-run-01.json", recMatchRun)
// recMatchRun := r.(*ptm_models.RecordMatchRun)
c.Assert(*recMatchRun, NotNil)
// confirm initial state - zero responses assoc. w/ run
c.Assert(len(recMatchRun.Responses), Equals, 0)
// Assign New Identifier to request message
// recMatchRun.Request.Message.Enry[0].Resource.ID = bson.NewObjectId()
reqMsg := recMatchRun.Request.Message
reqMsgHdr := reqMsg.Entry[0].Resource.(*fhir_models.MessageHeader)
recMatchRun.Request.ID = bson.NewObjectId()
reqMsg.Id = bson.NewObjectId().Hex()
reqMsgHdr.Id = bson.NewObjectId().Hex()
ptm_models.PersistResource(Database(), "RecordMatchRun", recMatchRun)
logger.Log.WithFields(
logrus.Fields{"func": "TestRecordMatchRunResponse",
"recMatchRun": recMatchRun}).Info("after insert recMatchRun")
respMsg := &fhir_models.Bundle{}
// Load text of a record match ack message
ptm_models.LoadResourceFromFile("../fixtures/record-match-ack-01.json", respMsg)
//respMsg := r.(*fhir_models.Bundle)
c.Assert(*respMsg, NotNil)
// Ensure the response references the request
// reqMsg := recMatchRun.Request.Message
c.Assert(reqMsg, NotNil)
c.Assert(reqMsg.Type, Equals, "message")
c.Assert(len(reqMsg.Entry) > 1, Equals, true)
c.Assert(reqMsg.Entry[0].Resource, NotNil)
// reqMsgHdr := reqMsg.Entry[0].Resource.(*fhir_models.MessageHeader)
respMsgHdr := respMsg.Entry[0].Resource.(*fhir_models.MessageHeader)
respMsgHdr.Response.Identifier = reqMsgHdr.Id
buf, _ := respMsg.MarshalJSON()
logger.Log.WithFields(
logrus.Fields{"func": "TestRecordMatchRunResponse",
"resp msg": string(buf)}).Info("prep to POST")
e := s.Server.Engine
code, body := request("POST", "/Bundle",
bytes.NewReader(buf), "application/json", e)
c.Assert(code, Equals, http.StatusCreated)
c.Assert(body, NotNil)
logger.Log.Info("Post Record Match response: " + body)
// Load the record match run object -- this time from database
r, err := ptm_models.LoadResource(Database(), "RecordMatchRun", recMatchRun.ID)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
recMatchRun = r.(*ptm_models.RecordMatchRun)
logger.Log.WithFields(
logrus.Fields{"func": "TestRecordMatchRunResponse",
"recMatchRun": recMatchRun}).Info("after recv response")
// The response should be attached to the record match run ObjectId
c.Assert(len(recMatchRun.Responses), Equals, 1)
c.Assert(recMatchRun.Responses[0].ID, NotNil)
c.Assert(recMatchRun.Responses[0].Message, NotNil)
var respMsg1 *fhir_models.Bundle
respMsg1 = recMatchRun.Responses[0].Message
// After inserting into database, we've lost knowledge about type of resource in response message
// so we use hack to decode to and then encode from json to get map to struct
respMsgHdr1 := &fhir_models.MessageHeader{}
mapToStruct(respMsg1.Entry[0].Resource.(bson.M), respMsgHdr1)
c.Assert(respMsgHdr1.Response.Identifier, Equals, respMsgHdr.Response.Identifier)
}