target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test public void testGetNaturalKeys() throws NoNaturalKeysDefinedException { Entity e = setup(); Map<String, String> naturalKeys = naturalKeyExtractor.getNaturalKeys(e); Assert.assertEquals(1, naturalKeys.size()); Assert.assertEquals("someValue", naturalKeys.get("someField")); Mockito.verify(entitySchemaRegistry, Mockito.times(1)).getSchema(Mockito.anyString()); }
|
@Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; }
|
NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; } }
|
NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; } }
|
NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; } @Override Map<String, String> getNaturalKeys(Entity entity); @Override Map<String, Boolean> getNaturalKeyFields(Entity entity); @Override NaturalKeyDescriptor getNaturalKeyDescriptor(Entity entity); String getCollectionName(Entity entity); }
|
NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; } @Override Map<String, String> getNaturalKeys(Entity entity); @Override Map<String, Boolean> getNaturalKeyFields(Entity entity); @Override NaturalKeyDescriptor getNaturalKeyDescriptor(Entity entity); String getCollectionName(Entity entity); }
|
@Test(expected = NaturalKeyValidationException.class) public void shouldThrowExceptionWhenMissingRequiredKeyField() throws NoNaturalKeysDefinedException { Entity e = setup(); e.getBody().remove("someField"); @SuppressWarnings("unused") Map<String, String> naturalKeys = naturalKeyExtractor.getNaturalKeys(e); }
|
@Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; }
|
NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; } }
|
NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; } }
|
NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; } @Override Map<String, String> getNaturalKeys(Entity entity); @Override Map<String, Boolean> getNaturalKeyFields(Entity entity); @Override NaturalKeyDescriptor getNaturalKeyDescriptor(Entity entity); String getCollectionName(Entity entity); }
|
NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; } @Override Map<String, String> getNaturalKeys(Entity entity); @Override Map<String, Boolean> getNaturalKeyFields(Entity entity); @Override NaturalKeyDescriptor getNaturalKeyDescriptor(Entity entity); String getCollectionName(Entity entity); }
|
@Test public void testIsBeforeOrEqualYear() { Assert.assertTrue(EntityDateHelper.isBeforeOrEqualYear("2008-2009", 2011)); Assert.assertTrue(EntityDateHelper.isBeforeOrEqualYear("2008-2008", 2011)); Assert.assertTrue(EntityDateHelper.isBeforeOrEqualYear("2009-2008", 2011)); Assert.assertTrue(EntityDateHelper.isBeforeOrEqualYear("2009-2010", 2011)); Assert.assertTrue(EntityDateHelper.isBeforeOrEqualYear("2009-2009", 2011)); Assert.assertTrue(EntityDateHelper.isBeforeOrEqualYear("2010-2009", 2011)); Assert.assertTrue(EntityDateHelper.isBeforeOrEqualYear("2010-2011", 2011)); Assert.assertTrue(EntityDateHelper.isBeforeOrEqualYear("2010-2010", 2011)); Assert.assertFalse(EntityDateHelper.isBeforeOrEqualYear("2011-2010", 2011)); Assert.assertFalse(EntityDateHelper.isBeforeOrEqualYear("2011-2012", 2011)); Assert.assertFalse(EntityDateHelper.isBeforeOrEqualYear("2012-2011", 2011)); Assert.assertFalse(EntityDateHelper.isBeforeOrEqualYear("2012-2013", 2011)); Assert.assertFalse(EntityDateHelper.isBeforeOrEqualYear("2013-2012", 2011)); }
|
protected static boolean isBeforeOrEqualYear(String yearSpan, int upToYear) { int fromYear = Integer.parseInt(yearSpan.split("-")[0]); int toYear = Integer.parseInt(yearSpan.split("-")[1]); return ((upToYear >= toYear) && (upToYear > fromYear)); }
|
EntityDateHelper { protected static boolean isBeforeOrEqualYear(String yearSpan, int upToYear) { int fromYear = Integer.parseInt(yearSpan.split("-")[0]); int toYear = Integer.parseInt(yearSpan.split("-")[1]); return ((upToYear >= toYear) && (upToYear > fromYear)); } }
|
EntityDateHelper { protected static boolean isBeforeOrEqualYear(String yearSpan, int upToYear) { int fromYear = Integer.parseInt(yearSpan.split("-")[0]); int toYear = Integer.parseInt(yearSpan.split("-")[1]); return ((upToYear >= toYear) && (upToYear > fromYear)); } }
|
EntityDateHelper { protected static boolean isBeforeOrEqualYear(String yearSpan, int upToYear) { int fromYear = Integer.parseInt(yearSpan.split("-")[0]); int toYear = Integer.parseInt(yearSpan.split("-")[1]); return ((upToYear >= toYear) && (upToYear > fromYear)); } static boolean shouldExtract(Entity entity, DateTime upToDate); static String retrieveDate(Entity entity); static boolean isPastOrCurrentDate(String entityDate, DateTime upToDate, String type); }
|
EntityDateHelper { protected static boolean isBeforeOrEqualYear(String yearSpan, int upToYear) { int fromYear = Integer.parseInt(yearSpan.split("-")[0]); int toYear = Integer.parseInt(yearSpan.split("-")[1]); return ((upToYear >= toYear) && (upToYear > fromYear)); } static boolean shouldExtract(Entity entity, DateTime upToDate); static String retrieveDate(Entity entity); static boolean isPastOrCurrentDate(String entityDate, DateTime upToDate, String type); }
|
@Test public void shouldNotThrowExceptionWhenMissingOptionalKeyField() throws NoNaturalKeysDefinedException { Entity e = setup(); AppInfo mockAppInfo = Mockito.mock(AppInfo.class); Mockito.when(mockAppInfo.applyNaturalKeys()).thenReturn(true); Mockito.when(mockAppInfo.getType()).thenReturn(AnnotationType.APPINFO); mockSchema.addAnnotation(mockAppInfo); NeutralSchema mockFieldSchema = Mockito.mock(NeutralSchema.class); mockSchema.addField("optionalField", mockFieldSchema); AppInfo mockFieldAppInfo = Mockito.mock(AppInfo.class); Mockito.when(mockFieldSchema.getAppInfo()).thenReturn(mockFieldAppInfo); Mockito.when(mockFieldAppInfo.isNaturalKey()).thenReturn(true); Mockito.when(mockFieldAppInfo.isRequired()).thenReturn(false); Map<String, String> naturalKeys = naturalKeyExtractor.getNaturalKeys(e); Assert.assertEquals(2, naturalKeys.size()); Assert.assertEquals("someValue", naturalKeys.get("someField")); Assert.assertEquals("", naturalKeys.get("optionalField")); Mockito.verify(entitySchemaRegistry, Mockito.times(1)).getSchema(Mockito.anyString()); }
|
@Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; }
|
NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; } }
|
NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; } }
|
NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; } @Override Map<String, String> getNaturalKeys(Entity entity); @Override Map<String, Boolean> getNaturalKeyFields(Entity entity); @Override NaturalKeyDescriptor getNaturalKeyDescriptor(Entity entity); String getCollectionName(Entity entity); }
|
NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; } @Override Map<String, String> getNaturalKeys(Entity entity); @Override Map<String, Boolean> getNaturalKeyFields(Entity entity); @Override NaturalKeyDescriptor getNaturalKeyDescriptor(Entity entity); String getCollectionName(Entity entity); }
|
@Test public void shouldExtractNestedKeyField() throws NoNaturalKeysDefinedException { Entity e = setup(); Map<String, String> parentValue = new HashMap<String, String>(); parentValue.put("childField", "someNestedValue"); e.getBody().put("parentField", parentValue); AppInfo mockAppInfo = Mockito.mock(AppInfo.class); Mockito.when(mockAppInfo.applyNaturalKeys()).thenReturn(true); Mockito.when(mockAppInfo.getType()).thenReturn(AnnotationType.APPINFO); mockSchema.addAnnotation(mockAppInfo); ComplexSchema parentFieldSchema = new ComplexSchema(); mockSchema.addField("parentField", parentFieldSchema); AppInfo mockAppInfoForParent = Mockito.mock(AppInfo.class); Mockito.when(mockAppInfoForParent.isNaturalKey()).thenReturn(true); Mockito.when(mockAppInfoForParent.getType()).thenReturn(AnnotationType.APPINFO); parentFieldSchema.addAnnotation(mockAppInfoForParent); NeutralSchema mockChildFieldSchema = Mockito.mock(NeutralSchema.class); AppInfo mockFieldAppInfo = Mockito.mock(AppInfo.class); Mockito.when(mockChildFieldSchema.getAppInfo()).thenReturn(mockFieldAppInfo); Mockito.when(mockFieldAppInfo.isNaturalKey()).thenReturn(true); Mockito.when(mockFieldAppInfo.isRequired()).thenReturn(false); parentFieldSchema.addField("childField", mockChildFieldSchema); Map<String, String> naturalKeys = naturalKeyExtractor.getNaturalKeys(e); Assert.assertEquals(2, naturalKeys.size()); Assert.assertEquals("someValue", naturalKeys.get("someField")); Assert.assertEquals("someNestedValue", naturalKeys.get("parentField.childField")); Mockito.verify(entitySchemaRegistry, Mockito.times(1)).getSchema(Mockito.anyString()); }
|
@Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; }
|
NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; } }
|
NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; } }
|
NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; } @Override Map<String, String> getNaturalKeys(Entity entity); @Override Map<String, Boolean> getNaturalKeyFields(Entity entity); @Override NaturalKeyDescriptor getNaturalKeyDescriptor(Entity entity); String getCollectionName(Entity entity); }
|
NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; } @Override Map<String, String> getNaturalKeys(Entity entity); @Override Map<String, Boolean> getNaturalKeyFields(Entity entity); @Override NaturalKeyDescriptor getNaturalKeyDescriptor(Entity entity); String getCollectionName(Entity entity); }
|
@Test public void shouldNotExtractNestedKeyFieldWhenParentFieldIsNotANaturalKey() throws NoNaturalKeysDefinedException { Entity e = setup(); Map<String, String> parentValue = new HashMap<String, String>(); parentValue.put("childField", "someNestedValue"); e.getBody().put("parentField", parentValue); AppInfo mockAppInfo = Mockito.mock(AppInfo.class); Mockito.when(mockAppInfo.applyNaturalKeys()).thenReturn(true); Mockito.when(mockAppInfo.getType()).thenReturn(AnnotationType.APPINFO); mockSchema.addAnnotation(mockAppInfo); ComplexSchema parentFieldSchema = new ComplexSchema(); mockSchema.addField("parentField", parentFieldSchema); AppInfo mockAppInfoForParent = Mockito.mock(AppInfo.class); Mockito.when(mockAppInfoForParent.isNaturalKey()).thenReturn(false); Mockito.when(mockAppInfoForParent.getType()).thenReturn(AnnotationType.APPINFO); parentFieldSchema.addAnnotation(mockAppInfoForParent); NeutralSchema mockChildFieldSchema = Mockito.mock(NeutralSchema.class); AppInfo mockFieldAppInfo = Mockito.mock(AppInfo.class); Mockito.when(mockChildFieldSchema.getAppInfo()).thenReturn(mockFieldAppInfo); Mockito.when(mockFieldAppInfo.isNaturalKey()).thenReturn(true); Mockito.when(mockFieldAppInfo.isRequired()).thenReturn(false); parentFieldSchema.addField("childField", mockChildFieldSchema); Map<String, String> naturalKeys = naturalKeyExtractor.getNaturalKeys(e); Assert.assertEquals(1, naturalKeys.size()); Assert.assertEquals("someValue", naturalKeys.get("someField")); Assert.assertNull("The nested field should not be extracted", naturalKeys.get("parentField.childField")); Mockito.verify(entitySchemaRegistry, Mockito.times(1)).getSchema(Mockito.anyString()); }
|
@Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; }
|
NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; } }
|
NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; } }
|
NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; } @Override Map<String, String> getNaturalKeys(Entity entity); @Override Map<String, Boolean> getNaturalKeyFields(Entity entity); @Override NaturalKeyDescriptor getNaturalKeyDescriptor(Entity entity); String getCollectionName(Entity entity); }
|
NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, String> getNaturalKeys(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = new HashMap<String, String>(); List<String> missingKeys = new ArrayList<String>(); Map<String, Boolean> naturalKeyFields = getNaturalKeyFields(entity); if (naturalKeyFields == null) { return null; } for (Entry<String, Boolean> keyField : naturalKeyFields.entrySet()) { Object value = null; try { value = PropertyUtils.getProperty(entity.getBody(), keyField.getKey()); } catch (IllegalAccessException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (InvocationTargetException e) { handleFieldAccessException(keyField.getKey(), entity); } catch (NoSuchMethodException e) { handleFieldAccessException(keyField.getKey(), entity); } if (value == null) { if (keyField.getValue().booleanValue()) { map.put(keyField.getKey(), ""); } else { missingKeys.add(keyField.getKey()); } } else { String strValue = value.toString(); map.put(keyField.getKey(), strValue); } } if (!missingKeys.isEmpty()) { throw new NaturalKeyValidationException(entity.getType(), missingKeys); } return map; } @Override Map<String, String> getNaturalKeys(Entity entity); @Override Map<String, Boolean> getNaturalKeyFields(Entity entity); @Override NaturalKeyDescriptor getNaturalKeyDescriptor(Entity entity); String getCollectionName(Entity entity); }
|
@Test public void shouldLookupEntityCollection() { Entity e = setup(); AppInfo mockAppInfo = Mockito.mock(AppInfo.class); mockSchema.addAnnotation(mockAppInfo); String collectionName = naturalKeyExtractor.getCollectionName(e); Assert.assertEquals(COLLECTION_TYPE, collectionName); }
|
public String getCollectionName(Entity entity) { NeutralSchema schema = entitySchemaRegistry.getSchema(entity.getType()); if (schema != null) { AppInfo appInfo = schema.getAppInfo(); if (appInfo != null) { return appInfo.getCollectionType(); } } LOG.error("No collectionType found in schema for entity: " + entity.getType()); return null; }
|
NaturalKeyExtractor implements INaturalKeyExtractor { public String getCollectionName(Entity entity) { NeutralSchema schema = entitySchemaRegistry.getSchema(entity.getType()); if (schema != null) { AppInfo appInfo = schema.getAppInfo(); if (appInfo != null) { return appInfo.getCollectionType(); } } LOG.error("No collectionType found in schema for entity: " + entity.getType()); return null; } }
|
NaturalKeyExtractor implements INaturalKeyExtractor { public String getCollectionName(Entity entity) { NeutralSchema schema = entitySchemaRegistry.getSchema(entity.getType()); if (schema != null) { AppInfo appInfo = schema.getAppInfo(); if (appInfo != null) { return appInfo.getCollectionType(); } } LOG.error("No collectionType found in schema for entity: " + entity.getType()); return null; } }
|
NaturalKeyExtractor implements INaturalKeyExtractor { public String getCollectionName(Entity entity) { NeutralSchema schema = entitySchemaRegistry.getSchema(entity.getType()); if (schema != null) { AppInfo appInfo = schema.getAppInfo(); if (appInfo != null) { return appInfo.getCollectionType(); } } LOG.error("No collectionType found in schema for entity: " + entity.getType()); return null; } @Override Map<String, String> getNaturalKeys(Entity entity); @Override Map<String, Boolean> getNaturalKeyFields(Entity entity); @Override NaturalKeyDescriptor getNaturalKeyDescriptor(Entity entity); String getCollectionName(Entity entity); }
|
NaturalKeyExtractor implements INaturalKeyExtractor { public String getCollectionName(Entity entity) { NeutralSchema schema = entitySchemaRegistry.getSchema(entity.getType()); if (schema != null) { AppInfo appInfo = schema.getAppInfo(); if (appInfo != null) { return appInfo.getCollectionType(); } } LOG.error("No collectionType found in schema for entity: " + entity.getType()); return null; } @Override Map<String, String> getNaturalKeys(Entity entity); @Override Map<String, Boolean> getNaturalKeyFields(Entity entity); @Override NaturalKeyDescriptor getNaturalKeyDescriptor(Entity entity); String getCollectionName(Entity entity); }
|
@Test public void testConvert() throws Exception { int value = 12345; Object convertedValue = this.schema.convert("" + value); assertTrue(convertedValue instanceof Integer); Integer convertedInput = (Integer) convertedValue; assertTrue(convertedInput.intValue() == value); }
|
@Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } IntegerSchema(); }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } IntegerSchema(); @Override Object convert(Object value); }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } IntegerSchema(); @Override Object convert(Object value); }
|
@Test(expected = IllegalArgumentException.class) public void testBadConvert() { this.schema.convert("INVALID INPUT"); }
|
@Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } IntegerSchema(); }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } IntegerSchema(); @Override Object convert(Object value); }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } IntegerSchema(); @Override Object convert(Object value); }
|
@Test public void testNonConvert() { Object convertedValue = this.schema.convert(12); assertTrue(convertedValue instanceof Integer); }
|
@Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } IntegerSchema(); }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } IntegerSchema(); @Override Object convert(Object value); }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } IntegerSchema(); @Override Object convert(Object value); }
|
@Test public void testIntegerConverter() { int data = 123; assertTrue("Failure returning same object", this.schema.convert(data).equals(data)); assertTrue("Failure parsing int data", this.schema.convert("" + data).equals(data)); }
|
@Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } IntegerSchema(); }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } IntegerSchema(); @Override Object convert(Object value); }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } IntegerSchema(); @Override Object convert(Object value); }
|
@Test(expected = IllegalArgumentException.class) public void testInvalidStringThrowsException() throws IllegalArgumentException { this.schema.convert("INVALID INPUT"); }
|
@Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } IntegerSchema(); }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } IntegerSchema(); @Override Object convert(Object value); }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } IntegerSchema(); @Override Object convert(Object value); }
|
@Test(expected = IllegalArgumentException.class) public void testUnsupportedObjectTypeThrowsException() throws IllegalArgumentException { this.schema.convert(new Object()); }
|
@Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } IntegerSchema(); }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } IntegerSchema(); @Override Object convert(Object value); }
|
IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } IntegerSchema(); @Override Object convert(Object value); }
|
@Test public void testSEValues() { SecurityEventUtil spyObject = Mockito.spy(securityEventUtil); SecurityEvent event = spyObject.createSecurityEvent("class", "Action Description", LogLevelType.TYPE_INFO, BEMessageCode.BE_SE_CODE_0001); String appId = null; Mockito.verify(spyObject, Mockito.atMost(1)).createSecurityEvent(Mockito.anyString(), Mockito.anyString(), Mockito.eq(LogLevelType.TYPE_INFO), Mockito.eq(appId), Mockito.eq(BEMessageCode.BE_SE_CODE_0001)); assertEquals("BulkExtract", event.getAppId()); String processName = ManagementFactory.getRuntimeMXBean().getName(); assertEquals(processName, event.getProcessNameOrId()); assertEquals(null, event.getTargetEdOrgList()); }
|
public SecurityEvent createSecurityEvent(String loggingClass, String actionDesc, LogLevelType logLevel, String appId, BEMessageCode code, Object... args) { SecurityEvent event = new SecurityEvent(); String seAppId = (appId == null) ? "BulkExtract" : "BulkExtract#" + appId; event.setTenantId(TenantContext.getTenantId()); event.setAppId(seAppId); event.setActionUri(actionDesc); event.setTimeStamp(new Date()); event.setProcessNameOrId(ManagementFactory.getRuntimeMXBean().getName()); try { event.setExecutedOn(InetAddress.getLocalHost().getHostName()); } catch (UnknownHostException e) { LOG.info("Could not find hostname/process for SecurityEventLogging!"); event.setExecutedOn("localhost"); } event.setClassName(loggingClass); event.setLogLevel(logLevel); event.setLogMessage(messageSource.getMessage(code.getCode(), args, "#?" + code.getCode() + "?#", null)); LOG.debug(event.toString()); return event; }
|
SecurityEventUtil implements MessageSourceAware { public SecurityEvent createSecurityEvent(String loggingClass, String actionDesc, LogLevelType logLevel, String appId, BEMessageCode code, Object... args) { SecurityEvent event = new SecurityEvent(); String seAppId = (appId == null) ? "BulkExtract" : "BulkExtract#" + appId; event.setTenantId(TenantContext.getTenantId()); event.setAppId(seAppId); event.setActionUri(actionDesc); event.setTimeStamp(new Date()); event.setProcessNameOrId(ManagementFactory.getRuntimeMXBean().getName()); try { event.setExecutedOn(InetAddress.getLocalHost().getHostName()); } catch (UnknownHostException e) { LOG.info("Could not find hostname/process for SecurityEventLogging!"); event.setExecutedOn("localhost"); } event.setClassName(loggingClass); event.setLogLevel(logLevel); event.setLogMessage(messageSource.getMessage(code.getCode(), args, "#?" + code.getCode() + "?#", null)); LOG.debug(event.toString()); return event; } }
|
SecurityEventUtil implements MessageSourceAware { public SecurityEvent createSecurityEvent(String loggingClass, String actionDesc, LogLevelType logLevel, String appId, BEMessageCode code, Object... args) { SecurityEvent event = new SecurityEvent(); String seAppId = (appId == null) ? "BulkExtract" : "BulkExtract#" + appId; event.setTenantId(TenantContext.getTenantId()); event.setAppId(seAppId); event.setActionUri(actionDesc); event.setTimeStamp(new Date()); event.setProcessNameOrId(ManagementFactory.getRuntimeMXBean().getName()); try { event.setExecutedOn(InetAddress.getLocalHost().getHostName()); } catch (UnknownHostException e) { LOG.info("Could not find hostname/process for SecurityEventLogging!"); event.setExecutedOn("localhost"); } event.setClassName(loggingClass); event.setLogLevel(logLevel); event.setLogMessage(messageSource.getMessage(code.getCode(), args, "#?" + code.getCode() + "?#", null)); LOG.debug(event.toString()); return event; } }
|
SecurityEventUtil implements MessageSourceAware { public SecurityEvent createSecurityEvent(String loggingClass, String actionDesc, LogLevelType logLevel, String appId, BEMessageCode code, Object... args) { SecurityEvent event = new SecurityEvent(); String seAppId = (appId == null) ? "BulkExtract" : "BulkExtract#" + appId; event.setTenantId(TenantContext.getTenantId()); event.setAppId(seAppId); event.setActionUri(actionDesc); event.setTimeStamp(new Date()); event.setProcessNameOrId(ManagementFactory.getRuntimeMXBean().getName()); try { event.setExecutedOn(InetAddress.getLocalHost().getHostName()); } catch (UnknownHostException e) { LOG.info("Could not find hostname/process for SecurityEventLogging!"); event.setExecutedOn("localhost"); } event.setClassName(loggingClass); event.setLogLevel(logLevel); event.setLogMessage(messageSource.getMessage(code.getCode(), args, "#?" + code.getCode() + "?#", null)); LOG.debug(event.toString()); return event; } SecurityEvent createSecurityEvent(String loggingClass, String actionDesc, LogLevelType logLevel, String appId, BEMessageCode code, Object... args); SecurityEvent createSecurityEvent(String loggingClass, String actionDesc, LogLevelType logLevel, BEMessageCode code, Object... args); @Override void setMessageSource(MessageSource messageSource); }
|
SecurityEventUtil implements MessageSourceAware { public SecurityEvent createSecurityEvent(String loggingClass, String actionDesc, LogLevelType logLevel, String appId, BEMessageCode code, Object... args) { SecurityEvent event = new SecurityEvent(); String seAppId = (appId == null) ? "BulkExtract" : "BulkExtract#" + appId; event.setTenantId(TenantContext.getTenantId()); event.setAppId(seAppId); event.setActionUri(actionDesc); event.setTimeStamp(new Date()); event.setProcessNameOrId(ManagementFactory.getRuntimeMXBean().getName()); try { event.setExecutedOn(InetAddress.getLocalHost().getHostName()); } catch (UnknownHostException e) { LOG.info("Could not find hostname/process for SecurityEventLogging!"); event.setExecutedOn("localhost"); } event.setClassName(loggingClass); event.setLogLevel(logLevel); event.setLogMessage(messageSource.getMessage(code.getCode(), args, "#?" + code.getCode() + "?#", null)); LOG.debug(event.toString()); return event; } SecurityEvent createSecurityEvent(String loggingClass, String actionDesc, LogLevelType logLevel, String appId, BEMessageCode code, Object... args); SecurityEvent createSecurityEvent(String loggingClass, String actionDesc, LogLevelType logLevel, BEMessageCode code, Object... args); @Override void setMessageSource(MessageSource messageSource); }
|
@Test public void testConvert() throws Exception { boolean value = true; Object convertedValue = this.schema.convert("" + value); assertTrue(convertedValue instanceof Boolean); Boolean convertedInput = (Boolean) convertedValue; assertTrue(convertedInput.booleanValue() == value); }
|
@Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); }
|
BooleanSchema extends PrimitiveSchema { @Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); } }
|
BooleanSchema extends PrimitiveSchema { @Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); } BooleanSchema(); }
|
BooleanSchema extends PrimitiveSchema { @Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); } BooleanSchema(); @Override Object convert(Object value); }
|
BooleanSchema extends PrimitiveSchema { @Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); } BooleanSchema(); @Override Object convert(Object value); }
|
@Test(expected = IllegalArgumentException.class) public void testInvalidStringThrowsException() throws IllegalArgumentException { this.schema.convert("INVALID INPUT"); }
|
@Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); }
|
BooleanSchema extends PrimitiveSchema { @Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); } }
|
BooleanSchema extends PrimitiveSchema { @Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); } BooleanSchema(); }
|
BooleanSchema extends PrimitiveSchema { @Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); } BooleanSchema(); @Override Object convert(Object value); }
|
BooleanSchema extends PrimitiveSchema { @Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); } BooleanSchema(); @Override Object convert(Object value); }
|
@Test(expected = IllegalArgumentException.class) public void testUnsupportedObjectTypeThrowsException() throws IllegalArgumentException { this.schema.convert(new Object()); }
|
@Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); }
|
BooleanSchema extends PrimitiveSchema { @Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); } }
|
BooleanSchema extends PrimitiveSchema { @Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); } BooleanSchema(); }
|
BooleanSchema extends PrimitiveSchema { @Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); } BooleanSchema(); @Override Object convert(Object value); }
|
BooleanSchema extends PrimitiveSchema { @Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); } BooleanSchema(); @Override Object convert(Object value); }
|
@Test public void testBooleanConverter() { assertTrue("Failure returning same object", this.schema.convert(true).equals(Boolean.TRUE)); assertTrue("Failure returning same object", this.schema.convert(false).equals(Boolean.FALSE)); assertTrue("Failure parsing true", this.schema.convert("true").equals(Boolean.TRUE)); assertTrue("Failure parsing false", this.schema.convert("false").equals(Boolean.FALSE)); }
|
@Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); }
|
BooleanSchema extends PrimitiveSchema { @Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); } }
|
BooleanSchema extends PrimitiveSchema { @Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); } BooleanSchema(); }
|
BooleanSchema extends PrimitiveSchema { @Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); } BooleanSchema(); @Override Object convert(Object value); }
|
BooleanSchema extends PrimitiveSchema { @Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); } BooleanSchema(); @Override Object convert(Object value); }
|
@Test public void testDateStringValidation() throws IllegalArgumentException { String dateString = "2012-01-01T12:00:00-05:00"; assertTrue("DateTime entity validation failed", schema.validate(dateString)); }
|
@Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid; try { javax.xml.bind.DatatypeConverter.parseDate((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339 Date", ErrorType.INVALID_DATE_FORMAT, errors); }
|
DateSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid; try { javax.xml.bind.DatatypeConverter.parseDate((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339 Date", ErrorType.INVALID_DATE_FORMAT, errors); } }
|
DateSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid; try { javax.xml.bind.DatatypeConverter.parseDate((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339 Date", ErrorType.INVALID_DATE_FORMAT, errors); } DateSchema(); DateSchema(String xsdType); }
|
DateSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid; try { javax.xml.bind.DatatypeConverter.parseDate((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339 Date", ErrorType.INVALID_DATE_FORMAT, errors); } DateSchema(); DateSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); @Override Object convert(Object value); }
|
DateSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid; try { javax.xml.bind.DatatypeConverter.parseDate((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339 Date", ErrorType.INVALID_DATE_FORMAT, errors); } DateSchema(); DateSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); @Override Object convert(Object value); }
|
@Test public void testDateValidation() { Calendar calendar = Calendar.getInstance(); String dateString = javax.xml.bind.DatatypeConverter.printDate(calendar); assertTrue("Date entity validation failed", schema.validate(dateString)); }
|
@Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid; try { javax.xml.bind.DatatypeConverter.parseDate((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339 Date", ErrorType.INVALID_DATE_FORMAT, errors); }
|
DateSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid; try { javax.xml.bind.DatatypeConverter.parseDate((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339 Date", ErrorType.INVALID_DATE_FORMAT, errors); } }
|
DateSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid; try { javax.xml.bind.DatatypeConverter.parseDate((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339 Date", ErrorType.INVALID_DATE_FORMAT, errors); } DateSchema(); DateSchema(String xsdType); }
|
DateSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid; try { javax.xml.bind.DatatypeConverter.parseDate((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339 Date", ErrorType.INVALID_DATE_FORMAT, errors); } DateSchema(); DateSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); @Override Object convert(Object value); }
|
DateSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid; try { javax.xml.bind.DatatypeConverter.parseDate((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339 Date", ErrorType.INVALID_DATE_FORMAT, errors); } DateSchema(); DateSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); @Override Object convert(Object value); }
|
@Test public void testValidationOfStringFailure() { String stringEntity = ""; assertFalse("Expected DateSchema string validation failure did not succeed", schema.validate(stringEntity)); }
|
@Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid; try { javax.xml.bind.DatatypeConverter.parseDate((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339 Date", ErrorType.INVALID_DATE_FORMAT, errors); }
|
DateSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid; try { javax.xml.bind.DatatypeConverter.parseDate((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339 Date", ErrorType.INVALID_DATE_FORMAT, errors); } }
|
DateSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid; try { javax.xml.bind.DatatypeConverter.parseDate((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339 Date", ErrorType.INVALID_DATE_FORMAT, errors); } DateSchema(); DateSchema(String xsdType); }
|
DateSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid; try { javax.xml.bind.DatatypeConverter.parseDate((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339 Date", ErrorType.INVALID_DATE_FORMAT, errors); } DateSchema(); DateSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); @Override Object convert(Object value); }
|
DateSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid; try { javax.xml.bind.DatatypeConverter.parseDate((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339 Date", ErrorType.INVALID_DATE_FORMAT, errors); } DateSchema(); DateSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); @Override Object convert(Object value); }
|
@Test public void testAnnotations() throws IllegalArgumentException { schema.clearFields(); complexSchema.clearFields(); AppInfo d = new AppInfo(null); d.put(AppInfo.READ_ENFORCEMENT_ELEMENT_NAME, new HashSet<String>(Arrays.asList(Right.READ_RESTRICTED.toString()))); complexSchema.addAnnotation(d); schema.getList().add(complexSchema); assertTrue("The schema should have a read_restricted annotation", schema.getAppInfo().getReadAuthorities() .contains(Right.READ_RESTRICTED)); }
|
public List<NeutralSchema> getList() { return list; }
|
ListSchema extends NeutralSchema { public List<NeutralSchema> getList() { return list; } }
|
ListSchema extends NeutralSchema { public List<NeutralSchema> getList() { return list; } ListSchema(); ListSchema(String xsdType); }
|
ListSchema extends NeutralSchema { public List<NeutralSchema> getList() { return list; } ListSchema(); ListSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); @Override boolean isPrimitive(); void setList(List<NeutralSchema> list); List<NeutralSchema> getList(); @Override boolean isSimple(); void updateAnnotations(); @Override Object convert(Object value); Map<String, NeutralSchema> getFields(); }
|
ListSchema extends NeutralSchema { public List<NeutralSchema> getList() { return list; } ListSchema(); ListSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); @Override boolean isPrimitive(); void setList(List<NeutralSchema> list); List<NeutralSchema> getList(); @Override boolean isSimple(); void updateAnnotations(); @Override Object convert(Object value); Map<String, NeutralSchema> getFields(); }
|
@Test public void testValidationOfBooleanFailure() { Boolean booleanEntity = true; assertFalse("Expected ListSchema boolean validation failure did not succeed", schema.validate(booleanEntity)); }
|
@Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = true; Object convertedEntity = convert(entity); if (convertedEntity instanceof Set) { convertedEntity = new ArrayList<Object>((Set) convertedEntity); } if (convertedEntity instanceof List) { List<?> entityList = (List<?>) convertedEntity; for (Object fieldEntity : entityList) { boolean isFieldValid = false; for (NeutralSchema itemSchema : getList()) { if (itemSchema.validate(fieldName, fieldEntity, errors, repo)) { isFieldValid = true; break; } } if (!isFieldValid) { isValid = false; if (errors == null) { return false; } } } if (getProperties() != null) { for (Entry<String, Object> entry : getProperties().entrySet()) { if (Restriction.isRestriction(entry.getKey())) { long restrictionValue = Long.parseLong(entry.getValue().toString()); switch (Restriction.fromValue(entry.getKey())) { case LENGTH: if (!addError(entityList.size() == restrictionValue, fieldName, convertedEntity, "length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MIN_LENGTH: if (!addError(entityList.size() >= restrictionValue, fieldName, convertedEntity, "min-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MAX_LENGTH: if (!addError(entityList.size() <= restrictionValue, fieldName, convertedEntity, "max-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; } } } } } else { return addError(false, fieldName, convertedEntity, "List", ErrorType.INVALID_DATATYPE, errors); } return isValid; }
|
ListSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = true; Object convertedEntity = convert(entity); if (convertedEntity instanceof Set) { convertedEntity = new ArrayList<Object>((Set) convertedEntity); } if (convertedEntity instanceof List) { List<?> entityList = (List<?>) convertedEntity; for (Object fieldEntity : entityList) { boolean isFieldValid = false; for (NeutralSchema itemSchema : getList()) { if (itemSchema.validate(fieldName, fieldEntity, errors, repo)) { isFieldValid = true; break; } } if (!isFieldValid) { isValid = false; if (errors == null) { return false; } } } if (getProperties() != null) { for (Entry<String, Object> entry : getProperties().entrySet()) { if (Restriction.isRestriction(entry.getKey())) { long restrictionValue = Long.parseLong(entry.getValue().toString()); switch (Restriction.fromValue(entry.getKey())) { case LENGTH: if (!addError(entityList.size() == restrictionValue, fieldName, convertedEntity, "length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MIN_LENGTH: if (!addError(entityList.size() >= restrictionValue, fieldName, convertedEntity, "min-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MAX_LENGTH: if (!addError(entityList.size() <= restrictionValue, fieldName, convertedEntity, "max-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; } } } } } else { return addError(false, fieldName, convertedEntity, "List", ErrorType.INVALID_DATATYPE, errors); } return isValid; } }
|
ListSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = true; Object convertedEntity = convert(entity); if (convertedEntity instanceof Set) { convertedEntity = new ArrayList<Object>((Set) convertedEntity); } if (convertedEntity instanceof List) { List<?> entityList = (List<?>) convertedEntity; for (Object fieldEntity : entityList) { boolean isFieldValid = false; for (NeutralSchema itemSchema : getList()) { if (itemSchema.validate(fieldName, fieldEntity, errors, repo)) { isFieldValid = true; break; } } if (!isFieldValid) { isValid = false; if (errors == null) { return false; } } } if (getProperties() != null) { for (Entry<String, Object> entry : getProperties().entrySet()) { if (Restriction.isRestriction(entry.getKey())) { long restrictionValue = Long.parseLong(entry.getValue().toString()); switch (Restriction.fromValue(entry.getKey())) { case LENGTH: if (!addError(entityList.size() == restrictionValue, fieldName, convertedEntity, "length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MIN_LENGTH: if (!addError(entityList.size() >= restrictionValue, fieldName, convertedEntity, "min-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MAX_LENGTH: if (!addError(entityList.size() <= restrictionValue, fieldName, convertedEntity, "max-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; } } } } } else { return addError(false, fieldName, convertedEntity, "List", ErrorType.INVALID_DATATYPE, errors); } return isValid; } ListSchema(); ListSchema(String xsdType); }
|
ListSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = true; Object convertedEntity = convert(entity); if (convertedEntity instanceof Set) { convertedEntity = new ArrayList<Object>((Set) convertedEntity); } if (convertedEntity instanceof List) { List<?> entityList = (List<?>) convertedEntity; for (Object fieldEntity : entityList) { boolean isFieldValid = false; for (NeutralSchema itemSchema : getList()) { if (itemSchema.validate(fieldName, fieldEntity, errors, repo)) { isFieldValid = true; break; } } if (!isFieldValid) { isValid = false; if (errors == null) { return false; } } } if (getProperties() != null) { for (Entry<String, Object> entry : getProperties().entrySet()) { if (Restriction.isRestriction(entry.getKey())) { long restrictionValue = Long.parseLong(entry.getValue().toString()); switch (Restriction.fromValue(entry.getKey())) { case LENGTH: if (!addError(entityList.size() == restrictionValue, fieldName, convertedEntity, "length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MIN_LENGTH: if (!addError(entityList.size() >= restrictionValue, fieldName, convertedEntity, "min-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MAX_LENGTH: if (!addError(entityList.size() <= restrictionValue, fieldName, convertedEntity, "max-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; } } } } } else { return addError(false, fieldName, convertedEntity, "List", ErrorType.INVALID_DATATYPE, errors); } return isValid; } ListSchema(); ListSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); @Override boolean isPrimitive(); void setList(List<NeutralSchema> list); List<NeutralSchema> getList(); @Override boolean isSimple(); void updateAnnotations(); @Override Object convert(Object value); Map<String, NeutralSchema> getFields(); }
|
ListSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = true; Object convertedEntity = convert(entity); if (convertedEntity instanceof Set) { convertedEntity = new ArrayList<Object>((Set) convertedEntity); } if (convertedEntity instanceof List) { List<?> entityList = (List<?>) convertedEntity; for (Object fieldEntity : entityList) { boolean isFieldValid = false; for (NeutralSchema itemSchema : getList()) { if (itemSchema.validate(fieldName, fieldEntity, errors, repo)) { isFieldValid = true; break; } } if (!isFieldValid) { isValid = false; if (errors == null) { return false; } } } if (getProperties() != null) { for (Entry<String, Object> entry : getProperties().entrySet()) { if (Restriction.isRestriction(entry.getKey())) { long restrictionValue = Long.parseLong(entry.getValue().toString()); switch (Restriction.fromValue(entry.getKey())) { case LENGTH: if (!addError(entityList.size() == restrictionValue, fieldName, convertedEntity, "length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MIN_LENGTH: if (!addError(entityList.size() >= restrictionValue, fieldName, convertedEntity, "min-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MAX_LENGTH: if (!addError(entityList.size() <= restrictionValue, fieldName, convertedEntity, "max-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; } } } } } else { return addError(false, fieldName, convertedEntity, "List", ErrorType.INVALID_DATATYPE, errors); } return isValid; } ListSchema(); ListSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); @Override boolean isPrimitive(); void setList(List<NeutralSchema> list); List<NeutralSchema> getList(); @Override boolean isSimple(); void updateAnnotations(); @Override Object convert(Object value); Map<String, NeutralSchema> getFields(); }
|
@Test public void testValidationOfIntegerFailure() { Integer integerEntity = 0; assertFalse("Expected ListSchema integer validation failure did not succeed", schema.validate(integerEntity)); }
|
@Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = true; Object convertedEntity = convert(entity); if (convertedEntity instanceof Set) { convertedEntity = new ArrayList<Object>((Set) convertedEntity); } if (convertedEntity instanceof List) { List<?> entityList = (List<?>) convertedEntity; for (Object fieldEntity : entityList) { boolean isFieldValid = false; for (NeutralSchema itemSchema : getList()) { if (itemSchema.validate(fieldName, fieldEntity, errors, repo)) { isFieldValid = true; break; } } if (!isFieldValid) { isValid = false; if (errors == null) { return false; } } } if (getProperties() != null) { for (Entry<String, Object> entry : getProperties().entrySet()) { if (Restriction.isRestriction(entry.getKey())) { long restrictionValue = Long.parseLong(entry.getValue().toString()); switch (Restriction.fromValue(entry.getKey())) { case LENGTH: if (!addError(entityList.size() == restrictionValue, fieldName, convertedEntity, "length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MIN_LENGTH: if (!addError(entityList.size() >= restrictionValue, fieldName, convertedEntity, "min-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MAX_LENGTH: if (!addError(entityList.size() <= restrictionValue, fieldName, convertedEntity, "max-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; } } } } } else { return addError(false, fieldName, convertedEntity, "List", ErrorType.INVALID_DATATYPE, errors); } return isValid; }
|
ListSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = true; Object convertedEntity = convert(entity); if (convertedEntity instanceof Set) { convertedEntity = new ArrayList<Object>((Set) convertedEntity); } if (convertedEntity instanceof List) { List<?> entityList = (List<?>) convertedEntity; for (Object fieldEntity : entityList) { boolean isFieldValid = false; for (NeutralSchema itemSchema : getList()) { if (itemSchema.validate(fieldName, fieldEntity, errors, repo)) { isFieldValid = true; break; } } if (!isFieldValid) { isValid = false; if (errors == null) { return false; } } } if (getProperties() != null) { for (Entry<String, Object> entry : getProperties().entrySet()) { if (Restriction.isRestriction(entry.getKey())) { long restrictionValue = Long.parseLong(entry.getValue().toString()); switch (Restriction.fromValue(entry.getKey())) { case LENGTH: if (!addError(entityList.size() == restrictionValue, fieldName, convertedEntity, "length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MIN_LENGTH: if (!addError(entityList.size() >= restrictionValue, fieldName, convertedEntity, "min-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MAX_LENGTH: if (!addError(entityList.size() <= restrictionValue, fieldName, convertedEntity, "max-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; } } } } } else { return addError(false, fieldName, convertedEntity, "List", ErrorType.INVALID_DATATYPE, errors); } return isValid; } }
|
ListSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = true; Object convertedEntity = convert(entity); if (convertedEntity instanceof Set) { convertedEntity = new ArrayList<Object>((Set) convertedEntity); } if (convertedEntity instanceof List) { List<?> entityList = (List<?>) convertedEntity; for (Object fieldEntity : entityList) { boolean isFieldValid = false; for (NeutralSchema itemSchema : getList()) { if (itemSchema.validate(fieldName, fieldEntity, errors, repo)) { isFieldValid = true; break; } } if (!isFieldValid) { isValid = false; if (errors == null) { return false; } } } if (getProperties() != null) { for (Entry<String, Object> entry : getProperties().entrySet()) { if (Restriction.isRestriction(entry.getKey())) { long restrictionValue = Long.parseLong(entry.getValue().toString()); switch (Restriction.fromValue(entry.getKey())) { case LENGTH: if (!addError(entityList.size() == restrictionValue, fieldName, convertedEntity, "length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MIN_LENGTH: if (!addError(entityList.size() >= restrictionValue, fieldName, convertedEntity, "min-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MAX_LENGTH: if (!addError(entityList.size() <= restrictionValue, fieldName, convertedEntity, "max-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; } } } } } else { return addError(false, fieldName, convertedEntity, "List", ErrorType.INVALID_DATATYPE, errors); } return isValid; } ListSchema(); ListSchema(String xsdType); }
|
ListSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = true; Object convertedEntity = convert(entity); if (convertedEntity instanceof Set) { convertedEntity = new ArrayList<Object>((Set) convertedEntity); } if (convertedEntity instanceof List) { List<?> entityList = (List<?>) convertedEntity; for (Object fieldEntity : entityList) { boolean isFieldValid = false; for (NeutralSchema itemSchema : getList()) { if (itemSchema.validate(fieldName, fieldEntity, errors, repo)) { isFieldValid = true; break; } } if (!isFieldValid) { isValid = false; if (errors == null) { return false; } } } if (getProperties() != null) { for (Entry<String, Object> entry : getProperties().entrySet()) { if (Restriction.isRestriction(entry.getKey())) { long restrictionValue = Long.parseLong(entry.getValue().toString()); switch (Restriction.fromValue(entry.getKey())) { case LENGTH: if (!addError(entityList.size() == restrictionValue, fieldName, convertedEntity, "length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MIN_LENGTH: if (!addError(entityList.size() >= restrictionValue, fieldName, convertedEntity, "min-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MAX_LENGTH: if (!addError(entityList.size() <= restrictionValue, fieldName, convertedEntity, "max-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; } } } } } else { return addError(false, fieldName, convertedEntity, "List", ErrorType.INVALID_DATATYPE, errors); } return isValid; } ListSchema(); ListSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); @Override boolean isPrimitive(); void setList(List<NeutralSchema> list); List<NeutralSchema> getList(); @Override boolean isSimple(); void updateAnnotations(); @Override Object convert(Object value); Map<String, NeutralSchema> getFields(); }
|
ListSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = true; Object convertedEntity = convert(entity); if (convertedEntity instanceof Set) { convertedEntity = new ArrayList<Object>((Set) convertedEntity); } if (convertedEntity instanceof List) { List<?> entityList = (List<?>) convertedEntity; for (Object fieldEntity : entityList) { boolean isFieldValid = false; for (NeutralSchema itemSchema : getList()) { if (itemSchema.validate(fieldName, fieldEntity, errors, repo)) { isFieldValid = true; break; } } if (!isFieldValid) { isValid = false; if (errors == null) { return false; } } } if (getProperties() != null) { for (Entry<String, Object> entry : getProperties().entrySet()) { if (Restriction.isRestriction(entry.getKey())) { long restrictionValue = Long.parseLong(entry.getValue().toString()); switch (Restriction.fromValue(entry.getKey())) { case LENGTH: if (!addError(entityList.size() == restrictionValue, fieldName, convertedEntity, "length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MIN_LENGTH: if (!addError(entityList.size() >= restrictionValue, fieldName, convertedEntity, "min-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MAX_LENGTH: if (!addError(entityList.size() <= restrictionValue, fieldName, convertedEntity, "max-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; } } } } } else { return addError(false, fieldName, convertedEntity, "List", ErrorType.INVALID_DATATYPE, errors); } return isValid; } ListSchema(); ListSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); @Override boolean isPrimitive(); void setList(List<NeutralSchema> list); List<NeutralSchema> getList(); @Override boolean isSimple(); void updateAnnotations(); @Override Object convert(Object value); Map<String, NeutralSchema> getFields(); }
|
@Test public void getBulkExtractAppsTest() { when(repository.findAll("application", new NeutralQuery())).thenReturn( Arrays.asList( buildAppEntity("1", true, true), buildAppEntity("2", false, false), buildAppEntity("3", true, false), buildAppEntity("4", false, true), buildAppEntity("5", true, true) ) ); Set<String> bulkExtractApps = helper.getBulkExtractApps(); bulkExtractApps.removeAll(Arrays.asList("1","5")); assertTrue(bulkExtractApps.isEmpty()); }
|
@SuppressWarnings("unchecked") public Set<String> getBulkExtractApps() { TenantContext.setIsSystemCall(true); Iterable<Entity> apps = repository.findAll("application", new NeutralQuery()); TenantContext.setIsSystemCall(false); Set<String> appIds = new HashSet<String>(); for (Entity app : apps) { if (app.getBody().containsKey("isBulkExtract") && (Boolean) app.getBody().get("isBulkExtract")) { if (app.getBody().containsKey("registration") && "APPROVED".equals(((Map<String, Object>) app.getBody().get("registration")).get("status"))) { appIds.add(app.getEntityId()); } } } return appIds; }
|
EdOrgExtractHelper implements InitializingBean { @SuppressWarnings("unchecked") public Set<String> getBulkExtractApps() { TenantContext.setIsSystemCall(true); Iterable<Entity> apps = repository.findAll("application", new NeutralQuery()); TenantContext.setIsSystemCall(false); Set<String> appIds = new HashSet<String>(); for (Entity app : apps) { if (app.getBody().containsKey("isBulkExtract") && (Boolean) app.getBody().get("isBulkExtract")) { if (app.getBody().containsKey("registration") && "APPROVED".equals(((Map<String, Object>) app.getBody().get("registration")).get("status"))) { appIds.add(app.getEntityId()); } } } return appIds; } }
|
EdOrgExtractHelper implements InitializingBean { @SuppressWarnings("unchecked") public Set<String> getBulkExtractApps() { TenantContext.setIsSystemCall(true); Iterable<Entity> apps = repository.findAll("application", new NeutralQuery()); TenantContext.setIsSystemCall(false); Set<String> appIds = new HashSet<String>(); for (Entity app : apps) { if (app.getBody().containsKey("isBulkExtract") && (Boolean) app.getBody().get("isBulkExtract")) { if (app.getBody().containsKey("registration") && "APPROVED".equals(((Map<String, Object>) app.getBody().get("registration")).get("status"))) { appIds.add(app.getEntityId()); } } } return appIds; } }
|
EdOrgExtractHelper implements InitializingBean { @SuppressWarnings("unchecked") public Set<String> getBulkExtractApps() { TenantContext.setIsSystemCall(true); Iterable<Entity> apps = repository.findAll("application", new NeutralQuery()); TenantContext.setIsSystemCall(false); Set<String> appIds = new HashSet<String>(); for (Entity app : apps) { if (app.getBody().containsKey("isBulkExtract") && (Boolean) app.getBody().get("isBulkExtract")) { if (app.getBody().containsKey("registration") && "APPROVED".equals(((Map<String, Object>) app.getBody().get("registration")).get("status"))) { appIds.add(app.getEntityId()); } } } return appIds; } @Override void afterPropertiesSet(); Set<String> getBulkExtractEdOrgs(); Map<String, Set<String>> getBulkExtractEdOrgsPerApp(); @SuppressWarnings("unchecked") Set<String> getBulkExtractApps(); Set<String> getChildEdOrgs(Collection<String> edOrgs); Iterable<Entity> retrieveSEOAS(String teacherId, String edorgId); void logSecurityEvent(Set<String> leas, String entityName, String className); void setSecurityEventUtil(SecurityEventUtil securityEventUtil); Map<String, List<String>> getEdOrgLineages(); void setEdOrgLineages(Map<String, List<String>> edOrgLineages); }
|
EdOrgExtractHelper implements InitializingBean { @SuppressWarnings("unchecked") public Set<String> getBulkExtractApps() { TenantContext.setIsSystemCall(true); Iterable<Entity> apps = repository.findAll("application", new NeutralQuery()); TenantContext.setIsSystemCall(false); Set<String> appIds = new HashSet<String>(); for (Entity app : apps) { if (app.getBody().containsKey("isBulkExtract") && (Boolean) app.getBody().get("isBulkExtract")) { if (app.getBody().containsKey("registration") && "APPROVED".equals(((Map<String, Object>) app.getBody().get("registration")).get("status"))) { appIds.add(app.getEntityId()); } } } return appIds; } @Override void afterPropertiesSet(); Set<String> getBulkExtractEdOrgs(); Map<String, Set<String>> getBulkExtractEdOrgsPerApp(); @SuppressWarnings("unchecked") Set<String> getBulkExtractApps(); Set<String> getChildEdOrgs(Collection<String> edOrgs); Iterable<Entity> retrieveSEOAS(String teacherId, String edorgId); void logSecurityEvent(Set<String> leas, String entityName, String className); void setSecurityEventUtil(SecurityEventUtil securityEventUtil); Map<String, List<String>> getEdOrgLineages(); void setEdOrgLineages(Map<String, List<String>> edOrgLineages); }
|
@Test public void testValidationOfFloatFailure() { Float floatEntity = new Float(0); assertFalse("Expected ListSchema float validation failure did not succeed", schema.validate(floatEntity)); }
|
@Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = true; Object convertedEntity = convert(entity); if (convertedEntity instanceof Set) { convertedEntity = new ArrayList<Object>((Set) convertedEntity); } if (convertedEntity instanceof List) { List<?> entityList = (List<?>) convertedEntity; for (Object fieldEntity : entityList) { boolean isFieldValid = false; for (NeutralSchema itemSchema : getList()) { if (itemSchema.validate(fieldName, fieldEntity, errors, repo)) { isFieldValid = true; break; } } if (!isFieldValid) { isValid = false; if (errors == null) { return false; } } } if (getProperties() != null) { for (Entry<String, Object> entry : getProperties().entrySet()) { if (Restriction.isRestriction(entry.getKey())) { long restrictionValue = Long.parseLong(entry.getValue().toString()); switch (Restriction.fromValue(entry.getKey())) { case LENGTH: if (!addError(entityList.size() == restrictionValue, fieldName, convertedEntity, "length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MIN_LENGTH: if (!addError(entityList.size() >= restrictionValue, fieldName, convertedEntity, "min-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MAX_LENGTH: if (!addError(entityList.size() <= restrictionValue, fieldName, convertedEntity, "max-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; } } } } } else { return addError(false, fieldName, convertedEntity, "List", ErrorType.INVALID_DATATYPE, errors); } return isValid; }
|
ListSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = true; Object convertedEntity = convert(entity); if (convertedEntity instanceof Set) { convertedEntity = new ArrayList<Object>((Set) convertedEntity); } if (convertedEntity instanceof List) { List<?> entityList = (List<?>) convertedEntity; for (Object fieldEntity : entityList) { boolean isFieldValid = false; for (NeutralSchema itemSchema : getList()) { if (itemSchema.validate(fieldName, fieldEntity, errors, repo)) { isFieldValid = true; break; } } if (!isFieldValid) { isValid = false; if (errors == null) { return false; } } } if (getProperties() != null) { for (Entry<String, Object> entry : getProperties().entrySet()) { if (Restriction.isRestriction(entry.getKey())) { long restrictionValue = Long.parseLong(entry.getValue().toString()); switch (Restriction.fromValue(entry.getKey())) { case LENGTH: if (!addError(entityList.size() == restrictionValue, fieldName, convertedEntity, "length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MIN_LENGTH: if (!addError(entityList.size() >= restrictionValue, fieldName, convertedEntity, "min-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MAX_LENGTH: if (!addError(entityList.size() <= restrictionValue, fieldName, convertedEntity, "max-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; } } } } } else { return addError(false, fieldName, convertedEntity, "List", ErrorType.INVALID_DATATYPE, errors); } return isValid; } }
|
ListSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = true; Object convertedEntity = convert(entity); if (convertedEntity instanceof Set) { convertedEntity = new ArrayList<Object>((Set) convertedEntity); } if (convertedEntity instanceof List) { List<?> entityList = (List<?>) convertedEntity; for (Object fieldEntity : entityList) { boolean isFieldValid = false; for (NeutralSchema itemSchema : getList()) { if (itemSchema.validate(fieldName, fieldEntity, errors, repo)) { isFieldValid = true; break; } } if (!isFieldValid) { isValid = false; if (errors == null) { return false; } } } if (getProperties() != null) { for (Entry<String, Object> entry : getProperties().entrySet()) { if (Restriction.isRestriction(entry.getKey())) { long restrictionValue = Long.parseLong(entry.getValue().toString()); switch (Restriction.fromValue(entry.getKey())) { case LENGTH: if (!addError(entityList.size() == restrictionValue, fieldName, convertedEntity, "length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MIN_LENGTH: if (!addError(entityList.size() >= restrictionValue, fieldName, convertedEntity, "min-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MAX_LENGTH: if (!addError(entityList.size() <= restrictionValue, fieldName, convertedEntity, "max-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; } } } } } else { return addError(false, fieldName, convertedEntity, "List", ErrorType.INVALID_DATATYPE, errors); } return isValid; } ListSchema(); ListSchema(String xsdType); }
|
ListSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = true; Object convertedEntity = convert(entity); if (convertedEntity instanceof Set) { convertedEntity = new ArrayList<Object>((Set) convertedEntity); } if (convertedEntity instanceof List) { List<?> entityList = (List<?>) convertedEntity; for (Object fieldEntity : entityList) { boolean isFieldValid = false; for (NeutralSchema itemSchema : getList()) { if (itemSchema.validate(fieldName, fieldEntity, errors, repo)) { isFieldValid = true; break; } } if (!isFieldValid) { isValid = false; if (errors == null) { return false; } } } if (getProperties() != null) { for (Entry<String, Object> entry : getProperties().entrySet()) { if (Restriction.isRestriction(entry.getKey())) { long restrictionValue = Long.parseLong(entry.getValue().toString()); switch (Restriction.fromValue(entry.getKey())) { case LENGTH: if (!addError(entityList.size() == restrictionValue, fieldName, convertedEntity, "length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MIN_LENGTH: if (!addError(entityList.size() >= restrictionValue, fieldName, convertedEntity, "min-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MAX_LENGTH: if (!addError(entityList.size() <= restrictionValue, fieldName, convertedEntity, "max-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; } } } } } else { return addError(false, fieldName, convertedEntity, "List", ErrorType.INVALID_DATATYPE, errors); } return isValid; } ListSchema(); ListSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); @Override boolean isPrimitive(); void setList(List<NeutralSchema> list); List<NeutralSchema> getList(); @Override boolean isSimple(); void updateAnnotations(); @Override Object convert(Object value); Map<String, NeutralSchema> getFields(); }
|
ListSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = true; Object convertedEntity = convert(entity); if (convertedEntity instanceof Set) { convertedEntity = new ArrayList<Object>((Set) convertedEntity); } if (convertedEntity instanceof List) { List<?> entityList = (List<?>) convertedEntity; for (Object fieldEntity : entityList) { boolean isFieldValid = false; for (NeutralSchema itemSchema : getList()) { if (itemSchema.validate(fieldName, fieldEntity, errors, repo)) { isFieldValid = true; break; } } if (!isFieldValid) { isValid = false; if (errors == null) { return false; } } } if (getProperties() != null) { for (Entry<String, Object> entry : getProperties().entrySet()) { if (Restriction.isRestriction(entry.getKey())) { long restrictionValue = Long.parseLong(entry.getValue().toString()); switch (Restriction.fromValue(entry.getKey())) { case LENGTH: if (!addError(entityList.size() == restrictionValue, fieldName, convertedEntity, "length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MIN_LENGTH: if (!addError(entityList.size() >= restrictionValue, fieldName, convertedEntity, "min-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MAX_LENGTH: if (!addError(entityList.size() <= restrictionValue, fieldName, convertedEntity, "max-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; } } } } } else { return addError(false, fieldName, convertedEntity, "List", ErrorType.INVALID_DATATYPE, errors); } return isValid; } ListSchema(); ListSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); @Override boolean isPrimitive(); void setList(List<NeutralSchema> list); List<NeutralSchema> getList(); @Override boolean isSimple(); void updateAnnotations(); @Override Object convert(Object value); Map<String, NeutralSchema> getFields(); }
|
@Test public void testTimeStringValidation() throws IllegalArgumentException { String timeString = "12:00:00-05:00"; assertTrue("Time entity validation failed", schema.validate(timeString)); }
|
protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = false; try { javax.xml.bind.DatatypeConverter.parseTime((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339", ErrorType.INVALID_DATE_FORMAT, errors); }
|
TimeSchema extends NeutralSchema { protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = false; try { javax.xml.bind.DatatypeConverter.parseTime((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339", ErrorType.INVALID_DATE_FORMAT, errors); } }
|
TimeSchema extends NeutralSchema { protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = false; try { javax.xml.bind.DatatypeConverter.parseTime((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339", ErrorType.INVALID_DATE_FORMAT, errors); } TimeSchema(); TimeSchema(String xsdType); }
|
TimeSchema extends NeutralSchema { protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = false; try { javax.xml.bind.DatatypeConverter.parseTime((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339", ErrorType.INVALID_DATE_FORMAT, errors); } TimeSchema(); TimeSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); }
|
TimeSchema extends NeutralSchema { protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = false; try { javax.xml.bind.DatatypeConverter.parseTime((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339", ErrorType.INVALID_DATE_FORMAT, errors); } TimeSchema(); TimeSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); }
|
@Test public void testTimeValidation() { Calendar calendar = Calendar.getInstance(); String timeString = javax.xml.bind.DatatypeConverter.printTime(calendar); assertTrue("Time entity validation failed", schema.validate(timeString)); }
|
protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = false; try { javax.xml.bind.DatatypeConverter.parseTime((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339", ErrorType.INVALID_DATE_FORMAT, errors); }
|
TimeSchema extends NeutralSchema { protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = false; try { javax.xml.bind.DatatypeConverter.parseTime((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339", ErrorType.INVALID_DATE_FORMAT, errors); } }
|
TimeSchema extends NeutralSchema { protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = false; try { javax.xml.bind.DatatypeConverter.parseTime((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339", ErrorType.INVALID_DATE_FORMAT, errors); } TimeSchema(); TimeSchema(String xsdType); }
|
TimeSchema extends NeutralSchema { protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = false; try { javax.xml.bind.DatatypeConverter.parseTime((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339", ErrorType.INVALID_DATE_FORMAT, errors); } TimeSchema(); TimeSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); }
|
TimeSchema extends NeutralSchema { protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = false; try { javax.xml.bind.DatatypeConverter.parseTime((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339", ErrorType.INVALID_DATE_FORMAT, errors); } TimeSchema(); TimeSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); }
|
@Test public void testValidationOfStringFailure() { String stringEntity = ""; assertFalse("Expected TimeSchema string validation failure did not succeed", schema.validate(stringEntity)); }
|
protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = false; try { javax.xml.bind.DatatypeConverter.parseTime((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339", ErrorType.INVALID_DATE_FORMAT, errors); }
|
TimeSchema extends NeutralSchema { protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = false; try { javax.xml.bind.DatatypeConverter.parseTime((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339", ErrorType.INVALID_DATE_FORMAT, errors); } }
|
TimeSchema extends NeutralSchema { protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = false; try { javax.xml.bind.DatatypeConverter.parseTime((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339", ErrorType.INVALID_DATE_FORMAT, errors); } TimeSchema(); TimeSchema(String xsdType); }
|
TimeSchema extends NeutralSchema { protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = false; try { javax.xml.bind.DatatypeConverter.parseTime((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339", ErrorType.INVALID_DATE_FORMAT, errors); } TimeSchema(); TimeSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); }
|
TimeSchema extends NeutralSchema { protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = false; try { javax.xml.bind.DatatypeConverter.parseTime((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339", ErrorType.INVALID_DATE_FORMAT, errors); } TimeSchema(); TimeSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); }
|
@Test public void testGetValueOneLevel() { Map<String, Object> data = new HashMap<String, Object>(); data.put("key1", "value1"); data.put("key2", "value2"); data.put("key3", "value3"); assertEquals("Should match", "value1", apiNeutralSchemaValidator.getValue("key1", data)); assertEquals("Should match", "value2", apiNeutralSchemaValidator.getValue("key2", data)); assertEquals("Should match", "value3", apiNeutralSchemaValidator.getValue("key3", data)); assertEquals("Should match", null, apiNeutralSchemaValidator.getValue("key4", data)); }
|
protected Object getValue(String path, Map<String, Object> data) { Object retValue = null; Map<?, ?> values = new HashMap<String, Object>(data); String[] keys = path.split("\\."); for (String key : keys) { Object value = values.get(key); if (Map.class.isInstance(value)) { values = (Map<?, ?>) value; retValue = value; } else { retValue = value; break; } } return retValue; }
|
ApiNeutralSchemaValidator extends NeutralSchemaValidator { protected Object getValue(String path, Map<String, Object> data) { Object retValue = null; Map<?, ?> values = new HashMap<String, Object>(data); String[] keys = path.split("\\."); for (String key : keys) { Object value = values.get(key); if (Map.class.isInstance(value)) { values = (Map<?, ?>) value; retValue = value; } else { retValue = value; break; } } return retValue; } }
|
ApiNeutralSchemaValidator extends NeutralSchemaValidator { protected Object getValue(String path, Map<String, Object> data) { Object retValue = null; Map<?, ?> values = new HashMap<String, Object>(data); String[] keys = path.split("\\."); for (String key : keys) { Object value = values.get(key); if (Map.class.isInstance(value)) { values = (Map<?, ?>) value; retValue = value; } else { retValue = value; break; } } return retValue; } }
|
ApiNeutralSchemaValidator extends NeutralSchemaValidator { protected Object getValue(String path, Map<String, Object> data) { Object retValue = null; Map<?, ?> values = new HashMap<String, Object>(data); String[] keys = path.split("\\."); for (String key : keys) { Object value = values.get(key); if (Map.class.isInstance(value)) { values = (Map<?, ?>) value; retValue = value; } else { retValue = value; break; } } return retValue; } @Override boolean validateNaturalKeys(final Entity entity, boolean overWrite); }
|
ApiNeutralSchemaValidator extends NeutralSchemaValidator { protected Object getValue(String path, Map<String, Object> data) { Object retValue = null; Map<?, ?> values = new HashMap<String, Object>(data); String[] keys = path.split("\\."); for (String key : keys) { Object value = values.get(key); if (Map.class.isInstance(value)) { values = (Map<?, ?>) value; retValue = value; } else { retValue = value; break; } } return retValue; } @Override boolean validateNaturalKeys(final Entity entity, boolean overWrite); }
|
@Test public void testGetValueMultiLevel() { Map<String, Object> inner2 = new HashMap<String, Object>(); inner2.put("key7", "value7"); inner2.put("key8", "value8"); Map<String, Object> inner1 = new HashMap<String, Object>(); inner1.put("key4", "value4"); inner1.put("key5", "value5"); inner1.put("key6", inner2); Map<String, Object> data = new HashMap<String, Object>(); data.put("key1", "value1"); data.put("key2", "value2"); data.put("key3", inner1); assertEquals("Should match", "value1", apiNeutralSchemaValidator.getValue("key1", data)); assertEquals("Should match", "value2", apiNeutralSchemaValidator.getValue("key2", data)); assertEquals("Should match", inner1, apiNeutralSchemaValidator.getValue("key3", data)); assertEquals("Should match", "value4", apiNeutralSchemaValidator.getValue("key3.key4", data)); assertEquals("Should match", "value5", apiNeutralSchemaValidator.getValue("key3.key5", data)); assertEquals("Should match", inner2, apiNeutralSchemaValidator.getValue("key3.key6", data)); assertEquals("Should match", "value7", apiNeutralSchemaValidator.getValue("key3.key6.key7", data)); assertEquals("Should match", "value8", apiNeutralSchemaValidator.getValue("key3.key6.key8", data)); }
|
protected Object getValue(String path, Map<String, Object> data) { Object retValue = null; Map<?, ?> values = new HashMap<String, Object>(data); String[] keys = path.split("\\."); for (String key : keys) { Object value = values.get(key); if (Map.class.isInstance(value)) { values = (Map<?, ?>) value; retValue = value; } else { retValue = value; break; } } return retValue; }
|
ApiNeutralSchemaValidator extends NeutralSchemaValidator { protected Object getValue(String path, Map<String, Object> data) { Object retValue = null; Map<?, ?> values = new HashMap<String, Object>(data); String[] keys = path.split("\\."); for (String key : keys) { Object value = values.get(key); if (Map.class.isInstance(value)) { values = (Map<?, ?>) value; retValue = value; } else { retValue = value; break; } } return retValue; } }
|
ApiNeutralSchemaValidator extends NeutralSchemaValidator { protected Object getValue(String path, Map<String, Object> data) { Object retValue = null; Map<?, ?> values = new HashMap<String, Object>(data); String[] keys = path.split("\\."); for (String key : keys) { Object value = values.get(key); if (Map.class.isInstance(value)) { values = (Map<?, ?>) value; retValue = value; } else { retValue = value; break; } } return retValue; } }
|
ApiNeutralSchemaValidator extends NeutralSchemaValidator { protected Object getValue(String path, Map<String, Object> data) { Object retValue = null; Map<?, ?> values = new HashMap<String, Object>(data); String[] keys = path.split("\\."); for (String key : keys) { Object value = values.get(key); if (Map.class.isInstance(value)) { values = (Map<?, ?>) value; retValue = value; } else { retValue = value; break; } } return retValue; } @Override boolean validateNaturalKeys(final Entity entity, boolean overWrite); }
|
ApiNeutralSchemaValidator extends NeutralSchemaValidator { protected Object getValue(String path, Map<String, Object> data) { Object retValue = null; Map<?, ?> values = new HashMap<String, Object>(data); String[] keys = path.split("\\."); for (String key : keys) { Object value = values.get(key); if (Map.class.isInstance(value)) { values = (Map<?, ?>) value; retValue = value; } else { retValue = value; break; } } return retValue; } @Override boolean validateNaturalKeys(final Entity entity, boolean overWrite); }
|
@Test public void testConvert() throws Exception { double value = 1.2; Object convertedValue = this.schema.convert("" + value); assertTrue(convertedValue instanceof Double); Double convertedInput = (Double) convertedValue; assertTrue(convertedInput.doubleValue() == value); }
|
@Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } DoubleSchema(); }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } DoubleSchema(); @Override Object convert(Object value); }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } DoubleSchema(); @Override Object convert(Object value); }
|
@Test(expected = IllegalArgumentException.class) public void testBadConvert() { this.schema.convert("INVALID INPUT"); }
|
@Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } DoubleSchema(); }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } DoubleSchema(); @Override Object convert(Object value); }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } DoubleSchema(); @Override Object convert(Object value); }
|
@Test public void testNonConvert() { Object convertedValue = this.schema.convert(12.345); assertTrue(convertedValue instanceof Double); }
|
@Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } DoubleSchema(); }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } DoubleSchema(); @Override Object convert(Object value); }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } DoubleSchema(); @Override Object convert(Object value); }
|
@Test public void testDoubleConverter() { double data = 12.0; float floatData = (float) data; int intData = (int) data; long longData = (long) data; assertTrue("Failure returning same object", this.schema.convert(data).equals(data)); assertTrue("Failure parsing double from long", this.schema.convert(longData).equals(data)); assertTrue("Failure parsing double from integer", this.schema.convert(intData).equals(data)); assertTrue("Failure parsing double from float", this.schema.convert(floatData).equals(data)); assertTrue("Failure parsing double data", this.schema.convert("" + data).equals(data)); }
|
@Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } DoubleSchema(); }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } DoubleSchema(); @Override Object convert(Object value); }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } DoubleSchema(); @Override Object convert(Object value); }
|
@Test public void getBulkExtractEdOrgsPerAppTest() { getBulkExtractAppsTest(); Map<String, Object> edorg1 = new HashMap<String, Object>(); edorg1.put("authorizedEdorg", "edOrg1"); Map<String, Object> edorg2 = new HashMap<String, Object>(); edorg2.put("authorizedEdorg", "edOrg2"); @SuppressWarnings("unchecked") Entity authOne = buildAuthEntity("1", Arrays.asList(edorg1, edorg2)); Entity authTwo = buildAuthEntity("5", new ArrayList<Map<String, Object>>()); List<Entity> auths = Arrays.asList(authOne, authTwo); when(repository.findAll(Mockito.eq("applicationAuthorization"), Mockito.any(NeutralQuery.class))).thenReturn(auths); Map<String, Set<String>> bulkExtractEdOrgsPerApp = helper.getBulkExtractEdOrgsPerApp(); assertTrue(bulkExtractEdOrgsPerApp.size() == 2); assertTrue(bulkExtractEdOrgsPerApp.get(authOne.getBody().get("applicationId")).containsAll( Arrays.asList("edOrg1","edOrg2"))); assertTrue(bulkExtractEdOrgsPerApp.get(authTwo.getBody().get("applicationId")).isEmpty()); }
|
public Map<String, Set<String>> getBulkExtractEdOrgsPerApp() { NeutralQuery appQuery = new NeutralQuery(new NeutralCriteria("applicationId", NeutralCriteria.CRITERIA_IN, getBulkExtractApps())); Iterable<Entity> apps = repository.findAll("applicationAuthorization", appQuery); Map<String, Set<String>> edorgIds = new HashMap<String, Set<String>>(); for (Entity app : apps) { Set<String> edorgs = new HashSet<String>(BulkExtractMongoDA.getAuthorizedEdOrgIds(app)); edorgIds.put((String) app.getBody().get("applicationId"), edorgs); } return edorgIds; }
|
EdOrgExtractHelper implements InitializingBean { public Map<String, Set<String>> getBulkExtractEdOrgsPerApp() { NeutralQuery appQuery = new NeutralQuery(new NeutralCriteria("applicationId", NeutralCriteria.CRITERIA_IN, getBulkExtractApps())); Iterable<Entity> apps = repository.findAll("applicationAuthorization", appQuery); Map<String, Set<String>> edorgIds = new HashMap<String, Set<String>>(); for (Entity app : apps) { Set<String> edorgs = new HashSet<String>(BulkExtractMongoDA.getAuthorizedEdOrgIds(app)); edorgIds.put((String) app.getBody().get("applicationId"), edorgs); } return edorgIds; } }
|
EdOrgExtractHelper implements InitializingBean { public Map<String, Set<String>> getBulkExtractEdOrgsPerApp() { NeutralQuery appQuery = new NeutralQuery(new NeutralCriteria("applicationId", NeutralCriteria.CRITERIA_IN, getBulkExtractApps())); Iterable<Entity> apps = repository.findAll("applicationAuthorization", appQuery); Map<String, Set<String>> edorgIds = new HashMap<String, Set<String>>(); for (Entity app : apps) { Set<String> edorgs = new HashSet<String>(BulkExtractMongoDA.getAuthorizedEdOrgIds(app)); edorgIds.put((String) app.getBody().get("applicationId"), edorgs); } return edorgIds; } }
|
EdOrgExtractHelper implements InitializingBean { public Map<String, Set<String>> getBulkExtractEdOrgsPerApp() { NeutralQuery appQuery = new NeutralQuery(new NeutralCriteria("applicationId", NeutralCriteria.CRITERIA_IN, getBulkExtractApps())); Iterable<Entity> apps = repository.findAll("applicationAuthorization", appQuery); Map<String, Set<String>> edorgIds = new HashMap<String, Set<String>>(); for (Entity app : apps) { Set<String> edorgs = new HashSet<String>(BulkExtractMongoDA.getAuthorizedEdOrgIds(app)); edorgIds.put((String) app.getBody().get("applicationId"), edorgs); } return edorgIds; } @Override void afterPropertiesSet(); Set<String> getBulkExtractEdOrgs(); Map<String, Set<String>> getBulkExtractEdOrgsPerApp(); @SuppressWarnings("unchecked") Set<String> getBulkExtractApps(); Set<String> getChildEdOrgs(Collection<String> edOrgs); Iterable<Entity> retrieveSEOAS(String teacherId, String edorgId); void logSecurityEvent(Set<String> leas, String entityName, String className); void setSecurityEventUtil(SecurityEventUtil securityEventUtil); Map<String, List<String>> getEdOrgLineages(); void setEdOrgLineages(Map<String, List<String>> edOrgLineages); }
|
EdOrgExtractHelper implements InitializingBean { public Map<String, Set<String>> getBulkExtractEdOrgsPerApp() { NeutralQuery appQuery = new NeutralQuery(new NeutralCriteria("applicationId", NeutralCriteria.CRITERIA_IN, getBulkExtractApps())); Iterable<Entity> apps = repository.findAll("applicationAuthorization", appQuery); Map<String, Set<String>> edorgIds = new HashMap<String, Set<String>>(); for (Entity app : apps) { Set<String> edorgs = new HashSet<String>(BulkExtractMongoDA.getAuthorizedEdOrgIds(app)); edorgIds.put((String) app.getBody().get("applicationId"), edorgs); } return edorgIds; } @Override void afterPropertiesSet(); Set<String> getBulkExtractEdOrgs(); Map<String, Set<String>> getBulkExtractEdOrgsPerApp(); @SuppressWarnings("unchecked") Set<String> getBulkExtractApps(); Set<String> getChildEdOrgs(Collection<String> edOrgs); Iterable<Entity> retrieveSEOAS(String teacherId, String edorgId); void logSecurityEvent(Set<String> leas, String entityName, String className); void setSecurityEventUtil(SecurityEventUtil securityEventUtil); Map<String, List<String>> getEdOrgLineages(); void setEdOrgLineages(Map<String, List<String>> edOrgLineages); }
|
@Test(expected = IllegalArgumentException.class) public void testInvalidStringThrowsException() throws IllegalArgumentException { this.schema.convert("INVALID INPUT"); }
|
@Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } DoubleSchema(); }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } DoubleSchema(); @Override Object convert(Object value); }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } DoubleSchema(); @Override Object convert(Object value); }
|
@Test(expected = IllegalArgumentException.class) public void testUnsupportedObjectTypeThrowsException() throws IllegalArgumentException { this.schema.convert(new Object()); }
|
@Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } DoubleSchema(); }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } DoubleSchema(); @Override Object convert(Object value); }
|
DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } DoubleSchema(); @Override Object convert(Object value); }
|
@Test public void testComplexValidation() throws IllegalArgumentException { schema.clearFields(); schema.addField("booleanField", booleanSchema); schema.addField("longField", longSchema); schema.addField("doubleField", doubleSchema); schema.addField("stringField", stringSchema); schema.addField("tokenField", tokenSchema); schema.addField("dateTimeField", dateTimeSchema); tokenSchema.getProperties().clear(); List<String> tokens = new ArrayList<String>(); tokens.add("validToken"); tokenSchema.getProperties().put(TokenSchema.TOKENS, tokens); Map<String, Object> complexEntity = new HashMap<String, Object>(); Boolean booleanEntity = true; Long longEntity = 0L; Double doubleEntity = 0.0; String stringEntity = "test"; String tokenEntity = "validToken"; String dateTimeEntity = "2012-01-01T12:00:00-05:00"; complexEntity.put("booleanField", booleanEntity); complexEntity.put("longField", longEntity); complexEntity.put("doubleField", doubleEntity); complexEntity.put("stringField", stringEntity); complexEntity.put("tokenField", tokenEntity); complexEntity.put("dateTimeField", dateTimeEntity); assertTrue("Complex entity validation failed", schema.validate(complexEntity)); }
|
@Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); @Override boolean isPrimitive(); @Override NeutralSchemaType getSchemaType(); @Override boolean validatePresent(Object entity, List<ValidationError> errors, Repository<Entity> repo); @Override boolean isSimple(); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); @Override boolean isPrimitive(); @Override NeutralSchemaType getSchemaType(); @Override boolean validatePresent(Object entity, List<ValidationError> errors, Repository<Entity> repo); @Override boolean isSimple(); }
|
@Test public void testInputConversionPerFieldSchema() { schema.clearFields(); schema.addField("booleanField", booleanSchema); schema.addField("longField", longSchema); schema.addField("doubleField", doubleSchema); schema.addField("stringField", stringSchema); schema.addField("tokenField", tokenSchema); tokenSchema.getProperties().clear(); List<String> tokens = new ArrayList<String>(); tokens.add("validToken"); tokenSchema.getProperties().put(TokenSchema.TOKENS, tokens); Map<String, Object> complexEntity = new HashMap<String, Object>(); String booleanEntity = "true"; String longEntity = "0"; String doubleEntity = "0.0"; String stringEntity = "test"; String tokenEntity = "validToken"; complexEntity.put("booleanField", booleanEntity); complexEntity.put("longField", longEntity); complexEntity.put("doubleField", doubleEntity); complexEntity.put("stringField", stringEntity); complexEntity.put("tokenField", tokenEntity); assertTrue("Complex entity validation failed", schema.validate(complexEntity)); assertTrue("Failed to properly convert boolean input", complexEntity.get("booleanField") instanceof Boolean); assertTrue("Failed to properly convert boolean input", complexEntity.get("longField") instanceof Long); assertTrue("Failed to properly convert boolean input", complexEntity.get("doubleField") instanceof Double); assertTrue("Failed to properly convert boolean input", complexEntity.get("stringField") instanceof String); assertTrue("Failed to properly convert boolean input", complexEntity.get("tokenField") instanceof String); }
|
@Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); @Override boolean isPrimitive(); @Override NeutralSchemaType getSchemaType(); @Override boolean validatePresent(Object entity, List<ValidationError> errors, Repository<Entity> repo); @Override boolean isSimple(); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); @Override boolean isPrimitive(); @Override NeutralSchemaType getSchemaType(); @Override boolean validatePresent(Object entity, List<ValidationError> errors, Repository<Entity> repo); @Override boolean isSimple(); }
|
@Test public void testOptionalFields() { schema.clearFields(); BooleanSchema required = new BooleanSchema(); AppInfo info = new AppInfo(null); info.put("required", "true"); required.addAnnotation(info); schema.addField("optionalField", booleanSchema); schema.addField("requiredField", required); Map<String, Object> complexEntity = new HashMap<String, Object>(); complexEntity.put("requiredField", Boolean.TRUE); assertTrue(schema.validate(complexEntity)); complexEntity.put("optionalField", Boolean.FALSE); assertTrue(schema.validate(complexEntity)); complexEntity.remove("requiredField"); assertFalse(schema.validate("requiredField")); }
|
@Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); @Override boolean isPrimitive(); @Override NeutralSchemaType getSchemaType(); @Override boolean validatePresent(Object entity, List<ValidationError> errors, Repository<Entity> repo); @Override boolean isSimple(); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); @Override boolean isPrimitive(); @Override NeutralSchemaType getSchemaType(); @Override boolean validatePresent(Object entity, List<ValidationError> errors, Repository<Entity> repo); @Override boolean isSimple(); }
|
@Test public void testComplexFailureValidation() throws IllegalArgumentException { schema.clearFields(); schema.addField("booleanField", booleanSchema); schema.addField("longField", longSchema); schema.addField("doubleField", doubleSchema); schema.addField("stringField", stringSchema); schema.addField("tokenField", tokenSchema); schema.addField("dateTimeField", dateTimeSchema); tokenSchema.getProperties().clear(); List<String> tokens = new ArrayList<String>(); tokens.add("validToken"); tokenSchema.getProperties().put(TokenSchema.TOKENS, tokens); Map<String, Object> complexEntity = new HashMap<String, Object>(); Long longEntity = 0L; Double doubleEntity = 0.0; BigDecimal decimalEntity = new BigDecimal(0); String stringEntity = "test"; String tokenEntity = "token"; String dateTimeEntity = "2012-01-01T12:00:00-05:00"; complexEntity.put("booleanField", stringEntity); complexEntity.put("longField", longEntity); complexEntity.put("doubleField", doubleEntity); complexEntity.put("decimalField", decimalEntity); complexEntity.put("stringField", stringEntity); complexEntity.put("tokenField", tokenEntity); complexEntity.put("dateTimeField", dateTimeEntity); assertFalse("Expected ComplexSchema validation failure did not succeed", schema.validate(complexEntity)); }
|
@Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); @Override boolean isPrimitive(); @Override NeutralSchemaType getSchemaType(); @Override boolean validatePresent(Object entity, List<ValidationError> errors, Repository<Entity> repo); @Override boolean isSimple(); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); @Override boolean isPrimitive(); @Override NeutralSchemaType getSchemaType(); @Override boolean validatePresent(Object entity, List<ValidationError> errors, Repository<Entity> repo); @Override boolean isSimple(); }
|
@Test public void testComplexHierarchyValidation() throws IllegalArgumentException { hierarchySchema.clearFields(); hierarchySchema.addField("schemaField", schema); schema.clearFields(); schema.addField("booleanField", booleanSchema); schema.addField("longField", longSchema); schema.addField("doubleField", doubleSchema); schema.addField("stringField", stringSchema); schema.addField("tokenField", tokenSchema); schema.addField("dateTimeField", dateTimeSchema); tokenSchema.getProperties().clear(); List<String> tokens = new ArrayList<String>(); tokens.add("validToken"); tokenSchema.getProperties().put(TokenSchema.TOKENS, tokens); Map<String, Object> hierarchyEntity = new HashMap<String, Object>(); Map<String, Object> complexEntity = new HashMap<String, Object>(); Boolean booleanEntity = true; Long longEntity = 0L; Double doubleEntity = 0.0; String stringEntity = "test"; String tokenEntity = "validToken"; String dateTimeEntity = "2012-01-01T12:00:00-05:00"; hierarchyEntity.put("schemaField", complexEntity); complexEntity.put("booleanField", booleanEntity); complexEntity.put("longField", longEntity); complexEntity.put("doubleField", doubleEntity); complexEntity.put("stringField", stringEntity); complexEntity.put("tokenField", tokenEntity); complexEntity.put("dateTimeField", dateTimeEntity); assertTrue("Complex hierarchy entity validation failed", hierarchySchema.validate(hierarchyEntity)); }
|
@Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); @Override boolean isPrimitive(); @Override NeutralSchemaType getSchemaType(); @Override boolean validatePresent(Object entity, List<ValidationError> errors, Repository<Entity> repo); @Override boolean isSimple(); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); @Override boolean isPrimitive(); @Override NeutralSchemaType getSchemaType(); @Override boolean validatePresent(Object entity, List<ValidationError> errors, Repository<Entity> repo); @Override boolean isSimple(); }
|
@Test public void testComplexHierarchyFailureValidation() throws IllegalArgumentException { hierarchySchema.clearFields(); hierarchySchema.addField("schemaField", schema); schema.clearFields(); schema.addField("booleanField", booleanSchema); schema.addField("longField", longSchema); schema.addField("doubleField", doubleSchema); schema.addField("stringField", stringSchema); schema.addField("tokenField", tokenSchema); schema.addField("dateTimeField", dateTimeSchema); tokenSchema.getProperties().clear(); List<String> tokens = new ArrayList<String>(); tokens.add("validToken"); tokenSchema.getProperties().put(TokenSchema.TOKENS, tokens); Map<String, Object> hierarchyEntity = new HashMap<String, Object>(); Map<String, Object> complexEntity = new HashMap<String, Object>(); Long longEntity = 0L; Double doubleEntity = 0.0; String stringEntity = "test"; String tokenEntity = "validToken"; String dateTimeEntity = "2012-01-01T12:00:00-05:00"; Boolean booleanEntity = true; hierarchyEntity.put("schemaField", complexEntity); complexEntity.put("longField", stringEntity); complexEntity.put("booleanField", booleanEntity); complexEntity.put("doubleField", doubleEntity); complexEntity.put("stringField", stringEntity); complexEntity.put("tokenField", tokenEntity); complexEntity.put("dateTimeField", dateTimeEntity); assertFalse("Expected ComplexSchema hierarchy validation failure did not succeed", hierarchySchema.validate(hierarchyEntity)); }
|
@Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); @Override boolean isPrimitive(); @Override NeutralSchemaType getSchemaType(); @Override boolean validatePresent(Object entity, List<ValidationError> errors, Repository<Entity> repo); @Override boolean isSimple(); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); @Override boolean isPrimitive(); @Override NeutralSchemaType getSchemaType(); @Override boolean validatePresent(Object entity, List<ValidationError> errors, Repository<Entity> repo); @Override boolean isSimple(); }
|
@Test public void testComplexHierarchyMapFailureValidation() throws IllegalArgumentException { hierarchySchema.clearFields(); hierarchySchema.addField("schemaField", schema); schema.clearFields(); schema.addField("booleanField", booleanSchema); schema.addField("longField", longSchema); schema.addField("doubleField", doubleSchema); schema.addField("stringField", stringSchema); schema.addField("tokenField", tokenSchema); schema.addField("dateTimeField", dateTimeSchema); tokenSchema.getProperties().clear(); List<String> tokens = new ArrayList<String>(); tokens.add("validToken"); tokenSchema.getProperties().put(TokenSchema.TOKENS, tokens); Map<String, Object> hierarchyEntity = new HashMap<String, Object>(); Map<String, Object> complexEntity = new HashMap<String, Object>(); Boolean booleanEntity = true; Long longEntity = 0L; Double doubleEntity = 0.0; BigDecimal decimalEntity = new BigDecimal(0); String stringEntity = "test"; String tokenEntity = "validToken"; String dateTimeEntity = "2012-01-01T12:00:00-05:00"; hierarchyEntity.put("schemaField", stringEntity); complexEntity.put("booleanField", booleanEntity); complexEntity.put("longField", longEntity); complexEntity.put("doubleField", doubleEntity); complexEntity.put("decimalField", decimalEntity); complexEntity.put("stringField", stringEntity); complexEntity.put("tokenField", tokenEntity); complexEntity.put("dateTimeField", dateTimeEntity); assertFalse("Expected ComplexSchema hierarchy validation failure did not succeed", hierarchySchema.validate(hierarchyEntity)); }
|
@Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); @Override boolean isPrimitive(); @Override NeutralSchemaType getSchemaType(); @Override boolean validatePresent(Object entity, List<ValidationError> errors, Repository<Entity> repo); @Override boolean isSimple(); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); @Override boolean isPrimitive(); @Override NeutralSchemaType getSchemaType(); @Override boolean validatePresent(Object entity, List<ValidationError> errors, Repository<Entity> repo); @Override boolean isSimple(); }
|
@Test public void testValidationOfBooleanFailure() { Boolean booleanEntity = true; assertFalse("Expected ComplexSchema boolean validation failure did not succeed", schema.validate(booleanEntity)); }
|
@Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); @Override boolean isPrimitive(); @Override NeutralSchemaType getSchemaType(); @Override boolean validatePresent(Object entity, List<ValidationError> errors, Repository<Entity> repo); @Override boolean isSimple(); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); @Override boolean isPrimitive(); @Override NeutralSchemaType getSchemaType(); @Override boolean validatePresent(Object entity, List<ValidationError> errors, Repository<Entity> repo); @Override boolean isSimple(); }
|
@Test public void testInvalidTenant() { String tenantId = "testTenant"; Mockito.when(bulkExtractMongoDA.getTenant(tenantId)).thenReturn(null); launcher.execute(tenantId, false); Mockito.verify(localEdOrgExtractor, Mockito.never()).execute(Mockito.eq("tenant"), Mockito.any(File.class), Mockito.any(DateTime.class)); }
|
public void execute(String tenant, boolean isDelta) { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_INFO, BEMessageCode.BE_SE_CODE_0001)); Entity tenantEntity = bulkExtractMongoDA.getTenant(tenant); if (tenantEntity != null) { DateTime startTime = new DateTime(); if (isDelta) { LOG.info("isDelta=true ... deltaExtractor.execute()"); deltaExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } else { LOG.info("isDelta=false ... localEdOrgExtractor.execute()"); edOrgExtractor.execute(tenant, getTenantDirectory(tenant), startTime); LOG.info("Starting public data extract..."); tenantPublicDataExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } } else { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_ERROR, BEMessageCode.BE_SE_CODE_0002, tenant)); LOG.error( "A bulk extract is not being initiated for the tenant {} because the tenant has not been onboarded.", tenant); } }
|
Launcher { public void execute(String tenant, boolean isDelta) { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_INFO, BEMessageCode.BE_SE_CODE_0001)); Entity tenantEntity = bulkExtractMongoDA.getTenant(tenant); if (tenantEntity != null) { DateTime startTime = new DateTime(); if (isDelta) { LOG.info("isDelta=true ... deltaExtractor.execute()"); deltaExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } else { LOG.info("isDelta=false ... localEdOrgExtractor.execute()"); edOrgExtractor.execute(tenant, getTenantDirectory(tenant), startTime); LOG.info("Starting public data extract..."); tenantPublicDataExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } } else { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_ERROR, BEMessageCode.BE_SE_CODE_0002, tenant)); LOG.error( "A bulk extract is not being initiated for the tenant {} because the tenant has not been onboarded.", tenant); } } }
|
Launcher { public void execute(String tenant, boolean isDelta) { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_INFO, BEMessageCode.BE_SE_CODE_0001)); Entity tenantEntity = bulkExtractMongoDA.getTenant(tenant); if (tenantEntity != null) { DateTime startTime = new DateTime(); if (isDelta) { LOG.info("isDelta=true ... deltaExtractor.execute()"); deltaExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } else { LOG.info("isDelta=false ... localEdOrgExtractor.execute()"); edOrgExtractor.execute(tenant, getTenantDirectory(tenant), startTime); LOG.info("Starting public data extract..."); tenantPublicDataExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } } else { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_ERROR, BEMessageCode.BE_SE_CODE_0002, tenant)); LOG.error( "A bulk extract is not being initiated for the tenant {} because the tenant has not been onboarded.", tenant); } } }
|
Launcher { public void execute(String tenant, boolean isDelta) { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_INFO, BEMessageCode.BE_SE_CODE_0001)); Entity tenantEntity = bulkExtractMongoDA.getTenant(tenant); if (tenantEntity != null) { DateTime startTime = new DateTime(); if (isDelta) { LOG.info("isDelta=true ... deltaExtractor.execute()"); deltaExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } else { LOG.info("isDelta=false ... localEdOrgExtractor.execute()"); edOrgExtractor.execute(tenant, getTenantDirectory(tenant), startTime); LOG.info("Starting public data extract..."); tenantPublicDataExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } } else { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_ERROR, BEMessageCode.BE_SE_CODE_0002, tenant)); LOG.error( "A bulk extract is not being initiated for the tenant {} because the tenant has not been onboarded.", tenant); } } void execute(String tenant, boolean isDelta); static String getTimeStamp(Date date); void setBaseDirectory(String baseDirectory); static void main(String[] args); void setEdOrgExtractor(EdOrgExtractor edOrgExtractor); EdOrgExtractor getEdOrgExtractor(); void setTenantPublicDataExtractor(TenantPublicDataExtractor tenantPublicDataExtractor); BulkExtractMongoDA getBulkExtractMongoDA(); void setBulkExtractMongoDA(BulkExtractMongoDA bulkExtractMongoDA); void setSecurityEventUtil(SecurityEventUtil securityEventUtil); }
|
Launcher { public void execute(String tenant, boolean isDelta) { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_INFO, BEMessageCode.BE_SE_CODE_0001)); Entity tenantEntity = bulkExtractMongoDA.getTenant(tenant); if (tenantEntity != null) { DateTime startTime = new DateTime(); if (isDelta) { LOG.info("isDelta=true ... deltaExtractor.execute()"); deltaExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } else { LOG.info("isDelta=false ... localEdOrgExtractor.execute()"); edOrgExtractor.execute(tenant, getTenantDirectory(tenant), startTime); LOG.info("Starting public data extract..."); tenantPublicDataExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } } else { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_ERROR, BEMessageCode.BE_SE_CODE_0002, tenant)); LOG.error( "A bulk extract is not being initiated for the tenant {} because the tenant has not been onboarded.", tenant); } } void execute(String tenant, boolean isDelta); static String getTimeStamp(Date date); void setBaseDirectory(String baseDirectory); static void main(String[] args); void setEdOrgExtractor(EdOrgExtractor edOrgExtractor); EdOrgExtractor getEdOrgExtractor(); void setTenantPublicDataExtractor(TenantPublicDataExtractor tenantPublicDataExtractor); BulkExtractMongoDA getBulkExtractMongoDA(); void setBulkExtractMongoDA(BulkExtractMongoDA bulkExtractMongoDA); void setSecurityEventUtil(SecurityEventUtil securityEventUtil); }
|
@Test public void testValidationOfIntegerFailure() { Integer integerEntity = 0; assertFalse("Expected ComplexSchema integer validation failure did not succeed", schema.validate(integerEntity)); }
|
@Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); @Override boolean isPrimitive(); @Override NeutralSchemaType getSchemaType(); @Override boolean validatePresent(Object entity, List<ValidationError> errors, Repository<Entity> repo); @Override boolean isSimple(); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); @Override boolean isPrimitive(); @Override NeutralSchemaType getSchemaType(); @Override boolean validatePresent(Object entity, List<ValidationError> errors, Repository<Entity> repo); @Override boolean isSimple(); }
|
@Test public void testValidationOfFloatFailure() { Float floatEntity = new Float(0); assertFalse("Expected ComplexSchema float validation failure did not succeed", schema.validate(floatEntity)); }
|
@Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); @Override boolean isPrimitive(); @Override NeutralSchemaType getSchemaType(); @Override boolean validatePresent(Object entity, List<ValidationError> errors, Repository<Entity> repo); @Override boolean isSimple(); }
|
ComplexSchema extends NeutralSchema { @Override protected boolean validate(String validateFieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return this.validate(validateFieldName, entity, errors, repo, true); } ComplexSchema(); ComplexSchema(String xsdType); @Override boolean isPrimitive(); @Override NeutralSchemaType getSchemaType(); @Override boolean validatePresent(Object entity, List<ValidationError> errors, Repository<Entity> repo); @Override boolean isSimple(); }
|
@Test public void testValidate() { Entity entity = Mockito.mock(Entity.class); Map<String, Object> body = new HashMap<String, Object>(); body.put(REFERENCE_FIELD, UUID); Mockito.when(entity.getBody()).thenReturn(body); Mockito.when(entity.getEntityId()).thenReturn(UUID); List<ValidationError> errors = new ArrayList<ValidationError>(); boolean valid = selfReferenceValidator.validate(entity, errors); Assert.assertFalse(valid); Assert.assertEquals(1, errors.size()); }
|
public boolean validate(Entity entity, List<ValidationError> errors) { String selfReferencePath = selfReferenceExtractor.getSelfReferenceFields(entity); if (selfReferencePath != null) { Map<String, Object> body = entity.getBody(); if (body != null) { String property = (String) body.get(selfReferencePath); String uuid = entity.getEntityId(); if (uuid == null) { uuid = getDeterministicId(entity); } if (property != null && property.equals(uuid)) { Map<String, String> naturalKeys = null; try { naturalKeys = naturalKeyExtractor.getNaturalKeys(entity); if (naturalKeys != null && naturalKeys.size() > 0) { property = naturalKeys.toString(); } } catch (NoNaturalKeysDefinedException e) { LOG.error(e.getMessage(), e); } errors.add(new ValidationError(ErrorType.SELF_REFERENCING_DATA, selfReferencePath, property, new String[] { "Reference to a separate entity" })); return false; } return true; } } return true; }
|
SelfReferenceValidator { public boolean validate(Entity entity, List<ValidationError> errors) { String selfReferencePath = selfReferenceExtractor.getSelfReferenceFields(entity); if (selfReferencePath != null) { Map<String, Object> body = entity.getBody(); if (body != null) { String property = (String) body.get(selfReferencePath); String uuid = entity.getEntityId(); if (uuid == null) { uuid = getDeterministicId(entity); } if (property != null && property.equals(uuid)) { Map<String, String> naturalKeys = null; try { naturalKeys = naturalKeyExtractor.getNaturalKeys(entity); if (naturalKeys != null && naturalKeys.size() > 0) { property = naturalKeys.toString(); } } catch (NoNaturalKeysDefinedException e) { LOG.error(e.getMessage(), e); } errors.add(new ValidationError(ErrorType.SELF_REFERENCING_DATA, selfReferencePath, property, new String[] { "Reference to a separate entity" })); return false; } return true; } } return true; } }
|
SelfReferenceValidator { public boolean validate(Entity entity, List<ValidationError> errors) { String selfReferencePath = selfReferenceExtractor.getSelfReferenceFields(entity); if (selfReferencePath != null) { Map<String, Object> body = entity.getBody(); if (body != null) { String property = (String) body.get(selfReferencePath); String uuid = entity.getEntityId(); if (uuid == null) { uuid = getDeterministicId(entity); } if (property != null && property.equals(uuid)) { Map<String, String> naturalKeys = null; try { naturalKeys = naturalKeyExtractor.getNaturalKeys(entity); if (naturalKeys != null && naturalKeys.size() > 0) { property = naturalKeys.toString(); } } catch (NoNaturalKeysDefinedException e) { LOG.error(e.getMessage(), e); } errors.add(new ValidationError(ErrorType.SELF_REFERENCING_DATA, selfReferencePath, property, new String[] { "Reference to a separate entity" })); return false; } return true; } } return true; } }
|
SelfReferenceValidator { public boolean validate(Entity entity, List<ValidationError> errors) { String selfReferencePath = selfReferenceExtractor.getSelfReferenceFields(entity); if (selfReferencePath != null) { Map<String, Object> body = entity.getBody(); if (body != null) { String property = (String) body.get(selfReferencePath); String uuid = entity.getEntityId(); if (uuid == null) { uuid = getDeterministicId(entity); } if (property != null && property.equals(uuid)) { Map<String, String> naturalKeys = null; try { naturalKeys = naturalKeyExtractor.getNaturalKeys(entity); if (naturalKeys != null && naturalKeys.size() > 0) { property = naturalKeys.toString(); } } catch (NoNaturalKeysDefinedException e) { LOG.error(e.getMessage(), e); } errors.add(new ValidationError(ErrorType.SELF_REFERENCING_DATA, selfReferencePath, property, new String[] { "Reference to a separate entity" })); return false; } return true; } } return true; } boolean validate(Entity entity, List<ValidationError> errors); String getDeterministicId(Entity entity); }
|
SelfReferenceValidator { public boolean validate(Entity entity, List<ValidationError> errors) { String selfReferencePath = selfReferenceExtractor.getSelfReferenceFields(entity); if (selfReferencePath != null) { Map<String, Object> body = entity.getBody(); if (body != null) { String property = (String) body.get(selfReferencePath); String uuid = entity.getEntityId(); if (uuid == null) { uuid = getDeterministicId(entity); } if (property != null && property.equals(uuid)) { Map<String, String> naturalKeys = null; try { naturalKeys = naturalKeyExtractor.getNaturalKeys(entity); if (naturalKeys != null && naturalKeys.size() > 0) { property = naturalKeys.toString(); } } catch (NoNaturalKeysDefinedException e) { LOG.error(e.getMessage(), e); } errors.add(new ValidationError(ErrorType.SELF_REFERENCING_DATA, selfReferencePath, property, new String[] { "Reference to a separate entity" })); return false; } return true; } } return true; } boolean validate(Entity entity, List<ValidationError> errors); String getDeterministicId(Entity entity); }
|
@Test public void testEquals() { String includeFields = "field1,field2"; String excludeFields = "field3,field4"; String sortBy = "field5"; int offset = 4; int limit = 5; NeutralQuery.SortOrder sortOrderAscending = NeutralQuery.SortOrder.ascending; NeutralQuery.SortOrder sortOrderDescending = NeutralQuery.SortOrder.descending; NeutralQuery neutralQuery1 = new NeutralQuery(); neutralQuery1.setIncludeFieldString(includeFields); neutralQuery1.setExcludeFieldString(excludeFields); neutralQuery1.setLimit(limit); neutralQuery1.setOffset(offset); neutralQuery1.setSortBy(sortBy); neutralQuery1.setSortOrder(sortOrderAscending); NeutralQuery neutralQuery2 = new NeutralQuery(neutralQuery1); assertTrue(neutralQuery1.equals(neutralQuery2)); assertTrue(neutralQuery1 != neutralQuery2); neutralQuery1.setIncludeFieldString(""); assertFalse(neutralQuery1.equals(neutralQuery2)); neutralQuery2.setIncludeFieldString(""); assertTrue(neutralQuery1.equals(neutralQuery2)); neutralQuery1.setExcludeFieldString(""); assertFalse(neutralQuery1.equals(neutralQuery2)); neutralQuery2.setExcludeFieldString(""); assertTrue(neutralQuery1.equals(neutralQuery2)); neutralQuery1.setLimit(7); assertFalse(neutralQuery1.equals(neutralQuery2)); neutralQuery2.setLimit(7); assertTrue(neutralQuery1.equals(neutralQuery2)); neutralQuery1.setOffset(9); assertFalse(neutralQuery1.equals(neutralQuery2)); neutralQuery2.setOffset(9); assertTrue(neutralQuery1.equals(neutralQuery2)); neutralQuery1.setSortBy(""); assertFalse(neutralQuery1.equals(neutralQuery2)); neutralQuery2.setSortBy(""); assertTrue(neutralQuery1.equals(neutralQuery2)); neutralQuery1.setSortOrder(sortOrderDescending); assertFalse(neutralQuery1.equals(neutralQuery2)); neutralQuery2.setSortOrder(sortOrderDescending); assertTrue(neutralQuery1.equals(neutralQuery2)); neutralQuery1.addCriteria(new NeutralCriteria("x=1")); neutralQuery2.addCriteria(new NeutralCriteria("x=2")); assertFalse(neutralQuery1.equals(neutralQuery2)); neutralQuery1.addCriteria(new NeutralCriteria("x=2")); assertFalse(neutralQuery1.equals(neutralQuery2)); neutralQuery2.prependCriteria(new NeutralCriteria("x=1")); assertTrue(neutralQuery1.equals(neutralQuery2)); }
|
@Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } NeutralQuery other = (NeutralQuery) obj; if (excludeFields == null) { if (other.excludeFields != null) { return false; } } else if (!excludeFields.equals(other.excludeFields)) { return false; } if (includeFields == null) { if (other.includeFields != null) { return false; } } else if (!includeFields.equals(other.includeFields)) { return false; } if (limit != other.limit) { return false; } if (offset != other.offset) { return false; } if (orQueries == null) { if (other.orQueries != null) { return false; } } else if (!orQueries.equals(other.orQueries)) { return false; } if (queryCriteria == null) { if (other.queryCriteria != null) { return false; } } else if (!queryCriteria.equals(other.queryCriteria)) { return false; } if (sortBy == null) { if (other.sortBy != null) { return false; } } else if (!sortBy.equals(other.sortBy)) { return false; } if (sortOrder != other.sortOrder) { return false; } return true; }
|
NeutralQuery { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } NeutralQuery other = (NeutralQuery) obj; if (excludeFields == null) { if (other.excludeFields != null) { return false; } } else if (!excludeFields.equals(other.excludeFields)) { return false; } if (includeFields == null) { if (other.includeFields != null) { return false; } } else if (!includeFields.equals(other.includeFields)) { return false; } if (limit != other.limit) { return false; } if (offset != other.offset) { return false; } if (orQueries == null) { if (other.orQueries != null) { return false; } } else if (!orQueries.equals(other.orQueries)) { return false; } if (queryCriteria == null) { if (other.queryCriteria != null) { return false; } } else if (!queryCriteria.equals(other.queryCriteria)) { return false; } if (sortBy == null) { if (other.sortBy != null) { return false; } } else if (!sortBy.equals(other.sortBy)) { return false; } if (sortOrder != other.sortOrder) { return false; } return true; } }
|
NeutralQuery { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } NeutralQuery other = (NeutralQuery) obj; if (excludeFields == null) { if (other.excludeFields != null) { return false; } } else if (!excludeFields.equals(other.excludeFields)) { return false; } if (includeFields == null) { if (other.includeFields != null) { return false; } } else if (!includeFields.equals(other.includeFields)) { return false; } if (limit != other.limit) { return false; } if (offset != other.offset) { return false; } if (orQueries == null) { if (other.orQueries != null) { return false; } } else if (!orQueries.equals(other.orQueries)) { return false; } if (queryCriteria == null) { if (other.queryCriteria != null) { return false; } } else if (!queryCriteria.equals(other.queryCriteria)) { return false; } if (sortBy == null) { if (other.sortBy != null) { return false; } } else if (!sortBy.equals(other.sortBy)) { return false; } if (sortOrder != other.sortOrder) { return false; } return true; } NeutralQuery(); NeutralQuery(int limit); NeutralQuery(NeutralQuery otherNeutralQuery); NeutralQuery(NeutralCriteria neutralCriteria); }
|
NeutralQuery { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } NeutralQuery other = (NeutralQuery) obj; if (excludeFields == null) { if (other.excludeFields != null) { return false; } } else if (!excludeFields.equals(other.excludeFields)) { return false; } if (includeFields == null) { if (other.includeFields != null) { return false; } } else if (!includeFields.equals(other.includeFields)) { return false; } if (limit != other.limit) { return false; } if (offset != other.offset) { return false; } if (orQueries == null) { if (other.orQueries != null) { return false; } } else if (!orQueries.equals(other.orQueries)) { return false; } if (queryCriteria == null) { if (other.queryCriteria != null) { return false; } } else if (!queryCriteria.equals(other.queryCriteria)) { return false; } if (sortBy == null) { if (other.sortBy != null) { return false; } } else if (!sortBy.equals(other.sortBy)) { return false; } if (sortOrder != other.sortOrder) { return false; } return true; } NeutralQuery(); NeutralQuery(int limit); NeutralQuery(NeutralQuery otherNeutralQuery); NeutralQuery(NeutralCriteria neutralCriteria); List<String> getEmbeddedFields(); void setEmbeddedFields(List<String> embeddedFields); @Override int hashCode(); @Override boolean equals(Object obj); NeutralQuery addOrQuery(NeutralQuery orQuery); List<NeutralQuery> getOrQueries(); final NeutralQuery addCriteria(NeutralCriteria criteria); NeutralQuery prependCriteria(NeutralCriteria criteria); List<NeutralCriteria> getCriteria(); List<String> getIncludeFields(); NeutralQuery setIncludeFields(List<String> includeFields); List<String> getExcludeFields(); NeutralQuery setExcludeFields(List<String> excludeFields); boolean removeCriteria(NeutralCriteria criteria); @Deprecated String getIncludeFieldString(); @Deprecated String getExcludeFieldString(); int getOffset(); int getLimit(); String getSortBy(); SortOrder getSortOrder(); NeutralQuery setLimit(int newLimit); NeutralQuery setOffset(int newOffset); NeutralQuery setIncludeFieldString(String newIncludeFields); NeutralQuery setExcludeFieldString(String newExcludeFields); NeutralQuery setEmbeddedFieldString(String newEmbeddedFields); NeutralQuery setSortBy(String newSortBy); NeutralQuery setSortOrder(SortOrder newSortOrder); NeutralQuery setQueryCriteria(List<NeutralCriteria> newQueryCriteria); void setCountOnly(boolean value); boolean getCountOnly(); boolean isCountOnly(); @Override String toString(); }
|
NeutralQuery { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } NeutralQuery other = (NeutralQuery) obj; if (excludeFields == null) { if (other.excludeFields != null) { return false; } } else if (!excludeFields.equals(other.excludeFields)) { return false; } if (includeFields == null) { if (other.includeFields != null) { return false; } } else if (!includeFields.equals(other.includeFields)) { return false; } if (limit != other.limit) { return false; } if (offset != other.offset) { return false; } if (orQueries == null) { if (other.orQueries != null) { return false; } } else if (!orQueries.equals(other.orQueries)) { return false; } if (queryCriteria == null) { if (other.queryCriteria != null) { return false; } } else if (!queryCriteria.equals(other.queryCriteria)) { return false; } if (sortBy == null) { if (other.sortBy != null) { return false; } } else if (!sortBy.equals(other.sortBy)) { return false; } if (sortOrder != other.sortOrder) { return false; } return true; } NeutralQuery(); NeutralQuery(int limit); NeutralQuery(NeutralQuery otherNeutralQuery); NeutralQuery(NeutralCriteria neutralCriteria); List<String> getEmbeddedFields(); void setEmbeddedFields(List<String> embeddedFields); @Override int hashCode(); @Override boolean equals(Object obj); NeutralQuery addOrQuery(NeutralQuery orQuery); List<NeutralQuery> getOrQueries(); final NeutralQuery addCriteria(NeutralCriteria criteria); NeutralQuery prependCriteria(NeutralCriteria criteria); List<NeutralCriteria> getCriteria(); List<String> getIncludeFields(); NeutralQuery setIncludeFields(List<String> includeFields); List<String> getExcludeFields(); NeutralQuery setExcludeFields(List<String> excludeFields); boolean removeCriteria(NeutralCriteria criteria); @Deprecated String getIncludeFieldString(); @Deprecated String getExcludeFieldString(); int getOffset(); int getLimit(); String getSortBy(); SortOrder getSortOrder(); NeutralQuery setLimit(int newLimit); NeutralQuery setOffset(int newOffset); NeutralQuery setIncludeFieldString(String newIncludeFields); NeutralQuery setExcludeFieldString(String newExcludeFields); NeutralQuery setEmbeddedFieldString(String newEmbeddedFields); NeutralQuery setSortBy(String newSortBy); NeutralQuery setSortOrder(SortOrder newSortOrder); NeutralQuery setQueryCriteria(List<NeutralCriteria> newQueryCriteria); void setCountOnly(boolean value); boolean getCountOnly(); boolean isCountOnly(); @Override String toString(); }
|
@Test public void testToString() { assertNotNull(new NeutralQuery().toString()); }
|
@Override public String toString() { return "NeutralQuery [includeFields=" + includeFields + ", excludeFields=" + excludeFields + ", offset=" + offset + ", limit=" + limit + ", sortBy=" + sortBy + ", sortOrder=" + sortOrder + ", queryCriteria=" + queryCriteria + ", orQueries=" + orQueries + "]"; }
|
NeutralQuery { @Override public String toString() { return "NeutralQuery [includeFields=" + includeFields + ", excludeFields=" + excludeFields + ", offset=" + offset + ", limit=" + limit + ", sortBy=" + sortBy + ", sortOrder=" + sortOrder + ", queryCriteria=" + queryCriteria + ", orQueries=" + orQueries + "]"; } }
|
NeutralQuery { @Override public String toString() { return "NeutralQuery [includeFields=" + includeFields + ", excludeFields=" + excludeFields + ", offset=" + offset + ", limit=" + limit + ", sortBy=" + sortBy + ", sortOrder=" + sortOrder + ", queryCriteria=" + queryCriteria + ", orQueries=" + orQueries + "]"; } NeutralQuery(); NeutralQuery(int limit); NeutralQuery(NeutralQuery otherNeutralQuery); NeutralQuery(NeutralCriteria neutralCriteria); }
|
NeutralQuery { @Override public String toString() { return "NeutralQuery [includeFields=" + includeFields + ", excludeFields=" + excludeFields + ", offset=" + offset + ", limit=" + limit + ", sortBy=" + sortBy + ", sortOrder=" + sortOrder + ", queryCriteria=" + queryCriteria + ", orQueries=" + orQueries + "]"; } NeutralQuery(); NeutralQuery(int limit); NeutralQuery(NeutralQuery otherNeutralQuery); NeutralQuery(NeutralCriteria neutralCriteria); List<String> getEmbeddedFields(); void setEmbeddedFields(List<String> embeddedFields); @Override int hashCode(); @Override boolean equals(Object obj); NeutralQuery addOrQuery(NeutralQuery orQuery); List<NeutralQuery> getOrQueries(); final NeutralQuery addCriteria(NeutralCriteria criteria); NeutralQuery prependCriteria(NeutralCriteria criteria); List<NeutralCriteria> getCriteria(); List<String> getIncludeFields(); NeutralQuery setIncludeFields(List<String> includeFields); List<String> getExcludeFields(); NeutralQuery setExcludeFields(List<String> excludeFields); boolean removeCriteria(NeutralCriteria criteria); @Deprecated String getIncludeFieldString(); @Deprecated String getExcludeFieldString(); int getOffset(); int getLimit(); String getSortBy(); SortOrder getSortOrder(); NeutralQuery setLimit(int newLimit); NeutralQuery setOffset(int newOffset); NeutralQuery setIncludeFieldString(String newIncludeFields); NeutralQuery setExcludeFieldString(String newExcludeFields); NeutralQuery setEmbeddedFieldString(String newEmbeddedFields); NeutralQuery setSortBy(String newSortBy); NeutralQuery setSortOrder(SortOrder newSortOrder); NeutralQuery setQueryCriteria(List<NeutralCriteria> newQueryCriteria); void setCountOnly(boolean value); boolean getCountOnly(); boolean isCountOnly(); @Override String toString(); }
|
NeutralQuery { @Override public String toString() { return "NeutralQuery [includeFields=" + includeFields + ", excludeFields=" + excludeFields + ", offset=" + offset + ", limit=" + limit + ", sortBy=" + sortBy + ", sortOrder=" + sortOrder + ", queryCriteria=" + queryCriteria + ", orQueries=" + orQueries + "]"; } NeutralQuery(); NeutralQuery(int limit); NeutralQuery(NeutralQuery otherNeutralQuery); NeutralQuery(NeutralCriteria neutralCriteria); List<String> getEmbeddedFields(); void setEmbeddedFields(List<String> embeddedFields); @Override int hashCode(); @Override boolean equals(Object obj); NeutralQuery addOrQuery(NeutralQuery orQuery); List<NeutralQuery> getOrQueries(); final NeutralQuery addCriteria(NeutralCriteria criteria); NeutralQuery prependCriteria(NeutralCriteria criteria); List<NeutralCriteria> getCriteria(); List<String> getIncludeFields(); NeutralQuery setIncludeFields(List<String> includeFields); List<String> getExcludeFields(); NeutralQuery setExcludeFields(List<String> excludeFields); boolean removeCriteria(NeutralCriteria criteria); @Deprecated String getIncludeFieldString(); @Deprecated String getExcludeFieldString(); int getOffset(); int getLimit(); String getSortBy(); SortOrder getSortOrder(); NeutralQuery setLimit(int newLimit); NeutralQuery setOffset(int newOffset); NeutralQuery setIncludeFieldString(String newIncludeFields); NeutralQuery setExcludeFieldString(String newExcludeFields); NeutralQuery setEmbeddedFieldString(String newEmbeddedFields); NeutralQuery setSortBy(String newSortBy); NeutralQuery setSortOrder(SortOrder newSortOrder); NeutralQuery setQueryCriteria(List<NeutralCriteria> newQueryCriteria); void setCountOnly(boolean value); boolean getCountOnly(); boolean isCountOnly(); @Override String toString(); }
|
@Test public void testEqualsComparison() { NeutralCriteria neutralCriteria1 = new NeutralCriteria("key", "=", "value"); NeutralCriteria neutralCriteria2 = new NeutralCriteria("key", "=", "value"); NeutralCriteria neutralCriteria3 = new NeutralCriteria("differentKey", "=", "value"); NeutralCriteria neutralCriteria4 = new NeutralCriteria("key", "!=", "value"); NeutralCriteria neutralCriteria5 = new NeutralCriteria("key", "!=", "differentValue"); NeutralCriteria neutralCriteria6 = new NeutralCriteria("key", "=", "value", true); NeutralCriteria neutralCriteria7 = new NeutralCriteria("key", "=", "value", false); assertTrue(neutralCriteria1.equals(neutralCriteria2)); assertFalse(neutralCriteria1 == neutralCriteria2); assertFalse(neutralCriteria1.equals(neutralCriteria3)); assertFalse(neutralCriteria1.equals(neutralCriteria4)); assertFalse(neutralCriteria1.equals(neutralCriteria5)); assertTrue(neutralCriteria1.equals(neutralCriteria6)); assertFalse(neutralCriteria1.equals(neutralCriteria7)); }
|
@Override public boolean equals(Object o) { if (o instanceof NeutralCriteria) { NeutralCriteria nc = (NeutralCriteria) o; boolean keysMatch = this.valuesMatch(this.key, nc.key); boolean operatorsMatch = this.valuesMatch(this.operator, nc.operator); boolean valuesMatch = this.valuesMatch(this.value, nc.value); boolean prefixesMatch = (this.canBePrefixed == nc.canBePrefixed); boolean typeMatch = ( this.getType() == nc.getType() ); boolean removableMatch = (this.isRemovable() == nc.isRemovable()); return (keysMatch && operatorsMatch && valuesMatch && prefixesMatch && typeMatch && removableMatch); } return false; }
|
NeutralCriteria { @Override public boolean equals(Object o) { if (o instanceof NeutralCriteria) { NeutralCriteria nc = (NeutralCriteria) o; boolean keysMatch = this.valuesMatch(this.key, nc.key); boolean operatorsMatch = this.valuesMatch(this.operator, nc.operator); boolean valuesMatch = this.valuesMatch(this.value, nc.value); boolean prefixesMatch = (this.canBePrefixed == nc.canBePrefixed); boolean typeMatch = ( this.getType() == nc.getType() ); boolean removableMatch = (this.isRemovable() == nc.isRemovable()); return (keysMatch && operatorsMatch && valuesMatch && prefixesMatch && typeMatch && removableMatch); } return false; } }
|
NeutralCriteria { @Override public boolean equals(Object o) { if (o instanceof NeutralCriteria) { NeutralCriteria nc = (NeutralCriteria) o; boolean keysMatch = this.valuesMatch(this.key, nc.key); boolean operatorsMatch = this.valuesMatch(this.operator, nc.operator); boolean valuesMatch = this.valuesMatch(this.value, nc.value); boolean prefixesMatch = (this.canBePrefixed == nc.canBePrefixed); boolean typeMatch = ( this.getType() == nc.getType() ); boolean removableMatch = (this.isRemovable() == nc.isRemovable()); return (keysMatch && operatorsMatch && valuesMatch && prefixesMatch && typeMatch && removableMatch); } return false; } NeutralCriteria(String criteria); NeutralCriteria(String newKey, String newOperator, Object newValue); NeutralCriteria(String newKey, String newOperator, Object newValue, boolean canBePrefixed); }
|
NeutralCriteria { @Override public boolean equals(Object o) { if (o instanceof NeutralCriteria) { NeutralCriteria nc = (NeutralCriteria) o; boolean keysMatch = this.valuesMatch(this.key, nc.key); boolean operatorsMatch = this.valuesMatch(this.operator, nc.operator); boolean valuesMatch = this.valuesMatch(this.value, nc.value); boolean prefixesMatch = (this.canBePrefixed == nc.canBePrefixed); boolean typeMatch = ( this.getType() == nc.getType() ); boolean removableMatch = (this.isRemovable() == nc.isRemovable()); return (keysMatch && operatorsMatch && valuesMatch && prefixesMatch && typeMatch && removableMatch); } return false; } NeutralCriteria(String criteria); NeutralCriteria(String newKey, String newOperator, Object newValue); NeutralCriteria(String newKey, String newOperator, Object newValue, boolean canBePrefixed); @SuppressWarnings("PMD.UselessOverridingMethod") // this is overridden because equals is also overridden @Override int hashCode(); String getKey(); String getOperator(); Object getValue(); void setKey(String key); void setOperator(String operator); void setValue(Object value); boolean canBePrefixed(); void setCanBePrefixed(boolean canBePrefixed); @Override String toString(); @Override boolean equals(Object o); SearchType getType(); void setType(SearchType type); boolean isRemovable(); void setRemovable(boolean removable); }
|
NeutralCriteria { @Override public boolean equals(Object o) { if (o instanceof NeutralCriteria) { NeutralCriteria nc = (NeutralCriteria) o; boolean keysMatch = this.valuesMatch(this.key, nc.key); boolean operatorsMatch = this.valuesMatch(this.operator, nc.operator); boolean valuesMatch = this.valuesMatch(this.value, nc.value); boolean prefixesMatch = (this.canBePrefixed == nc.canBePrefixed); boolean typeMatch = ( this.getType() == nc.getType() ); boolean removableMatch = (this.isRemovable() == nc.isRemovable()); return (keysMatch && operatorsMatch && valuesMatch && prefixesMatch && typeMatch && removableMatch); } return false; } NeutralCriteria(String criteria); NeutralCriteria(String newKey, String newOperator, Object newValue); NeutralCriteria(String newKey, String newOperator, Object newValue, boolean canBePrefixed); @SuppressWarnings("PMD.UselessOverridingMethod") // this is overridden because equals is also overridden @Override int hashCode(); String getKey(); String getOperator(); Object getValue(); void setKey(String key); void setOperator(String operator); void setValue(Object value); boolean canBePrefixed(); void setCanBePrefixed(boolean canBePrefixed); @Override String toString(); @Override boolean equals(Object o); SearchType getType(); void setType(SearchType type); boolean isRemovable(); void setRemovable(boolean removable); static final String CRITERIA_IN; static final String CRITERIA_REGEX; static final String CRITERIA_GT; static final String CRITERIA_GTE; static final String CRITERIA_LT; static final String CRITERIA_LTE; static final String OPERATOR_EQUAL; static final String CRITERIA_EXISTS; }
|
@Test public void testGetAncestorsOfEdOrgWithCycle() { Entity sea = buildEntityType(SEA); Entity lea = buildEntityType(LEA); Entity school = buildEntityType(SCHOOL); school.getBody().put(PARENT_ED_ORG_REF, Arrays.asList(lea.getEntityId())); lea.getBody().put(PARENT_ED_ORG_REF, Arrays.asList(sea.getEntityId(), school.getEntityId())); sea.getBody().put(PARENT_ED_ORG_REF, Arrays.asList()); when(repo.findById(EntityNames.EDUCATION_ORGANIZATION, sea.getEntityId())).thenReturn(sea); when(repo.findById(EntityNames.EDUCATION_ORGANIZATION, lea.getEntityId())).thenReturn(lea); when(repo.findById(EntityNames.EDUCATION_ORGANIZATION, school.getEntityId())).thenReturn(school); Set<Entity> ancestors = underTest.getAncestorsOfEdOrg(school); assertNotNull(ancestors); assertTrue("LEA must be an ancestor", ancestors.contains(lea)); assertTrue("school should be contained in the results as well, per required behavior", ancestors.contains(school)); assertEquals("unexpected ancestors", 2, ancestors.size()); }
|
public Set<Entity> getAncestorsOfEdOrg(Entity entity) { if (isSEA(entity)) { return null; } Set<String> visitedIds = new HashSet<String>(); Set<Entity> ancestors = new HashSet<Entity>(); List<Entity> stack = new ArrayList<Entity>(10); ancestors.add(entity); stack.add(entity); while (!stack.isEmpty()) { Entity cur = stack.remove(stack.size() - 1); if (visitedIds.contains(cur.getEntityId())) { continue; } else { visitedIds.add(cur.getEntityId()); } if (cur.getBody().containsKey("parentEducationAgencyReference")) { List<Entity> parentEdOrgs = getParentEdOrg(cur); if (parentEdOrgs != null) { for (Entity parent:parentEdOrgs) { stack.add(parent); if (!isSEA(parent)) { ancestors.add(parent); } } } } } return ancestors; }
|
EdOrgHierarchyHelper { public Set<Entity> getAncestorsOfEdOrg(Entity entity) { if (isSEA(entity)) { return null; } Set<String> visitedIds = new HashSet<String>(); Set<Entity> ancestors = new HashSet<Entity>(); List<Entity> stack = new ArrayList<Entity>(10); ancestors.add(entity); stack.add(entity); while (!stack.isEmpty()) { Entity cur = stack.remove(stack.size() - 1); if (visitedIds.contains(cur.getEntityId())) { continue; } else { visitedIds.add(cur.getEntityId()); } if (cur.getBody().containsKey("parentEducationAgencyReference")) { List<Entity> parentEdOrgs = getParentEdOrg(cur); if (parentEdOrgs != null) { for (Entity parent:parentEdOrgs) { stack.add(parent); if (!isSEA(parent)) { ancestors.add(parent); } } } } } return ancestors; } }
|
EdOrgHierarchyHelper { public Set<Entity> getAncestorsOfEdOrg(Entity entity) { if (isSEA(entity)) { return null; } Set<String> visitedIds = new HashSet<String>(); Set<Entity> ancestors = new HashSet<Entity>(); List<Entity> stack = new ArrayList<Entity>(10); ancestors.add(entity); stack.add(entity); while (!stack.isEmpty()) { Entity cur = stack.remove(stack.size() - 1); if (visitedIds.contains(cur.getEntityId())) { continue; } else { visitedIds.add(cur.getEntityId()); } if (cur.getBody().containsKey("parentEducationAgencyReference")) { List<Entity> parentEdOrgs = getParentEdOrg(cur); if (parentEdOrgs != null) { for (Entity parent:parentEdOrgs) { stack.add(parent); if (!isSEA(parent)) { ancestors.add(parent); } } } } } return ancestors; } EdOrgHierarchyHelper(Repository<Entity> repo); }
|
EdOrgHierarchyHelper { public Set<Entity> getAncestorsOfEdOrg(Entity entity) { if (isSEA(entity)) { return null; } Set<String> visitedIds = new HashSet<String>(); Set<Entity> ancestors = new HashSet<Entity>(); List<Entity> stack = new ArrayList<Entity>(10); ancestors.add(entity); stack.add(entity); while (!stack.isEmpty()) { Entity cur = stack.remove(stack.size() - 1); if (visitedIds.contains(cur.getEntityId())) { continue; } else { visitedIds.add(cur.getEntityId()); } if (cur.getBody().containsKey("parentEducationAgencyReference")) { List<Entity> parentEdOrgs = getParentEdOrg(cur); if (parentEdOrgs != null) { for (Entity parent:parentEdOrgs) { stack.add(parent); if (!isSEA(parent)) { ancestors.add(parent); } } } } } return ancestors; } EdOrgHierarchyHelper(Repository<Entity> repo); boolean isSEA(Entity entity); boolean isLEA(Entity entity); boolean isSchool(Entity entity); List<Entity> getTopLEAOfEdOrg(Entity entity); Set<Entity> getAncestorsOfEdOrg(Entity entity); String getSEAOfEdOrg(Entity entity); Entity getSEA(); }
|
EdOrgHierarchyHelper { public Set<Entity> getAncestorsOfEdOrg(Entity entity) { if (isSEA(entity)) { return null; } Set<String> visitedIds = new HashSet<String>(); Set<Entity> ancestors = new HashSet<Entity>(); List<Entity> stack = new ArrayList<Entity>(10); ancestors.add(entity); stack.add(entity); while (!stack.isEmpty()) { Entity cur = stack.remove(stack.size() - 1); if (visitedIds.contains(cur.getEntityId())) { continue; } else { visitedIds.add(cur.getEntityId()); } if (cur.getBody().containsKey("parentEducationAgencyReference")) { List<Entity> parentEdOrgs = getParentEdOrg(cur); if (parentEdOrgs != null) { for (Entity parent:parentEdOrgs) { stack.add(parent); if (!isSEA(parent)) { ancestors.add(parent); } } } } } return ancestors; } EdOrgHierarchyHelper(Repository<Entity> repo); boolean isSEA(Entity entity); boolean isLEA(Entity entity); boolean isSchool(Entity entity); List<Entity> getTopLEAOfEdOrg(Entity entity); Set<Entity> getAncestorsOfEdOrg(Entity entity); String getSEAOfEdOrg(Entity entity); Entity getSEA(); }
|
@Test public void testValidTenant() { String tenantId = "Midgar"; Mockito.doNothing().when(localEdOrgExtractor).execute(Mockito.eq("tenant"), Mockito.any(File.class), Mockito.any(DateTime.class)); Mockito.when(bulkExtractMongoDA.getTenant(tenantId)).thenReturn(testTenantEntity); launcher.execute(tenantId, false); Mockito.verify(localEdOrgExtractor, Mockito.times(1)).execute(Mockito.eq(tenantId), Mockito.any(File.class), Mockito.any(DateTime.class)); }
|
public void execute(String tenant, boolean isDelta) { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_INFO, BEMessageCode.BE_SE_CODE_0001)); Entity tenantEntity = bulkExtractMongoDA.getTenant(tenant); if (tenantEntity != null) { DateTime startTime = new DateTime(); if (isDelta) { LOG.info("isDelta=true ... deltaExtractor.execute()"); deltaExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } else { LOG.info("isDelta=false ... localEdOrgExtractor.execute()"); edOrgExtractor.execute(tenant, getTenantDirectory(tenant), startTime); LOG.info("Starting public data extract..."); tenantPublicDataExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } } else { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_ERROR, BEMessageCode.BE_SE_CODE_0002, tenant)); LOG.error( "A bulk extract is not being initiated for the tenant {} because the tenant has not been onboarded.", tenant); } }
|
Launcher { public void execute(String tenant, boolean isDelta) { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_INFO, BEMessageCode.BE_SE_CODE_0001)); Entity tenantEntity = bulkExtractMongoDA.getTenant(tenant); if (tenantEntity != null) { DateTime startTime = new DateTime(); if (isDelta) { LOG.info("isDelta=true ... deltaExtractor.execute()"); deltaExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } else { LOG.info("isDelta=false ... localEdOrgExtractor.execute()"); edOrgExtractor.execute(tenant, getTenantDirectory(tenant), startTime); LOG.info("Starting public data extract..."); tenantPublicDataExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } } else { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_ERROR, BEMessageCode.BE_SE_CODE_0002, tenant)); LOG.error( "A bulk extract is not being initiated for the tenant {} because the tenant has not been onboarded.", tenant); } } }
|
Launcher { public void execute(String tenant, boolean isDelta) { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_INFO, BEMessageCode.BE_SE_CODE_0001)); Entity tenantEntity = bulkExtractMongoDA.getTenant(tenant); if (tenantEntity != null) { DateTime startTime = new DateTime(); if (isDelta) { LOG.info("isDelta=true ... deltaExtractor.execute()"); deltaExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } else { LOG.info("isDelta=false ... localEdOrgExtractor.execute()"); edOrgExtractor.execute(tenant, getTenantDirectory(tenant), startTime); LOG.info("Starting public data extract..."); tenantPublicDataExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } } else { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_ERROR, BEMessageCode.BE_SE_CODE_0002, tenant)); LOG.error( "A bulk extract is not being initiated for the tenant {} because the tenant has not been onboarded.", tenant); } } }
|
Launcher { public void execute(String tenant, boolean isDelta) { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_INFO, BEMessageCode.BE_SE_CODE_0001)); Entity tenantEntity = bulkExtractMongoDA.getTenant(tenant); if (tenantEntity != null) { DateTime startTime = new DateTime(); if (isDelta) { LOG.info("isDelta=true ... deltaExtractor.execute()"); deltaExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } else { LOG.info("isDelta=false ... localEdOrgExtractor.execute()"); edOrgExtractor.execute(tenant, getTenantDirectory(tenant), startTime); LOG.info("Starting public data extract..."); tenantPublicDataExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } } else { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_ERROR, BEMessageCode.BE_SE_CODE_0002, tenant)); LOG.error( "A bulk extract is not being initiated for the tenant {} because the tenant has not been onboarded.", tenant); } } void execute(String tenant, boolean isDelta); static String getTimeStamp(Date date); void setBaseDirectory(String baseDirectory); static void main(String[] args); void setEdOrgExtractor(EdOrgExtractor edOrgExtractor); EdOrgExtractor getEdOrgExtractor(); void setTenantPublicDataExtractor(TenantPublicDataExtractor tenantPublicDataExtractor); BulkExtractMongoDA getBulkExtractMongoDA(); void setBulkExtractMongoDA(BulkExtractMongoDA bulkExtractMongoDA); void setSecurityEventUtil(SecurityEventUtil securityEventUtil); }
|
Launcher { public void execute(String tenant, boolean isDelta) { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_INFO, BEMessageCode.BE_SE_CODE_0001)); Entity tenantEntity = bulkExtractMongoDA.getTenant(tenant); if (tenantEntity != null) { DateTime startTime = new DateTime(); if (isDelta) { LOG.info("isDelta=true ... deltaExtractor.execute()"); deltaExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } else { LOG.info("isDelta=false ... localEdOrgExtractor.execute()"); edOrgExtractor.execute(tenant, getTenantDirectory(tenant), startTime); LOG.info("Starting public data extract..."); tenantPublicDataExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } } else { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_ERROR, BEMessageCode.BE_SE_CODE_0002, tenant)); LOG.error( "A bulk extract is not being initiated for the tenant {} because the tenant has not been onboarded.", tenant); } } void execute(String tenant, boolean isDelta); static String getTimeStamp(Date date); void setBaseDirectory(String baseDirectory); static void main(String[] args); void setEdOrgExtractor(EdOrgExtractor edOrgExtractor); EdOrgExtractor getEdOrgExtractor(); void setTenantPublicDataExtractor(TenantPublicDataExtractor tenantPublicDataExtractor); BulkExtractMongoDA getBulkExtractMongoDA(); void setBulkExtractMongoDA(BulkExtractMongoDA bulkExtractMongoDA); void setSecurityEventUtil(SecurityEventUtil securityEventUtil); }
|
@Test public void educationOrganzationCollectionAlsoContainsSchools() { Set<String> types = resolver.resolveType("educationOrganization"); assertTrue(types.size() == 2); assertTrue(types.contains("school")); assertTrue(types.contains("educationOrganization")); types = resolver.resolveType("staff"); assertTrue(types.size() == 2); assertTrue(types.contains("teacher")); assertTrue(types.contains("staff")); types = resolver.resolveType("non-existance"); assertTrue(types.size() == 1); }
|
public Set<String> resolveType(String type) { if (typeMaps.containsKey(type)) { return typeMaps.get(type); } return new HashSet<String>(Arrays.asList(type)); }
|
TypeResolver { public Set<String> resolveType(String type) { if (typeMaps.containsKey(type)) { return typeMaps.get(type); } return new HashSet<String>(Arrays.asList(type)); } }
|
TypeResolver { public Set<String> resolveType(String type) { if (typeMaps.containsKey(type)) { return typeMaps.get(type); } return new HashSet<String>(Arrays.asList(type)); } }
|
TypeResolver { public Set<String> resolveType(String type) { if (typeMaps.containsKey(type)) { return typeMaps.get(type); } return new HashSet<String>(Arrays.asList(type)); } Set<String> resolveType(String type); }
|
TypeResolver { public Set<String> resolveType(String type) { if (typeMaps.containsKey(type)) { return typeMaps.get(type); } return new HashSet<String>(Arrays.asList(type)); } Set<String> resolveType(String type); }
|
@Test public void test() { assertNull(factory.getResolver("doesn't exist")); ContextResolver resolver = factory.getResolver("educationOrganization"); assertTrue(resolver instanceof SimpleEntityTypeContextResolver); }
|
public ContextResolver getResolver(String entityType) { return resolverMap.get(entityType); }
|
EdOrgContextResolverFactory { public ContextResolver getResolver(String entityType) { return resolverMap.get(entityType); } }
|
EdOrgContextResolverFactory { public ContextResolver getResolver(String entityType) { return resolverMap.get(entityType); } }
|
EdOrgContextResolverFactory { public ContextResolver getResolver(String entityType) { return resolverMap.get(entityType); } ContextResolver getResolver(String entityType); }
|
EdOrgContextResolverFactory { public ContextResolver getResolver(String entityType) { return resolverMap.get(entityType); } ContextResolver getResolver(String entityType); }
|
@SuppressWarnings("unchecked") @Test public void testMapTenantAndIdKey() throws Exception { String[] fields = { "metaData.tenantId", "data.element.id" }; BSONObject elem = new BasicBSONObject("value", 7632); BSONObject data = new BasicBSONObject("element", elem); BSONObject entry = new BasicBSONObject("data", data); final BSONWritable entity = new BSONWritable(entry); BSONObject tenantId = new BasicBSONObject("EdOrgs", "Midtown"); entity.put("metaData", tenantId); IDMapper<TenantAndIdEmittableKey> mapper = new IDMapper<TenantAndIdEmittableKey>(); IDMapper<TenantAndIdEmittableKey>.Context context = Mockito.mock(IDMapper.Context.class); PowerMockito.when(context, "write", Matchers.any(EmittableKey.class), Matchers.any(BSONObject.class)).thenAnswer(new Answer<BSONObject>() { @Override public BSONObject answer(InvocationOnMock invocation) throws Throwable { Object[] args = invocation.getArguments(); assertNotNull(args); assertEquals(args.length, 2); assertTrue(args[0] instanceof TenantAndIdEmittableKey); assertTrue(args[1] instanceof BSONObject); TenantAndIdEmittableKey id = (TenantAndIdEmittableKey) args[0]; assertEquals(id.getIdField().toString(), "data.element.id"); Text idValue = id.getId(); assertEquals(Long.parseLong(idValue.toString()), 90210); assertEquals(id.getTenantIdField().toString(), "metaData.tenantId"); idValue = id.getTenantId(); assertEquals(idValue.toString(), "Midgar"); BSONObject e = (BSONObject) args[1]; assertEquals(e, entity); return null; } }); TenantAndIdEmittableKey id = new TenantAndIdEmittableKey(); id.setFieldNames(fields); id.setTenantId(new Text("Midgar")); id.setId(new Text("90210")); mapper.map(id, entity, context); }
|
@Override public void map(T id, BSONWritable entity, Context context) throws IOException, InterruptedException { for (String field : idFields.values()) { BSONUtilities.removeField(entity, field); } context.write(id, entity); }
|
IDMapper extends Mapper<T, BSONWritable, T, BSONWritable> { @Override public void map(T id, BSONWritable entity, Context context) throws IOException, InterruptedException { for (String field : idFields.values()) { BSONUtilities.removeField(entity, field); } context.write(id, entity); } }
|
IDMapper extends Mapper<T, BSONWritable, T, BSONWritable> { @Override public void map(T id, BSONWritable entity, Context context) throws IOException, InterruptedException { for (String field : idFields.values()) { BSONUtilities.removeField(entity, field); } context.write(id, entity); } }
|
IDMapper extends Mapper<T, BSONWritable, T, BSONWritable> { @Override public void map(T id, BSONWritable entity, Context context) throws IOException, InterruptedException { for (String field : idFields.values()) { BSONUtilities.removeField(entity, field); } context.write(id, entity); } @Override void map(T id, BSONWritable entity, Context context); }
|
IDMapper extends Mapper<T, BSONWritable, T, BSONWritable> { @Override public void map(T id, BSONWritable entity, Context context) throws IOException, InterruptedException { for (String field : idFields.values()) { BSONUtilities.removeField(entity, field); } context.write(id, entity); } @Override void map(T id, BSONWritable entity, Context context); }
|
@Test public void testStudentParent() { assertTrue(factory.getResolver("studentParentAssociation") instanceof StudentDirectRelatedContextResolver); }
|
public ContextResolver getResolver(String entityType) { return resolverMap.get(entityType); }
|
EdOrgContextResolverFactory { public ContextResolver getResolver(String entityType) { return resolverMap.get(entityType); } }
|
EdOrgContextResolverFactory { public ContextResolver getResolver(String entityType) { return resolverMap.get(entityType); } }
|
EdOrgContextResolverFactory { public ContextResolver getResolver(String entityType) { return resolverMap.get(entityType); } ContextResolver getResolver(String entityType); }
|
EdOrgContextResolverFactory { public ContextResolver getResolver(String entityType) { return resolverMap.get(entityType); } ContextResolver getResolver(String entityType); }
|
@Test public void canResolveTeacherAndStaffRelatedEntities() { assertEquals(ParameterConstants.TEACHER_ID, resolver.getReferenceProperty(EntityNames.TEACHER_SCHOOL_ASSOCIATION)); assertEquals(ParameterConstants.TEACHER_ID, resolver.getReferenceProperty(EntityNames.TEACHER_SECTION_ASSOCIATION)); assertEquals(ParameterConstants.STAFF_REFERENCE, resolver.getReferenceProperty(EntityNames.STAFF_ED_ORG_ASSOCIATION)); assertEquals(ParameterConstants.STAFF_ID, resolver.getReferenceProperty(EntityNames.STAFF_COHORT_ASSOCIATION)); assertEquals(ParameterConstants.STAFF_ID, resolver.getReferenceProperty(EntityNames.STAFF_PROGRAM_ASSOCIATION)); assertEquals(null, resolver.getReferenceProperty(EntityNames.STAFF)); assertEquals(null, resolver.getReferenceProperty(EntityNames.TEACHER)); }
|
@Override protected String getReferenceProperty(String entityType) { if (EntityNames.TEACHER_SCHOOL_ASSOCIATION.equals(entityType) || EntityNames.TEACHER_SECTION_ASSOCIATION.equals(entityType)) { return ParameterConstants.TEACHER_ID; } if (EntityNames.STAFF_ED_ORG_ASSOCIATION.equals(entityType)) { return ParameterConstants.STAFF_REFERENCE; } if (EntityNames.STAFF_COHORT_ASSOCIATION.equals(entityType) || EntityNames.STAFF_PROGRAM_ASSOCIATION.equals(entityType)) { return ParameterConstants.STAFF_ID; } return null; }
|
StaffTeacherDirectRelatedContextResolver extends RelatedContextResolver { @Override protected String getReferenceProperty(String entityType) { if (EntityNames.TEACHER_SCHOOL_ASSOCIATION.equals(entityType) || EntityNames.TEACHER_SECTION_ASSOCIATION.equals(entityType)) { return ParameterConstants.TEACHER_ID; } if (EntityNames.STAFF_ED_ORG_ASSOCIATION.equals(entityType)) { return ParameterConstants.STAFF_REFERENCE; } if (EntityNames.STAFF_COHORT_ASSOCIATION.equals(entityType) || EntityNames.STAFF_PROGRAM_ASSOCIATION.equals(entityType)) { return ParameterConstants.STAFF_ID; } return null; } }
|
StaffTeacherDirectRelatedContextResolver extends RelatedContextResolver { @Override protected String getReferenceProperty(String entityType) { if (EntityNames.TEACHER_SCHOOL_ASSOCIATION.equals(entityType) || EntityNames.TEACHER_SECTION_ASSOCIATION.equals(entityType)) { return ParameterConstants.TEACHER_ID; } if (EntityNames.STAFF_ED_ORG_ASSOCIATION.equals(entityType)) { return ParameterConstants.STAFF_REFERENCE; } if (EntityNames.STAFF_COHORT_ASSOCIATION.equals(entityType) || EntityNames.STAFF_PROGRAM_ASSOCIATION.equals(entityType)) { return ParameterConstants.STAFF_ID; } return null; } }
|
StaffTeacherDirectRelatedContextResolver extends RelatedContextResolver { @Override protected String getReferenceProperty(String entityType) { if (EntityNames.TEACHER_SCHOOL_ASSOCIATION.equals(entityType) || EntityNames.TEACHER_SECTION_ASSOCIATION.equals(entityType)) { return ParameterConstants.TEACHER_ID; } if (EntityNames.STAFF_ED_ORG_ASSOCIATION.equals(entityType)) { return ParameterConstants.STAFF_REFERENCE; } if (EntityNames.STAFF_COHORT_ASSOCIATION.equals(entityType) || EntityNames.STAFF_PROGRAM_ASSOCIATION.equals(entityType)) { return ParameterConstants.STAFF_ID; } return null; } }
|
StaffTeacherDirectRelatedContextResolver extends RelatedContextResolver { @Override protected String getReferenceProperty(String entityType) { if (EntityNames.TEACHER_SCHOOL_ASSOCIATION.equals(entityType) || EntityNames.TEACHER_SECTION_ASSOCIATION.equals(entityType)) { return ParameterConstants.TEACHER_ID; } if (EntityNames.STAFF_ED_ORG_ASSOCIATION.equals(entityType)) { return ParameterConstants.STAFF_REFERENCE; } if (EntityNames.STAFF_COHORT_ASSOCIATION.equals(entityType) || EntityNames.STAFF_PROGRAM_ASSOCIATION.equals(entityType)) { return ParameterConstants.STAFF_ID; } return null; } }
|
@Test public void noStudentSectionAssociation() { Entity studentCompetency = buildStudentCompetency(); when(repo.findById(EntityNames.STUDENT_SECTION_ASSOCIATION, "association123")).thenReturn(null); assertEquals(Collections.<String> emptySet(), underTest.findGoverningEdOrgs(studentCompetency)); }
|
@Override public Set<String> findGoverningEdOrgs(Entity entity) { if (entity == null) { return Collections.emptySet(); } String studentSectionAssociationId = (String) entity.getBody().get(ParameterConstants.STUDENT_SECTION_ASSOCIATION_ID); Entity studentSectionAssociation = repo.findById(EntityNames.STUDENT_SECTION_ASSOCIATION, studentSectionAssociationId); if (studentSectionAssociation == null) { return Collections.emptySet(); } String studentId = (String) studentSectionAssociation.getBody().get(ParameterConstants.STUDENT_ID); return studentResolver.findGoverningEdOrgs(studentId, entity); }
|
StudentCompetencyContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { if (entity == null) { return Collections.emptySet(); } String studentSectionAssociationId = (String) entity.getBody().get(ParameterConstants.STUDENT_SECTION_ASSOCIATION_ID); Entity studentSectionAssociation = repo.findById(EntityNames.STUDENT_SECTION_ASSOCIATION, studentSectionAssociationId); if (studentSectionAssociation == null) { return Collections.emptySet(); } String studentId = (String) studentSectionAssociation.getBody().get(ParameterConstants.STUDENT_ID); return studentResolver.findGoverningEdOrgs(studentId, entity); } }
|
StudentCompetencyContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { if (entity == null) { return Collections.emptySet(); } String studentSectionAssociationId = (String) entity.getBody().get(ParameterConstants.STUDENT_SECTION_ASSOCIATION_ID); Entity studentSectionAssociation = repo.findById(EntityNames.STUDENT_SECTION_ASSOCIATION, studentSectionAssociationId); if (studentSectionAssociation == null) { return Collections.emptySet(); } String studentId = (String) studentSectionAssociation.getBody().get(ParameterConstants.STUDENT_ID); return studentResolver.findGoverningEdOrgs(studentId, entity); } }
|
StudentCompetencyContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { if (entity == null) { return Collections.emptySet(); } String studentSectionAssociationId = (String) entity.getBody().get(ParameterConstants.STUDENT_SECTION_ASSOCIATION_ID); Entity studentSectionAssociation = repo.findById(EntityNames.STUDENT_SECTION_ASSOCIATION, studentSectionAssociationId); if (studentSectionAssociation == null) { return Collections.emptySet(); } String studentId = (String) studentSectionAssociation.getBody().get(ParameterConstants.STUDENT_ID); return studentResolver.findGoverningEdOrgs(studentId, entity); } @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
StudentCompetencyContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { if (entity == null) { return Collections.emptySet(); } String studentSectionAssociationId = (String) entity.getBody().get(ParameterConstants.STUDENT_SECTION_ASSOCIATION_ID); Entity studentSectionAssociation = repo.findById(EntityNames.STUDENT_SECTION_ASSOCIATION, studentSectionAssociationId); if (studentSectionAssociation == null) { return Collections.emptySet(); } String studentId = (String) studentSectionAssociation.getBody().get(ParameterConstants.STUDENT_ID); return studentResolver.findGoverningEdOrgs(studentId, entity); } @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
@Test public void shouldFollowStudent() { Entity studentCompetency = buildStudentCompetency(); when(repo.findById(EntityNames.STUDENT_SECTION_ASSOCIATION, "association123")).thenReturn(buildStudentSectionAssociation()); Set<String> topLeas = new HashSet<String>(Arrays.asList("lea1", "lea2")); when(studentResolver.findGoverningEdOrgs("student123", studentCompetency)).thenReturn(topLeas); assertEquals(topLeas, underTest.findGoverningEdOrgs(studentCompetency)); }
|
@Override public Set<String> findGoverningEdOrgs(Entity entity) { if (entity == null) { return Collections.emptySet(); } String studentSectionAssociationId = (String) entity.getBody().get(ParameterConstants.STUDENT_SECTION_ASSOCIATION_ID); Entity studentSectionAssociation = repo.findById(EntityNames.STUDENT_SECTION_ASSOCIATION, studentSectionAssociationId); if (studentSectionAssociation == null) { return Collections.emptySet(); } String studentId = (String) studentSectionAssociation.getBody().get(ParameterConstants.STUDENT_ID); return studentResolver.findGoverningEdOrgs(studentId, entity); }
|
StudentCompetencyContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { if (entity == null) { return Collections.emptySet(); } String studentSectionAssociationId = (String) entity.getBody().get(ParameterConstants.STUDENT_SECTION_ASSOCIATION_ID); Entity studentSectionAssociation = repo.findById(EntityNames.STUDENT_SECTION_ASSOCIATION, studentSectionAssociationId); if (studentSectionAssociation == null) { return Collections.emptySet(); } String studentId = (String) studentSectionAssociation.getBody().get(ParameterConstants.STUDENT_ID); return studentResolver.findGoverningEdOrgs(studentId, entity); } }
|
StudentCompetencyContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { if (entity == null) { return Collections.emptySet(); } String studentSectionAssociationId = (String) entity.getBody().get(ParameterConstants.STUDENT_SECTION_ASSOCIATION_ID); Entity studentSectionAssociation = repo.findById(EntityNames.STUDENT_SECTION_ASSOCIATION, studentSectionAssociationId); if (studentSectionAssociation == null) { return Collections.emptySet(); } String studentId = (String) studentSectionAssociation.getBody().get(ParameterConstants.STUDENT_ID); return studentResolver.findGoverningEdOrgs(studentId, entity); } }
|
StudentCompetencyContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { if (entity == null) { return Collections.emptySet(); } String studentSectionAssociationId = (String) entity.getBody().get(ParameterConstants.STUDENT_SECTION_ASSOCIATION_ID); Entity studentSectionAssociation = repo.findById(EntityNames.STUDENT_SECTION_ASSOCIATION, studentSectionAssociationId); if (studentSectionAssociation == null) { return Collections.emptySet(); } String studentId = (String) studentSectionAssociation.getBody().get(ParameterConstants.STUDENT_ID); return studentResolver.findGoverningEdOrgs(studentId, entity); } @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
StudentCompetencyContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { if (entity == null) { return Collections.emptySet(); } String studentSectionAssociationId = (String) entity.getBody().get(ParameterConstants.STUDENT_SECTION_ASSOCIATION_ID); Entity studentSectionAssociation = repo.findById(EntityNames.STUDENT_SECTION_ASSOCIATION, studentSectionAssociationId); if (studentSectionAssociation == null) { return Collections.emptySet(); } String studentId = (String) studentSectionAssociation.getBody().get(ParameterConstants.STUDENT_ID); return studentResolver.findGoverningEdOrgs(studentId, entity); } @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
@Test public void returnEmptySetIfNoStudent() { Entity courseTranscript = buildCourseTranscript(); courseTranscript.getBody().remove(STUDENT_ID); courseTranscript.getBody().remove(STUDENT_ACADEMIC_RECORD_ID); assertEquals(Collections.emptySet(), underTest.findGoverningEdOrgs(courseTranscript)); }
|
@Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; }
|
CourseTranscriptContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; } }
|
CourseTranscriptContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; } }
|
CourseTranscriptContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
CourseTranscriptContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); static final String ED_ORG_REFERENCE; static final String STUDENT_ACADEMIC_RECORD_ID; static final String STUDENT_ID; }
|
@Test public void followStudentId() { Entity courseTranscript = buildCourseTranscript(); when(studentResolver.findGoverningEdOrgs("student1", courseTranscript)).thenReturn(new HashSet<String>(Arrays.asList("toplea2"))); assertEquals(new HashSet<String>(Arrays.asList("toplea2")), underTest.findGoverningEdOrgs(courseTranscript)); }
|
@Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; }
|
CourseTranscriptContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; } }
|
CourseTranscriptContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; } }
|
CourseTranscriptContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
CourseTranscriptContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); static final String ED_ORG_REFERENCE; static final String STUDENT_ACADEMIC_RECORD_ID; static final String STUDENT_ID; }
|
@Test public void noStudentIdFollowAcademicRecord() { Entity courseTranscript = buildCourseTranscript(); courseTranscript.getBody().remove(STUDENT_ID); when(studentResolver.findGoverningEdOrgs("student1", courseTranscript)).thenReturn(new HashSet<String>(Arrays.asList("toplea2"))); assertEquals(new HashSet<String>(Arrays.asList("toplea2")), underTest.findGoverningEdOrgs(courseTranscript)); }
|
@Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; }
|
CourseTranscriptContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; } }
|
CourseTranscriptContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; } }
|
CourseTranscriptContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
CourseTranscriptContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); static final String ED_ORG_REFERENCE; static final String STUDENT_ACADEMIC_RECORD_ID; static final String STUDENT_ID; }
|
@Test public void testDifferentEdOrgs() { Entity courseTranscript = buildCourseTranscript(); Entity studentAcademicRecord = buildStudentAcademicRecord(); studentAcademicRecord.getBody().put(STUDENT_ID, "student2"); when(repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, "studentacademicrecord1")).thenReturn(studentAcademicRecord); when(studentResolver.findGoverningEdOrgs("student1", courseTranscript)).thenReturn(new HashSet<String>(Arrays.asList("edOrg1"))); when(studentResolver.findGoverningEdOrgs("student2", courseTranscript)).thenReturn(new HashSet<String>(Arrays.asList("edOrg2"))); assertEquals(new HashSet<String>(Arrays.asList("edOrg1", "edOrg2")), underTest.findGoverningEdOrgs(courseTranscript)); }
|
@Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; }
|
CourseTranscriptContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; } }
|
CourseTranscriptContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; } }
|
CourseTranscriptContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
CourseTranscriptContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); static final String ED_ORG_REFERENCE; static final String STUDENT_ACADEMIC_RECORD_ID; static final String STUDENT_ID; }
|
@Test public void test() { Entity gradebookEntry = Mockito.mock(Entity.class); Mockito.when(gradebookEntry.getEntityId()).thenReturn("123_id"); Mockito.when(gradebookEntry.getType()).thenReturn(EntityNames.GRADEBOOK_ENTRY); Entity sgbe1 = Mockito.mock(Entity.class); Map<String, Object> body1 = new HashMap<String, Object>(); body1.put(ParameterConstants.STUDENT_ID, "student1"); Mockito.when(sgbe1.getBody()).thenReturn(body1); Entity sgbe2 = Mockito.mock(Entity.class); Map<String, Object> body2 = new HashMap<String, Object>(); body2.put(ParameterConstants.STUDENT_ID, "student2"); Mockito.when(sgbe2.getBody()).thenReturn(body2); Mockito.when(repo.findEach(eq(EntityNames.STUDENT_GRADEBOOK_ENTRY), argThat(new BaseMatcher<Query>() { @Override public boolean matches(Object item) { Query q = (Query) item; return q.getQueryObject().get("body.gradebookEntryId").equals("123_id"); } @Override public void describeTo(Description description) { } }))).thenReturn(Arrays.asList(sgbe1, sgbe2).iterator()); Mockito.when(studentResolver.findGoverningEdOrgs("student1", gradebookEntry)).thenReturn(new HashSet<String>(Arrays.asList("lea1", "lea2"))); Mockito.when(studentResolver.findGoverningEdOrgs("student2", gradebookEntry)).thenReturn(new HashSet<String>(Arrays.asList("lea1", "lea3"))); Assert.assertEquals(new HashSet<String>(Arrays.asList("lea1", "lea2", "lea3")), resolver.findGoverningEdOrgs(gradebookEntry)); }
|
@Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> studentGradebookEntries = repo.findEach(EntityNames.STUDENT_GRADEBOOK_ENTRY, Query.query(Criteria.where("body.gradebookEntryId").is(entity.getEntityId()))); while(studentGradebookEntries.hasNext()) { Entity studentGradebookEntry = studentGradebookEntries.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentGradebookEntry.getBody().get(ParameterConstants.STUDENT_ID), entity)); } return edOrgs; }
|
GradebookEntryContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> studentGradebookEntries = repo.findEach(EntityNames.STUDENT_GRADEBOOK_ENTRY, Query.query(Criteria.where("body.gradebookEntryId").is(entity.getEntityId()))); while(studentGradebookEntries.hasNext()) { Entity studentGradebookEntry = studentGradebookEntries.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentGradebookEntry.getBody().get(ParameterConstants.STUDENT_ID), entity)); } return edOrgs; } }
|
GradebookEntryContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> studentGradebookEntries = repo.findEach(EntityNames.STUDENT_GRADEBOOK_ENTRY, Query.query(Criteria.where("body.gradebookEntryId").is(entity.getEntityId()))); while(studentGradebookEntries.hasNext()) { Entity studentGradebookEntry = studentGradebookEntries.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentGradebookEntry.getBody().get(ParameterConstants.STUDENT_ID), entity)); } return edOrgs; } }
|
GradebookEntryContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> studentGradebookEntries = repo.findEach(EntityNames.STUDENT_GRADEBOOK_ENTRY, Query.query(Criteria.where("body.gradebookEntryId").is(entity.getEntityId()))); while(studentGradebookEntries.hasNext()) { Entity studentGradebookEntry = studentGradebookEntries.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentGradebookEntry.getBody().get(ParameterConstants.STUDENT_ID), entity)); } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
GradebookEntryContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> studentGradebookEntries = repo.findEach(EntityNames.STUDENT_GRADEBOOK_ENTRY, Query.query(Criteria.where("body.gradebookEntryId").is(entity.getEntityId()))); while(studentGradebookEntries.hasNext()) { Entity studentGradebookEntry = studentGradebookEntries.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentGradebookEntry.getBody().get(ParameterConstants.STUDENT_ID), entity)); } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
@Test public void test() { Entity parent = mock(Entity.class); Entity kid1 = mock(Entity.class); when(kid1.getEntityId()).thenReturn("kid1"); Entity kid2 = mock(Entity.class); when(kid2.getEntityId()).thenReturn("kid2"); when(parent.getEntityId()).thenReturn("parentId"); when(repo.findEach(eq("student"), argThat(new BaseMatcher<Query>() { @Override public boolean matches(Object item) { Query q = (Query) item; return q.getQueryObject().get("studentParentAssociation.body.parentId").equals("parentId"); } @Override public void describeTo(Description description) { } }))).thenReturn(Arrays.asList(kid1, kid2).iterator()); when(studentResolver.findGoverningEdOrgs("kid1", parent)).thenReturn(new HashSet<String>(Arrays.asList("lea1", "lea2"))); when(studentResolver.findGoverningEdOrgs("kid2", parent)).thenReturn(new HashSet<String>(Arrays.asList("lea1", "lea3"))); assertEquals(new HashSet<String>(Arrays.asList("lea1", "lea2", "lea3")), underTest.findGoverningEdOrgs(parent)); }
|
@Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> leas = new HashSet<String>(); Iterator<Entity> kids = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(PATH_TO_PARENT).is(entity.getEntityId()))); while(kids.hasNext()) { Entity student = kids.next(); leas.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return leas; }
|
ParentContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> leas = new HashSet<String>(); Iterator<Entity> kids = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(PATH_TO_PARENT).is(entity.getEntityId()))); while(kids.hasNext()) { Entity student = kids.next(); leas.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return leas; } }
|
ParentContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> leas = new HashSet<String>(); Iterator<Entity> kids = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(PATH_TO_PARENT).is(entity.getEntityId()))); while(kids.hasNext()) { Entity student = kids.next(); leas.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return leas; } }
|
ParentContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> leas = new HashSet<String>(); Iterator<Entity> kids = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(PATH_TO_PARENT).is(entity.getEntityId()))); while(kids.hasNext()) { Entity student = kids.next(); leas.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return leas; } @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
ParentContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> leas = new HashSet<String>(); Iterator<Entity> kids = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(PATH_TO_PARENT).is(entity.getEntityId()))); while(kids.hasNext()) { Entity student = kids.next(); leas.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return leas; } @Override Set<String> findGoverningEdOrgs(Entity entity); static final String PATH_TO_PARENT; }
|
@Test public void testGetValue() { BSONObject field = new BasicBSONObject("field", 123L); BSONObject entry = new BasicBSONObject("long", field); BSONWritable entity = new BSONWritable(entry); LongValueMapper mapper = new LongValueMapper("long.field"); Writable value = mapper.getValue(entity); assertFalse(value instanceof NullWritable); assertTrue(value instanceof LongWritable); assertEquals(((LongWritable) value).get(), 123L); }
|
@Override public Writable getValue(BSONWritable entity) { Writable rval = NullWritable.get(); String value = null; try { value = BSONUtilities.getValue(entity, fieldName); if (value != null) { rval = new LongWritable(Long.parseLong(value.toString())); } } catch (NumberFormatException e) { log.severe(String.format("Failed to convert value {'%s'} to Long", value)); } return rval; }
|
LongValueMapper extends ValueMapper { @Override public Writable getValue(BSONWritable entity) { Writable rval = NullWritable.get(); String value = null; try { value = BSONUtilities.getValue(entity, fieldName); if (value != null) { rval = new LongWritable(Long.parseLong(value.toString())); } } catch (NumberFormatException e) { log.severe(String.format("Failed to convert value {'%s'} to Long", value)); } return rval; } }
|
LongValueMapper extends ValueMapper { @Override public Writable getValue(BSONWritable entity) { Writable rval = NullWritable.get(); String value = null; try { value = BSONUtilities.getValue(entity, fieldName); if (value != null) { rval = new LongWritable(Long.parseLong(value.toString())); } } catch (NumberFormatException e) { log.severe(String.format("Failed to convert value {'%s'} to Long", value)); } return rval; } LongValueMapper(String fieldName); }
|
LongValueMapper extends ValueMapper { @Override public Writable getValue(BSONWritable entity) { Writable rval = NullWritable.get(); String value = null; try { value = BSONUtilities.getValue(entity, fieldName); if (value != null) { rval = new LongWritable(Long.parseLong(value.toString())); } } catch (NumberFormatException e) { log.severe(String.format("Failed to convert value {'%s'} to Long", value)); } return rval; } LongValueMapper(String fieldName); @Override Writable getValue(BSONWritable entity); }
|
LongValueMapper extends ValueMapper { @Override public Writable getValue(BSONWritable entity) { Writable rval = NullWritable.get(); String value = null; try { value = BSONUtilities.getValue(entity, fieldName); if (value != null) { rval = new LongWritable(Long.parseLong(value.toString())); } } catch (NumberFormatException e) { log.severe(String.format("Failed to convert value {'%s'} to Long", value)); } return rval; } LongValueMapper(String fieldName); @Override Writable getValue(BSONWritable entity); }
|
@Test public void testfindGoverningEdOrgs() { Mockito.when(mockEntity.getType()).thenReturn(EntityNames.TEACHER_SCHOOL_ASSOCIATION); Mockito.when(mockEntity.getBody()).thenReturn(body); Set<String> edOrgs = new HashSet<String>(Arrays.asList("springfieldElementary", "springfieldHigh")); Mockito.when(staffTeacherResolver.findGoverningEdOrgs(Mockito.eq(REFERRED_ID), Mockito.eq(mockEntity))).thenReturn(edOrgs); assertTrue(resolver.findGoverningEdOrgs(mockEntity).equals(edOrgs)); }
|
@Override public Set<String> findGoverningEdOrgs(Entity entity) { if (entity.getBody() == null) { return Collections.emptySet(); } String referredId = getReferredId(entity.getType(), entity.getBody()); if (referredId == null) { return Collections.emptySet(); } return getReferredResolver().findGoverningEdOrgs(referredId, entity); }
|
RelatedContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { if (entity.getBody() == null) { return Collections.emptySet(); } String referredId = getReferredId(entity.getType(), entity.getBody()); if (referredId == null) { return Collections.emptySet(); } return getReferredResolver().findGoverningEdOrgs(referredId, entity); } }
|
RelatedContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { if (entity.getBody() == null) { return Collections.emptySet(); } String referredId = getReferredId(entity.getType(), entity.getBody()); if (referredId == null) { return Collections.emptySet(); } return getReferredResolver().findGoverningEdOrgs(referredId, entity); } RelatedContextResolver(); }
|
RelatedContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { if (entity.getBody() == null) { return Collections.emptySet(); } String referredId = getReferredId(entity.getType(), entity.getBody()); if (referredId == null) { return Collections.emptySet(); } return getReferredResolver().findGoverningEdOrgs(referredId, entity); } RelatedContextResolver(); @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
RelatedContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { if (entity.getBody() == null) { return Collections.emptySet(); } String referredId = getReferredId(entity.getType(), entity.getBody()); if (referredId == null) { return Collections.emptySet(); } return getReferredResolver().findGoverningEdOrgs(referredId, entity); } RelatedContextResolver(); @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
@Test public void testgetReferredId() { assertTrue(resolver.getReferredId(EntityNames.TEACHER_SCHOOL_ASSOCIATION, body).equals(REFERRED_ID)); }
|
protected String getReferredId(String type, Map<String, Object> body) { String reference = getReferenceProperty(type); if (reference == null) { return null; } String referredId = (String) body.get(reference); return referredId; }
|
RelatedContextResolver implements ContextResolver { protected String getReferredId(String type, Map<String, Object> body) { String reference = getReferenceProperty(type); if (reference == null) { return null; } String referredId = (String) body.get(reference); return referredId; } }
|
RelatedContextResolver implements ContextResolver { protected String getReferredId(String type, Map<String, Object> body) { String reference = getReferenceProperty(type); if (reference == null) { return null; } String referredId = (String) body.get(reference); return referredId; } RelatedContextResolver(); }
|
RelatedContextResolver implements ContextResolver { protected String getReferredId(String type, Map<String, Object> body) { String reference = getReferenceProperty(type); if (reference == null) { return null; } String referredId = (String) body.get(reference); return referredId; } RelatedContextResolver(); @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
RelatedContextResolver implements ContextResolver { protected String getReferredId(String type, Map<String, Object> body) { String reference = getReferenceProperty(type); if (reference == null) { return null; } String referredId = (String) body.get(reference); return referredId; } RelatedContextResolver(); @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
@Test public void testSingleStudent() { setFindEachReturn(Arrays.asList(student1)); Assert.assertEquals(new HashSet<String>(Arrays.asList("school1")), resolver.findGoverningEdOrgs(disciplineIncident)); }
|
@Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> students = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(DISCIPLINE_INCIDENT_ID).is(entity.getEntityId()))); while (students.hasNext()) { Entity student = students.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return edOrgs; }
|
DisciplineIncidentContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> students = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(DISCIPLINE_INCIDENT_ID).is(entity.getEntityId()))); while (students.hasNext()) { Entity student = students.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return edOrgs; } }
|
DisciplineIncidentContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> students = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(DISCIPLINE_INCIDENT_ID).is(entity.getEntityId()))); while (students.hasNext()) { Entity student = students.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return edOrgs; } }
|
DisciplineIncidentContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> students = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(DISCIPLINE_INCIDENT_ID).is(entity.getEntityId()))); while (students.hasNext()) { Entity student = students.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
DisciplineIncidentContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> students = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(DISCIPLINE_INCIDENT_ID).is(entity.getEntityId()))); while (students.hasNext()) { Entity student = students.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); static final String DISCIPLINE_INCIDENT_ID; }
|
@Test public void testMultipleStudents() { setFindEachReturn(Arrays.asList(student1, student2, student3)); Assert.assertEquals(new HashSet<String>(Arrays.asList("school1", "school2", "school3")), resolver.findGoverningEdOrgs(disciplineIncident)); }
|
@Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> students = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(DISCIPLINE_INCIDENT_ID).is(entity.getEntityId()))); while (students.hasNext()) { Entity student = students.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return edOrgs; }
|
DisciplineIncidentContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> students = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(DISCIPLINE_INCIDENT_ID).is(entity.getEntityId()))); while (students.hasNext()) { Entity student = students.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return edOrgs; } }
|
DisciplineIncidentContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> students = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(DISCIPLINE_INCIDENT_ID).is(entity.getEntityId()))); while (students.hasNext()) { Entity student = students.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return edOrgs; } }
|
DisciplineIncidentContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> students = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(DISCIPLINE_INCIDENT_ID).is(entity.getEntityId()))); while (students.hasNext()) { Entity student = students.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
DisciplineIncidentContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> students = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(DISCIPLINE_INCIDENT_ID).is(entity.getEntityId()))); while (students.hasNext()) { Entity student = students.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); static final String DISCIPLINE_INCIDENT_ID; }
|
@Test public void testNoStudentDIAssociation() { setFindEachReturn(Arrays.asList(student4)); Assert.assertTrue(resolver.findGoverningEdOrgs(disciplineIncident).isEmpty()); }
|
@Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> students = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(DISCIPLINE_INCIDENT_ID).is(entity.getEntityId()))); while (students.hasNext()) { Entity student = students.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return edOrgs; }
|
DisciplineIncidentContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> students = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(DISCIPLINE_INCIDENT_ID).is(entity.getEntityId()))); while (students.hasNext()) { Entity student = students.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return edOrgs; } }
|
DisciplineIncidentContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> students = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(DISCIPLINE_INCIDENT_ID).is(entity.getEntityId()))); while (students.hasNext()) { Entity student = students.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return edOrgs; } }
|
DisciplineIncidentContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> students = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(DISCIPLINE_INCIDENT_ID).is(entity.getEntityId()))); while (students.hasNext()) { Entity student = students.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
DisciplineIncidentContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> students = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(DISCIPLINE_INCIDENT_ID).is(entity.getEntityId()))); while (students.hasNext()) { Entity student = students.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); static final String DISCIPLINE_INCIDENT_ID; }
|
@Test public void testSingleStudent() { Entity disciplineAction = Mockito.mock(Entity.class); Map<String, Object> body = new HashMap<String, Object>(); body.put(ParameterConstants.STUDENT_ID, Arrays.asList("student1")); Mockito.when(disciplineAction.getBody()).thenReturn(body); Mockito.when(studentResolver.findGoverningEdOrgs("student1", disciplineAction)).thenReturn(new HashSet<String>(Arrays.asList("edOrg1"))); Assert.assertEquals(new HashSet<String>(Arrays.asList("edOrg1")), resolver.findGoverningEdOrgs(disciplineAction)); }
|
@Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); List<String> studentIds = (List<String>) entity.getBody().get(ParameterConstants.STUDENT_ID); for(String studentId: studentIds){ edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } return edOrgs; }
|
DisciplineActionContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); List<String> studentIds = (List<String>) entity.getBody().get(ParameterConstants.STUDENT_ID); for(String studentId: studentIds){ edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } return edOrgs; } }
|
DisciplineActionContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); List<String> studentIds = (List<String>) entity.getBody().get(ParameterConstants.STUDENT_ID); for(String studentId: studentIds){ edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } return edOrgs; } }
|
DisciplineActionContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); List<String> studentIds = (List<String>) entity.getBody().get(ParameterConstants.STUDENT_ID); for(String studentId: studentIds){ edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
DisciplineActionContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); List<String> studentIds = (List<String>) entity.getBody().get(ParameterConstants.STUDENT_ID); for(String studentId: studentIds){ edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
@Test public void testMultipleStudents() { Entity disciplineAction = Mockito.mock(Entity.class); Map<String, Object> body = new HashMap<String, Object>(); body.put(ParameterConstants.STUDENT_ID, Arrays.asList("student1", "student2", "student3", "student4")); Mockito.when(disciplineAction.getBody()).thenReturn(body); Mockito.when(studentResolver.findGoverningEdOrgs("student1", disciplineAction)).thenReturn(new HashSet<String>(Arrays.asList("edOrg1"))); Mockito.when(studentResolver.findGoverningEdOrgs("student2", disciplineAction)).thenReturn(new HashSet<String>(Arrays.asList("edOrg2", "edOrg1"))); Mockito.when(studentResolver.findGoverningEdOrgs("student3", disciplineAction)).thenReturn(new HashSet<String>(Arrays.asList("edOrg3","edOrg2", "edOrg1"))); Mockito.when(studentResolver.findGoverningEdOrgs("student4", disciplineAction)).thenReturn(new HashSet<String>(Arrays.asList("edOrg4"))); Assert.assertEquals(new HashSet<String>(Arrays.asList("edOrg1", "edOrg2", "edOrg3", "edOrg4")), resolver.findGoverningEdOrgs(disciplineAction)); }
|
@Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); List<String> studentIds = (List<String>) entity.getBody().get(ParameterConstants.STUDENT_ID); for(String studentId: studentIds){ edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } return edOrgs; }
|
DisciplineActionContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); List<String> studentIds = (List<String>) entity.getBody().get(ParameterConstants.STUDENT_ID); for(String studentId: studentIds){ edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } return edOrgs; } }
|
DisciplineActionContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); List<String> studentIds = (List<String>) entity.getBody().get(ParameterConstants.STUDENT_ID); for(String studentId: studentIds){ edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } return edOrgs; } }
|
DisciplineActionContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); List<String> studentIds = (List<String>) entity.getBody().get(ParameterConstants.STUDENT_ID); for(String studentId: studentIds){ edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
DisciplineActionContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); List<String> studentIds = (List<String>) entity.getBody().get(ParameterConstants.STUDENT_ID); for(String studentId: studentIds){ edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); }
|
@Test public void testExtract() { publicDataExtractor.extract(file); for (PublicEntityDefinition definition : PublicEntityDefinition.values()) { Mockito.verify(extractor, Mockito.times(1)).extractEntities(Mockito.eq(file), Mockito.eq(definition.getEntityName()), Mockito.any(Predicate.class)); } }
|
@Override public void extract(ExtractFile file) { extractor.setExtractionQuery(new NeutralQuery()); for (PublicEntityDefinition entity : PublicEntityDefinition.values()) { extractor.extractEntities(file, entity.getEntityName(), new Predicate<Entity>() { @Override public boolean apply(Entity input) { boolean shouldExtract = true; if (!isPublicEntity(input.getType())) { shouldExtract = false; } return shouldExtract; } }); } }
|
AllPublicDataExtractor implements PublicDataExtractor { @Override public void extract(ExtractFile file) { extractor.setExtractionQuery(new NeutralQuery()); for (PublicEntityDefinition entity : PublicEntityDefinition.values()) { extractor.extractEntities(file, entity.getEntityName(), new Predicate<Entity>() { @Override public boolean apply(Entity input) { boolean shouldExtract = true; if (!isPublicEntity(input.getType())) { shouldExtract = false; } return shouldExtract; } }); } } }
|
AllPublicDataExtractor implements PublicDataExtractor { @Override public void extract(ExtractFile file) { extractor.setExtractionQuery(new NeutralQuery()); for (PublicEntityDefinition entity : PublicEntityDefinition.values()) { extractor.extractEntities(file, entity.getEntityName(), new Predicate<Entity>() { @Override public boolean apply(Entity input) { boolean shouldExtract = true; if (!isPublicEntity(input.getType())) { shouldExtract = false; } return shouldExtract; } }); } } AllPublicDataExtractor(EntityExtractor extractor); }
|
AllPublicDataExtractor implements PublicDataExtractor { @Override public void extract(ExtractFile file) { extractor.setExtractionQuery(new NeutralQuery()); for (PublicEntityDefinition entity : PublicEntityDefinition.values()) { extractor.extractEntities(file, entity.getEntityName(), new Predicate<Entity>() { @Override public boolean apply(Entity input) { boolean shouldExtract = true; if (!isPublicEntity(input.getType())) { shouldExtract = false; } return shouldExtract; } }); } } AllPublicDataExtractor(EntityExtractor extractor); @Override void extract(ExtractFile file); }
|
AllPublicDataExtractor implements PublicDataExtractor { @Override public void extract(ExtractFile file) { extractor.setExtractionQuery(new NeutralQuery()); for (PublicEntityDefinition entity : PublicEntityDefinition.values()) { extractor.extractEntities(file, entity.getEntityName(), new Predicate<Entity>() { @Override public boolean apply(Entity input) { boolean shouldExtract = true; if (!isPublicEntity(input.getType())) { shouldExtract = false; } return shouldExtract; } }); } } AllPublicDataExtractor(EntityExtractor extractor); @Override void extract(ExtractFile file); }
|
@Test public void buildUnfilteredPublicDataExtractor() { Assert.assertTrue(factory.buildAllPublicDataExtractor(null) != null); Assert.assertTrue(factory.buildAllPublicDataExtractor(null).getClass() == AllPublicDataExtractor.class); }
|
public PublicDataExtractor buildAllPublicDataExtractor(EntityExtractor extractor) { return new AllPublicDataExtractor(extractor); }
|
PublicDataFactory { public PublicDataExtractor buildAllPublicDataExtractor(EntityExtractor extractor) { return new AllPublicDataExtractor(extractor); } }
|
PublicDataFactory { public PublicDataExtractor buildAllPublicDataExtractor(EntityExtractor extractor) { return new AllPublicDataExtractor(extractor); } }
|
PublicDataFactory { public PublicDataExtractor buildAllPublicDataExtractor(EntityExtractor extractor) { return new AllPublicDataExtractor(extractor); } PublicDataExtractor buildAllPublicDataExtractor(EntityExtractor extractor); List<PublicDataExtractor> buildPublicDataExtracts(EntityExtractor extractor); }
|
PublicDataFactory { public PublicDataExtractor buildAllPublicDataExtractor(EntityExtractor extractor) { return new AllPublicDataExtractor(extractor); } PublicDataExtractor buildAllPublicDataExtractor(EntityExtractor extractor); List<PublicDataExtractor> buildPublicDataExtracts(EntityExtractor extractor); }
|
@Test public void testBuildAllPublicDataExtracts() { Assert.assertTrue(factory.buildPublicDataExtracts(null) != null); List<PublicDataExtractor> extractors = factory.buildPublicDataExtracts(null); Assert.assertEquals(extractors.size(), 1); Assert.assertTrue(extractors.get(0).getClass() == AllPublicDataExtractor.class); }
|
public List<PublicDataExtractor> buildPublicDataExtracts(EntityExtractor extractor) { List<PublicDataExtractor> list = new ArrayList<PublicDataExtractor>(); list.add(buildAllPublicDataExtractor(extractor)); return list; }
|
PublicDataFactory { public List<PublicDataExtractor> buildPublicDataExtracts(EntityExtractor extractor) { List<PublicDataExtractor> list = new ArrayList<PublicDataExtractor>(); list.add(buildAllPublicDataExtractor(extractor)); return list; } }
|
PublicDataFactory { public List<PublicDataExtractor> buildPublicDataExtracts(EntityExtractor extractor) { List<PublicDataExtractor> list = new ArrayList<PublicDataExtractor>(); list.add(buildAllPublicDataExtractor(extractor)); return list; } }
|
PublicDataFactory { public List<PublicDataExtractor> buildPublicDataExtracts(EntityExtractor extractor) { List<PublicDataExtractor> list = new ArrayList<PublicDataExtractor>(); list.add(buildAllPublicDataExtractor(extractor)); return list; } PublicDataExtractor buildAllPublicDataExtractor(EntityExtractor extractor); List<PublicDataExtractor> buildPublicDataExtracts(EntityExtractor extractor); }
|
PublicDataFactory { public List<PublicDataExtractor> buildPublicDataExtracts(EntityExtractor extractor) { List<PublicDataExtractor> list = new ArrayList<PublicDataExtractor>(); list.add(buildAllPublicDataExtractor(extractor)); return list; } PublicDataExtractor buildAllPublicDataExtractor(EntityExtractor extractor); List<PublicDataExtractor> buildPublicDataExtracts(EntityExtractor extractor); }
|
@Test public void testValueNotFound() { BSONObject field = new BasicBSONObject("field", 123L); BSONObject entry = new BasicBSONObject("long", field); BSONWritable entity = new BSONWritable(entry); LongValueMapper mapper = new LongValueMapper("long.missing_field"); Writable value = mapper.getValue(entity); assertTrue(value instanceof NullWritable); }
|
@Override public Writable getValue(BSONWritable entity) { Writable rval = NullWritable.get(); String value = null; try { value = BSONUtilities.getValue(entity, fieldName); if (value != null) { rval = new LongWritable(Long.parseLong(value.toString())); } } catch (NumberFormatException e) { log.severe(String.format("Failed to convert value {'%s'} to Long", value)); } return rval; }
|
LongValueMapper extends ValueMapper { @Override public Writable getValue(BSONWritable entity) { Writable rval = NullWritable.get(); String value = null; try { value = BSONUtilities.getValue(entity, fieldName); if (value != null) { rval = new LongWritable(Long.parseLong(value.toString())); } } catch (NumberFormatException e) { log.severe(String.format("Failed to convert value {'%s'} to Long", value)); } return rval; } }
|
LongValueMapper extends ValueMapper { @Override public Writable getValue(BSONWritable entity) { Writable rval = NullWritable.get(); String value = null; try { value = BSONUtilities.getValue(entity, fieldName); if (value != null) { rval = new LongWritable(Long.parseLong(value.toString())); } } catch (NumberFormatException e) { log.severe(String.format("Failed to convert value {'%s'} to Long", value)); } return rval; } LongValueMapper(String fieldName); }
|
LongValueMapper extends ValueMapper { @Override public Writable getValue(BSONWritable entity) { Writable rval = NullWritable.get(); String value = null; try { value = BSONUtilities.getValue(entity, fieldName); if (value != null) { rval = new LongWritable(Long.parseLong(value.toString())); } } catch (NumberFormatException e) { log.severe(String.format("Failed to convert value {'%s'} to Long", value)); } return rval; } LongValueMapper(String fieldName); @Override Writable getValue(BSONWritable entity); }
|
LongValueMapper extends ValueMapper { @Override public Writable getValue(BSONWritable entity) { Writable rval = NullWritable.get(); String value = null; try { value = BSONUtilities.getValue(entity, fieldName); if (value != null) { rval = new LongWritable(Long.parseLong(value.toString())); } } catch (NumberFormatException e) { log.severe(String.format("Failed to convert value {'%s'} to Long", value)); } return rval; } LongValueMapper(String fieldName); @Override Writable getValue(BSONWritable entity); }
|
@Test public void testExtractValidTSA() throws Exception { List<Entity> list = Arrays.asList(AccessibleVia.VALIDTSA.generate(), AccessibleVia.VALIDTSA.generate(), AccessibleVia.VALIDTSA.generate(), AccessibleVia.NONE.generate()); Mockito.when(repo.findEach(Mockito.eq(EntityNames.SECTION), Mockito.any(NeutralQuery.class))).thenReturn(list.iterator()); se.extractEntities(null); Mockito.verify(ex, Mockito.times(3)).extractEntity(Mockito.any(Entity.class), Mockito.any(ExtractFile.class), Mockito.eq(EntityNames.TEACHER_SECTION_ASSOCIATION)); }
|
@SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } }
|
SectionEmbeddedDocsExtractor implements EntityDatedExtract { @SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } } }
|
SectionEmbeddedDocsExtractor implements EntityDatedExtract { @SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } } SectionEmbeddedDocsExtractor(EntityExtractor entityExtractor, ExtractFileMap leaToExtractFileMap,
Repository<Entity> repository, EntityToEdOrgDateCache studentCache,
EntityToEdOrgDateCache staffDatedCache); }
|
SectionEmbeddedDocsExtractor implements EntityDatedExtract { @SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } } SectionEmbeddedDocsExtractor(EntityExtractor entityExtractor, ExtractFileMap leaToExtractFileMap,
Repository<Entity> repository, EntityToEdOrgDateCache studentCache,
EntityToEdOrgDateCache staffDatedCache); @SuppressWarnings("unchecked") @Override void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache); EntityToEdOrgDateCache getStudentSectionAssociationDateCache(); }
|
SectionEmbeddedDocsExtractor implements EntityDatedExtract { @SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } } SectionEmbeddedDocsExtractor(EntityExtractor entityExtractor, ExtractFileMap leaToExtractFileMap,
Repository<Entity> repository, EntityToEdOrgDateCache studentCache,
EntityToEdOrgDateCache staffDatedCache); @SuppressWarnings("unchecked") @Override void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache); EntityToEdOrgDateCache getStudentSectionAssociationDateCache(); }
|
@Test public void testExtractInvalidTSAs() throws Exception { List<Entity> list = Arrays.asList(AccessibleVia.INVALIDTSA.generate(), AccessibleVia.INVALIDTSA.generate(), AccessibleVia.INVALIDTSA.generate()); Mockito.when(repo.findEach(Mockito.eq(EntityNames.SECTION), Mockito.any(NeutralQuery.class))).thenReturn(list.iterator()); se.extractEntities(null); Mockito.verify(ex, Mockito.never()).extractEntity(Mockito.any(Entity.class), Mockito.any(ExtractFile.class), Mockito.eq(EntityNames.TEACHER_SECTION_ASSOCIATION)); }
|
@SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } }
|
SectionEmbeddedDocsExtractor implements EntityDatedExtract { @SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } } }
|
SectionEmbeddedDocsExtractor implements EntityDatedExtract { @SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } } SectionEmbeddedDocsExtractor(EntityExtractor entityExtractor, ExtractFileMap leaToExtractFileMap,
Repository<Entity> repository, EntityToEdOrgDateCache studentCache,
EntityToEdOrgDateCache staffDatedCache); }
|
SectionEmbeddedDocsExtractor implements EntityDatedExtract { @SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } } SectionEmbeddedDocsExtractor(EntityExtractor entityExtractor, ExtractFileMap leaToExtractFileMap,
Repository<Entity> repository, EntityToEdOrgDateCache studentCache,
EntityToEdOrgDateCache staffDatedCache); @SuppressWarnings("unchecked") @Override void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache); EntityToEdOrgDateCache getStudentSectionAssociationDateCache(); }
|
SectionEmbeddedDocsExtractor implements EntityDatedExtract { @SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } } SectionEmbeddedDocsExtractor(EntityExtractor entityExtractor, ExtractFileMap leaToExtractFileMap,
Repository<Entity> repository, EntityToEdOrgDateCache studentCache,
EntityToEdOrgDateCache staffDatedCache); @SuppressWarnings("unchecked") @Override void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache); EntityToEdOrgDateCache getStudentSectionAssociationDateCache(); }
|
@Test public void testExtractValidSSAs() throws Exception { List<Entity> list = Arrays.asList(AccessibleVia.VALIDSSA.generate(), AccessibleVia.VALIDSSA.generate(), AccessibleVia.VALIDSSA.generate(), AccessibleVia.NONE.generate()); Mockito.when(repo.findEach(Mockito.eq(EntityNames.SECTION), Mockito.any(NeutralQuery.class))).thenReturn(list.iterator()); se.extractEntities(null); Mockito.verify(ex, Mockito.times(3)).extractEntity(Mockito.any(Entity.class), Mockito.any(ExtractFile.class), Mockito.eq(EntityNames.STUDENT_SECTION_ASSOCIATION)); }
|
@SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } }
|
SectionEmbeddedDocsExtractor implements EntityDatedExtract { @SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } } }
|
SectionEmbeddedDocsExtractor implements EntityDatedExtract { @SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } } SectionEmbeddedDocsExtractor(EntityExtractor entityExtractor, ExtractFileMap leaToExtractFileMap,
Repository<Entity> repository, EntityToEdOrgDateCache studentCache,
EntityToEdOrgDateCache staffDatedCache); }
|
SectionEmbeddedDocsExtractor implements EntityDatedExtract { @SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } } SectionEmbeddedDocsExtractor(EntityExtractor entityExtractor, ExtractFileMap leaToExtractFileMap,
Repository<Entity> repository, EntityToEdOrgDateCache studentCache,
EntityToEdOrgDateCache staffDatedCache); @SuppressWarnings("unchecked") @Override void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache); EntityToEdOrgDateCache getStudentSectionAssociationDateCache(); }
|
SectionEmbeddedDocsExtractor implements EntityDatedExtract { @SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } } SectionEmbeddedDocsExtractor(EntityExtractor entityExtractor, ExtractFileMap leaToExtractFileMap,
Repository<Entity> repository, EntityToEdOrgDateCache studentCache,
EntityToEdOrgDateCache staffDatedCache); @SuppressWarnings("unchecked") @Override void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache); EntityToEdOrgDateCache getStudentSectionAssociationDateCache(); }
|
@Test public void testExtractInvalidSSAs() throws Exception { List<Entity> list = Arrays.asList(AccessibleVia.INVALIDSSA.generate(), AccessibleVia.INVALIDSSA.generate(), AccessibleVia.INVALIDSSA.generate()); Mockito.when(repo.findEach(Mockito.eq(EntityNames.SECTION), Mockito.any(NeutralQuery.class))).thenReturn(list.iterator()); se.extractEntities(null); Mockito.verify(ex, Mockito.never()).extractEntity(Mockito.any(Entity.class), Mockito.any(ExtractFile.class), Mockito.any(String.class)); }
|
@SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } }
|
SectionEmbeddedDocsExtractor implements EntityDatedExtract { @SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } } }
|
SectionEmbeddedDocsExtractor implements EntityDatedExtract { @SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } } SectionEmbeddedDocsExtractor(EntityExtractor entityExtractor, ExtractFileMap leaToExtractFileMap,
Repository<Entity> repository, EntityToEdOrgDateCache studentCache,
EntityToEdOrgDateCache staffDatedCache); }
|
SectionEmbeddedDocsExtractor implements EntityDatedExtract { @SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } } SectionEmbeddedDocsExtractor(EntityExtractor entityExtractor, ExtractFileMap leaToExtractFileMap,
Repository<Entity> repository, EntityToEdOrgDateCache studentCache,
EntityToEdOrgDateCache staffDatedCache); @SuppressWarnings("unchecked") @Override void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache); EntityToEdOrgDateCache getStudentSectionAssociationDateCache(); }
|
SectionEmbeddedDocsExtractor implements EntityDatedExtract { @SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } } SectionEmbeddedDocsExtractor(EntityExtractor entityExtractor, ExtractFileMap leaToExtractFileMap,
Repository<Entity> repository, EntityToEdOrgDateCache studentCache,
EntityToEdOrgDateCache staffDatedCache); @SuppressWarnings("unchecked") @Override void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache); EntityToEdOrgDateCache getStudentSectionAssociationDateCache(); }
|
@Test public void testExtractNoEntityBecauseOfIdMiss() { entityBody.put(ParameterConstants.STUDENT_ID, "studentId99"); Mockito.when(mockRepo.findEach(Mockito.eq("studentGradebookEntry"), Mockito.eq(new NeutralQuery()))) .thenReturn(Arrays.asList(mockEntity).iterator()); Mockito.when(mockMap.getExtractFileForEdOrg("LEA")).thenReturn(mockFile); extractor.extractEntities(mockStudentCache); Mockito.verify(mockExtractor, Mockito.never()).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq("studentGradebookEntry")); }
|
@Override public void extractEntities(EntityToEdOrgDateCache studentCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STUDENT_GRADEBOOK_ENTRY, this.getClass().getName()); Iterator<Entity> studentGradebookEntries = repo.findEach(EntityNames.STUDENT_GRADEBOOK_ENTRY, new NeutralQuery()); while (studentGradebookEntries.hasNext()) { Entity studentGradebookEntry = studentGradebookEntries.next(); String studentId = (String) studentGradebookEntry.getBody().get(ParameterConstants.STUDENT_ID); String gradebookEntryId = (String) studentGradebookEntry.getBody().get(ParameterConstants.GRADEBOOK_ENTRY_ID); Map<String, DateTime> studentEdOrgs = studentCache.getEntriesById(studentId); for (Map.Entry<String, DateTime> entry: studentEdOrgs.entrySet()) { DateTime upToDate = entry.getValue(); if(shouldExtract(studentGradebookEntry, upToDate)) { extractor.extractEntity(studentGradebookEntry, map.getExtractFileForEdOrg(entry.getKey()), EntityNames.STUDENT_GRADEBOOK_ENTRY); gradebookEntryCache.addEntry(gradebookEntryId, entry.getKey(), upToDate); } } } }
|
StudentGradebookEntryExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STUDENT_GRADEBOOK_ENTRY, this.getClass().getName()); Iterator<Entity> studentGradebookEntries = repo.findEach(EntityNames.STUDENT_GRADEBOOK_ENTRY, new NeutralQuery()); while (studentGradebookEntries.hasNext()) { Entity studentGradebookEntry = studentGradebookEntries.next(); String studentId = (String) studentGradebookEntry.getBody().get(ParameterConstants.STUDENT_ID); String gradebookEntryId = (String) studentGradebookEntry.getBody().get(ParameterConstants.GRADEBOOK_ENTRY_ID); Map<String, DateTime> studentEdOrgs = studentCache.getEntriesById(studentId); for (Map.Entry<String, DateTime> entry: studentEdOrgs.entrySet()) { DateTime upToDate = entry.getValue(); if(shouldExtract(studentGradebookEntry, upToDate)) { extractor.extractEntity(studentGradebookEntry, map.getExtractFileForEdOrg(entry.getKey()), EntityNames.STUDENT_GRADEBOOK_ENTRY); gradebookEntryCache.addEntry(gradebookEntryId, entry.getKey(), upToDate); } } } } }
|
StudentGradebookEntryExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STUDENT_GRADEBOOK_ENTRY, this.getClass().getName()); Iterator<Entity> studentGradebookEntries = repo.findEach(EntityNames.STUDENT_GRADEBOOK_ENTRY, new NeutralQuery()); while (studentGradebookEntries.hasNext()) { Entity studentGradebookEntry = studentGradebookEntries.next(); String studentId = (String) studentGradebookEntry.getBody().get(ParameterConstants.STUDENT_ID); String gradebookEntryId = (String) studentGradebookEntry.getBody().get(ParameterConstants.GRADEBOOK_ENTRY_ID); Map<String, DateTime> studentEdOrgs = studentCache.getEntriesById(studentId); for (Map.Entry<String, DateTime> entry: studentEdOrgs.entrySet()) { DateTime upToDate = entry.getValue(); if(shouldExtract(studentGradebookEntry, upToDate)) { extractor.extractEntity(studentGradebookEntry, map.getExtractFileForEdOrg(entry.getKey()), EntityNames.STUDENT_GRADEBOOK_ENTRY); gradebookEntryCache.addEntry(gradebookEntryId, entry.getKey(), upToDate); } } } } StudentGradebookEntryExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
EdOrgExtractHelper edOrgExtractHelper); }
|
StudentGradebookEntryExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STUDENT_GRADEBOOK_ENTRY, this.getClass().getName()); Iterator<Entity> studentGradebookEntries = repo.findEach(EntityNames.STUDENT_GRADEBOOK_ENTRY, new NeutralQuery()); while (studentGradebookEntries.hasNext()) { Entity studentGradebookEntry = studentGradebookEntries.next(); String studentId = (String) studentGradebookEntry.getBody().get(ParameterConstants.STUDENT_ID); String gradebookEntryId = (String) studentGradebookEntry.getBody().get(ParameterConstants.GRADEBOOK_ENTRY_ID); Map<String, DateTime> studentEdOrgs = studentCache.getEntriesById(studentId); for (Map.Entry<String, DateTime> entry: studentEdOrgs.entrySet()) { DateTime upToDate = entry.getValue(); if(shouldExtract(studentGradebookEntry, upToDate)) { extractor.extractEntity(studentGradebookEntry, map.getExtractFileForEdOrg(entry.getKey()), EntityNames.STUDENT_GRADEBOOK_ENTRY); gradebookEntryCache.addEntry(gradebookEntryId, entry.getKey(), upToDate); } } } } StudentGradebookEntryExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache studentCache); EntityToEdOrgDateCache getGradebookEntryCache(); }
|
StudentGradebookEntryExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STUDENT_GRADEBOOK_ENTRY, this.getClass().getName()); Iterator<Entity> studentGradebookEntries = repo.findEach(EntityNames.STUDENT_GRADEBOOK_ENTRY, new NeutralQuery()); while (studentGradebookEntries.hasNext()) { Entity studentGradebookEntry = studentGradebookEntries.next(); String studentId = (String) studentGradebookEntry.getBody().get(ParameterConstants.STUDENT_ID); String gradebookEntryId = (String) studentGradebookEntry.getBody().get(ParameterConstants.GRADEBOOK_ENTRY_ID); Map<String, DateTime> studentEdOrgs = studentCache.getEntriesById(studentId); for (Map.Entry<String, DateTime> entry: studentEdOrgs.entrySet()) { DateTime upToDate = entry.getValue(); if(shouldExtract(studentGradebookEntry, upToDate)) { extractor.extractEntity(studentGradebookEntry, map.getExtractFileForEdOrg(entry.getKey()), EntityNames.STUDENT_GRADEBOOK_ENTRY); gradebookEntryCache.addEntry(gradebookEntryId, entry.getKey(), upToDate); } } } } StudentGradebookEntryExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache studentCache); EntityToEdOrgDateCache getGradebookEntryCache(); }
|
@Test public void testDoNotWriteDatedBasedEntity() { Mockito.when(mockRepo.findEach(Mockito.eq(ContainerEntityNames.YEARLY_TRANSCRIPT), Mockito.eq(new NeutralQuery()))) .thenReturn(Arrays.asList(mockEntity).iterator()); entityBody.put(ParameterConstants.STUDENT_ID, "student"); entityBody.put(ParameterConstants.SCHOOL_YEAR, "2012-2013"); extractor.extractEntities(mockStudentCache); Mockito.verify(mockExtractor, Mockito.never()).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq(ContainerEntityNames.YEARLY_TRANSCRIPT)); }
|
@Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } }
|
YearlyTranscriptExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } } }
|
YearlyTranscriptExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } } YearlyTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
EdOrgExtractHelper edOrgExtractHelper); }
|
YearlyTranscriptExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } } YearlyTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache studentDatedCache); EntityToEdOrgDateCache getStudentAcademicRecordDateCache(); }
|
YearlyTranscriptExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } } YearlyTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache studentDatedCache); EntityToEdOrgDateCache getStudentAcademicRecordDateCache(); }
|
@Test public void testWriteOneEntity() { Mockito.when(mockRepo.findEach(Mockito.eq(ContainerEntityNames.YEARLY_TRANSCRIPT), Mockito.eq(new NeutralQuery()))) .thenReturn(Arrays.asList(mockEntity).iterator()); entityBody.put(ParameterConstants.STUDENT_ID, "student"); extractor.extractEntities(mockStudentCache); Mockito.verify(mockExtractor).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq(ContainerEntityNames.YEARLY_TRANSCRIPT)); }
|
@Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } }
|
YearlyTranscriptExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } } }
|
YearlyTranscriptExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } } YearlyTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
EdOrgExtractHelper edOrgExtractHelper); }
|
YearlyTranscriptExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } } YearlyTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache studentDatedCache); EntityToEdOrgDateCache getStudentAcademicRecordDateCache(); }
|
YearlyTranscriptExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } } YearlyTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache studentDatedCache); EntityToEdOrgDateCache getStudentAcademicRecordDateCache(); }
|
@Test public void testWriteManyEntities() { Mockito.when(mockRepo.findEach(Mockito.eq(ContainerEntityNames.YEARLY_TRANSCRIPT), Mockito.eq(new NeutralQuery()))) .thenReturn(Arrays.asList(mockEntity, mockEntity, mockEntity).iterator()); entityBody.put(ParameterConstants.STUDENT_ID, "student"); extractor.extractEntities(mockStudentCache); Mockito.verify(mockExtractor, Mockito.times(3)).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq(ContainerEntityNames.YEARLY_TRANSCRIPT)); }
|
@Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } }
|
YearlyTranscriptExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } } }
|
YearlyTranscriptExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } } YearlyTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
EdOrgExtractHelper edOrgExtractHelper); }
|
YearlyTranscriptExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } } YearlyTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache studentDatedCache); EntityToEdOrgDateCache getStudentAcademicRecordDateCache(); }
|
YearlyTranscriptExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } } YearlyTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache studentDatedCache); EntityToEdOrgDateCache getStudentAcademicRecordDateCache(); }
|
@Test public void testExtractNoEntityBecauseOfLEAMiss() { Mockito.when(mockRepo.findEach(Mockito.eq(ContainerEntityNames.YEARLY_TRANSCRIPT), Mockito.eq(new NeutralQuery()))) .thenReturn(Arrays.asList(mockEntity).iterator()); Mockito.when(mockMap.getExtractFileForEdOrg("LEA")).thenReturn(null); extractor.extractEntities(mockStudentCache); Mockito.verify(mockExtractor, Mockito.never()).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq(ContainerEntityNames.YEARLY_TRANSCRIPT)); }
|
@Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } }
|
YearlyTranscriptExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } } }
|
YearlyTranscriptExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } } YearlyTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
EdOrgExtractHelper edOrgExtractHelper); }
|
YearlyTranscriptExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } } YearlyTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache studentDatedCache); EntityToEdOrgDateCache getStudentAcademicRecordDateCache(); }
|
YearlyTranscriptExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } } YearlyTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache studentDatedCache); EntityToEdOrgDateCache getStudentAcademicRecordDateCache(); }
|
@Test public void testExtractNoEntityBecauseOfIdMiss() { entityBody.put(ParameterConstants.STUDENT_ID, "STUDENT1"); Mockito.when(mockRepo.findEach(Mockito.eq(ContainerEntityNames.YEARLY_TRANSCRIPT), Mockito.eq(new NeutralQuery()))) .thenReturn(Arrays.asList(mockEntity).iterator()); Mockito.when(mockMap.getExtractFileForEdOrg("LEA")).thenReturn(mockFile); extractor.extractEntities(mockStudentCache); Mockito.verify(mockExtractor, Mockito.never()).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq(ContainerEntityNames.YEARLY_TRANSCRIPT)); }
|
@Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } }
|
YearlyTranscriptExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } } }
|
YearlyTranscriptExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } } YearlyTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
EdOrgExtractHelper edOrgExtractHelper); }
|
YearlyTranscriptExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } } YearlyTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache studentDatedCache); EntityToEdOrgDateCache getStudentAcademicRecordDateCache(); }
|
YearlyTranscriptExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentDatedCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), ContainerEntityNames.YEARLY_TRANSCRIPT, this.getClass().getName()); Iterator<Entity> yearlyTranscripts = repo.findEach(ContainerEntityNames.YEARLY_TRANSCRIPT, new NeutralQuery()); while (yearlyTranscripts.hasNext()) { Entity yearlyTranscript = yearlyTranscripts.next(); String studentId = (String) yearlyTranscript.getBody().get(ParameterConstants.STUDENT_ID); final Map<String, DateTime> studentEdOrgs = studentDatedCache.getEntriesById(studentId); Set<String> studentAcademicRecords = fetchStudentAcademicRecordsFromYearlyTranscript(yearlyTranscript); for (Map.Entry<String, DateTime> studentEdOrg : studentEdOrgs.entrySet()) { if (shouldExtract(yearlyTranscript, studentEdOrg.getValue())) { extractor.extractEntity(yearlyTranscript, map.getExtractFileForEdOrg(studentEdOrg.getKey()), ContainerEntityNames.YEARLY_TRANSCRIPT); for (String sarId : studentAcademicRecords) { studentAcademicRecordDateCache.addEntry(sarId, studentEdOrg.getKey(), studentEdOrg.getValue()); } } } } } YearlyTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache studentDatedCache); EntityToEdOrgDateCache getStudentAcademicRecordDateCache(); }
|
@Test public void testValueNotLong() { BSONObject field = new BasicBSONObject("field", true); BSONObject entry = new BasicBSONObject("long", field); BSONWritable entity = new BSONWritable(entry); LongValueMapper mapper = new LongValueMapper("long.field"); Writable value = mapper.getValue(entity); assertTrue(value instanceof NullWritable); }
|
@Override public Writable getValue(BSONWritable entity) { Writable rval = NullWritable.get(); String value = null; try { value = BSONUtilities.getValue(entity, fieldName); if (value != null) { rval = new LongWritable(Long.parseLong(value.toString())); } } catch (NumberFormatException e) { log.severe(String.format("Failed to convert value {'%s'} to Long", value)); } return rval; }
|
LongValueMapper extends ValueMapper { @Override public Writable getValue(BSONWritable entity) { Writable rval = NullWritable.get(); String value = null; try { value = BSONUtilities.getValue(entity, fieldName); if (value != null) { rval = new LongWritable(Long.parseLong(value.toString())); } } catch (NumberFormatException e) { log.severe(String.format("Failed to convert value {'%s'} to Long", value)); } return rval; } }
|
LongValueMapper extends ValueMapper { @Override public Writable getValue(BSONWritable entity) { Writable rval = NullWritable.get(); String value = null; try { value = BSONUtilities.getValue(entity, fieldName); if (value != null) { rval = new LongWritable(Long.parseLong(value.toString())); } } catch (NumberFormatException e) { log.severe(String.format("Failed to convert value {'%s'} to Long", value)); } return rval; } LongValueMapper(String fieldName); }
|
LongValueMapper extends ValueMapper { @Override public Writable getValue(BSONWritable entity) { Writable rval = NullWritable.get(); String value = null; try { value = BSONUtilities.getValue(entity, fieldName); if (value != null) { rval = new LongWritable(Long.parseLong(value.toString())); } } catch (NumberFormatException e) { log.severe(String.format("Failed to convert value {'%s'} to Long", value)); } return rval; } LongValueMapper(String fieldName); @Override Writable getValue(BSONWritable entity); }
|
LongValueMapper extends ValueMapper { @Override public Writable getValue(BSONWritable entity) { Writable rval = NullWritable.get(); String value = null; try { value = BSONUtilities.getValue(entity, fieldName); if (value != null) { rval = new LongWritable(Long.parseLong(value.toString())); } } catch (NumberFormatException e) { log.severe(String.format("Failed to convert value {'%s'} to Long", value)); } return rval; } LongValueMapper(String fieldName); @Override Writable getValue(BSONWritable entity); }
|
@Test(expected = MissingArgumentException.class) public void missingUserValue() throws ParseException, MissingConfigException { String[] args = new String[] { "-u", "-pass", "password", "-s", "server", "-d", "localDir", "-port", "22" }; propUtils.getUploadProperties(args); }
|
public UploadProperties getUploadProperties(String[] args) throws ParseException, MissingConfigException { CommandLine cmd = parser.parse(OPTIONS, args); String user = cmd.getOptionValue(FLAG_USER); if (user == null) { throw new MissingConfigException(FLAG_USER); } String password = cmd.getOptionValue(FLAG_PASSWORD); if (password == null) { throw new MissingConfigException(FLAG_PASSWORD); } String server = cmd.getOptionValue(FLAG_SFTP_SERVER); if (server == null) { throw new MissingConfigException(FLAG_SFTP_SERVER); } String localDir = cmd.getOptionValue(FLAG_LOCAL_DIRECTORY); if (localDir == null) { throw new MissingConfigException(FLAG_LOCAL_DIRECTORY); } int port; try { port = Integer.parseInt(cmd.getOptionValue(FLAG_PORT)); } catch (NumberFormatException e) { throw new MissingConfigException(FLAG_PORT); } return new UploadProperties(user, password, server, localDir, port); }
|
PropertyUtils { public UploadProperties getUploadProperties(String[] args) throws ParseException, MissingConfigException { CommandLine cmd = parser.parse(OPTIONS, args); String user = cmd.getOptionValue(FLAG_USER); if (user == null) { throw new MissingConfigException(FLAG_USER); } String password = cmd.getOptionValue(FLAG_PASSWORD); if (password == null) { throw new MissingConfigException(FLAG_PASSWORD); } String server = cmd.getOptionValue(FLAG_SFTP_SERVER); if (server == null) { throw new MissingConfigException(FLAG_SFTP_SERVER); } String localDir = cmd.getOptionValue(FLAG_LOCAL_DIRECTORY); if (localDir == null) { throw new MissingConfigException(FLAG_LOCAL_DIRECTORY); } int port; try { port = Integer.parseInt(cmd.getOptionValue(FLAG_PORT)); } catch (NumberFormatException e) { throw new MissingConfigException(FLAG_PORT); } return new UploadProperties(user, password, server, localDir, port); } }
|
PropertyUtils { public UploadProperties getUploadProperties(String[] args) throws ParseException, MissingConfigException { CommandLine cmd = parser.parse(OPTIONS, args); String user = cmd.getOptionValue(FLAG_USER); if (user == null) { throw new MissingConfigException(FLAG_USER); } String password = cmd.getOptionValue(FLAG_PASSWORD); if (password == null) { throw new MissingConfigException(FLAG_PASSWORD); } String server = cmd.getOptionValue(FLAG_SFTP_SERVER); if (server == null) { throw new MissingConfigException(FLAG_SFTP_SERVER); } String localDir = cmd.getOptionValue(FLAG_LOCAL_DIRECTORY); if (localDir == null) { throw new MissingConfigException(FLAG_LOCAL_DIRECTORY); } int port; try { port = Integer.parseInt(cmd.getOptionValue(FLAG_PORT)); } catch (NumberFormatException e) { throw new MissingConfigException(FLAG_PORT); } return new UploadProperties(user, password, server, localDir, port); } PropertyUtils(CommandLineParser parser); }
|
PropertyUtils { public UploadProperties getUploadProperties(String[] args) throws ParseException, MissingConfigException { CommandLine cmd = parser.parse(OPTIONS, args); String user = cmd.getOptionValue(FLAG_USER); if (user == null) { throw new MissingConfigException(FLAG_USER); } String password = cmd.getOptionValue(FLAG_PASSWORD); if (password == null) { throw new MissingConfigException(FLAG_PASSWORD); } String server = cmd.getOptionValue(FLAG_SFTP_SERVER); if (server == null) { throw new MissingConfigException(FLAG_SFTP_SERVER); } String localDir = cmd.getOptionValue(FLAG_LOCAL_DIRECTORY); if (localDir == null) { throw new MissingConfigException(FLAG_LOCAL_DIRECTORY); } int port; try { port = Integer.parseInt(cmd.getOptionValue(FLAG_PORT)); } catch (NumberFormatException e) { throw new MissingConfigException(FLAG_PORT); } return new UploadProperties(user, password, server, localDir, port); } PropertyUtils(CommandLineParser parser); UploadProperties getUploadProperties(String[] args); }
|
PropertyUtils { public UploadProperties getUploadProperties(String[] args) throws ParseException, MissingConfigException { CommandLine cmd = parser.parse(OPTIONS, args); String user = cmd.getOptionValue(FLAG_USER); if (user == null) { throw new MissingConfigException(FLAG_USER); } String password = cmd.getOptionValue(FLAG_PASSWORD); if (password == null) { throw new MissingConfigException(FLAG_PASSWORD); } String server = cmd.getOptionValue(FLAG_SFTP_SERVER); if (server == null) { throw new MissingConfigException(FLAG_SFTP_SERVER); } String localDir = cmd.getOptionValue(FLAG_LOCAL_DIRECTORY); if (localDir == null) { throw new MissingConfigException(FLAG_LOCAL_DIRECTORY); } int port; try { port = Integer.parseInt(cmd.getOptionValue(FLAG_PORT)); } catch (NumberFormatException e) { throw new MissingConfigException(FLAG_PORT); } return new UploadProperties(user, password, server, localDir, port); } PropertyUtils(CommandLineParser parser); UploadProperties getUploadProperties(String[] args); static final String KEY_USER; static final String KEY_PASSWORD; static final String KEY_SFTP_SERVER; static final String KEY_LOCAL_DIRECTORY; static final String KEY_PORT; final static Options OPTIONS; }
|
@Test public void testWriteOneEntity() { Mockito.when(mockRepo.findEach(Mockito.eq(EntityNames.PARENT), Mockito.eq(new NeutralQuery()))).thenReturn( Arrays.asList(mockEntity).iterator()); extractor.extractEntities(mockParentCache); Mockito.verify(mockExtractor).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq(EntityNames.PARENT)); }
|
@Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } }
|
ParentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } } }
|
ParentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } } ParentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); }
|
ParentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } } ParentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgCache entityToEdorgCache); }
|
ParentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } } ParentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgCache entityToEdorgCache); }
|
@Test public void testWriteManyEntities() { Mockito.when(mockRepo.findEach(Mockito.eq(EntityNames.PARENT), Mockito.eq(new NeutralQuery()))).thenReturn( Arrays.asList(mockEntity, mockEntity, mockEntity).iterator()); extractor.extractEntities(mockParentCache); Mockito.verify(mockExtractor, Mockito.times(3)).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq(EntityNames.PARENT)); }
|
@Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } }
|
ParentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } } }
|
ParentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } } ParentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); }
|
ParentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } } ParentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgCache entityToEdorgCache); }
|
ParentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } } ParentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgCache entityToEdorgCache); }
|
@Test public void testExtractNoEntityBecauseOfLEAMiss() { Mockito.when(mockRepo.findEach(Mockito.eq(EntityNames.PARENT), Mockito.eq(new NeutralQuery()))).thenReturn( Arrays.asList(mockEntity).iterator()); Mockito.when(mockMap.getExtractFileForEdOrg("LEA")).thenReturn(null); extractor.extractEntities(mockParentCache); Mockito.verify(mockExtractor, Mockito.never()).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq(EntityNames.PARENT)); }
|
@Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } }
|
ParentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } } }
|
ParentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } } ParentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); }
|
ParentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } } ParentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgCache entityToEdorgCache); }
|
ParentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } } ParentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgCache entityToEdorgCache); }
|
@Test public void testExtractNoEntityBecauseOfIdMiss() { Mockito.when(mockEntity.getEntityId()).thenReturn("parent2"); Mockito.when(mockRepo.findEach(Mockito.eq(EntityNames.PARENT), Mockito.eq(new NeutralQuery()))).thenReturn( Arrays.asList(mockEntity).iterator()); Mockito.when(mockMap.getExtractFileForEdOrg("LEA")).thenReturn(mockFile); extractor.extractEntities(mockParentCache); Mockito.verify(mockExtractor, Mockito.never()).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq(EntityNames.PARENT)); }
|
@Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } }
|
ParentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } } }
|
ParentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } } ParentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); }
|
ParentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } } ParentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgCache entityToEdorgCache); }
|
ParentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } } ParentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgCache entityToEdorgCache); }
|
@Test public void testExtractOneEntity() { Mockito.when(mockRepo.findEach(Mockito.eq(EntityNames.STAFF), Mockito.eq(new NeutralQuery()))) .thenReturn(Arrays.asList(mockEntity).iterator()); Mockito.when(mockMap.getExtractFileForEdOrg("LEA")).thenReturn(mockFile); extractor.extractEntities(staffToLeaDateCache); Mockito.verify(mockExtractor).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq(EntityNames.STAFF)); }
|
@Override public void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STAFF, this.getClass().getName()); Iterator<Entity> staffs = repo.findEach(EntityNames.STAFF, new NeutralQuery()); while (staffs.hasNext()) { Entity staff = staffs.next(); Set<String> edOrgs = staffToEdorgDateCache.getEntriesById(staff.getEntityId()).keySet(); for (String edOrg : edOrgs) { extractor.extractEntity(staff, map.getExtractFileForEdOrg(edOrg), EntityNames.STAFF); } } }
|
StaffExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STAFF, this.getClass().getName()); Iterator<Entity> staffs = repo.findEach(EntityNames.STAFF, new NeutralQuery()); while (staffs.hasNext()) { Entity staff = staffs.next(); Set<String> edOrgs = staffToEdorgDateCache.getEntriesById(staff.getEntityId()).keySet(); for (String edOrg : edOrgs) { extractor.extractEntity(staff, map.getExtractFileForEdOrg(edOrg), EntityNames.STAFF); } } } }
|
StaffExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STAFF, this.getClass().getName()); Iterator<Entity> staffs = repo.findEach(EntityNames.STAFF, new NeutralQuery()); while (staffs.hasNext()) { Entity staff = staffs.next(); Set<String> edOrgs = staffToEdorgDateCache.getEntriesById(staff.getEntityId()).keySet(); for (String edOrg : edOrgs) { extractor.extractEntity(staff, map.getExtractFileForEdOrg(edOrg), EntityNames.STAFF); } } } StaffExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); }
|
StaffExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STAFF, this.getClass().getName()); Iterator<Entity> staffs = repo.findEach(EntityNames.STAFF, new NeutralQuery()); while (staffs.hasNext()) { Entity staff = staffs.next(); Set<String> edOrgs = staffToEdorgDateCache.getEntriesById(staff.getEntityId()).keySet(); for (String edOrg : edOrgs) { extractor.extractEntity(staff, map.getExtractFileForEdOrg(edOrg), EntityNames.STAFF); } } } StaffExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache); }
|
StaffExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STAFF, this.getClass().getName()); Iterator<Entity> staffs = repo.findEach(EntityNames.STAFF, new NeutralQuery()); while (staffs.hasNext()) { Entity staff = staffs.next(); Set<String> edOrgs = staffToEdorgDateCache.getEntriesById(staff.getEntityId()).keySet(); for (String edOrg : edOrgs) { extractor.extractEntity(staff, map.getExtractFileForEdOrg(edOrg), EntityNames.STAFF); } } } StaffExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache); }
|
@Test public void testExtractManyEntity() { Mockito.when(mockRepo.findEach(Mockito.eq(EntityNames.STAFF), Mockito.eq(new NeutralQuery()))) .thenReturn(Arrays.asList(mockEntity, mockEntity).iterator()); Mockito.when(mockMap.getExtractFileForEdOrg("LEA")).thenReturn(mockFile); extractor.extractEntities(staffToLeaDateCache); Mockito.verify(mockExtractor, Mockito.times(2)).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq(EntityNames.STAFF)); }
|
@Override public void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STAFF, this.getClass().getName()); Iterator<Entity> staffs = repo.findEach(EntityNames.STAFF, new NeutralQuery()); while (staffs.hasNext()) { Entity staff = staffs.next(); Set<String> edOrgs = staffToEdorgDateCache.getEntriesById(staff.getEntityId()).keySet(); for (String edOrg : edOrgs) { extractor.extractEntity(staff, map.getExtractFileForEdOrg(edOrg), EntityNames.STAFF); } } }
|
StaffExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STAFF, this.getClass().getName()); Iterator<Entity> staffs = repo.findEach(EntityNames.STAFF, new NeutralQuery()); while (staffs.hasNext()) { Entity staff = staffs.next(); Set<String> edOrgs = staffToEdorgDateCache.getEntriesById(staff.getEntityId()).keySet(); for (String edOrg : edOrgs) { extractor.extractEntity(staff, map.getExtractFileForEdOrg(edOrg), EntityNames.STAFF); } } } }
|
StaffExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STAFF, this.getClass().getName()); Iterator<Entity> staffs = repo.findEach(EntityNames.STAFF, new NeutralQuery()); while (staffs.hasNext()) { Entity staff = staffs.next(); Set<String> edOrgs = staffToEdorgDateCache.getEntriesById(staff.getEntityId()).keySet(); for (String edOrg : edOrgs) { extractor.extractEntity(staff, map.getExtractFileForEdOrg(edOrg), EntityNames.STAFF); } } } StaffExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); }
|
StaffExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STAFF, this.getClass().getName()); Iterator<Entity> staffs = repo.findEach(EntityNames.STAFF, new NeutralQuery()); while (staffs.hasNext()) { Entity staff = staffs.next(); Set<String> edOrgs = staffToEdorgDateCache.getEntriesById(staff.getEntityId()).keySet(); for (String edOrg : edOrgs) { extractor.extractEntity(staff, map.getExtractFileForEdOrg(edOrg), EntityNames.STAFF); } } } StaffExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache); }
|
StaffExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STAFF, this.getClass().getName()); Iterator<Entity> staffs = repo.findEach(EntityNames.STAFF, new NeutralQuery()); while (staffs.hasNext()) { Entity staff = staffs.next(); Set<String> edOrgs = staffToEdorgDateCache.getEntriesById(staff.getEntityId()).keySet(); for (String edOrg : edOrgs) { extractor.extractEntity(staff, map.getExtractFileForEdOrg(edOrg), EntityNames.STAFF); } } } StaffExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache); }
|
@Test public void testExtractNoEntityBecauseOfLEAMiss() { Mockito.when(mockEntity.getEntityId()).thenReturn("Staff2"); Mockito.when(mockRepo.findEach(Mockito.eq(EntityNames.STAFF), Mockito.eq(new NeutralQuery()))).thenReturn( Arrays.asList(mockEntity).iterator()); Mockito.when(mockMap.getExtractFileForEdOrg("LEA")).thenReturn(null); extractor.extractEntities(staffToLeaDateCache); Mockito.verify(mockExtractor, Mockito.never()).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq(EntityNames.STAFF)); }
|
@Override public void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STAFF, this.getClass().getName()); Iterator<Entity> staffs = repo.findEach(EntityNames.STAFF, new NeutralQuery()); while (staffs.hasNext()) { Entity staff = staffs.next(); Set<String> edOrgs = staffToEdorgDateCache.getEntriesById(staff.getEntityId()).keySet(); for (String edOrg : edOrgs) { extractor.extractEntity(staff, map.getExtractFileForEdOrg(edOrg), EntityNames.STAFF); } } }
|
StaffExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STAFF, this.getClass().getName()); Iterator<Entity> staffs = repo.findEach(EntityNames.STAFF, new NeutralQuery()); while (staffs.hasNext()) { Entity staff = staffs.next(); Set<String> edOrgs = staffToEdorgDateCache.getEntriesById(staff.getEntityId()).keySet(); for (String edOrg : edOrgs) { extractor.extractEntity(staff, map.getExtractFileForEdOrg(edOrg), EntityNames.STAFF); } } } }
|
StaffExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STAFF, this.getClass().getName()); Iterator<Entity> staffs = repo.findEach(EntityNames.STAFF, new NeutralQuery()); while (staffs.hasNext()) { Entity staff = staffs.next(); Set<String> edOrgs = staffToEdorgDateCache.getEntriesById(staff.getEntityId()).keySet(); for (String edOrg : edOrgs) { extractor.extractEntity(staff, map.getExtractFileForEdOrg(edOrg), EntityNames.STAFF); } } } StaffExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); }
|
StaffExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STAFF, this.getClass().getName()); Iterator<Entity> staffs = repo.findEach(EntityNames.STAFF, new NeutralQuery()); while (staffs.hasNext()) { Entity staff = staffs.next(); Set<String> edOrgs = staffToEdorgDateCache.getEntriesById(staff.getEntityId()).keySet(); for (String edOrg : edOrgs) { extractor.extractEntity(staff, map.getExtractFileForEdOrg(edOrg), EntityNames.STAFF); } } } StaffExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache); }
|
StaffExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STAFF, this.getClass().getName()); Iterator<Entity> staffs = repo.findEach(EntityNames.STAFF, new NeutralQuery()); while (staffs.hasNext()) { Entity staff = staffs.next(); Set<String> edOrgs = staffToEdorgDateCache.getEntriesById(staff.getEntityId()).keySet(); for (String edOrg : edOrgs) { extractor.extractEntity(staff, map.getExtractFileForEdOrg(edOrg), EntityNames.STAFF); } } } StaffExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache); }
|
@Test public void testOneExtractedEntity() { Entity e = Mockito.mock(Entity.class); Mockito.when(mockRepo.findEach(Mockito.eq("student"), Mockito.eq(new NeutralQuery()))).thenReturn(Arrays.asList(e).iterator()); Map<String, DateTime> datedEdorgs = new HashMap<String, DateTime>(); datedEdorgs.put("LEA", DateTime.now()); Mockito.when(helper.fetchAllEdOrgsForStudent(Mockito.any(Entity.class))).thenReturn(datedEdorgs); extractor.extractEntities(null); Mockito.verify(mockExtractor).extractEntity(Mockito.any(Entity.class), Mockito.any(ExtractFile.class), Mockito.eq("student"), Mockito.any(Predicate.class)); }
|
@Override public void extractEntities(EntityToEdOrgCache dummyCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STUDENT, this.getClass().getName()); Iterator<Entity> cursor = repo.findEach(EntityNames.STUDENT, new NeutralQuery()); while (cursor.hasNext()) { Entity student = cursor.next(); buildStudentDatedCache(student); final Map<String, DateTime> datedEdOrgs = studentDatedCache.getEntriesById(student.getEntityId()); for (final String edOrg : map.getEdOrgs()) { if (datedEdOrgs.containsKey(edOrg)) { extractor.extractEntity(student, map.getExtractFileForEdOrg(edOrg), EntityNames.STUDENT, new Predicate<Entity>() { @Override public boolean apply(Entity input) { boolean shouldExtract = true; if (DATED_SUBDOCS.contains(input.getType())) { DateTime upToDate = datedEdOrgs.get(edOrg); shouldExtract = EntityDateHelper.shouldExtract(input, upToDate); } return shouldExtract; } }); Iterable<String> parents = helper.fetchCurrentParentsFromStudent(student); for (String parent : parents) { parentCache.addEntry(parent, edOrg); } } } List<Entity> sdias = student.getEmbeddedData().get("studentDisciplineIncidentAssociation"); if (sdias != null) { for (Entity sdia : sdias) { String did = (String) sdia.getBody().get("disciplineIncidentId"); Map<String, DateTime> edOrgsDate = studentDatedCache.getEntriesById(student.getEntityId()); for (Map.Entry<String, DateTime> entry : edOrgsDate.entrySet()) { diDateCache.addEntry(did, entry.getKey(), entry.getValue()); } } } } }
|
StudentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache dummyCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STUDENT, this.getClass().getName()); Iterator<Entity> cursor = repo.findEach(EntityNames.STUDENT, new NeutralQuery()); while (cursor.hasNext()) { Entity student = cursor.next(); buildStudentDatedCache(student); final Map<String, DateTime> datedEdOrgs = studentDatedCache.getEntriesById(student.getEntityId()); for (final String edOrg : map.getEdOrgs()) { if (datedEdOrgs.containsKey(edOrg)) { extractor.extractEntity(student, map.getExtractFileForEdOrg(edOrg), EntityNames.STUDENT, new Predicate<Entity>() { @Override public boolean apply(Entity input) { boolean shouldExtract = true; if (DATED_SUBDOCS.contains(input.getType())) { DateTime upToDate = datedEdOrgs.get(edOrg); shouldExtract = EntityDateHelper.shouldExtract(input, upToDate); } return shouldExtract; } }); Iterable<String> parents = helper.fetchCurrentParentsFromStudent(student); for (String parent : parents) { parentCache.addEntry(parent, edOrg); } } } List<Entity> sdias = student.getEmbeddedData().get("studentDisciplineIncidentAssociation"); if (sdias != null) { for (Entity sdia : sdias) { String did = (String) sdia.getBody().get("disciplineIncidentId"); Map<String, DateTime> edOrgsDate = studentDatedCache.getEntriesById(student.getEntityId()); for (Map.Entry<String, DateTime> entry : edOrgsDate.entrySet()) { diDateCache.addEntry(did, entry.getKey(), entry.getValue()); } } } } } }
|
StudentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache dummyCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STUDENT, this.getClass().getName()); Iterator<Entity> cursor = repo.findEach(EntityNames.STUDENT, new NeutralQuery()); while (cursor.hasNext()) { Entity student = cursor.next(); buildStudentDatedCache(student); final Map<String, DateTime> datedEdOrgs = studentDatedCache.getEntriesById(student.getEntityId()); for (final String edOrg : map.getEdOrgs()) { if (datedEdOrgs.containsKey(edOrg)) { extractor.extractEntity(student, map.getExtractFileForEdOrg(edOrg), EntityNames.STUDENT, new Predicate<Entity>() { @Override public boolean apply(Entity input) { boolean shouldExtract = true; if (DATED_SUBDOCS.contains(input.getType())) { DateTime upToDate = datedEdOrgs.get(edOrg); shouldExtract = EntityDateHelper.shouldExtract(input, upToDate); } return shouldExtract; } }); Iterable<String> parents = helper.fetchCurrentParentsFromStudent(student); for (String parent : parents) { parentCache.addEntry(parent, edOrg); } } } List<Entity> sdias = student.getEmbeddedData().get("studentDisciplineIncidentAssociation"); if (sdias != null) { for (Entity sdia : sdias) { String did = (String) sdia.getBody().get("disciplineIncidentId"); Map<String, DateTime> edOrgsDate = studentDatedCache.getEntriesById(student.getEntityId()); for (Map.Entry<String, DateTime> entry : edOrgsDate.entrySet()) { diDateCache.addEntry(did, entry.getKey(), entry.getValue()); } } } } } StudentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
ExtractorHelper helper, EdOrgExtractHelper edOrgExtractHelper); }
|
StudentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache dummyCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STUDENT, this.getClass().getName()); Iterator<Entity> cursor = repo.findEach(EntityNames.STUDENT, new NeutralQuery()); while (cursor.hasNext()) { Entity student = cursor.next(); buildStudentDatedCache(student); final Map<String, DateTime> datedEdOrgs = studentDatedCache.getEntriesById(student.getEntityId()); for (final String edOrg : map.getEdOrgs()) { if (datedEdOrgs.containsKey(edOrg)) { extractor.extractEntity(student, map.getExtractFileForEdOrg(edOrg), EntityNames.STUDENT, new Predicate<Entity>() { @Override public boolean apply(Entity input) { boolean shouldExtract = true; if (DATED_SUBDOCS.contains(input.getType())) { DateTime upToDate = datedEdOrgs.get(edOrg); shouldExtract = EntityDateHelper.shouldExtract(input, upToDate); } return shouldExtract; } }); Iterable<String> parents = helper.fetchCurrentParentsFromStudent(student); for (String parent : parents) { parentCache.addEntry(parent, edOrg); } } } List<Entity> sdias = student.getEmbeddedData().get("studentDisciplineIncidentAssociation"); if (sdias != null) { for (Entity sdia : sdias) { String did = (String) sdia.getBody().get("disciplineIncidentId"); Map<String, DateTime> edOrgsDate = studentDatedCache.getEntriesById(student.getEntityId()); for (Map.Entry<String, DateTime> entry : edOrgsDate.entrySet()) { diDateCache.addEntry(did, entry.getKey(), entry.getValue()); } } } } } StudentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
ExtractorHelper helper, EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgCache dummyCache); EntityToEdOrgCache getParentCache(); EntityToEdOrgDateCache getStudentDatedCache(); EntityToEdOrgDateCache getDiDateCache(); }
|
StudentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache dummyCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STUDENT, this.getClass().getName()); Iterator<Entity> cursor = repo.findEach(EntityNames.STUDENT, new NeutralQuery()); while (cursor.hasNext()) { Entity student = cursor.next(); buildStudentDatedCache(student); final Map<String, DateTime> datedEdOrgs = studentDatedCache.getEntriesById(student.getEntityId()); for (final String edOrg : map.getEdOrgs()) { if (datedEdOrgs.containsKey(edOrg)) { extractor.extractEntity(student, map.getExtractFileForEdOrg(edOrg), EntityNames.STUDENT, new Predicate<Entity>() { @Override public boolean apply(Entity input) { boolean shouldExtract = true; if (DATED_SUBDOCS.contains(input.getType())) { DateTime upToDate = datedEdOrgs.get(edOrg); shouldExtract = EntityDateHelper.shouldExtract(input, upToDate); } return shouldExtract; } }); Iterable<String> parents = helper.fetchCurrentParentsFromStudent(student); for (String parent : parents) { parentCache.addEntry(parent, edOrg); } } } List<Entity> sdias = student.getEmbeddedData().get("studentDisciplineIncidentAssociation"); if (sdias != null) { for (Entity sdia : sdias) { String did = (String) sdia.getBody().get("disciplineIncidentId"); Map<String, DateTime> edOrgsDate = studentDatedCache.getEntriesById(student.getEntityId()); for (Map.Entry<String, DateTime> entry : edOrgsDate.entrySet()) { diDateCache.addEntry(did, entry.getKey(), entry.getValue()); } } } } } StudentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo,
ExtractorHelper helper, EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgCache dummyCache); EntityToEdOrgCache getParentCache(); EntityToEdOrgDateCache getStudentDatedCache(); EntityToEdOrgDateCache getDiDateCache(); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.