@BeforeTest
  public void createEntity() {
    entityType = when(mock(EntityType.class).getName()).thenReturn("Source").getMock();
    Attribute idAttr = when(mock(Attribute.class).getName()).thenReturn("Identifier").getMock();

    when(idAttr.getDataType()).thenReturn(INT);
    Attribute intAttr = when(mock(Attribute.class).getName()).thenReturn("Int").getMock();
    when(intAttr.getDataType()).thenReturn(INT);
    Attribute stringAttr = when(mock(Attribute.class).getName()).thenReturn("String").getMock();
    when(stringAttr.getDataType()).thenReturn(STRING);
    Attribute nonNumericStringAttr =
        when(mock(Attribute.class).getName()).thenReturn("NonNumericString").getMock();
    when(nonNumericStringAttr.getDataType()).thenReturn(STRING);
    Attribute longAttr = when(mock(Attribute.class).getName()).thenReturn("Long").getMock();
    when(longAttr.getDataType()).thenReturn(LONG);
    when(entityType.getIdAttribute()).thenReturn(idAttr);
    when(entityType.getAttribute("Identifier")).thenReturn(idAttr);
    when(entityType.getAttribute("Int")).thenReturn(intAttr);
    when(entityType.getAttribute("String")).thenReturn(stringAttr);
    when(entityType.getAttribute("NonNumericString")).thenReturn(nonNumericStringAttr);
    when(entityType.getAttribute("Long")).thenReturn(longAttr);

    entity = new DynamicEntity(entityType);
    entity.set("Int", 1);
    entity.set("String", "12");
    entity.set("Long", 10L);
    entity.set("NonNumericString", "Hello World!");
  }
  private void validateEntityValueUniqueness(
      Entity entity, ValidationResource validationResource, ValidationMode validationMode) {
    validationResource
        .getUniqueAttrs()
        .forEach(
            uniqueAttr -> {
              Object attrValue = entity.get(uniqueAttr.getName());
              if (attrValue != null) {
                if (uniqueAttr.getDataType() instanceof XrefField) {
                  attrValue = ((Entity) attrValue).getIdValue();
                }

                HugeMap<Object, Object> uniqueAttrValues =
                    validationResource.getUniqueAttrsValues().get(uniqueAttr.getName());
                Object existingEntityId = uniqueAttrValues.get(attrValue);
                if ((validationMode == ValidationMode.ADD && existingEntityId != null)
                    || (validationMode == ValidationMode.UPDATE
                        && existingEntityId != null
                        && !existingEntityId.equals(entity.getIdValue()))) {
                  ConstraintViolation constraintViolation =
                      new ConstraintViolation(
                          format(
                              "Duplicate value '%s' for unique attribute '%s' from entity '%s'",
                              attrValue, uniqueAttr.getName(), getName()),
                          uniqueAttr,
                          Long.valueOf(validationResource.getRow()));
                  validationResource.addViolation(constraintViolation);
                } else {
                  uniqueAttrValues.put(attrValue, entity.getIdValue());
                }
              }
            });
  }
  private EntityMapping toEntityMapping(Entity entityMappingEntity) {
    String identifier = entityMappingEntity.getString(EntityMappingMetaData.IDENTIFIER);

    EntityType targetEntityType;
    try {
      targetEntityType =
          dataService.getEntityType(
              entityMappingEntity.getString(EntityMappingMetaData.TARGET_ENTITY_TYPE));
    } catch (UnknownEntityException uee) {
      LOG.error(uee.getMessage());
      targetEntityType = null;
    }

    EntityType sourceEntityType;
    try {
      sourceEntityType =
          dataService.getEntityType(
              entityMappingEntity.getString(EntityMappingMetaData.SOURCE_ENTITY_TYPE));
    } catch (UnknownEntityException uee) {
      LOG.error(uee.getMessage());
      sourceEntityType = null;
    }

    List<Entity> attributeMappingEntities =
        Lists.<Entity>newArrayList(
            entityMappingEntity.getEntities(EntityMappingMetaData.ATTRIBUTE_MAPPINGS));
    List<AttributeMapping> attributeMappings =
        attributeMappingRepository.getAttributeMappings(
            attributeMappingEntities, sourceEntityType, targetEntityType);

    return new EntityMapping(identifier, sourceEntityType, targetEntityType, attributeMappings);
  }
 @Override
 public void populateTestEntity(Entity entity) throws Exception {
   entity.set("col1", sdf.parse("2012-03-13 23:59:33"));
   entity.set("col2", sdf.parse("2013-02-09 13:12:11"));
   assertEquals(entity.getUtilDate("col1"), sdf.parse("2012-03-13 23:59:33"));
   assertEquals(entity.getUtilDate("col2"), sdf.parse("2013-02-09 13:12:11"));
 }
 @Override
 public String toString() {
   StringBuilder strBuilder = new StringBuilder(entityType.getName()).append('{');
   strBuilder.append(
       stream(entityType.getAtomicAttributes().spliterator(), false)
           .map(
               attr -> {
                 StringBuilder attrStrBuilder = new StringBuilder(attr.getName()).append('=');
                 if (EntityTypeUtils.isSingleReferenceType(attr)) {
                   Entity refEntity = getEntity(attr.getName());
                   attrStrBuilder.append(refEntity != null ? refEntity.getIdValue() : null);
                 } else if (EntityTypeUtils.isMultipleReferenceType(attr)) {
                   attrStrBuilder
                       .append('[')
                       .append(
                           stream(getEntities(attr.getName()).spliterator(), false)
                               .map(Entity::getIdValue)
                               .map(Object::toString)
                               .collect(joining(",")))
                       .append(']');
                 } else {
                   attrStrBuilder.append(get(attr.getName()));
                 }
                 return attrStrBuilder.toString();
               })
           .collect(Collectors.joining("&")));
   strBuilder.append('}');
   return strBuilder.toString();
 }
  @Override
  public List<Entity> annotateEntity(Entity entity) {
    HttpGet httpGet = new HttpGet(getServiceUri(entity));
    Entity resultEntity = new MapEntity();

    if (!annotatedInput.contains(entity.get(UNIPROT_ID))) {
      annotatedInput.add(entity.get(UNIPROT_ID));
      try {
        HttpResponse response = httpClient.execute(httpGet);
        BufferedReader br =
            new BufferedReader(
                new InputStreamReader(
                    (response.getEntity().getContent()), Charset.forName("UTF-8")));

        String output;
        StringBuilder result = new StringBuilder();

        while ((output = br.readLine()) != null) {
          result.append(output);
        }
        resultEntity = parseResult(entity, result.toString());
      } catch (Exception e) {
        httpGet.abort();
        // TODO: how to handle exceptions at this point
        throw new RuntimeException(e);
      }
    }
    return Collections.singletonList(resultEntity);
  }
  @BeforeMethod
  public void beforeMethod() {
    owner = new MolgenisUser();
    owner.setUsername("flup");
    owner.setPassword("geheim");
    owner.setId("12345");
    owner.setActive(true);
    owner.setEmail("*****@*****.**");
    owner.setFirstName("Flup");
    owner.setLastName("de Flap");

    DefaultEntityMetaData target1 = new DefaultEntityMetaData("target1");
    target1.addAttribute("id", ROLE_ID);
    DefaultEntityMetaData target2 = new DefaultEntityMetaData("target2");
    target2.addAttribute("id", ROLE_ID);

    mappingProject = new MappingProject("My first mapping project", owner);
    mappingTarget1 = mappingProject.addTarget(target1);
    mappingTarget2 = mappingProject.addTarget(target2);

    Entity mappingTargetEntity = new MapEntity(MappingTargetRepositoryImpl.META_DATA);
    mappingTargetEntity.set(MappingTargetMetaData.TARGET, "target1");
    mappingTargetEntity.set(MappingTargetMetaData.IDENTIFIER, "mappingTargetID1");
    Entity mappingTargetEntity2 = new MapEntity(MappingTargetRepositoryImpl.META_DATA);
    mappingTargetEntity2.set(MappingTargetMetaData.TARGET, "target2");
    mappingTargetEntity2.set(MappingTargetMetaData.IDENTIFIER, "mappingTargetID2");
    mappingTargetEntities = asList(mappingTargetEntity, mappingTargetEntity2);

    mappingProjectEntity = new MapEntity(META_DATA);
    mappingProjectEntity.set(IDENTIFIER, "mappingProjectID");
    mappingProjectEntity.set(MAPPINGTARGETS, mappingTargetEntities);
    mappingProjectEntity.set(OWNER, owner);
    mappingProjectEntity.set(NAME, "My first mapping project");
  }
 @Override
 public Entity createTestEntity() {
   Entity e = new MapEntity();
   e.set("col1", "lorem");
   e.set("col2", "ipsum");
   return e;
 }
  /**
   * @param entityName The name of the entity to update
   * @param attributeName The name of the attribute to update
   * @param request EntityCollectionBatchRequestV2
   * @param response HttpServletResponse
   * @throws Exception
   */
  @RequestMapping(value = "/{entityName}/{attributeName}", method = PUT)
  @ResponseStatus(OK)
  public synchronized void updateAttribute(
      @PathVariable("entityName") String entityName,
      @PathVariable("attributeName") String attributeName,
      @RequestBody @Valid EntityCollectionBatchRequestV2 request,
      HttpServletResponse response)
      throws Exception {
    final EntityMetaData meta = dataService.getEntityMetaData(entityName);
    if (meta == null) {
      throw createUnknownEntityException(entityName);
    }

    try {
      AttributeMetaData attr = meta.getAttribute(attributeName);
      if (attr == null) {
        throw createUnknownAttributeException(entityName, attributeName);
      }

      if (attr.isReadonly()) {
        throw createMolgenisDataAccessExceptionReadOnlyAttribute(entityName, attributeName);
      }

      final List<Entity> entities =
          request
              .getEntities()
              .stream()
              .filter(e -> e.size() == 2)
              .map(e -> this.restService.toEntity(meta, e))
              .collect(Collectors.toList());
      if (entities.size() != request.getEntities().size()) {
        throw createMolgenisDataExceptionIdentifierAndValue();
      }

      final List<Entity> updatedEntities = new ArrayList<Entity>();
      int count = 0;
      for (Entity entity : entities) {
        String id = checkForEntityId(entity, count);

        Entity originalEntity = dataService.findOne(entityName, id);
        if (originalEntity == null) {
          throw createUnknownEntityExceptionNotValidId(id);
        }

        Object value = this.restService.toEntityValue(attr, entity.get(attributeName));
        originalEntity.set(attributeName, value);
        updatedEntities.add(originalEntity);
        count++;
      }

      // update all entities
      this.dataService.update(entityName, updatedEntities.stream());
      response.setStatus(HttpServletResponse.SC_OK);
    } catch (Exception e) {
      response.setStatus(HttpServletResponse.SC_NO_CONTENT);
      throw e;
    }
  }
Exemple #10
0
 @Test
 public void checkRangeMaxOnly() {
   Entity entity = new DynamicEntity(intRangeMaxMeta);
   entity.set("id", "123");
   entity.set("intrangemin", 0);
   Set<ConstraintViolation> constraints =
       entityAttributesValidator.validate(entity, intRangeMaxMeta);
   assertTrue(constraints.isEmpty());
 }
Exemple #11
0
 @Test
 public void checkRangeMaxOnlyInvalid() {
   Entity entity = new DynamicEntity(intRangeMaxMeta);
   entity.set("id", "123");
   entity.set("intrangemin", 2);
   Set<ConstraintViolation> constraints =
       entityAttributesValidator.validate(entity, intRangeMaxMeta);
   assertEquals(constraints.size(), 1);
 }
Exemple #12
0
  /**
   * Creates a internal molgenis id from a vcf entity
   *
   * @param vcfEntity
   * @return the id
   */
  public static String createId(Entity vcfEntity) {
    StringBuilder id = new StringBuilder();
    id.append(StringUtils.strip(vcfEntity.get(CHROM).toString()));
    id.append("_");
    id.append(StringUtils.strip(vcfEntity.get(POS).toString()));
    id.append("_");
    id.append(StringUtils.strip(vcfEntity.get(REF).toString()));
    id.append("_");
    id.append(StringUtils.strip(vcfEntity.get(ALT).toString()));

    return id.toString();
  }
 Entity getDefaultSettings() {
   Entity defaultSettingsEntity = new DynamicEntity(this);
   for (Attribute attr : this.getAtomicAttributes()) {
     // default values are stored/retrieved as strings, so we convert them to the required type
     // here.
     String defaultValue = attr.getDefaultValue();
     if (defaultValue != null) {
       Object typedDefaultValue = getTypedValue(defaultValue, attr, entityManager);
       defaultSettingsEntity.set(attr.getName(), typedDefaultValue);
     }
   }
   return defaultSettingsEntity;
 }
 private Entity toEntityMappingEntity(
     EntityMapping entityMapping, List<Entity> attributeMappingEntities) {
   Entity entityMappingEntity = new DynamicEntity(entityMappingMetaData);
   entityMappingEntity.set(EntityMappingMetaData.IDENTIFIER, entityMapping.getIdentifier());
   entityMappingEntity.set(EntityMappingMetaData.SOURCE_ENTITY_TYPE, entityMapping.getName());
   entityMappingEntity.set(
       EntityMappingMetaData.TARGET_ENTITY_TYPE,
       entityMapping.getTargetEntityType() != null
           ? entityMapping.getTargetEntityType().getName()
           : null);
   entityMappingEntity.set(EntityMappingMetaData.ATTRIBUTE_MAPPINGS, attributeMappingEntities);
   return entityMappingEntity;
 }
 private Entity toEntityMappingEntity(
     EntityMapping entityMapping, List<Entity> attributeMappingEntities) {
   Entity entityMappingEntity = new MapEntity(META_DATA);
   entityMappingEntity.set(EntityMappingMetaData.IDENTIFIER, entityMapping.getIdentifier());
   entityMappingEntity.set(EntityMappingMetaData.SOURCEENTITYMETADATA, entityMapping.getName());
   entityMappingEntity.set(
       EntityMappingMetaData.TARGETENTITYMETADATA,
       entityMapping.getTargetEntityMetaData() != null
           ? entityMapping.getTargetEntityMetaData().getName()
           : null);
   entityMappingEntity.set(EntityMappingMetaData.ATTRIBUTEMAPPINGS, attributeMappingEntities);
   return entityMappingEntity;
 }
 @SuppressWarnings("unchecked")
 @Test
 public void iterator() throws IOException, ServiceException {
   when(spreadsheetService.getFeed(any(URL.class), (Class<IFeed>) any(Class.class)))
       .thenReturn(cellFeed)
       .thenReturn(listFeed);
   Iterator<Entity> it = spreadsheetRepository.iterator();
   assertTrue(it.hasNext());
   Entity entity = it.next();
   assertEquals(entity.getString("col1"), "val1");
   assertEquals(entity.getString("col2"), "val2");
   assertEquals(entity.getString("col3"), "val3");
   assertFalse(it.hasNext());
 }
  private void toEntity(
      EntityMetaData emd, Map<String, Entity> entities, Map<String, Entity> attributes) {
    // TODO prevent duplicates
    Entity e = new MapEntity();
    e.set("name", emd.getName());
    entities.put(emd.getName(), e);

    logger.debug("entity: " + e);

    for (AttributeMetaData amd : emd.getAttributes()) {
      Entity a = new MapEntity();
      a.set("name", amd.getName());
      a.set("entity", emd.getName());
      if (amd.getDataType() != null && amd.getDataType() != MolgenisFieldTypes.STRING)
        a.set("dataType", amd.getDataType());
      if (amd.getDefaultValue() != null) a.set("defaultValue", amd.getDefaultValue());
      if (amd.getRefEntity() != null) a.set("refEntity", amd.getRefEntity().getName());

      logger.debug("attribute: " + a);

      attributes.put(emd.getName() + "." + amd.getName(), a);

      // compound
      if (amd.getDataType() == MolgenisFieldTypes.COMPOUND
          && entities.get(amd.getRefEntity().getName()) == null) {
        this.toEntity(amd.getRefEntity(), entities, attributes);
      }
    }
  }
 /**
  * Get entity id and perform a check, throwing an MolgenisDataException when necessary
  *
  * @param entity
  * @param count
  * @return
  */
 private String checkForEntityId(Entity entity, int count) {
   Object id = entity.getIdValue();
   if (null == id) {
     throw createMolgenisDataExceptionUnknownIdentifier(count);
   }
   return id.toString();
 }
Exemple #19
0
 private FileMeta convertFile(Attribute attr, Object paramValue) {
   Entity entity = convertRef(attr, paramValue);
   if (entity == null) {
     return null;
   }
   if (!(entity instanceof FileMeta)) {
     throw new MolgenisValidationException(
         new ConstraintViolation(
             format(
                 "Attribute [%s] value is of type [%s] instead of [%s]",
                 attr.getName(),
                 entity.getClass().getSimpleName(),
                 FileMeta.class.getSimpleName())));
   }
   return (FileMeta) entity;
 }
  @RequestMapping(
      value = "/aggregate",
      method = RequestMethod.POST,
      produces = "application/json",
      consumes = "application/json")
  @ResponseBody
  public AggregateResponse aggregate(@Valid @RequestBody AggregateRequest request) {
    // TODO create utility class to extract info from entity/attribute uris
    String[] attributeUriTokens = request.getAttributeUri().split("/");
    String entityName = attributeUriTokens[3];
    String attributeName = attributeUriTokens[5];
    QueryImpl q = request.getQ() != null ? new QueryImpl(request.getQ()) : new QueryImpl();

    EntityMetaData entityMeta = dataService.getEntityMetaData(entityName);
    AttributeMetaData attributeMeta = entityMeta.getAttribute(attributeName);
    FieldTypeEnum dataType = attributeMeta.getDataType().getEnumType();
    if (dataType != FieldTypeEnum.BOOL && dataType != FieldTypeEnum.CATEGORICAL) {
      throw new RuntimeException("Unsupported data type " + dataType);
    }

    EntityMetaData refEntityMeta = null;
    String refAttributeName = null;
    if (dataType == FieldTypeEnum.CATEGORICAL) {
      refEntityMeta = attributeMeta.getRefEntity();
      refAttributeName = refEntityMeta.getLabelAttribute().getName();
    }
    Map<String, Integer> aggregateMap = new HashMap<String, Integer>();
    for (Entity entity : dataService.findAll(entityName, q)) {
      String val;
      switch (dataType) {
        case BOOL:
          val = entity.getString(attributeName);
          break;
        case CATEGORICAL:
          Entity refEntity = (Entity) entity.get(attributeName);
          val = refEntity.getString(refAttributeName);
          break;
        default:
          throw new RuntimeException("Unsupported data type " + dataType);
      }

      Integer count = aggregateMap.get(val);
      if (count == null) aggregateMap.put(val, 1);
      else aggregateMap.put(val, count + 1);
    }
    return new AggregateResponse(aggregateMap);
  }
 @Override
 public Double getDouble(String attributeName) {
   if (fetch.hasField(attributeName)) {
     return decoratedEntity.getDouble(attributeName);
   } else {
     return entityManager.getReference(getEntityMetaData(), getIdValue()).getDouble(attributeName);
   }
 }
  private String getServiceUri(Entity entity) {
    StringBuilder uriStringBuilder = new StringBuilder();
    uriStringBuilder.append(EBI_CHEMBLWS_URL);
    uriStringBuilder.append(entity.get(UNIPROT_ID));
    uriStringBuilder.append(".json");

    return uriStringBuilder.toString();
  }
  @Test
  public void createByUrl() throws IOException {
    InputStream in = getClass().getResourceAsStream("/testdata.csv");
    File csvFile = new File(FileUtils.getTempDirectory(), "testdata.csv");
    FileCopyUtils.copy(in, new FileOutputStream(csvFile));
    String url = "csv://" + csvFile.getAbsolutePath();

    EntitySource entitySource = new CsvEntitySource(url, null);
    try {
      assertEquals(entitySource.getUrl(), url);

      Iterator<String> it = entitySource.getEntityNames().iterator();
      assertNotNull(it);
      assertTrue(it.hasNext());
      assertEquals(it.next(), "testdata");
      assertFalse(it.hasNext());

      Repository<? extends Entity> repo = entitySource.getRepositoryByEntityName("testdata");
      assertNotNull(repo);

      Iterator<AttributeMetaData> itMeta = repo.getAttributes().iterator();
      assertNotNull(itMeta);
      assertTrue(itMeta.hasNext());

      AttributeMetaData col1 = itMeta.next();
      assertNotNull(col1);
      assertEquals(col1.getName(), "col1");

      AttributeMetaData col2 = itMeta.next();
      assertNotNull(col2);
      assertEquals(col2.getName(), "col2");
      assertFalse(itMeta.hasNext());

      Iterator<? extends Entity> itEntity = repo.iterator();
      assertNotNull(itEntity);
      assertTrue(itEntity.hasNext());

      Entity entity = itEntity.next();
      assertNotNull(entity);
      assertEquals(entity.get("col1"), "val1");
      assertEquals(entity.get("col2"), "val2");
    } finally {
      entitySource.close();
    }
  }
Exemple #24
0
  public void check(String file, String datasetMatrix) throws IOException {
    EntitySource entitySource = new ExcelEntitySourceFactory().create(new File(file));
    Repository<? extends Entity> repo = entitySource.getRepositoryByEntityName("observablefeature");

    List<String> listOfCategoricalFeatures = new ArrayList<String>();
    Map<String, List<String>> hashCategories = new HashMap<String, List<String>>();

    for (Entity entity : repo) {
      if ("categorical".equals(entity.getString("dataType"))) {
        listOfCategoricalFeatures.add(entity.getString("identifier"));
        hashCategories.put(entity.getString("identifier"), new ArrayList<String>());
      }
    }

    Repository<? extends Entity> readObservableDataMatrixRepo =
        entitySource.getRepositoryByEntityName(datasetMatrix);

    for (Entity entity : readObservableDataMatrixRepo) {
      for (String category : listOfCategoricalFeatures) {
        List<String> getList = hashCategories.get(category);
        if (!hashCategories.get(category).contains(entity.getString(category))) {
          getList.add(entity.getString(category));
        }
      }
    }
    printForCategoryTab(hashCategories);
    entitySource.close();
  }
  @SuppressWarnings("unchecked")
  private void validateEntityValueReadOnly(Entity entity, ValidationResource validationResource) {
    Entity entityToUpdate = findOne(entity.getIdValue());
    validationResource
        .getReadonlyAttrs()
        .forEach(
            readonlyAttr -> {
              Object value = entity.get(readonlyAttr.getName());
              Object existingValue = entityToUpdate.get(readonlyAttr.getName());

              if (readonlyAttr.getDataType() instanceof XrefField) {
                if (value != null) {
                  value = ((Entity) value).getIdValue();
                }
                if (existingValue != null) {
                  existingValue = ((Entity) existingValue).getIdValue();
                }
              } else if (readonlyAttr.getDataType() instanceof MrefField) {
                List<Object> entityIds = new ArrayList<>();
                ((Iterable<Entity>) value)
                    .forEach(
                        mrefEntity -> {
                          entityIds.add(mrefEntity.getIdValue());
                        });
                value = entityIds;

                List<Object> existingEntityIds = new ArrayList<>();
                ((Iterable<Entity>) existingValue)
                    .forEach(
                        mrefEntity -> {
                          existingEntityIds.add(mrefEntity.getIdValue());
                        });
                existingValue = existingEntityIds;
              }

              if (value != null && existingValue != null && !value.equals(existingValue)) {
                validationResource.addViolation(
                    new ConstraintViolation(
                        format(
                            "The attribute '%s' of entity '%s' can not be changed it is readonly.",
                            readonlyAttr.getName(), getName()),
                        Long.valueOf(validationResource.getRow())));
              }
            });
  }
  @RunAsSystem
  public FileIngestJob createJob(FileIngestJobExecution fileIngestJobExecution) {
    dataService.add(FileIngestJobExecutionMetaData.ENTITY_NAME, fileIngestJobExecution);
    String username = fileIngestJobExecution.getUser();
    Progress progress = new ProgressImpl(fileIngestJobExecution, jobExecutionUpdater, mailSender);
    TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
    RunAsUserToken runAsAuthentication =
        new RunAsUserToken(
            "Job Execution",
            username,
            null,
            userDetailsService.loadUserByUsername(username).getAuthorities(),
            null);
    Entity fileIngestEntity = fileIngestJobExecution.getFileIngest();
    Entity targetEntityEntity = fileIngestEntity.getEntity(FileIngestMetaData.ENTITY_META_DATA);
    String targetEntityName = targetEntityEntity.getString(EntityMetaDataMetaData.FULL_NAME);
    String url = fileIngestEntity.getString(FileIngestMetaData.URL);
    String loader = fileIngestEntity.getString(FileIngestMetaData.LOADER);
    String failureEmail = fileIngestEntity.getString(FileIngestMetaData.FAILURE_EMAIL);

    return new FileIngestJob(
        progress,
        transactionTemplate,
        runAsAuthentication,
        fileIngester,
        targetEntityName,
        url,
        loader,
        failureEmail,
        fileIngestJobExecution.getIdentifier());
  }
 private Map<String, Object> createEntityResponse(
     Entity entity, Fetch fetch, boolean includeMetaData) {
   Map<String, Object> responseData = new LinkedHashMap<String, Object>();
   if (includeMetaData) {
     createEntityMetaResponse(entity.getEntityMetaData(), fetch, responseData);
   }
   createEntityValuesResponse(entity, fetch, responseData);
   return responseData;
 }
 private Entity parseResult(Entity entity, String json) throws IOException {
   Entity result = new MapEntity();
   if (!"".equals(json)) {
     Map<String, Object> rootMap = jsonStringToMap(json);
     Map<String, Object> resultMap = (Map<String, Object>) rootMap.get("target");
     resultMap.put(UNIPROT_ID, entity.get(UNIPROT_ID));
     result = new MapEntity(resultMap);
   }
   return result;
 }
  /**
   * A helper function that gets identifiers of all the attributes from one entityMetaData
   *
   * @param sourceEntityMetaData
   * @return
   */
  public List<String> getAttributeIdentifiers(EntityMetaData sourceEntityMetaData) {
    Entity entityMetaDataEntity =
        dataService.findOne(
            EntityMetaDataMetaData.ENTITY_NAME,
            new QueryImpl().eq(EntityMetaDataMetaData.FULL_NAME, sourceEntityMetaData.getName()));

    if (entityMetaDataEntity == null)
      throw new MolgenisDataAccessException(
          "Could not find EntityMetaDataEntity by the name of " + sourceEntityMetaData.getName());

    return FluentIterable.from(entityMetaDataEntity.getEntities(EntityMetaDataMetaData.ATTRIBUTES))
        .transform(
            new Function<Entity, String>() {
              public String apply(Entity attributeEntity) {
                return attributeEntity.getString(AttributeMetaDataMetaData.IDENTIFIER);
              }
            })
        .toList();
  }
 @Override
 public <E extends Entity> Iterable<E> getEntities(String attributeName, Class<E> clazz) {
   if (fetch.hasField(attributeName)) {
     return decoratedEntity.getEntities(attributeName, clazz);
   } else {
     return entityManager
         .getReference(getEntityMetaData(), getIdValue())
         .getEntities(attributeName, clazz);
   }
 }