@Test
 public void testReferencesForPurchasedInCategory() {
   final UserModel user = userService.getUserForUID("dejol");
   userService.setCurrentUser(user);
   List<ProductData> result =
       simpleSuggestionFacade.getReferencesForPurchasedInCategory(
           "cameras", Collections.EMPTY_LIST, false, null);
   Assert.assertEquals(4, result.size());
   result =
       simpleSuggestionFacade.getReferencesForPurchasedInCategory(
           "cameras", Collections.EMPTY_LIST, false, NumberUtils.INTEGER_ONE);
   Assert.assertEquals(1, result.size());
   result =
       simpleSuggestionFacade.getReferencesForPurchasedInCategory(
           "cameras", Arrays.asList(ProductReferenceTypeEnum.SIMILAR), false, null);
   Assert.assertEquals(1, result.size());
   result =
       simpleSuggestionFacade.getReferencesForPurchasedInCategory(
           "cameras", Arrays.asList(ProductReferenceTypeEnum.ACCESSORIES), false, null);
   Assert.assertEquals(2, result.size());
   result =
       simpleSuggestionFacade.getReferencesForPurchasedInCategory(
           "cameras", Arrays.asList(ProductReferenceTypeEnum.ACCESSORIES), true, null);
   Assert.assertEquals(1, result.size());
   final ProductData product = result.get(0);
   Assert.assertEquals("adapterDC", product.getCode());
   Assert.assertEquals("adapter", product.getName());
 }
  @Test
  public void testHasWriteCollectionRight() {
    final UserModel otherUser = userService.getUserForUID("other");
    final UserModel abrode = userService.getUserForUID("abrode");
    final UserModel deJol = userService.getUserForUID("deJol");

    final List<CockpitObjectAbstractCollectionModel> collections =
        cockpitCollectionService.getCollectionsForUser(deJol);

    assertThat(collections).isNotNull();
    assertThat(collections.size()).isEqualTo(2);

    CockpitObjectAbstractCollectionModel writableCollection = null;
    for (final CockpitObjectAbstractCollectionModel collection : collections) {
      if ("writable".equals(collection.getQualifier())) {
        writableCollection = collection;
        break;
      }
    }

    boolean hasRight =
        cockpitCollectionService.hasWriteCollectionRight(otherUser, writableCollection);
    assertThat(hasRight).isFalse();

    hasRight = cockpitCollectionService.hasWriteCollectionRight(abrode, writableCollection);
    assertThat(hasRight).isTrue();

    hasRight = cockpitCollectionService.hasWriteCollectionRight(deJol, writableCollection);
    assertThat(hasRight).isTrue();
  }
コード例 #3
0
  private void prepareData() {
    catVersion = catalogVersionService.getCatalogVersion("hwcatalog", "Online");
    catalogVersionService.addSessionCatalogVersion(catVersion);

    user = userService.getUserForUID("ariel");
    userService.setCurrentUser(user);
    cart = cartService.getSessionCart();
    commonI18NService.setCurrentCurrency(commonI18NService.getCurrency("EUR"));
    product1 = productService.getProductForCode(catVersion, "HW2110-0012");
  }
  @Before
  public void setUp() throws Exception {
    // Create data for tests
    LOG.info("Creating data for collections ..");
    userService.setCurrentUser(userService.getAdminUser());
    final long startTime = System.currentTimeMillis();
    new CoreBasicDataCreator().createEssentialData(Collections.EMPTY_MAP, null);
    // importing test csv
    importCsv("/test/testCollections.csv", "windows-1252");

    LOG.info("Finished data for collections " + (System.currentTimeMillis() - startTime) + "ms");
  }
コード例 #5
0
  @Test
  public void testIsUserAssignedPrincipalForAdmin() {
    // given
    final WorkflowActionModel mockAction = mock(WorkflowActionModel.class);
    final UserModel mockUser = mock(UserModel.class);
    when(Boolean.valueOf(userService.isAdmin(mockUser))).thenReturn(Boolean.TRUE);
    when(userService.getCurrentUser()).thenReturn(mockUser);

    // when
    final boolean isAssigned = workflowActionService.isUserAssignedPrincipal(mockAction);

    // then
    assertThat(isAssigned).isTrue();
  }
  @Test
  public void testGetCollectionsForUser() {
    UserModel user = userService.getUserForUID("ahertz");
    List<CockpitObjectAbstractCollectionModel> collections =
        cockpitCollectionService.getCollectionsForUser(user);

    assertThat(collections).isNotNull();
    assertThat(collections.size()).isEqualTo(3);

    user = userService.getUserForUID("abrode");
    collections = cockpitCollectionService.getCollectionsForUser(user);

    assertThat(collections).isNotNull();
    assertThat(collections.size()).isEqualTo(4);
  }
  @Override
  @Before
  public void setUp() throws Exception {
    super.setUp();

    final CatalogVersionModel version =
        catalogVersionService.getCatalogVersion("hwcatalog", "Online");
    catalogVersionService.addSessionCatalogVersion(version);
    baseProduct = productService.getProductForCode(version, "HW2110-0019");
    partnerProduct = productService.getProductForCode(version, "HW2200-0561");
    user = userService.getUserForUID("demo");
    userService.setCurrentUser(user);
    currency = commonI18NService.getCurrency("EUR");
    commonI18NService.setCurrentCurrency(currency);
  }
コード例 #8
0
  @Before
  public void setUp() throws Exception {
    createCoreData();
    createDefaultCatalog();
    productModel01 = productService.getProduct("testProduct1");
    userModel01 = userService.getUser("anonymous");
    userModel02 = userService.getCurrentUser();

    oldMinimalRating = Config.getParameter(CustomerReviewConstants.KEYS.MINIMAL_RATING);
    oldMaximalRating = Config.getParameter(CustomerReviewConstants.KEYS.MAXIMAL_RATING);

    // Set some configuration values to be used generally in the tests
    Config.setParameter(CustomerReviewConstants.KEYS.MINIMAL_RATING, String.valueOf(0));
    Config.setParameter(CustomerReviewConstants.KEYS.MAXIMAL_RATING, String.valueOf(4));
  }
 /*
  * (non-Javadoc)
  *
  * @see de.hybris.platform.b2bacceleratorfacades.company.CompanyB2BCommerceFacade#getContactNumber(java.lang.String)
  */
 @Override
 public String getContactNumber(final String uuid, final CustomerData customerData) {
   final EnergizerB2BCustomerModel model =
       userService.getUserForUID(uuid, EnergizerB2BCustomerModel.class);
   contactNumberPopulator.populate(model, customerData);
   return customerData.getContactNumber();
 }
  @Test
  public void testGetElements() {
    final UserModel user = userService.getUserForUID("abrode");
    final List<CockpitObjectSpecialCollectionModel> collections =
        cockpitCollectionService.getSpecialCollections(user, "quickcollection");
    CockpitObjectSpecialCollectionModel threeElementsCollection = null;
    for (final CockpitObjectSpecialCollectionModel collection : collections) {
      if ("testSpecialB".equals(collection.getQualifier())) {
        threeElementsCollection = collection;
        break;
      }
    }

    assertThat(threeElementsCollection).isNotNull();

    List<ItemModel> elements =
        cockpitCollectionService.getElements(threeElementsCollection, 0, 100);

    assertThat(elements.size()).isEqualTo(3);
    assertThat(elements.get(0) instanceof ProductModel).isTrue();

    elements = cockpitCollectionService.getElements(threeElementsCollection, 0, 2);

    assertThat(elements.size()).isEqualTo(2);
  }
  @Test
  public void testAddToCollection() {
    final UserModel user = userService.getUserForUID("ahertz");
    List<CockpitObjectAbstractCollectionModel> collections =
        cockpitCollectionService.getCollectionsForUser(user);
    CockpitObjectAbstractCollectionModel collection = null;
    for (final CockpitObjectAbstractCollectionModel coll : collections) {
      if ("testA".equals(coll.getQualifier())) {
        collection = coll;
        break;
      }
    }

    assertThat(collection.getElements().size()).isEqualTo(2);

    final CatalogVersionModel catalogVersion =
        catalogService.getCatalogVersion("testCatalog", "Online");
    final List<ItemModel> elements = new ArrayList<ItemModel>();
    elements.add(productService.getProductForCode(catalogVersion, "testProduct4"));

    final int n = cockpitCollectionService.addToCollection(collection, elements);

    collections = cockpitCollectionService.getCollectionsForUser(user);
    CockpitObjectAbstractCollectionModel changedCollection = null;
    for (final CockpitObjectAbstractCollectionModel coll : collections) {
      if ("testA".equals(coll.getQualifier())) {
        changedCollection = coll;
        break;
      }
    }

    assertThat(changedCollection.getElements().size()).isEqualTo(3);
    assertThat(n).isEqualTo(1);
  }
コード例 #12
0
  @Test
  public void shouldUpdateBranchInSession() throws Exception {
    sessionService.executeInLocalView(
        new SessionExecutionBody() {
          @Override
          public void executeWithoutResult() {
            final JaloSession currentSession = JaloSession.getCurrentSession();
            final DefaultSession session =
                (DefaultSession) sessionService.getSession(currentSession.getSessionID());
            Assert.assertEquals(currentSession, session.getJaloSession());

            session.setAttribute("test", new Object());
            Assert.assertNotNull(currentSession.getAttribute("test"));
            final B2BCustomerModel user = (B2BCustomerModel) userService.getUserForUID("IC CEO");
            session.setAttribute(B2BConstants.CTX_ATTRIBUTE_BRANCH, null);
            session.setAttribute(B2BConstants.CTX_ATTRIBUTE_ROOTUNIT, null);
            Assert.assertNull(currentSession.getAttribute(B2BConstants.CTX_ATTRIBUTE_BRANCH));
            Assert.assertNull(currentSession.getAttribute(B2BConstants.CTX_ATTRIBUTE_ROOTUNIT));

            b2bUnitService.updateBranchInSession(session, user);
            Assert.assertNotNull(currentSession.getAttribute(B2BConstants.CTX_ATTRIBUTE_BRANCH));
            Assert.assertNotNull(currentSession.getAttribute(B2BConstants.CTX_ATTRIBUTE_ROOTUNIT));
          }
        },
        userService.getAdminUser());
  }
コード例 #13
0
  @Test
  public void testGetBranch() throws Exception {
    sessionService.executeInLocalView(
        new SessionExecutionBody() {
          @Override
          public void executeWithoutResult() {
            final String userId = "IC CEO";
            login(userId);

            // test getBranchMethod
            B2BUnitModel unit = b2bUnitService.getUnitForUid("IC");
            Assert.assertNotNull(unit);
            final Set<B2BUnitModel> decendents = b2bUnitService.getBranch(unit);
            Assert.assertNotNull(decendents);
            Assert.assertEquals(11, decendents.size());

            // test getAllUnitsOfOrganization
            final Set<B2BUnitModel> allUnits = b2bUnitService.getBranch(unit);
            Assert.assertNotNull(allUnits);
            Assert.assertEquals(11, allUnits.size());

            unit = b2bUnitService.getUnitForUid("IC Sales");
            Assert.assertNotNull(unit);
            Assert.assertEquals(b2bUnitService.getParent(unit).getUid(), "IC");
            Assert.assertEquals(b2bUnitService.getRootUnit(unit).getUid(), "IC");
            Assert.assertEquals(9, b2bUnitService.getBranch(unit).size());
          }
        },
        userService.getAdminUser());
  }
コード例 #14
0
 @Test
 public void searchRestrictionTest() {
   final UserGroupModel group = new UserGroupModel();
   group.setUid("customergroup");
   modelService.save(group);
   // create test user
   final UserModel user = new UserModel();
   user.setUid(TEST_USER);
   // assign user to customergroup
   user.setGroups(Collections.singleton((PrincipalGroupModel) group));
   modelService.save(user);
   // create test catalog
   final CatalogModel catalog = new CatalogModel();
   catalog.setId(TEST_CATALOG);
   modelService.save(catalog);
   // create test catalog version
   final CatalogVersionModel catalogVersion = new CatalogVersionModel();
   catalogVersion.setCatalog(catalog);
   catalogVersion.setVersion(TEST_VERSION);
   modelService.save(catalogVersion);
   // create test product
   final ProductModel product = new ProductModel();
   product.setCode(TEST_PRODUCT);
   product.setCatalogVersion(catalogVersion);
   modelService.save(product);
   // set current user
   userService.setCurrentUser(user);
   // create search restriction
   commonI18NService.setCurrentLanguage(commonI18NService.getLanguage(LANG_EN));
   final Map<String, String[]> params = new HashMap<String, String[]>();
   params.put("customerreview.searchrestrictions.create", new String[] {"true"});
   final SystemSetupContext ctx =
       new SystemSetupContext(params, Type.ESSENTIAL, Process.ALL, "customerreview");
   customerReviewSystemSetup.createSearchRestrictions(ctx);
   // enable search restrictions
   searchRestrictionService.enableSearchRestrictions();
   // make sure that number of customer reviews is 0
   assertEquals(
       INVALID_NUMBER_OF_CUSTOMER_REVIEWS,
       Integer.valueOf(0),
       customerReviewService.getNumberOfReviews(product));
   // create restricted customer review
   createCustomerReview(null, user, product, CustomerReviewApprovalType.PENDING);
   // create valid customer review
   createCustomerReview("headline", user, product, CustomerReviewApprovalType.APPROVED);
   // make sure that number of customer reviews is 1
   assertEquals(
       INVALID_NUMBER_OF_CUSTOMER_REVIEWS,
       Integer.valueOf(1),
       customerReviewService.getNumberOfReviews(product));
   // disable search restrictions
   searchRestrictionService.disableSearchRestrictions();
   // make sure that number of customer reviews is 2
   assertEquals(
       INVALID_NUMBER_OF_CUSTOMER_REVIEWS,
       Integer.valueOf(2),
       customerReviewService.getNumberOfReviews(product));
 }
  @Test
  public void testCloneCollection() {
    final UserModel user = userService.getUserForUID("ahertz");
    final UserModel userB = userService.getUserForUID("abrode");
    final List<CockpitObjectAbstractCollectionModel> collections =
        cockpitCollectionService.getCollectionsForUser(user);
    final CockpitObjectCollectionModel collection =
        (CockpitObjectCollectionModel) collections.get(0);

    final CockpitObjectAbstractCollectionModel clone =
        cockpitCollectionService.cloneCollection(collection, userB);

    assertThat(clone).isNotNull();
    assertThat(clone.getUser()).isEqualTo(userB);
    assertThat(clone.getQualifier()).isEqualTo(collection.getQualifier());
    assertThat(clone.getElements().size())
        .isEqualTo(Integer.valueOf(collection.getElements().size()));
  }
  @Test
  public void testGetSpecialCollectionsForUser() {
    final UserModel user = userService.getUserForUID("ahertz");
    final List<CockpitObjectSpecialCollectionModel> collections =
        cockpitCollectionService.getSpecialCollectionsForUser(user);

    assertThat(collections).isNotNull();
    assertThat(collections.size()).isEqualTo(1);
    assertThat(collections.get(0).getQualifier()).isEqualTo("testSpecialA");
    assertThat(collections.get(0).getCollectionType().getCode()).isEqualTo("blacklist");
    assertThat(collections.get(0).getElements().size()).isEqualTo(2);
  }
  @Test
  public void testGetSpecialCollections() {
    final UserModel user = userService.getUserForUID("abrode");
    final List<CockpitObjectSpecialCollectionModel> collections =
        cockpitCollectionService.getSpecialCollections(user, "quickcollection");

    assertThat(collections).isNotNull();
    assertThat(collections.size()).isEqualTo(1);
    assertThat(collections.get(0).getQualifier()).isEqualTo("testSpecialB");
    assertThat(collections.get(0).getCollectionType().getCode()).isEqualTo("quickcollection");
    assertThat(collections.get(0).getElements().size()).isEqualTo(3);
  }
  @Before
  public void setUp() throws Exception {
    // final Create data for tests
    LOG.info("Creating data for DefaultChangeProductPriceBundleRuleDaoIntegrationTest ..");
    userService.setCurrentUser(userService.getAdminUser());
    final long startTime = System.currentTimeMillis();
    new CoreBasicDataCreator().createEssentialData(Collections.EMPTY_MAP, null);

    // importing test csv
    final String legacyModeBackup = Config.getParameter(ImpExConstants.Params.LEGACY_MODE_KEY);
    LOG.info(
        "Existing value for " + ImpExConstants.Params.LEGACY_MODE_KEY + " :" + legacyModeBackup);
    Config.setParameter(ImpExConstants.Params.LEGACY_MODE_KEY, "true");
    importCsv("/commerceservices/test/testCommerceCart.csv", "utf-8");
    Config.setParameter(ImpExConstants.Params.LEGACY_MODE_KEY, "false");
    importCsv("/subscriptionservices/test/testSubscriptionCommerceCartService.impex", "utf-8");
    importCsv("/configurablebundleservices/test/testBundleCommerceCartService.impex", "utf-8");
    importCsv("/configurablebundleservices/test/testApproveAllBundleTemplates.impex", "utf-8");
    Config.setParameter(ImpExConstants.Params.LEGACY_MODE_KEY, legacyModeBackup);

    LOG.info(
        "Finished data for DefaultChangeProductPriceBundleRuleDaoIntegrationTest "
            + (System.currentTimeMillis() - startTime)
            + "ms");

    baseSiteService.setCurrentBaseSite(baseSiteService.getBaseSiteForUID(TEST_BASESITE_UID), false);
    catalogVersionService.setSessionCatalogVersion("testCatalog", "Online");

    currencyUSD = commonI18NService.getCurrency("USD");
    currencyEUR = commonI18NService.getCurrency("EUR");
    galaxynexus = productService.getProductForCode("GALAXY_NEXUS");
    standardplan1y = productService.getProductForCode("PLAN_STANDARD_1Y");
    standardplan3y = productService.getProductForCode("PLAN_STANDARD_3Y");
    smartPhonePlanBundleTemplate =
        bundleTemplateService.getBundleTemplateForCode("SmartPhonePlanSelection");
    smartPhoneDeviceBundleTemplate =
        bundleTemplateService.getBundleTemplateForCode("SmartPhoneDeviceSelection");

    modelService.detachAll();
  }
  @Test
  public void testRemoveFromCollection() {
    final UserModel user = userService.getUserForUID("ahertz");
    List<CockpitObjectAbstractCollectionModel> collections =
        cockpitCollectionService.getCollectionsForUser(user);
    CockpitObjectAbstractCollectionModel collection = null;

    for (final CockpitObjectAbstractCollectionModel coll : collections) {
      if ("testA".equals(coll.getQualifier())) {
        collection = coll;
        break;
      }
    }

    assertThat(collection.getElements().size()).isEqualTo(2);

    final CatalogVersionModel catalogVersion =
        catalogService.getCatalogVersion("testCatalog", "Online");
    final List<ItemModel> elements = new ArrayList<ItemModel>();
    elements.add(productService.getProductForCode(catalogVersion, "testProduct4"));

    int n = cockpitCollectionService.removeFromCollection(collection, elements);

    collections = cockpitCollectionService.getCollectionsForUser(user);
    CockpitObjectAbstractCollectionModel changedCollection = null;
    for (final CockpitObjectAbstractCollectionModel coll : collections) {
      if ("testA".equals(coll.getQualifier())) {
        changedCollection = coll;
        break;
      }
    }
    // should not change, before we tried to remove the element that does not exist in the
    // collection
    assertThat(changedCollection.getElements().size()).isEqualTo(2);
    assertThat(n).isEqualTo(0);

    elements.clear();
    elements.add(productService.getProductForCode(catalogVersion, "testProduct0"));

    n = cockpitCollectionService.removeFromCollection(collection, elements);

    collections = cockpitCollectionService.getCollectionsForUser(user);
    changedCollection = null;
    for (final CockpitObjectAbstractCollectionModel coll : collections) {
      if ("testA".equals(coll.getQualifier())) {
        changedCollection = coll;
        break;
      }
    }
    assertThat(changedCollection.getElements().size()).isEqualTo(1);
    assertThat(n).isEqualTo(1);
  }
  @Before
  public void setUp() throws Exception {
    LOG.info("Creating data for SubscriptionEntitlementTest ...");
    userService.setCurrentUser(userService.getAdminUser());
    final long startTime = System.currentTimeMillis();
    new CoreBasicDataCreator().createEssentialData(Collections.EMPTY_MAP, null);
    // importing test csv
    final String legacyModeBackup = Config.getParameter(ImpExConstants.Params.LEGACY_MODE_KEY);
    LOG.info(
        "Existing value for " + ImpExConstants.Params.LEGACY_MODE_KEY + " :" + legacyModeBackup);
    Config.setParameter(ImpExConstants.Params.LEGACY_MODE_KEY, "true");
    importCsv("/commerceservices/test/testCommerceCart.csv", "utf-8");
    Config.setParameter(ImpExConstants.Params.LEGACY_MODE_KEY, "false");
    importCsv("/subscriptionservices/test/testSubscriptionCommerceCartService.impex", "utf-8");
    Config.setParameter(ImpExConstants.Params.LEGACY_MODE_KEY, legacyModeBackup);

    LOG.info(
        "Finished data for SubscriptionEntitlementTest "
            + (System.currentTimeMillis() - startTime)
            + "ms");
    modelService.detachAll();
  }
  @Test
  public void testHasReadCollectionRight() {
    final UserModel otherUser = userService.getUserForUID("other");
    final UserModel abrode = userService.getUserForUID("abrode");
    final UserModel deJol = userService.getUserForUID("deJol");

    final List<CockpitObjectAbstractCollectionModel> collections =
        cockpitCollectionService.getCollectionsForUser(deJol);

    assertThat(collections).isNotNull();
    assertThat(collections.size()).isEqualTo(2);

    final CockpitObjectAbstractCollectionModel collection = collections.get(0);
    boolean hasRight = cockpitCollectionService.hasReadCollectionRight(otherUser, collection);
    assertThat(hasRight).isFalse();

    hasRight = cockpitCollectionService.hasReadCollectionRight(abrode, collection);
    assertThat(hasRight).isTrue();

    hasRight = cockpitCollectionService.hasReadCollectionRight(deJol, collection);
    assertThat(hasRight).isTrue();
  }
コード例 #22
0
  @Before
  public void beforeTest() throws Exception {
    B2BIntegrationTest.loadTestData();
    importCsv("/b2bapprovalprocess/test/b2borganizations.csv", "UTF-8");
    importCsv("/b2bapprovalprocess/test/creditlimit.impex", "UTF-8");

    sessionService
        .getCurrentSession()
        .setAttribute(
            "user", this.modelService.<Object>toPersistenceLayer(userService.getAdminUser()));
    i18nService.setCurrentLocale(Locale.ENGLISH);
    commonI18NService.setCurrentLanguage(commonI18NService.getLanguage("en"));
    commonI18NService.setCurrentCurrency(commonI18NService.getCurrency("EUR"));
  }
  @Before
  public void setUp() throws Exception {
    // final Create data for tests
    LOG.info("Creating data for BundleSelectionCriteriaIDPrepareInterceptorIntegrationTest ...");
    userService.setCurrentUser(userService.getAdminUser());
    final long startTime = System.currentTimeMillis();
    new CoreBasicDataCreator().createEssentialData(Collections.EMPTY_MAP, null);
    // importing test csv
    final String legacyModeBackup = Config.getParameter(ImpExConstants.Params.LEGACY_MODE_KEY);
    LOG.info(
        "Existing value for " + ImpExConstants.Params.LEGACY_MODE_KEY + " :" + legacyModeBackup);
    Config.setParameter(ImpExConstants.Params.LEGACY_MODE_KEY, "true");
    importCsv("/commerceservices/test/testCommerceCart.csv", "utf-8");
    Config.setParameter(ImpExConstants.Params.LEGACY_MODE_KEY, legacyModeBackup);

    LOG.info(
        "Finished data for BundleSelectionCriteriaIDPrepareInterceptorIntegrationTest "
            + (System.currentTimeMillis() - startTime)
            + "ms");

    baseSiteService.setCurrentBaseSite(baseSiteService.getBaseSiteForUID(TEST_BASESITE_UID), false);
    catalogVersionService.setSessionCatalogVersion("testCatalog", "Online");
  }
  @Test
  public void testOnEvent() throws Exception {
    // get admin user
    final UserModel user = userService.getAdminUser();

    // create session cart, anonymous user is set on cart
    cartService.getSessionCart();

    // set admin user as current
    userService.setCurrentUser(user);

    // AfterSessionUserChangeEvent processed in background
    // ....

    // get current cart
    final CartModel cart = cartService.getSessionCart();

    // refresh cart to ensure that cart user is persisted
    modelService.refresh(cart);

    assertNotNull("Cart is null.", cart);
    assertNotNull("Cart user is null.", cart.getUser());
    assertEquals("Cart user differs.", user, cart.getUser());
  }
コード例 #25
0
  @Test
  public void shouldTriggerCreditAlert() throws Exception {
    // Step 1 There should not be any template for Alert
    final EmployeeModel employeeModel = userService.getAdminUser();
    WorkflowTemplateModel workflowTemplateModel = null;
    try {
      workflowTemplateModel =
          workflowTemplateService.getWorkflowTemplateForCode("B2B-Alert-GC Acct Mgr");
    } catch (final UnknownIdentifierException uie) {
      // Do nothing
    }

    Assert.assertNull(workflowTemplateModel);

    /**
     * Create and order between 8000 - 10000 EUR for unit GC Sales DE Alert should be created for GC
     * Sales Rep
     */
    final OrderModel order = createOrder("GC Sales DE Boss", 900, OrderStatus.CREATED);
    Assert.assertNotNull(order);

    // Set up credit limit data for test so that it generates an Alert
    final B2BUnitModel unitLoggedIn = b2bUnitService.getUnitForUid("GC Sales DE");
    final B2BCreditLimitModel creditLimitToUse = unitLoggedIn.getCreditLimit();
    creditLimitToUse.setActive(Boolean.TRUE);
    creditLimitToUse.setDateRange(B2BPeriodRange.DAY);
    creditLimitToUse.setDatePeriod(null);
    creditLimitToUse.setAlertSentDate(null);
    modelService.save(creditLimitToUse);

    final B2BApprovalProcessModel b2bApprovalProcessModel =
        getB2BApprovalProcessModelForOrder(order);

    this.waitForProcessToEnd(b2bApprovalProcessModel.getCode(), 20000);
    this.modelService.refresh(order);
    this.modelService.refresh(b2bApprovalProcessModel);

    // verify that creditCheckAlert was sent - template and workflow should exist for an Alert
    workflowTemplateModel =
        workflowTemplateService.getWorkflowTemplateForCode("B2B-Alert-GC Acct Mgr");
    Assert.assertNotNull(workflowTemplateModel);
    final List<WorkflowModel> workflowModelList =
        newestWorkflowService.getWorkflowsForTemplateAndUser(workflowTemplateModel, employeeModel);
    Assert.assertTrue(CollectionUtils.isNotEmpty(workflowModelList));

    Assert.assertEquals(OrderStatus.APPROVED, order.getStatus());
    Assert.assertEquals(ProcessState.SUCCEEDED, b2bApprovalProcessModel.getProcessState());
  }
コード例 #26
0
  @Test
  public void testIsUserAssignedPrincipalForSameGroup() {
    // given
    final WorkflowActionModel mockAction = mock(WorkflowActionModel.class);
    final UserModel mockUser = mock(UserModel.class);
    final UserGroupModel mockGroup = mock(UserGroupModel.class);
    when(mockAction.getPrincipalAssigned()).thenReturn(mockGroup);
    when(userService.getCurrentUser()).thenReturn(mockUser);
    when(mockUser.getAllGroups()).thenReturn((Set) Collections.singleton(mockGroup));

    // when
    final boolean isAssigned = workflowActionService.isUserAssignedPrincipal(mockAction);

    // then
    assertThat(isAssigned).isTrue();
  }
 @Override
 public void updateCustomer(final CustomerData customerData) throws DuplicateUidException {
   validateParameterNotNullStandardMessage("customerData", customerData);
   final EnergizerB2BCustomerModel energizerB2BCustomerModel;
   if (StringUtils.isEmpty(customerData.getUid())) {
     energizerB2BCustomerModel = this.getModelService().create(EnergizerB2BCustomerModel.class);
     energizerB2BCustomerModel.setRegistrationEmailFlag(Boolean.TRUE);
   } else {
     energizerB2BCustomerModel =
         (EnergizerB2BCustomerModel) userService.getUserForUID(customerData.getUid());
   }
   if (null != customerData && null != energizerB2BCustomerModel) {
     energizerCustomerReversePopulator.populate(customerData, energizerB2BCustomerModel);
     companyB2BCommerceService.saveModel(energizerB2BCustomerModel);
   }
 }
コード例 #28
0
 /**
  * This test is specially added for fetching the tree of child Unit in the organization hierarchy.
  * So used a user Id which is not the root unit for example GC.
  */
 @Test
 public void shouldGetAllBranchAndParentUnitOfChildUnit() {
   sessionService.executeInLocalView(
       new SessionExecutionBody() {
         @Override
         public void executeWithoutResult() {
           final String userId = "GC Sales UK Boss";
           login(userId);
           final Set<B2BUnitModel> allUnitsOfOrganization =
               b2bUnitService.getAllUnitsOfOrganization(
                   b2bCustomerService.getCurrentB2BCustomer());
           Assert.assertTrue(allUnitsOfOrganization.size() >= 3);
         }
       },
       userService.getAdminUser());
 }
コード例 #29
0
  @Test
  public void shouldGetParentUnitForCustomerWithMultipleUnitsAssigned() {
    sessionService.executeInLocalView(
        new SessionExecutionBody() {
          @Override
          public void executeWithoutResult() {
            final B2BCustomerModel user =
                userService.getUserForUID("GC CEO", B2BCustomerModel.class);
            // assign user to session
            login(user);
            final B2BUnitModel parent = b2bUnitService.getParent(user);
            Assert.assertNotNull(parent);
            // try to add the member which the user is already a member of
            b2bUnitService.addMember(parent, user);
            modelService.save(user);
            Assert.assertEquals(
                1,
                CollectionUtils.select(
                        user.getGroups(), PredicateUtils.instanceofPredicate(B2BUnitModel.class))
                    .size());

            // assign a 2nd unit to GC CEO
            final B2BUnitModel unitUK = b2bUnitService.getUnitForUid("GC Sales UK");
            b2bUnitService.addMember(unitUK, user);
            modelService.save(user);
            Assert.assertEquals(
                2,
                CollectionUtils.select(
                        user.getGroups(), PredicateUtils.instanceofPredicate(B2BUnitModel.class))
                    .size());

            b2bUnitService.updateParentB2BUnit(unitUK, user);
            modelService.save(user);

            Assert.assertEquals(unitUK, b2bUnitService.getParent(user));
            // make sure user is still belongs to 2 units
            Assert.assertEquals(
                2,
                CollectionUtils.select(
                        user.getGroups(), PredicateUtils.instanceofPredicate(B2BUnitModel.class))
                    .size());
          }
        },
        userService.getAdminUser());
  }
コード例 #30
0
  private OrderModel createNewOrder() {
    final OrderModel order = modelService.create(OrderModel.class);

    final UserModel user = userService.getCurrentUser();

    order.setUser(user);

    order.setCurrency(commonI18NService.getBaseCurrency());
    order.setDate(new java.util.Date());
    order.setNet(Boolean.FALSE);

    final OrderEntryModel entry1 = modelService.create(OrderEntryModel.class);
    entry1.setOrder(order);
    entry1.setQuantity(Long.valueOf(1));
    entry1.setUnit(productService.getOrderableUnit(product1));
    entry1.setProduct(product1);
    entry1.setEntryNumber(Integer.valueOf(0));

    final OrderEntryModel entry2 = modelService.create(OrderEntryModel.class);
    entry2.setOrder(order);
    entry2.setQuantity(Long.valueOf(1));
    entry2.setUnit(productService.getOrderableUnit(product2));
    entry2.setProduct(product2);
    entry2.setEntryNumber(Integer.valueOf(1));

    final OrderEntryModel entry3 = modelService.create(OrderEntryModel.class);
    entry3.setOrder(order);
    entry3.setQuantity(Long.valueOf(1));
    entry3.setUnit(productService.getOrderableUnit(product3));
    entry3.setProduct(product3);
    entry3.setEntryNumber(Integer.valueOf(2));

    final OrderEntryModel entry4 = modelService.create(OrderEntryModel.class);
    entry4.setOrder(order);
    entry4.setQuantity(Long.valueOf(1));
    entry4.setUnit(productService.getOrderableUnit(product4));
    entry4.setProduct(product4);
    entry4.setEntryNumber(Integer.valueOf(3));

    order.setEntries((List) Arrays.asList(entry1, entry2, entry3, entry4));

    return order;
  }