@RequestMapping(
      method = RequestMethod.POST,
      produces = "application/xml",
      consumes = "application/xml")
  @Transactional
  public ResponseEntity<? extends Serializable> processForm(
      @RequestBody InMigrationForm inMigrationForm) throws JAXBException {

    try {
      context = JAXBContext.newInstance(InMigrationForm.class);
      marshaller = context.createMarshaller();
      marshaller.setAdapter(adapter);
    } catch (JAXBException e) {
      throw new RuntimeException(
          "Could not create JAXB context and marshaller for InMigrationFormResource");
    }

    InMigration inMigration = new InMigration();

    inMigration.setRecordedDate(inMigrationForm.getMigrationDate());
    inMigration.setReason(inMigrationForm.getMigrationReason());
    inMigration.setOrigin(inMigrationForm.getMigrationOrigin());

    // TODO: determine a consistent configuration plan between siteProperties and MigrationType enum
    // TODO: (question) why use an enum and not the siteproperties?
    if ("internal_inmigration".equals(inMigrationForm.getMigrationType())) {
      inMigration.setMigType(MigrationType.INTERNAL_INMIGRATION);
    } else {
      inMigration.setMigType(MigrationType.EXTERNAL_INMIGRATION);
    }

    FieldWorker fieldWorker = fieldWorkerService.getByUuid(inMigrationForm.getFieldWorkerUuid());
    if (null == fieldWorker) {
      ConstraintViolations cv = new ConstraintViolations();
      cv.addViolations(
          ConstraintViolations.INVALID_FIELD_WORKER_UUID
              + " : "
              + inMigrationForm.getFieldWorkerUuid());
      logError(
          cv,
          fieldWorker,
          createDTOPayload(inMigrationForm),
          InMigrationForm.class.getSimpleName(),
          ConstraintViolations.INVALID_FIELD_WORKER_UUID);
      return requestError(cv);
    }
    inMigration.setCollectedBy(fieldWorker);

    Visit visit = visitService.findVisitByUuid(inMigrationForm.getVisitUuid());
    if (null == visit) {
      ConstraintViolations cv = new ConstraintViolations();
      cv.addViolations(
          ConstraintViolations.INVALID_VISIT_UUID + " : " + inMigrationForm.getVisitUuid());
      logError(
          cv,
          fieldWorker,
          createDTOPayload(inMigrationForm),
          InMigrationForm.class.getSimpleName(),
          ConstraintViolations.INVALID_VISIT_UUID);
      return requestError(cv);
    }
    inMigration.setVisit(visit);

    Individual individual = individualService.getByUuid(inMigrationForm.getIndividualUuid());
    if (null == individual) {
      ConstraintViolations cv = new ConstraintViolations();
      cv.addViolations(
          ConstraintViolations.INVALID_INDIVIDUAL_UUID
              + " : "
              + inMigrationForm.getIndividualUuid());
      logError(
          cv,
          fieldWorker,
          createDTOPayload(inMigrationForm),
          InMigrationForm.class.getSimpleName(),
          ConstraintViolations.INVALID_INDIVIDUAL_UUID);
      return requestError(cv);
    }
    inMigration.setIndividual(individual);

    Location location = locationService.getByUuid(inMigrationForm.getLocationUuid());
    if (null == location) {
      ConstraintViolations cv = new ConstraintViolations();
      cv.addViolations(
          ConstraintViolations.INVALID_LOCATION_UUID + " : " + inMigrationForm.getLocationUuid());
      logError(
          cv,
          fieldWorker,
          createDTOPayload(inMigrationForm),
          InMigrationForm.class.getSimpleName(),
          ConstraintViolations.INVALID_LOCATION_UUID);
      return requestError(cv);
    }

    Residency newResidency = new Residency();

    // TODO: since the InMigration domain model contains a reference to a Residency instead of a
    // Location,
    // we must assemble the Residency at this level to provide a fully-graphed InMigration to the
    // service
    newResidency.setCollectedBy(fieldWorker);

    newResidency.setLocation(location);
    newResidency.setIndividual(individual);
    newResidency.setUuid(UUID.randomUUID().toString().replace("-", ""));
    newResidency.setStartDate(inMigration.getRecordedDate());
    newResidency.setStartType(sitePropertiesService.getInmigrationCode());
    newResidency.setEndType(sitePropertiesService.getNotApplicableCode());

    if (null != currentUser) {
      newResidency.setInsertBy(currentUser.getCurrentUser());
    }

    Calendar insertDate = calendarUtil.convertDateToCalendar(new Date());
    newResidency.setInsertDate(insertDate);

    newResidency.setStatus(sitePropertiesService.getDataStatusPendingCode());

    inMigration.setResidency(newResidency);

    try {
      inMigrationService.create(inMigration);
    } catch (ConstraintViolations cv) {
      logError(
          cv,
          fieldWorker,
          createDTOPayload(inMigrationForm),
          InMigrationForm.class.getSimpleName(),
          ConstraintViolations.INVALID_IN_MIGRATION);
      return requestError(cv);
    }

    return new ResponseEntity<InMigrationForm>(inMigrationForm, HttpStatus.CREATED);
  }
  @Transactional(rollbackFor = Exception.class)
  public void createPregnancyOutcome(PregnancyOutcome pregOutcome) throws ConstraintViolations {
    Location motherLocation = pregOutcome.getMother().getCurrentResidency().getLocation();

    int totalEverBorn = 0;
    int liveBirths = 0;

    int numberOfOutcomes = pregOutcome.getOutcomes().size();
    for (int i = 0; i < numberOfOutcomes; i++) {

      Outcome outcome = pregOutcome.getOutcomes().get(i);

      totalEverBorn++;
      if (!outcome.getType().equals(siteProperties.getLiveBirthCode())) {
        // not a live birth so individual, residency and membership not needed
        continue;
      }

      liveBirths++;
      // create individual
      try {
        outcome.getChild().setDob(pregOutcome.getOutcomeDate());
        entityService.create(outcome.getChild());
      } catch (IllegalArgumentException e) {
        throw new ConstraintViolations(
            "IllegalArgumentException creating child individual in the database");
      } catch (SQLException e) {
        throw new ConstraintViolations("SQLException creating child individual in the database");
      }

      // use mothers location for the residency
      Residency residency = new Residency();
      residency.setStartDate(pregOutcome.getOutcomeDate());
      residency.setIndividual(outcome.getChild());
      residency.setStartType(siteProperties.getBirthCode());
      residency.setLocation(motherLocation);
      residency.setCollectedBy(pregOutcome.getCollectedBy());
      residency.setEndType(siteProperties.getNotApplicableCode());

      try {
        entityService.create(residency);
      } catch (IllegalArgumentException e) {
        throw new ConstraintViolations(
            "IllegalArgumentException creating residency for child in database");
      } catch (SQLException e) {
        throw new ConstraintViolations("SQLException creating residency for child in database");
      }

      // persist membership
      try {
        entityService.create(outcome.getChildMembership());
      } catch (IllegalArgumentException e) {
        throw new ConstraintViolations(
            "IllegalArgumentException creating membership for child in database");
      } catch (SQLException e) {
        throw new ConstraintViolations("SQLException creating membership for child in database");
      }
    }

    pregOutcome.setChildEverBorn(totalEverBorn);
    pregOutcome.setNumberOfLiveBirths(liveBirths);

    // close any pregnancy observation
    closePregnancyObservation(pregOutcome.getMother());

    PregnancyOutcome persistedPregnancyOutcome = getPregnancyOutcomeByUuid(pregOutcome.getUuid());

    if (null == persistedPregnancyOutcome) {
      try {
        entityService.create(pregOutcome);
      } catch (SQLException e) {
        throw new ConstraintViolations("Problem creating pregnancy outcome to database");
      }
    } else {
      try {
        entityService.save(pregOutcome);
      } catch (IllegalArgumentException e) {
        throw new ConstraintViolations(
            "IllegalArgumentException saving pregnancy outcome in the database");
      } catch (SQLException e) {
        throw new ConstraintViolations("SQLException saving pregnancy outcome in the database");
      }
    }
  }
  /**
   * Copy a residency TODO: use the clone method?
   *
   * @param primary
   * @param origResidency
   * @return
   */
  private Residency copyResidency(Individual primary, Residency origResidency) {
    Residency residency = new Residency();
    residency.setEndDate(origResidency.getEndDate());
    residency.setEndType(origResidency.getEndType());
    residency.setIndividual(primary);
    residency.setLocation(origResidency.getLocation());
    residency.setStartDate(origResidency.getStartDate());
    residency.setStartType(origResidency.getStartType());
    residency.setCollectedBy(origResidency.getCollectedBy());

    return residency;
  }