コード例 #1
0
  @Test
  public void testUpdateDOBAndCompleteActiveSubscription() throws Exception {
    createLocationData();

    Long msisdn = subscriptionHelper.makeNumber();
    String childId = "0123456789";
    DateTime originalDOB = DateTime.now().minusDays(100);
    DateTime updatedDOB = originalDOB.minusDays(400);

    MctsChild child = new MctsChild(childId);
    child.setState(stateDataService.findByCode(21L));
    child.setDistrict(districtService.findByStateAndCode(child.getState(), 3L));
    makeMctsSubscription(child, originalDOB, SubscriptionPackType.CHILD, msisdn);

    // verify that the subscription is active
    Subscriber subscriber = subscriberDataService.findByCallingNumber(msisdn);
    Subscription subscription = subscriber.getAllSubscriptions().iterator().next();
    assertEquals(SubscriptionStatus.ACTIVE, subscription.getStatus());

    // now, via CSV update, change the DOB to a past subscription date; subscription should be
    // marked completed
    Reader reader =
        createUpdateReaderWithHeaders(
            "1," + childId + ",," + getDateString(updatedDOB) + ",,,,,,,,,,,");
    mctsBeneficiaryUpdateService.updateBeneficiaryData(reader);

    Subscriber updatedSubscriber = subscriberDataService.findByCallingNumber(msisdn);
    assertEquals(getDateString(updatedDOB), getDateString(updatedSubscriber.getDateOfBirth()));
    Subscription updatedSubscription = updatedSubscriber.getAllSubscriptions().iterator().next();
    assertEquals(getDateString(updatedDOB), getDateString(updatedSubscription.getStartDate()));
    assertEquals(SubscriptionStatus.COMPLETED, updatedSubscription.getStatus());
  }
コード例 #2
0
  @Test
  public void testUpdateLMP() throws Exception {
    createLocationData();

    Long msisdn = subscriptionHelper.makeNumber();
    String motherId = "0123456789";
    DateTime originalLMP = DateTime.now().minusDays(100);
    DateTime updatedLMP = originalLMP.minusDays(200);

    subscriptionHelper.mksub(
        SubscriptionOrigin.MCTS_IMPORT, originalLMP, SubscriptionPackType.PREGNANCY, msisdn);
    Subscriber subscriber = subscriberDataService.findByCallingNumber(msisdn);
    subscriber.setLastMenstrualPeriod(originalLMP);
    MctsMother mother = new MctsMother(motherId);
    mother.setState(stateDataService.findByCode(21L));
    mother.setDistrict(districtService.findByStateAndCode(mother.getState(), 3L));
    subscriber.setMother(mother);
    subscriberDataService.update(subscriber);

    Reader reader =
        createUpdateReaderWithHeaders(
            "1," + motherId + ",,," + getDateString(updatedLMP) + ",,,,,,,,,,");
    mctsBeneficiaryUpdateService.updateBeneficiaryData(reader);

    Subscriber updatedSubscriber = subscriberDataService.findByCallingNumber(msisdn);
    assertEquals(
        getDateString(updatedLMP), getDateString(updatedSubscriber.getLastMenstrualPeriod()));
    Subscription updatedSubscription =
        updatedSubscriber.getActiveAndPendingSubscriptions().iterator().next();
    assertEquals(
        getDateString(updatedLMP.plusDays(90)), getDateString(updatedSubscription.getStartDate()));
    assertEquals(SubscriptionStatus.ACTIVE, updatedSubscription.getStatus());
  }
コード例 #3
0
  @Test
  public void testUpdateDOB() throws Exception {
    createLocationData();

    Long msisdn = subscriptionHelper.makeNumber();
    String childId = "0123456789";
    DateTime originalDOB = DateTime.now();
    DateTime updatedDOB = originalDOB.minusDays(100);

    subscriptionHelper.mksub(
        SubscriptionOrigin.MCTS_IMPORT, originalDOB, SubscriptionPackType.CHILD, msisdn);
    Subscriber subscriber = subscriberDataService.findByCallingNumber(msisdn);
    subscriber.setDateOfBirth(originalDOB);
    MctsChild child = new MctsChild(childId);
    child.setState(stateDataService.findByCode(21L));
    child.setDistrict(districtService.findByStateAndCode(child.getState(), 3L));
    subscriber.setChild(child);
    subscriberDataService.update(subscriber);

    // this updates the db with the new data (DOB)
    Reader reader =
        createUpdateReaderWithHeaders(
            "1," + childId + ",," + getDateString(updatedDOB) + ",,,,,,,,,,,");
    mctsBeneficiaryUpdateService.updateBeneficiaryData(reader);

    // This query should return the updated subscriber information (but it doesn't...causing the
    // assert to fail)
    Subscriber updatedSubscriber = subscriberDataService.findByCallingNumber(msisdn);
    assertEquals(getDateString(updatedDOB), getDateString(updatedSubscriber.getDateOfBirth()));
    Subscription updatedSubscription =
        updatedSubscriber.getActiveAndPendingSubscriptions().iterator().next();
    assertEquals(getDateString(updatedDOB), getDateString(updatedSubscription.getStartDate()));
    assertEquals(SubscriptionStatus.ACTIVE, updatedSubscription.getStatus());
  }
コード例 #4
0
  @Test
  public void testUpdateMsisdnNumberAlreadyInUse() throws Exception {
    Long firstMsisdn = subscriptionHelper.makeNumber();
    Long secondMsisdn = subscriptionHelper.makeNumber();

    // create two child subscriptions with different MSISDNs
    Subscription firstSubscription =
        subscriptionHelper.mksub(
            SubscriptionOrigin.MCTS_IMPORT,
            DateTime.now(),
            SubscriptionPackType.CHILD,
            firstMsisdn);
    String firstChildId = "0123456789";
    firstSubscription.getSubscriber().setChild(new MctsChild(firstChildId));
    subscriberDataService.update(firstSubscription.getSubscriber());

    Subscription secondSubscription =
        subscriptionHelper.mksub(
            SubscriptionOrigin.MCTS_IMPORT,
            DateTime.now(),
            SubscriptionPackType.CHILD,
            secondMsisdn);
    String secondChildId = "9123456789";
    secondSubscription.getSubscriber().setChild(new MctsChild(secondChildId));
    subscriberDataService.update(secondSubscription.getSubscriber());

    // try to set the second child's MSISDN to the same number as the first child's MSISDN
    Reader reader =
        createUpdateReaderWithHeaders("1," + secondChildId + ",,,,,,,,,,,,," + firstMsisdn);
    mctsBeneficiaryUpdateService.updateBeneficiaryData(reader);

    List<SubscriptionError> errors = subscriptionErrorDataService.findByContactNumber(firstMsisdn);
    assertEquals(1, errors.size());
  }
コード例 #5
0
 private void makeMctsSubscription(
     MctsBeneficiary beneficiary, DateTime startDate, SubscriptionPackType packType, Long number) {
   subscriptionHelper.mksub(SubscriptionOrigin.MCTS_IMPORT, startDate, packType, number);
   Subscriber subscriber = subscriberDataService.findByCallingNumber(number);
   if (packType == SubscriptionPackType.CHILD) {
     subscriber.setChild((MctsChild) beneficiary);
     subscriber.setDateOfBirth(startDate);
   } else {
     subscriber.setMother((MctsMother) beneficiary);
     subscriber.setLastMenstrualPeriod(startDate.minusDays(90));
   }
   subscriberDataService.update(subscriber);
 }
コード例 #6
0
  /*
   * To verify that NMS is not able to change the location of
   * beneficiary using MCTS ID when location information is wrong.
   *
   * https://applab.atlassian.net/browse/NMS-231
   */
  @Test
  public void verifyFT325() throws Exception {
    createLocationData();

    Long msisdn = subscriptionHelper.makeNumber();
    String childId = "0123456789";

    MctsChild child = new MctsChild(childId);
    child.setState(stateDataService.findByCode(21L));
    child.setDistrict(districtService.findByStateAndCode(child.getState(), 2L));
    makeMctsSubscription(child, DateTime.now().minusDays(100), SubscriptionPackType.CHILD, msisdn);

    // district provided in request doesn't exist in nms-db
    Reader reader = createUpdateReaderWithHeaders("1," + childId + ",,,,21,8,0026,453,,,,,,");
    mctsBeneficiaryUpdateService.updateBeneficiaryData(reader);

    Subscriber subscriber = subscriberDataService.findByCallingNumber(msisdn);
    assertNotNull(subscriber);
    assertNotEquals(subscriber.getChild().getDistrict().getCode(), new Long(7));

    List<SubscriptionError> susbErrors = subscriptionErrorDataService.findByBeneficiaryId(childId);
    SubscriptionError susbError = susbErrors.iterator().next();
    assertNotNull(susbError);
    assertEquals(SubscriptionRejectionReason.INVALID_LOCATION, susbError.getRejectionReason());
  }
コード例 #7
0
  @Test
  public void testUpdateMsisdnForSubscriberWithBothPacks() throws Exception {
    Long oldMsisdn = subscriptionHelper.makeNumber();
    Long newMsisdn = subscriptionHelper.makeNumber();

    Subscription childSubscription =
        subscriptionHelper.mksub(
            SubscriptionOrigin.MCTS_IMPORT, DateTime.now(), SubscriptionPackType.CHILD, oldMsisdn);
    String childId = "0123456789";
    childSubscription.getSubscriber().setChild(new MctsChild(childId));
    subscriberDataService.update(childSubscription.getSubscriber());

    Subscription pregnancySubscription =
        subscriptionHelper.mksub(
            SubscriptionOrigin.MCTS_IMPORT,
            DateTime.now().minusDays(150),
            SubscriptionPackType.PREGNANCY,
            oldMsisdn);
    String motherId = "9876543210";
    pregnancySubscription.getSubscriber().setMother(new MctsMother(motherId));
    subscriberDataService.update(pregnancySubscription.getSubscriber());

    assertEquals(
        2,
        subscriberDataService
            .findByCallingNumber(oldMsisdn)
            .getActiveAndPendingSubscriptions()
            .size());

    Reader reader = createUpdateReaderWithHeaders("1," + motherId + ",,,,,,,,,,,,," + newMsisdn);
    mctsBeneficiaryUpdateService.updateBeneficiaryData(reader);

    Subscriber pregnancySubscriber = subscriberDataService.findByCallingNumber(newMsisdn);
    Subscriber childSubscriber = subscriberDataService.findByCallingNumber(oldMsisdn);

    assertNotNull(pregnancySubscriber);
    assertNotNull(childSubscriber);
    assertNotEquals(childSubscriber, pregnancySubscriber);
    assertEquals(newMsisdn, pregnancySubscriber.getCallingNumber());
    assertEquals(oldMsisdn, childSubscriber.getCallingNumber());
    assertNull(pregnancySubscriber.getChild());
    assertNull(childSubscriber.getMother());
    assertEquals(1, pregnancySubscriber.getActiveAndPendingSubscriptions().size());
    assertEquals(1, childSubscriber.getActiveAndPendingSubscriptions().size());
  }
コード例 #8
0
  @Test
  public void testUpdateMsisdn() throws Exception {
    Long oldMsisdn = subscriptionHelper.makeNumber();
    Long newMsisdn = subscriptionHelper.makeNumber();

    Subscription subscription =
        subscriptionHelper.mksub(
            SubscriptionOrigin.MCTS_IMPORT, DateTime.now(), SubscriptionPackType.CHILD, oldMsisdn);
    String mctsId = "0123456789";

    subscription.getSubscriber().setChild(new MctsChild(mctsId));
    subscriberDataService.update(subscription.getSubscriber());

    Reader reader = createUpdateReaderWithHeaders("1," + mctsId + ",,,,,,,,,,,,," + newMsisdn);
    mctsBeneficiaryUpdateService.updateBeneficiaryData(reader);

    Subscriber oldSubscriber = subscriberDataService.findByCallingNumber(oldMsisdn);
    assertNull(oldSubscriber.getChild());
    assertEquals(0, oldSubscriber.getActiveAndPendingSubscriptions().size());

    Subscriber subscriber = subscriberDataService.findByCallingNumber(newMsisdn);
    assertNotNull(subscriber);
    assertEquals(mctsId, subscriber.getChild().getBeneficiaryId());
  }
コード例 #9
0
  @Test
  public void testUpdateBeneficiariesFromFile() throws Exception {
    createLocationData();

    // ----Create 4 beneficiaries:----

    String child1id = "1234567890";
    MctsChild child1 = new MctsChild(child1id);
    child1.setState(stateDataService.findByCode(21L));
    child1.setDistrict(districtService.findByStateAndCode(child1.getState(), 3L));
    Long child1msisdn = subscriptionHelper.makeNumber();
    makeMctsSubscription(
        child1, DateTime.now().minusDays(100), SubscriptionPackType.CHILD, child1msisdn);

    String mother2id = "1234567899";
    MctsMother mother2 = new MctsMother(mother2id);
    mother2.setState(stateDataService.findByCode(21L));
    mother2.setDistrict(districtService.findByStateAndCode(mother2.getState(), 3L));
    Long mother2msisdn = subscriptionHelper.makeNumber();
    makeMctsSubscription(
        mother2, DateTime.now().minusDays(100), SubscriptionPackType.PREGNANCY, mother2msisdn);

    String mother3id = "9876543210";
    MctsMother mother3 = new MctsMother(mother3id);
    mother3.setState(stateDataService.findByCode(21L));
    mother3.setDistrict(districtService.findByStateAndCode(mother3.getState(), 3L));
    makeMctsSubscription(
        mother3,
        DateTime.now().minusDays(100),
        SubscriptionPackType.PREGNANCY,
        subscriptionHelper.makeNumber());

    Long child4msisdn = subscriptionHelper.makeNumber();
    MctsChild child4 = new MctsChild("9876543211");
    child4.setState(stateDataService.findByCode(21L));
    child4.setDistrict(districtService.findByStateAndCode(child4.getState(), 3L));
    makeMctsSubscription(
        child4, DateTime.now().minusDays(100), SubscriptionPackType.CHILD, child4msisdn);

    // ----Update all 4 via CSV:----

    mctsBeneficiaryUpdateService.updateBeneficiaryData(read("csv/mcts_beneficiary_update.csv"));

    // ----Validate updates to each:----

    // MSISDN update:
    Subscriber oldSubscriber1 = subscriberDataService.findByCallingNumber(child1msisdn);
    assertNull(oldSubscriber1.getChild());
    assertEquals(0, oldSubscriber1.getAllSubscriptions().size());

    Subscriber subscriber1 = subscriberDataService.findByCallingNumber(9439986187L);
    assertNotNull(subscriber1);
    assertEquals(child1id, subscriber1.getChild().getBeneficiaryId());

    // MSISDN update:
    Subscriber oldSubscriber2 = subscriberDataService.findByCallingNumber(mother2msisdn);
    assertNull(oldSubscriber2.getMother());
    assertEquals(0, oldSubscriber2.getAllSubscriptions().size());

    Subscriber subscriber2 = subscriberDataService.findByCallingNumber(9439986188L);
    assertNotNull(subscriber2);
    assertEquals(mother2id, subscriber2.getMother().getBeneficiaryId());

    // Location update:
    MctsMother updatedMother3 = mctsMotherDataService.findByBeneficiaryId(mother3id);
    assertEquals(21L, (long) updatedMother3.getState().getCode());
    assertEquals(3L, (long) updatedMother3.getDistrict().getCode());
    assertEquals("0026", updatedMother3.getTaluka().getCode());
    assertEquals(453L, (long) updatedMother3.getHealthBlock().getCode());

    // DOB update:
    String updatedDOB = "01-07-2015";
    Subscriber subscriber4 = subscriberDataService.findByCallingNumber(child4msisdn);
    assertEquals(updatedDOB, getDateString(subscriber4.getDateOfBirth()));
    Subscription updatedSubscription =
        subscriber4.getActiveAndPendingSubscriptions().iterator().next();
    assertEquals(updatedDOB, getDateString(updatedSubscription.getStartDate()));
    assertEquals(SubscriptionStatus.ACTIVE, updatedSubscription.getStatus());
  }