conflict_resolution
stringlengths 27
16k
|
|---|
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaDataFactory;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.meta.model.EntityTypeFactory;
=======
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityMetaData;
import org.molgenis.data.meta.model.EntityMetaDataFactory;
>>>>>>>
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.meta.model.EntityTypeFactory;
<<<<<<<
private final AttributeMetaDataFactory attributeMetaDataFactory;
private final EntityTypeFactory entityTypeFactory;
=======
private final AttributeFactory attributeFactory;
private final EntityMetaDataFactory entityMetaDataFactory;
>>>>>>>
private final AttributeFactory attributeFactory;
private final EntityTypeFactory entityTypeFactory;
<<<<<<<
public OmimRepository(File file, EntityTypeFactory entityTypeFactory,
AttributeMetaDataFactory attributeMetaDataFactory)
=======
public OmimRepository(File file, EntityMetaDataFactory entityMetaDataFactory,
AttributeFactory attributeFactory)
>>>>>>>
public OmimRepository(File file, EntityTypeFactory entityTypeFactory, AttributeFactory attributeFactory)
<<<<<<<
this.entityTypeFactory = entityTypeFactory;
this.attributeMetaDataFactory = attributeMetaDataFactory;
=======
this.entityMetaDataFactory = entityMetaDataFactory;
this.attributeFactory = attributeFactory;
>>>>>>>
this.entityTypeFactory = entityTypeFactory;
this.attributeFactory = attributeFactory;
<<<<<<<
EntityType entityType = entityTypeFactory.create().setSimpleName(NAME);
entityType.addAttribute(attributeMetaDataFactory.create().setName(OMIM_GENE_SYMBOLS_COL_NAME), ROLE_ID);
entityType.addAttribute(attributeMetaDataFactory.create().setName(OMIM_PHENOTYPE_COL_NAME));
entityType.addAttribute(attributeMetaDataFactory.create().setName(OMIM_MIM_NUMBER_COL_NAME));
entityType.addAttribute(attributeMetaDataFactory.create().setName(OMIM_CYTO_LOCATION_COL_NAME));
entityType.addAttribute(attributeMetaDataFactory.create().setName(OMIM_ENTRY_COL_NAME));
entityType.addAttribute(attributeMetaDataFactory.create().setName(OMIM_TYPE_COL_NAME));
return entityType;
=======
EntityMetaData entityMeta = entityMetaDataFactory.create().setSimpleName(NAME);
entityMeta.addAttribute(attributeFactory.create().setName(OMIM_GENE_SYMBOLS_COL_NAME), ROLE_ID);
entityMeta.addAttribute(attributeFactory.create().setName(OMIM_PHENOTYPE_COL_NAME));
entityMeta.addAttribute(attributeFactory.create().setName(OMIM_MIM_NUMBER_COL_NAME));
entityMeta.addAttribute(attributeFactory.create().setName(OMIM_CYTO_LOCATION_COL_NAME));
entityMeta.addAttribute(attributeFactory.create().setName(OMIM_ENTRY_COL_NAME));
entityMeta.addAttribute(attributeFactory.create().setName(OMIM_TYPE_COL_NAME));
return entityMeta;
>>>>>>>
EntityType entityType = entityTypeFactory.create().setSimpleName(NAME);
entityType.addAttribute(attributeFactory.create().setName(OMIM_GENE_SYMBOLS_COL_NAME), ROLE_ID);
entityType.addAttribute(attributeFactory.create().setName(OMIM_PHENOTYPE_COL_NAME));
entityType.addAttribute(attributeFactory.create().setName(OMIM_MIM_NUMBER_COL_NAME));
entityType.addAttribute(attributeFactory.create().setName(OMIM_CYTO_LOCATION_COL_NAME));
entityType.addAttribute(attributeFactory.create().setName(OMIM_ENTRY_COL_NAME));
entityType.addAttribute(attributeFactory.create().setName(OMIM_TYPE_COL_NAME));
return entityType; |
<<<<<<<
import com.google.gerrit.server.extensions.webui.UiActions;
import com.google.gerrit.server.git.TransferConfig;
=======
>>>>>>>
import com.google.gerrit.server.extensions.webui.UiActions; |
<<<<<<<
EntityType mrefEntity = attr.getRefEntity();
=======
case ONE_TO_MANY:
EntityMetaData mrefEntity = attr.getRefEntity();
>>>>>>>
case ONE_TO_MANY:
EntityType mrefEntity = attr.getRefEntity(); |
<<<<<<<
import org.molgenis.MolgenisFieldTypes;
import org.molgenis.MolgenisFieldTypes.FieldTypeEnum;
=======
import org.molgenis.data.AttributeMetaData;
>>>>>>>
import org.molgenis.MolgenisFieldTypes;
import org.molgenis.MolgenisFieldTypes.FieldTypeEnum;
import org.molgenis.data.AttributeMetaData;
<<<<<<<
import org.molgenis.data.support.QueryImpl;
import org.molgenis.fieldtypes.FieldType;
=======
import org.molgenis.data.validation.ConstraintViolation;
import org.molgenis.data.validation.EntityValidator;
import org.molgenis.data.validation.MolgenisValidationException;
>>>>>>>
import org.molgenis.data.support.QueryImpl;
import org.molgenis.data.validation.ConstraintViolation;
import org.molgenis.data.validation.EntityValidator;
import org.molgenis.data.validation.MolgenisValidationException;
import org.molgenis.fieldtypes.FieldType;
<<<<<<<
dataService.addRepository(new OmxRepository(dataService, searchService, identifier));
DataSet dataSet = dataService.findOne(DataSet.ENTITY_NAME,
new QueryImpl().eq(DataSet.IDENTIFIER, identifier), DataSet.class);
List<Protocol> protocols = ProtocolUtils.getProtocolDescendants(dataSet.getProtocolUsed());
List<ObservableFeature> categoricalFeatures = new ArrayList<ObservableFeature>();
for (Protocol protocol : protocols)
{
List<ObservableFeature> observableFeatures = protocol.getFeatures();
if (observableFeatures != null)
{
for (ObservableFeature observableFeature : observableFeatures)
{
String dataType = observableFeature.getDataType();
FieldType type = MolgenisFieldTypes.getType(dataType);
if (type.getEnumType() == FieldTypeEnum.CATEGORICAL)
{
categoricalFeatures.add(observableFeature);
}
}
}
}
for (ObservableFeature categoricalFeature : categoricalFeatures)
{
dataService.addRepository(new OmxLookupTableRepository(dataService, categoricalFeature
.getIdentifier()));
}
=======
dataService
.addRepository(new OmxRepository(dataService, searchService, identifier, entityValidator));
}
// Check if all column names in the excel sheet exist as attributes of the entity
Set<ConstraintViolation> violations = Sets.newLinkedHashSet();
EntityMetaData meta = dataService.getRepositoryByEntityName(identifier);
for (AttributeMetaData attr : repository.getAttributes())
{
if (meta.getAttribute(attr.getName()) == null)
{
String message = String.format("Unknown attributename '%s' for entity '%s'. Sheet: '%s'",
attr.getName(), meta.getName(), repository.getName());
violations.add(new ConstraintViolation(message, attr.getName(), null, null, meta, 0));
}
}
if (!violations.isEmpty())
{
throw new MolgenisValidationException(violations);
}
// Import data into new OmxRepository
try
{
dataService.add(identifier, repository);
}
catch (MolgenisValidationException e)
{
// Add sheet info
for (ConstraintViolation violation : e.getViolations())
{
if (violation.getRownr() > 0)
{
// Rownr +1 for header
violation.setImportInfo(String.format("Sheet: '%s', row: %d", repository.getName(),
violation.getRownr() + 1));
}
else
{
violation.setImportInfo(String.format("Sheet: '%s'", repository.getName()));
}
}
throw e;
>>>>>>>
dataService
.addRepository(new OmxRepository(dataService, searchService, identifier, entityValidator));
DataSet dataSet = dataService.findOne(DataSet.ENTITY_NAME,
new QueryImpl().eq(DataSet.IDENTIFIER, identifier), DataSet.class);
List<Protocol> protocols = ProtocolUtils.getProtocolDescendants(dataSet.getProtocolUsed());
List<ObservableFeature> categoricalFeatures = new ArrayList<ObservableFeature>();
for (Protocol protocol : protocols)
{
List<ObservableFeature> observableFeatures = protocol.getFeatures();
if (observableFeatures != null)
{
for (ObservableFeature observableFeature : observableFeatures)
{
String dataType = observableFeature.getDataType();
FieldType type = MolgenisFieldTypes.getType(dataType);
if (type.getEnumType() == FieldTypeEnum.CATEGORICAL)
{
categoricalFeatures.add(observableFeature);
}
}
}
}
for (ObservableFeature categoricalFeature : categoricalFeatures)
{
dataService.addRepository(new OmxLookupTableRepository(dataService, categoricalFeature
.getIdentifier()));
}
}
// Check if all column names in the excel sheet exist as attributes of the entity
Set<ConstraintViolation> violations = Sets.newLinkedHashSet();
EntityMetaData meta = dataService.getRepositoryByEntityName(identifier);
for (AttributeMetaData attr : repository.getAttributes())
{
if (meta.getAttribute(attr.getName()) == null)
{
String message = String.format("Unknown attributename '%s' for entity '%s'. Sheet: '%s'",
attr.getName(), meta.getName(), repository.getName());
violations.add(new ConstraintViolation(message, attr.getName(), null, null, meta, 0));
}
}
if (!violations.isEmpty())
{
throw new MolgenisValidationException(violations);
}
// Import data into new OmxRepository
try
{
dataService.add(identifier, repository);
}
catch (MolgenisValidationException e)
{
// Add sheet info
for (ConstraintViolation violation : e.getViolations())
{
if (violation.getRownr() > 0)
{
// Rownr +1 for header
violation.setImportInfo(String.format("Sheet: '%s', row: %d", repository.getName(),
violation.getRownr() + 1));
}
else
{
violation.setImportInfo(String.format("Sheet: '%s'", repository.getName()));
}
}
throw e; |
<<<<<<<
public Integer add(Stream<? extends Entity> entities)
=======
@Transactional
public Integer add(Stream<Entity> entities)
>>>>>>>
public Integer add(Stream<Entity> entities)
<<<<<<<
public void update(Stream<? extends Entity> entities)
=======
@Transactional
public void update(Stream<Entity> entities)
>>>>>>>
public void update(Stream<Entity> entities)
<<<<<<<
public void delete(Stream<? extends Entity> entities)
=======
@Transactional
public void delete(Stream<Entity> entities)
>>>>>>>
public void delete(Stream<Entity> entities) |
<<<<<<<
.addAttribute(attributeMetaDataFactory.create().setName("id"), ROLE_ID, ROLE_LABEL, ROLE_LOOKUP);
selfRefEntityType.addAttribute(
attributeMetaDataFactory.create().setName("selfRef").setDataType(XREF).setRefEntity(selfRefEntityType));
=======
.addAttribute(attributeFactory.create().setName("id"), ROLE_ID, ROLE_LABEL, ROLE_LOOKUP);
selfRefEntityMeta.addAttribute(
attributeFactory.create().setName("selfRef").setDataType(XREF).setRefEntity(selfRefEntityMeta));
>>>>>>>
.addAttribute(attributeFactory.create().setName("id"), ROLE_ID, ROLE_LABEL, ROLE_LOOKUP);
selfRefEntityType.addAttribute(
attributeFactory.create().setName("selfRef").setDataType(XREF).setRefEntity(selfRefEntityType));
<<<<<<<
EntityType refEntityType = entityTypeFactory.create().setName(REF_ENTITY_NAME).setLabel(REF_ENTITY_NAME)
.addAttribute(attributeMetaDataFactory.create().setName(REF_ATTR_ID_NAME), ROLE_ID, ROLE_LABEL,
ROLE_LOOKUP).addAttribute(attributeMetaDataFactory.create().setName(REF_ATTR_VALUE_NAME))
.addAttribute(attributeMetaDataFactory.create().setName(REF_ATTR_REF_NAME).setDataType(XREF)
.setRefEntity(refRefEntityType));
=======
EntityMetaData refEntityMeta = entityMetaDataFactory.create().setName(REF_ENTITY_NAME).setLabel(REF_ENTITY_NAME)
.addAttribute(attributeFactory.create().setName(REF_ATTR_ID_NAME), ROLE_ID, ROLE_LABEL,
ROLE_LOOKUP).addAttribute(attributeFactory.create().setName(REF_ATTR_VALUE_NAME))
.addAttribute(attributeFactory.create().setName(REF_ATTR_REF_NAME).setDataType(XREF)
.setRefEntity(refRefEntityMeta));
>>>>>>>
EntityType refEntityType = entityTypeFactory.create().setName(REF_ENTITY_NAME).setLabel(REF_ENTITY_NAME)
.addAttribute(attributeFactory.create().setName(REF_ATTR_ID_NAME), ROLE_ID, ROLE_LABEL, ROLE_LOOKUP)
.addAttribute(attributeFactory.create().setName(REF_ATTR_VALUE_NAME)).addAttribute(
attributeFactory.create().setName(REF_ATTR_REF_NAME).setDataType(XREF)
.setRefEntity(selfRefEntityType));
<<<<<<<
AttributeMetaData attrBoolOptional = createAttributeMeta(entityType, attrBoolOptionalName, BOOL);
AttributeMetaData attrCategoricalOptional = createAttributeMeta(entityType, attrCategoricalOptionalName,
CATEGORICAL, refEntityType);
AttributeMetaData attrCategoricalMrefOptional = createAttributeMeta(entityType, attrCategoricalMrefOptionalName,
CATEGORICAL_MREF, refEntityType);
AttributeMetaData attrDateOptional = createAttributeMeta(entityType, attrDateOptionalName, DATE);
AttributeMetaData attrDateTimeOptional = createAttributeMeta(entityType, attrDateTimeOptionalName, DATE_TIME);
AttributeMetaData attrDecimalOptional = createAttributeMeta(entityType, attrDecimalOptionalName, DECIMAL, null);
AttributeMetaData attrEmailOptional = createAttributeMeta(entityType, attrEmailOptionalName, EMAIL);
AttributeMetaData attrEnumOptional = createAttributeMeta(entityType, attrEnumOptionalName, ENUM)
=======
Attribute attrBoolOptional = createAttributeMeta(entityMeta, attrBoolOptionalName, BOOL);
Attribute attrCategoricalOptional = createAttributeMeta(entityMeta, attrCategoricalOptionalName,
CATEGORICAL, refEntityMeta);
Attribute attrCategoricalMrefOptional = createAttributeMeta(entityMeta, attrCategoricalMrefOptionalName,
CATEGORICAL_MREF, refEntityMeta);
Attribute attrDateOptional = createAttributeMeta(entityMeta, attrDateOptionalName, DATE);
Attribute attrDateTimeOptional = createAttributeMeta(entityMeta, attrDateTimeOptionalName, DATE_TIME);
Attribute attrDecimalOptional = createAttributeMeta(entityMeta, attrDecimalOptionalName, DECIMAL, null);
Attribute attrEmailOptional = createAttributeMeta(entityMeta, attrEmailOptionalName, EMAIL);
Attribute attrEnumOptional = createAttributeMeta(entityMeta, attrEnumOptionalName, ENUM)
>>>>>>>
Attribute attrBoolOptional = createAttributeMeta(entityType, attrBoolOptionalName, BOOL);
Attribute attrCategoricalOptional = createAttributeMeta(entityType, attrCategoricalOptionalName, CATEGORICAL,
refEntityType);
Attribute attrCategoricalMrefOptional = createAttributeMeta(entityType, attrCategoricalMrefOptionalName,
CATEGORICAL_MREF, refEntityType);
Attribute attrDateOptional = createAttributeMeta(entityType, attrDateOptionalName, DATE);
Attribute attrDateTimeOptional = createAttributeMeta(entityType, attrDateTimeOptionalName, DATE_TIME);
Attribute attrDecimalOptional = createAttributeMeta(entityType, attrDecimalOptionalName, DECIMAL, null);
Attribute attrEmailOptional = createAttributeMeta(entityType, attrEmailOptionalName, EMAIL);
Attribute attrEnumOptional = createAttributeMeta(entityType, attrEnumOptionalName, ENUM)
<<<<<<<
private AttributeMetaData createAttributeMeta(EntityType entityType, String attrName, AttributeType type)
=======
private Attribute createAttributeMeta(EntityMetaData entityMeta, String attrName, AttributeType type)
>>>>>>>
private Attribute createAttributeMeta(EntityType entityType, String attrName, AttributeType type) |
<<<<<<<
import org.molgenis.data.meta.system.SystemEntityTypeRegistry;
import org.molgenis.util.DependencyResolver;
=======
import org.molgenis.data.meta.model.Tag;
import org.molgenis.data.meta.system.SystemEntityMetaDataRegistry;
>>>>>>>
import org.molgenis.data.meta.model.Tag;
import org.molgenis.data.meta.system.SystemEntityTypeRegistry;
<<<<<<<
import static org.molgenis.data.meta.MetaUtils.getEntityTypeFetch;
import static org.molgenis.data.meta.model.AttributeMetaDataMetaData.ATTRIBUTE_META_DATA;
import static org.molgenis.data.meta.model.EntityTypeMetadata.*;
=======
import static org.molgenis.data.meta.MetaUtils.getEntityMetaDataFetch;
import static org.molgenis.data.meta.model.AttributeMetaDataMetaData.*;
import static org.molgenis.data.meta.model.EntityMetaDataMetaData.*;
>>>>>>>
import static org.molgenis.data.meta.MetaUtils.getEntityTypeFetch;
import static org.molgenis.data.meta.model.AttributeMetaDataMetaData.*;
import static org.molgenis.data.meta.model.EntityTypeMetadata.*;
<<<<<<<
private final SystemEntityTypeRegistry systemEntityTypeRegistry;
=======
private final SystemEntityMetaDataRegistry systemEntityMetaRegistry;
private final EntityMetaDataDependencyResolver entityMetaDependencyResolver;
>>>>>>>
private final SystemEntityTypeRegistry systemEntityTypeRegistry;
private final EntityTypeDependencyResolver entityMetaDependencyResolver;
<<<<<<<
SystemEntityTypeRegistry systemEntityTypeRegistry)
=======
SystemEntityMetaDataRegistry systemEntityMetaRegistry,
EntityMetaDataDependencyResolver entityMetaDependencyResolver)
>>>>>>>
SystemEntityTypeRegistry systemEntityTypeRegistry,
EntityTypeDependencyResolver entityMetaDependencyResolver)
<<<<<<<
this.systemEntityTypeRegistry = requireNonNull(systemEntityTypeRegistry);
}
@Override
public Stream<String> getLanguageCodes()
{
return getDefaultBackend().getLanguageCodes();
=======
this.systemEntityMetaRegistry = requireNonNull(systemEntityMetaRegistry);
this.entityMetaDependencyResolver = requireNonNull(entityMetaDependencyResolver);
>>>>>>>
this.systemEntityTypeRegistry = requireNonNull(systemEntityTypeRegistry);
this.entityMetaDependencyResolver = requireNonNull(entityMetaDependencyResolver); |
<<<<<<<
=======
@Autowired
MysqlRepositoryCollection mysqlRepositoryCollection;
@Autowired
PermissionSystemService permissionSystemService;
>>>>>>>
@Autowired
PermissionSystemService permissionSystemService;
<<<<<<<
CrudRepositoryAnnotator crudRepositoryAnnotator = new CrudRepositoryAnnotator(dataService,
getNewRepositoryName(annotatorNames, repository.getEntityMetaData().getSimpleName()));
=======
CrudRepositoryAnnotator crudRepositoryAnnotator = new CrudRepositoryAnnotator(mysqlRepositoryCollection,
getNewRepositoryName(annotatorNames, repository.getEntityMetaData().getSimpleName()),
searchService, dataService, permissionSystemService);
>>>>>>>
CrudRepositoryAnnotator crudRepositoryAnnotator = new CrudRepositoryAnnotator(dataService,
getNewRepositoryName(annotatorNames, repository.getEntityMetaData().getSimpleName()),
permissionSystemService);
<<<<<<<
// running annotator
Repository repo = dataService.getRepository(entityName);
repository = crudRepositoryAnnotator.annotate(annotator, repo, createCopy);
entityName = repository.getName();
createCopy = false;
=======
try
{
// running annotator
Repository repo = dataService.getRepositoryByEntityName(entityName);
repository = crudRepositoryAnnotator.annotate(annotator, repo, createCopy);
entityName = repository.getName();
createCopy = false;
}
catch (IOException e)
{
throw new RuntimeException(e.getMessage());
}
>>>>>>>
// running annotator
try
{
Repository repo = dataService.getRepository(entityName);
repository = crudRepositoryAnnotator.annotate(annotator, repo, createCopy);
entityName = repository.getName();
createCopy = false;
}
catch (IOException e)
{
throw new RuntimeException(e.getMessage());
} |
<<<<<<<
registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/")
.setCachePeriod(3600).resourceChain(true);
// see https://github.com/spring-projects/spring-boot/issues/4403 for why the resourceChain needs to be explicitly added.
=======
// Add resource handler for apps
FileStore fileStore = fileStore();
registry.addResourceHandler("/" + PATH_SEGMENT_APPS + "/**")
.addResourceLocations("file:///" + fileStore.getStorageDir() + '/' + FILE_STORE_PLUGIN_APPS_PATH + '/');
>>>>>>>
// Add resource handler for apps
FileStore fileStore = fileStore();
registry.addResourceHandler("/" + PATH_SEGMENT_APPS + "/**")
.addResourceLocations("file:///" + fileStore.getStorageDir() + '/' + FILE_STORE_PLUGIN_APPS_PATH + '/');
registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/")
.setCachePeriod(3600).resourceChain(true);
// see https://github.com/spring-projects/spring-boot/issues/4403 for why the resourceChain needs to be explicitly added. |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
AttributeMetaData sortAttr = entityType.getAttribute(sortAttrName);
=======
Attribute sortAttr = entityMetaData.getAttribute(sortAttrName);
>>>>>>>
Attribute sortAttr = entityType.getAttribute(sortAttrName); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
AttributeMetaData attr = entityType.getAttribute(attrTokens[0]);
=======
Attribute attr = entityMetaData.getAttribute(attrTokens[0]);
>>>>>>>
Attribute attr = entityType.getAttribute(attrTokens[0]); |
<<<<<<<
import org.molgenis.data.annotation.entity.impl.CGDAnnotator;
=======
import org.molgenis.data.annotation.entity.impl.ClinicalGenomicsDatabaseServiceAnnotator;
import org.molgenis.data.annotation.entity.impl.ClinvarAnnotator;
import org.molgenis.data.annotation.entity.impl.DannAnnotator;
>>>>>>>
import org.molgenis.data.annotation.entity.impl.ClinvarAnnotator;
import org.molgenis.data.annotation.entity.impl.DannAnnotator; |
<<<<<<<
import org.molgenis.data.*;
import org.molgenis.data.support.AbstractRepository;
=======
import org.molgenis.data.AggregateResult;
import org.molgenis.data.AttributeMetaData;
import org.molgenis.data.CrudRepository;
import org.molgenis.data.DataConverter;
import org.molgenis.data.DatabaseAction;
import org.molgenis.data.Entity;
import org.molgenis.data.EntityMetaData;
import org.molgenis.data.Manageable;
import org.molgenis.data.Query;
import org.molgenis.data.QueryRule;
import org.molgenis.data.Queryable;
import org.molgenis.data.Repository;
import org.molgenis.data.Writable;
>>>>>>>
import org.molgenis.data.*;
import org.molgenis.data.support.AbstractRepository;
import org.molgenis.data.AggregateResult;
import org.molgenis.data.AttributeMetaData;
import org.molgenis.data.CrudRepository;
import org.molgenis.data.DataConverter;
import org.molgenis.data.DatabaseAction;
import org.molgenis.data.Entity;
import org.molgenis.data.EntityMetaData;
import org.molgenis.data.Manageable;
import org.molgenis.data.Query;
import org.molgenis.data.QueryRule;
import org.molgenis.data.Queryable;
import org.molgenis.data.Repository;
import org.molgenis.data.Writable;
<<<<<<<
super(metaData.getName());
if (metaData == null) throw new IllegalArgumentException("DataSource is null");
=======
if (collection == null) throw new IllegalArgumentException("DataSource is null");
>>>>>>>
super(metaData.getName()); |
<<<<<<<
=======
import java.util.ArrayList;
import java.util.Arrays;
>>>>>>>
import java.util.ArrayList;
import java.util.Arrays;
<<<<<<<
private static final int DEFAULT_BATCH_SIZE = 1000;
=======
private static final List<String> SUPPORTED_FILE_EXTENSIONS = Arrays.asList("vcf", "vcf.gz");
private static final int BATCH_SIZE = 10000;
>>>>>>>
private static final int BATCH_SIZE = 10000; |
<<<<<<<
for (Comment sc : commentsUtil.draftByChange(db, notes)) {
draftsByUser.add(sc.author.getId());
=======
for (PatchLineComment sc : plcUtil.draftByChange(db, notes())) {
draftsByUser.add(sc.getAuthor());
>>>>>>>
for (Comment sc : commentsUtil.draftByChange(db, notes())) {
draftsByUser.add(sc.author.getId()); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
AttributeMetaData sampleAttribute = entityType.getAttribute(VcfAttributes.SAMPLES);
=======
Attribute sampleAttribute = entityMetaData.getAttribute(VcfAttributes.SAMPLES);
>>>>>>>
Attribute sampleAttribute = entityType.getAttribute(VcfAttributes.SAMPLES); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
private final ImmutableSetMultimap<EntityType, SemanticTag<AttributeMetaData, LabeledResource, LabeledResource>> attributeTags;
private final ImmutableList<SemanticTag<EntityType, LabeledResource, LabeledResource>> entityTags;
=======
private final ImmutableSetMultimap<EntityMetaData, SemanticTag<Attribute, LabeledResource, LabeledResource>> attributeTags;
private final ImmutableList<SemanticTag<EntityMetaData, LabeledResource, LabeledResource>> entityTags;
>>>>>>>
private final ImmutableSetMultimap<EntityType, SemanticTag<Attribute, LabeledResource, LabeledResource>> attributeTags;
private final ImmutableList<SemanticTag<EntityType, LabeledResource, LabeledResource>> entityTags;
<<<<<<<
ImmutableSetMultimap.Builder<EntityType, SemanticTag<AttributeMetaData, LabeledResource, LabeledResource>> attrTagBuilder = ImmutableSetMultimap
=======
ImmutableSetMultimap.Builder<EntityMetaData, SemanticTag<Attribute, LabeledResource, LabeledResource>> attrTagBuilder = ImmutableSetMultimap
>>>>>>>
ImmutableSetMultimap.Builder<EntityType, SemanticTag<Attribute, LabeledResource, LabeledResource>> attrTagBuilder = ImmutableSetMultimap
<<<<<<<
public SetMultimap<EntityType, SemanticTag<AttributeMetaData, LabeledResource, LabeledResource>> getAttributeTags()
=======
public SetMultimap<EntityMetaData, SemanticTag<Attribute, LabeledResource, LabeledResource>> getAttributeTags()
>>>>>>>
public SetMultimap<EntityType, SemanticTag<Attribute, LabeledResource, LabeledResource>> getAttributeTags() |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.AttributeMetaDataFactory;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.meta.model.EntityTypeFactory;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityMetaData;
import org.molgenis.data.meta.model.EntityMetaDataFactory;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.meta.model.EntityTypeFactory;
<<<<<<<
public SortaCsvRepository(File file, EntityTypeFactory entityTypeFactory,
AttributeMetaDataFactory attrMetaFactory)
=======
public SortaCsvRepository(File file, EntityMetaDataFactory entityMetaFactory,
AttributeFactory attrMetaFactory)
>>>>>>>
public SortaCsvRepository(File file, EntityTypeFactory entityTypeFactory, AttributeFactory attrMetaFactory)
<<<<<<<
EntityTypeFactory entityTypeFactory, AttributeMetaDataFactory attrMetaFactory)
=======
EntityMetaDataFactory entityMetaFactory, AttributeFactory attrMetaFactory)
>>>>>>>
EntityTypeFactory entityTypeFactory, AttributeFactory attrMetaFactory)
<<<<<<<
AttributeMetaData nameAttribute = entityType.getAttribute(SortaServiceImpl.DEFAULT_MATCHING_NAME_FIELD);
=======
Attribute nameAttribute = entityMetaData.getAttribute(SortaServiceImpl.DEFAULT_MATCHING_NAME_FIELD);
>>>>>>>
Attribute nameAttribute = entityType.getAttribute(SortaServiceImpl.DEFAULT_MATCHING_NAME_FIELD); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.AttributeMetaDataFactory;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.meta.model.EntityTypeFactory;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityMetaData;
import org.molgenis.data.meta.model.EntityMetaDataFactory;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.meta.model.EntityTypeFactory;
<<<<<<<
EntityType targetRefEntityType = entityTypeFactory.create("POTATO_REF");
AttributeMetaData targetCodeAttributeMetaData = attrMetaFactory.create().setName("code").setDataType(INT);
AttributeMetaData targetLabelAttributeMetaData = attrMetaFactory.create().setName("label");
targetRefEntityType.addAttribute(targetCodeAttributeMetaData, ROLE_ID);
targetRefEntityType.addAttribute(targetLabelAttributeMetaData, ROLE_LABEL);
=======
EntityMetaData targetRefEntityMeta = entityMetaFactory.create("POTATO_REF");
Attribute targetCodeAttribute = attrMetaFactory.create().setName("code").setDataType(INT);
Attribute targetLabelAttribute = attrMetaFactory.create().setName("label");
targetRefEntityMeta.addAttribute(targetCodeAttribute, ROLE_ID);
targetRefEntityMeta.addAttribute(targetLabelAttribute, ROLE_LABEL);
>>>>>>>
EntityType targetRefEntityType = entityTypeFactory.create("POTATO_REF");
Attribute targetCodeAttribute = attrMetaFactory.create().setName("code").setDataType(INT);
Attribute targetLabelAttribute = attrMetaFactory.create().setName("label");
targetRefEntityType.addAttribute(targetCodeAttribute, ROLE_ID);
targetRefEntityType.addAttribute(targetLabelAttribute, ROLE_LABEL);
<<<<<<<
targetAttributeMetaData.setRefEntity(targetRefEntityType);
=======
targetAttribute.setRefEntity(targetRefEntityMeta);
>>>>>>>
targetAttribute.setRefEntity(targetRefEntityType);
<<<<<<<
targetEntityType = entityTypeFactory.create("target");
targetEntityType.addAttribute(targetAttributeMetaData);
=======
targetEntityMetaData = entityMetaFactory.create("target");
targetEntityMetaData.addAttribute(targetAttribute);
>>>>>>>
targetEntityType = entityTypeFactory.create("target");
targetEntityType.addAttribute(targetAttribute);
<<<<<<<
sourceAttributeMetaData.setRefEntity(sourceRefEntityType);
=======
sourceAttribute.setRefEntity(sourceRefEntityMetaData);
>>>>>>>
sourceAttribute.setRefEntity(sourceRefEntityType);
<<<<<<<
sourceAttributeMetaData1.setRefEntity(sourceRefEntityType1);
=======
sourceAttribute1.setRefEntity(sourceRefEntityMetaData1);
>>>>>>>
sourceAttribute1.setRefEntity(sourceRefEntityType1);
<<<<<<<
sourceAttributeMetaData2 = attrMetaFactory.create().setName("Stroke").setDataType(CATEGORICAL);
sourceAttributeMetaData2.setLabel("History of stroke");
sourceAttributeMetaData2.setRefEntity(sourceRefEntityType2);
=======
sourceAttribute2 = attrMetaFactory.create().setName("Stroke").setDataType(CATEGORICAL);
sourceAttribute2.setLabel("History of stroke");
sourceAttribute2.setRefEntity(sourceRefEntityMetaData2);
>>>>>>>
sourceAttribute2 = attrMetaFactory.create().setName("Stroke").setDataType(CATEGORICAL);
sourceAttribute2.setLabel("History of stroke");
sourceAttribute2.setRefEntity(sourceRefEntityType2);
<<<<<<<
sourceEntityType = entityTypeFactory.create("source");
sourceEntityType.addAttributes(
Lists.newArrayList(sourceAttributeMetaData, sourceAttributeMetaData1, sourceAttributeMetaData2));
=======
sourceEntityMetaData = entityMetaFactory.create("source");
sourceEntityMetaData.addAttributes(
Lists.newArrayList(sourceAttribute, sourceAttribute1, sourceAttribute2));
>>>>>>>
sourceEntityType = entityTypeFactory.create("source");
sourceEntityType.addAttributes(Lists.newArrayList(sourceAttribute, sourceAttribute1, sourceAttribute2));
<<<<<<<
AttributeMetaData sourceCodeAttributeMetaData = attrMetaFactory.create().setName("code").setDataType(INT);
AttributeMetaData sourceLabelAttributeMetaData = attrMetaFactory.create().setName("label");
sourceRefEntityType.addAttribute(sourceCodeAttributeMetaData, ROLE_ID);
sourceRefEntityType.addAttribute(sourceLabelAttributeMetaData, ROLE_LABEL);
return sourceRefEntityType;
=======
Attribute sourceCodeAttribute = attrMetaFactory.create().setName("code").setDataType(INT);
Attribute sourceLabelAttribute = attrMetaFactory.create().setName("label");
sourceRefEntityMetaData.addAttribute(sourceCodeAttribute, ROLE_ID);
sourceRefEntityMetaData.addAttribute(sourceLabelAttribute, ROLE_LABEL);
return sourceRefEntityMetaData;
>>>>>>>
Attribute sourceCodeAttribute = attrMetaFactory.create().setName("code").setDataType(INT);
Attribute sourceLabelAttribute = attrMetaFactory.create().setName("label");
sourceRefEntityType.addAttribute(sourceCodeAttribute, ROLE_ID);
sourceRefEntityType.addAttribute(sourceLabelAttribute, ROLE_LABEL);
return sourceRefEntityType;
<<<<<<<
.generate(targetAttributeMetaData, Arrays.asList(sourceAttributeMetaData, sourceAttributeMetaData1),
targetEntityType, sourceEntityType);
=======
.generate(targetAttribute, Arrays.asList(sourceAttribute, sourceAttribute1),
targetEntityMetaData, sourceEntityMetaData);
>>>>>>>
.generate(targetAttribute, Arrays.asList(sourceAttribute, sourceAttribute1), targetEntityType,
sourceEntityType);
<<<<<<<
.generate(targetAttributeMetaData, Arrays.asList(sourceAttributeMetaData, sourceAttributeMetaData1),
targetEntityType, sourceEntityType), expectedAlgorithm);
=======
.generate(targetAttribute, Arrays.asList(sourceAttribute, sourceAttribute1),
targetEntityMetaData, sourceEntityMetaData), expectedAlgorithm);
>>>>>>>
.generate(targetAttribute, Arrays.asList(sourceAttribute, sourceAttribute1), targetEntityType,
sourceEntityType), expectedAlgorithm);
<<<<<<<
String actual = categoryAlgorithmGenerator.generate(targetAttributeMetaData,
Arrays.asList(sourceAttributeMetaData1, sourceAttributeMetaData, sourceAttributeMetaData2),
targetEntityType, sourceEntityType);
=======
String actual = categoryAlgorithmGenerator.generate(targetAttribute,
Arrays.asList(sourceAttribute1, sourceAttribute, sourceAttribute2),
targetEntityMetaData, sourceEntityMetaData);
>>>>>>>
String actual = categoryAlgorithmGenerator
.generate(targetAttribute, Arrays.asList(sourceAttribute1, sourceAttribute, sourceAttribute2),
targetEntityType, sourceEntityType); |
<<<<<<<
@Test
public void getJunctionTableNameMappedBy() throws Exception
{
EntityType entityType = when(mock(EntityType.class).getName()).thenReturn("entity").getMock();
Attribute attr = when(mock(Attribute.class).getName()).thenReturn("attr").getMock();
when(attr.isMappedBy()).thenReturn(true);
EntityType refEntityMeta = when(mock(EntityType.class).getName()).thenReturn("refEntity").getMock();
when(attr.getRefEntity()).thenReturn(refEntityMeta);
Attribute refAttr = when(mock(Attribute.class).getName()).thenReturn("refAttr").getMock();
when(attr.getMappedBy()).thenReturn(refAttr);
assertEquals(PostgreSqlQueryUtils.getJunctionTableName(entityType, attr), "\"refEntity_refAttr\"");
}
=======
>>>>>>>
<<<<<<<
List<Attribute> junctionTableAttrs = newArrayList(mrefAttr, xrefAttrInversedBy);
assertEquals(PostgreSqlQueryUtils.getJunctionTableAttributes(entityType).collect(toList()), junctionTableAttrs);
=======
List<AttributeMetaData> junctionTableAttrs = newArrayList(mrefAttr);
assertEquals(PostgreSqlQueryUtils.getJunctionTableAttributes(entityMeta).collect(toList()), junctionTableAttrs);
>>>>>>>
List<Attribute> junctionTableAttrs = newArrayList(mrefAttr);
assertEquals(PostgreSqlQueryUtils.getJunctionTableAttributes(entityMeta).collect(toList()), junctionTableAttrs);
<<<<<<<
List<Attribute> junctionTableAttrs = newArrayList(stringAttr, xrefAttr);
assertEquals(PostgreSqlQueryUtils.getTableAttributes(entityType).collect(toList()), junctionTableAttrs);
=======
List<AttributeMetaData> junctionTableAttrs = newArrayList(stringAttr, xrefAttr, xrefAttrInversedBy);
assertEquals(PostgreSqlQueryUtils.getTableAttributes(entityMeta).collect(toList()), junctionTableAttrs);
>>>>>>>
List<Attribute> junctionTableAttrs = newArrayList(stringAttr, xrefAttr, xrefAttrInversedBy);
assertEquals(PostgreSqlQueryUtils.getTableAttributes(entityMeta).collect(toList()), junctionTableAttrs); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaDataFactory;
import org.molgenis.data.meta.model.EntityTypeFactory;
=======
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityMetaDataFactory;
>>>>>>>
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityTypeFactory;
<<<<<<<
this.entityTypeFactory = requireNonNull(entityTypeFactory);
this.attributeMetaDataFactory = requireNonNull(attrMetaFactory);
=======
this.entityMetaDataFactory = requireNonNull(entityMetaFactory);
this.attributeFactory = requireNonNull(attrMetaFactory);
>>>>>>>
this.entityTypeFactory = requireNonNull(entityTypeFactory);
this.attributeFactory = requireNonNull(attrMetaFactory);
<<<<<<<
return new TabixVcfRepository(file, name, vcfAttributes, entityTypeFactory, attributeMetaDataFactory);
=======
return new TabixVcfRepository(file, name, vcfAttributes, entityMetaDataFactory, attributeFactory);
>>>>>>>
return new TabixVcfRepository(file, name, vcfAttributes, entityTypeFactory, attributeFactory); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaDataFactory;
import org.molgenis.data.meta.model.EntityTypeFactory;
=======
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityMetaDataFactory;
>>>>>>>
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityTypeFactory; |
<<<<<<<
import org.molgenis.data.meta.SystemEntityType;
import org.molgenis.data.index.meta.IndexPackage;
=======
import org.molgenis.data.meta.SystemEntityMetaData;
>>>>>>>
import org.molgenis.data.meta.SystemEntityType; |
<<<<<<<
createJunctionTable(entityType, attr);
}
else
{
createColumn(entityType, attr);
=======
if (isMultipleReferenceType(attr))
{
createJunctionTable(entityMeta, attr);
}
else
{
createColumn(entityMeta, attr);
}
>>>>>>>
if (isMultipleReferenceType(attr))
{
createJunctionTable(entityType, attr);
}
else
{
createColumn(entityType, attr);
}
<<<<<<<
dropJunctionTable(entityType, attr);
}
else
{
dropColumn(entityType, attr);
=======
if (isMultipleReferenceType(attr))
{
dropJunctionTable(entityMeta, attr);
}
else
{
dropColumn(entityMeta, attr);
}
>>>>>>>
if (isMultipleReferenceType(attr))
{
dropJunctionTable(entityType, attr);
}
else
{
dropColumn(entityType, attr);
}
<<<<<<<
getJunctionTableAttributes(entityType).filter(attr -> !attr.isInversedBy())
.forEach(attr -> createJunctionTable(entityType, attr));
getJunctionTableAttributes(entityType).filter(Attribute::isInversedBy)
.forEach(attr -> createJunctionTable(entityType, attr));
=======
getJunctionTableAttributes(entityMeta).forEach(attr -> createJunctionTable(entityMeta, attr));
>>>>>>>
getJunctionTableAttributes(entityType).forEach(attr -> createJunctionTable(entityType, attr));
<<<<<<<
String addColumnSql = getSqlAddColumn(entityType, attr);
if (addColumnSql != null)
=======
String addColumnSql = getSqlAddColumn(entityMeta, attr);
if (LOG.isDebugEnabled())
>>>>>>>
String addColumnSql = getSqlAddColumn(entityType, attr);
if (LOG.isDebugEnabled())
<<<<<<<
LOG.debug("Creating column for entity [{}] attribute [{}]", entityType.getName(), attr.getName());
if (LOG.isTraceEnabled())
{
LOG.trace("SQL: {}", addColumnSql);
}
=======
LOG.trace("SQL: {}", addColumnSql);
>>>>>>>
LOG.trace("SQL: {}", addColumnSql); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
AttributeMetaData attr = entityType.getAttribute(attrName);
=======
Attribute attr = entityMeta.getAttribute(attrName);
>>>>>>>
Attribute attr = entityType.getAttribute(attrName); |
<<<<<<<
return entityTypeFactory.create().setSimpleName("Location")
.addAttribute(attributeMetaDataFactory.create().setName("Identifier").setDataType(STRING), ROLE_ID)
.addAttribute(attributeMetaDataFactory.create().setName("Chromosome").setDataType(STRING))
.addAttribute(attributeMetaDataFactory.create().setName("Position").setDataType(STRING));
=======
return entityMetaDataFactory.create().setSimpleName("Location")
.addAttribute(attributeFactory.create().setName("Identifier").setDataType(STRING), ROLE_ID)
.addAttribute(attributeFactory.create().setName("Chromosome").setDataType(STRING))
.addAttribute(attributeFactory.create().setName("Position").setDataType(STRING));
>>>>>>>
return entityTypeFactory.create().setSimpleName("Location")
.addAttribute(attributeFactory.create().setName("Identifier").setDataType(STRING), ROLE_ID)
.addAttribute(attributeFactory.create().setName("Chromosome").setDataType(STRING))
.addAttribute(attributeFactory.create().setName("Position").setDataType(STRING));
<<<<<<<
return entityTypeFactory.create().setSimpleName("Source")
.addAttribute(attributeMetaDataFactory.create().setName("Identifier").setDataType(STRING), ROLE_ID)
.addAttribute(attributeMetaDataFactory.create().setName("Int").setDataType(INT))
.addAttribute(attributeMetaDataFactory.create().setName("String").setDataType(STRING))
.addAttribute(attributeMetaDataFactory.create().setName("NonNumericString").setDataType(STRING))
.addAttribute(attributeMetaDataFactory.create().setName("Long").setDataType(LONG));
=======
return entityMetaDataFactory.create().setSimpleName("Source")
.addAttribute(attributeFactory.create().setName("Identifier").setDataType(STRING), ROLE_ID)
.addAttribute(attributeFactory.create().setName("Int").setDataType(INT))
.addAttribute(attributeFactory.create().setName("String").setDataType(STRING))
.addAttribute(attributeFactory.create().setName("NonNumericString").setDataType(STRING))
.addAttribute(attributeFactory.create().setName("Long").setDataType(LONG));
>>>>>>>
return entityTypeFactory.create().setSimpleName("Source")
.addAttribute(attributeFactory.create().setName("Identifier").setDataType(STRING), ROLE_ID)
.addAttribute(attributeFactory.create().setName("Int").setDataType(INT))
.addAttribute(attributeFactory.create().setName("String").setDataType(STRING))
.addAttribute(attributeFactory.create().setName("NonNumericString").setDataType(STRING))
.addAttribute(attributeFactory.create().setName("Long").setDataType(LONG));
<<<<<<<
EntityTypeMetadata entityTypeMeta = applicationContext.getBean(EntityTypeMetadata.class);
applicationContext.getBean(AttributeMetaDataMetaData.class).bootstrap(entityTypeMeta);
Map<String, SystemEntityType> systemEntityTypeMap = applicationContext
.getBeansOfType(SystemEntityType.class);
systemEntityTypeMap.values().forEach(systemEntityType -> systemEntityType.bootstrap(entityTypeMeta));
=======
EntityMetaDataMetaData entityMetaMeta = applicationContext.getBean(EntityMetaDataMetaData.class);
applicationContext.getBean(AttributeMetadata.class).bootstrap(entityMetaMeta);
Map<String, SystemEntityMetaData> systemEntityMetaMap = applicationContext
.getBeansOfType(SystemEntityMetaData.class);
systemEntityMetaMap.values().forEach(systemEntityMetaData -> systemEntityMetaData.bootstrap(entityMetaMeta));
>>>>>>>
EntityTypeMetadata entityTypeMeta = applicationContext.getBean(EntityTypeMetadata.class);
applicationContext.getBean(AttributeMetadata.class).bootstrap(entityTypeMeta);
Map<String, SystemEntityType> systemEntityMetaMap = applicationContext.getBeansOfType(SystemEntityType.class);
systemEntityMetaMap.values().forEach(systemEntityType -> systemEntityType.bootstrap(entityTypeMeta)); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.AttributeMetaDataFactory;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.meta.model.EntityTypeFactory;
import org.molgenis.data.semanticsearch.explain.bean.ExplainedAttributeMetaData;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityMetaData;
import org.molgenis.data.meta.model.EntityMetaDataFactory;
import org.molgenis.data.semanticsearch.explain.bean.ExplainedAttribute;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.meta.model.EntityTypeFactory;
import org.molgenis.data.semanticsearch.explain.bean.ExplainedAttribute;
<<<<<<<
EntityType sourceEntityType = entityTypeFactory.create("source");
AttributeMetaData sourceAttr0 = attrMetaFactory.create().setName(sourceAttr0Name);
AttributeMetaData sourceAttr1 = attrMetaFactory.create().setName(sourceAttr1Name);
sourceEntityType.addAttribute(sourceAttr0);
sourceEntityType.addAttribute(sourceAttr1);
=======
EntityMetaData sourceEntityMeta = entityMetaFactory.create("source");
Attribute sourceAttr0 = attrMetaFactory.create().setName(sourceAttr0Name);
Attribute sourceAttr1 = attrMetaFactory.create().setName(sourceAttr1Name);
sourceEntityMeta.addAttribute(sourceAttr0);
sourceEntityMeta.addAttribute(sourceAttr1);
>>>>>>>
EntityType sourceEntityMeta = entityTypeFactory.create("source");
Attribute sourceAttr0 = attrMetaFactory.create().setName(sourceAttr0Name);
Attribute sourceAttr1 = attrMetaFactory.create().setName(sourceAttr1Name);
sourceEntityMeta.addAttribute(sourceAttr0);
sourceEntityMeta.addAttribute(sourceAttr1); |
<<<<<<<
import com.google.gerrit.extensions.registration.DynamicMap;
=======
import com.google.gerrit.extensions.registration.DynamicItem;
>>>>>>>
import com.google.gerrit.extensions.registration.DynamicItem;
import com.google.gerrit.extensions.registration.DynamicMap;
<<<<<<<
DynamicMap.mapOf(binder(), DynamicOptions.DynamicBean.class);
=======
DynamicItem.itemOf(binder(), SshCreateCommandInterceptor.class);
>>>>>>>
DynamicMap.mapOf(binder(), DynamicOptions.DynamicBean.class);
DynamicItem.itemOf(binder(), SshCreateCommandInterceptor.class); |
<<<<<<<
import org.molgenis.data.meta.SystemEntityType;
import org.molgenis.data.meta.model.Attribute;
=======
import org.molgenis.data.Sort;
import org.molgenis.data.meta.SystemEntityMetaData;
import org.molgenis.data.meta.model.AttributeMetaData;
>>>>>>>
import org.molgenis.data.Sort;
import org.molgenis.data.meta.SystemEntityMetaData;
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.SystemEntityType;
import org.molgenis.data.meta.model.Attribute;
<<<<<<<
import static org.molgenis.data.meta.model.EntityType.AttributeRole.ROLE_ID;
import static org.molgenis.data.meta.model.EntityType.AttributeRole.ROLE_LABEL;
=======
import static org.molgenis.data.Sort.Direction.ASC;
import static org.molgenis.data.meta.model.EntityMetaData.AttributeRole.ROLE_ID;
import static org.molgenis.data.meta.model.EntityMetaData.AttributeRole.ROLE_LABEL;
>>>>>>>
import static org.molgenis.data.Sort.Direction.ASC;
import static org.molgenis.data.meta.model.EntityType.AttributeRole.ROLE_ID;
import static org.molgenis.data.meta.model.EntityType.AttributeRole.ROLE_LABEL; |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
public boolean mustDoNotNullCheck(EntityType entityType, AttributeMetaData attr, Entity entity)
=======
public boolean mustDoNotNullCheck(EntityMetaData entityMetaData, Attribute attr, Entity entity)
>>>>>>>
public boolean mustDoNotNullCheck(EntityType entityType, Attribute attr, Entity entity) |
<<<<<<<
private final DataService dataService;
=======
private Database db;
public static final Set<String> STOPWORDSLIST;
static
{
STOPWORDSLIST = new HashSet<String>(Arrays.asList("a", "you", "about", "above", "after", "again", "against",
"all", "am", "an", "and", "any", "are", "aren't", "as", "at", "be", "because", "been", "before",
"being", "below", "between", "both", "but", "by", "can't", "cannot", "could", "couldn't", "did",
"didn't", "do", "does", "doesn't", "doing", "don't", "down", "during", "each", "few", "for", "from",
"further", "had", "hadn't", "has", "hasn't", "have", "haven't", "having", "he", "he'd", "he'll",
"he's", "her", "here", "here's", "hers", "herself", "him", "himself", "his", "how", "how's", "i",
"i'd", "i'll", "i'm", "i've", "if", "in", "into", "is", "isn't", "it", "it's", "its", "itself",
"let's", "me", "more", "most", "mustn't", "my", "myself", "no", "nor", "not", "of", "off", "on",
"once", "only", "or", "other", "ought", "our", "ours ", " ourselves", "out", "over", "own", "same",
"shan't", "she", "she'd", "she'll", "she's", "should", "shouldn't", "so", "some", "such", "than",
"that", "that's", "the", "their", "theirs", "them", "themselves", "then", "there", "there's", "these",
"they", "they'd", "they'll", "they're", "they've", "this", "those", "through", "to", "too", "under",
"until", "up", "very", "was", "wasn't", "we", "we'd", "we'll", "we're", "we've", "were", "weren't",
"what", "what's", "when", "when's", "where", "where's", "which", "while", "who", "who's", "whom",
"why", "why's", "with", "won't", "would", "wouldn't", "you", "you'd", "you'll", "you're", "you've",
"your", "yours", "yourself", "yourselves", "many", ")", "("));
}
>>>>>>>
private final DataService dataService;
public static final Set<String> STOPWORDSLIST;
static
{
STOPWORDSLIST = new HashSet<String>(Arrays.asList("a", "you", "about", "above", "after", "again", "against",
"all", "am", "an", "and", "any", "are", "aren't", "as", "at", "be", "because", "been", "before",
"being", "below", "between", "both", "but", "by", "can't", "cannot", "could", "couldn't", "did",
"didn't", "do", "does", "doesn't", "doing", "don't", "down", "during", "each", "few", "for", "from",
"further", "had", "hadn't", "has", "hasn't", "have", "haven't", "having", "he", "he'd", "he'll",
"he's", "her", "here", "here's", "hers", "herself", "him", "himself", "his", "how", "how's", "i",
"i'd", "i'll", "i'm", "i've", "if", "in", "into", "is", "isn't", "it", "it's", "its", "itself",
"let's", "me", "more", "most", "mustn't", "my", "myself", "no", "nor", "not", "of", "off", "on",
"once", "only", "or", "other", "ought", "our", "ours ", " ourselves", "out", "over", "own", "same",
"shan't", "she", "she'd", "she'll", "she's", "should", "shouldn't", "so", "some", "such", "than",
"that", "that's", "the", "their", "theirs", "them", "themselves", "then", "there", "there's", "these",
"they", "they'd", "they'll", "they're", "they've", "this", "those", "through", "to", "too", "under",
"until", "up", "very", "was", "wasn't", "we", "we'd", "we'll", "we're", "we've", "were", "weren't",
"what", "what's", "when", "when's", "where", "where's", "which", "while", "who", "who's", "whom",
"why", "why's", "with", "won't", "would", "wouldn't", "you", "you'd", "you'll", "you're", "you've",
"your", "yours", "yourself", "yourselves", "many", ")", "("));
} |
<<<<<<<
import org.molgenis.data.meta.PackageImpl;
=======
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.EntityMetaData;
import org.molgenis.data.meta.PackageImpl;
<<<<<<<
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static java.util.Arrays.asList;
import static java.util.stream.Collectors.toList;
import static java.util.stream.Stream.concat;
import static java.util.stream.Stream.of;
import static org.molgenis.data.RepositoryCapability.*;
import static org.molgenis.data.Sort.Direction.DESC;
import static org.molgenis.integrationtest.data.harness.EntitiesHarness.ATTR_ID;
import static org.molgenis.integrationtest.data.harness.EntitiesHarness.ATTR_STRING;
import static org.molgenis.security.core.runas.RunAsSystemProxy.runAsSystem;
import static org.testng.Assert.*;
=======
import com.google.common.collect.Iterators;
>>>>>>>
import com.google.common.collect.Iterators;
import static java.util.Arrays.asList;
import static java.util.stream.Collectors.toList;
import static java.util.stream.Stream.concat;
import static java.util.stream.Stream.of;
import static org.molgenis.data.RepositoryCapability.*;
import static org.molgenis.data.Sort.Direction.DESC;
import static org.molgenis.integrationtest.data.harness.EntitiesHarness.ATTR_ID;
import static org.molgenis.integrationtest.data.harness.EntitiesHarness.ATTR_STRING;
import static org.molgenis.security.core.runas.RunAsSystemProxy.runAsSystem;
import static org.testng.Assert.*;
<<<<<<<
* Wait till the index is stable. Reindex job is done asynchronously.
=======
* Wait till the index is stable. Reindex job is done a-synchronized.
>>>>>>>
* Wait till the index is stable. Reindex job is done a-synchronized.
* @param entityName
* Wait till the index is stable. Reindex job is done a-synchronized.
* Wait till the index is stable. Reindex job is done asynchronously.
<<<<<<<
List<Entity> entities = create(1).collect(Collectors.toList());
dataService.add(ENTITY_NAME, entities.stream());
waitForIndexToBeStable(ENTITY_NAME);
Supplier<Stream<TestEntity>> retrieved = () -> dataService.findAll(ENTITY_NAME, TestEntity.class);
assertEquals(retrieved.get().count(), 1);
assertEquals(retrieved.get().iterator().next().getId(), entities.get(0).getIdValue());
=======
// FIXME
// List<Entity> entities = create(1);
// dataService.add(ENTITY_NAME, entities.stream());
// waitForIndexToBeStable(ENTITY_NAME);
// Supplier<Stream<TestEntity>> retrieved = () -> dataService.findAll(ENTITY_NAME, TestEntity.class);
// assertEquals(retrieved.get().count(), 1);
// assertEquals(retrieved.get().iterator().next().getId(), entities.get(0).getIdValue());
>>>>>>>
List<Entity> entities = create(1).collect(Collectors.toList());
dataService.add(ENTITY_NAME, entities.stream());
waitForIndexToBeStable(ENTITY_NAME);
Supplier<Stream<TestEntity>> retrieved = () -> dataService.findAll(ENTITY_NAME, TestEntity.class);
assertEquals(retrieved.get().count(), 1);
assertEquals(retrieved.get().iterator().next().getId(), entities.get(0).getIdValue());
<<<<<<<
List<Entity> entities = create(5).collect(Collectors.toList());
dataService.add(ENTITY_NAME, entities.stream());
waitForIndexToBeStable(ENTITY_NAME);
Supplier<Stream<TestEntity>> retrieved = () -> dataService
.findAll(ENTITY_NAME, Stream.concat(entities.stream().map(Entity::getIdValue), of("bogus")),
TestEntity.class);
assertEquals(retrieved.get().count(), entities.size());
assertEquals(retrieved.get().iterator().next().getId(), entities.get(0).getIdValue());
=======
// FIXME
// List<Entity> entities = create(5);
// dataService.add(ENTITY_NAME, entities.stream());
// waitForIndexToBeStable(ENTITY_NAME);
//
// Supplier<Stream<TestEntity>> retrieved = () -> dataService
// .findAll(ENTITY_NAME, Stream.concat(entities.stream().map(Entity::getIdValue), of("bogus")),
// TestEntity.class);
// assertEquals(retrieved.get().count(), entities.size());
// assertEquals(retrieved.get().iterator().next().getId(), entities.get(0).getIdValue());
>>>>>>>
List<Entity> entities = create(5).collect(Collectors.toList());
dataService.add(ENTITY_NAME, entities.stream());
waitForIndexToBeStable(ENTITY_NAME);
Supplier<Stream<TestEntity>> retrieved = () -> dataService
.findAll(ENTITY_NAME, Stream.concat(entities.stream().map(Entity::getIdValue), of("bogus")),
TestEntity.class);
assertEquals(retrieved.get().count(), entities.size());
assertEquals(retrieved.get().iterator().next().getId(), entities.get(0).getIdValue());
<<<<<<<
List<Entity> entities = create(5).collect(Collectors.toList());
dataService.add(ENTITY_NAME, entities.stream());
waitForIndexToBeStable(ENTITY_NAME);
Supplier<Stream<TestEntity>> found = () -> dataService
.findAll(ENTITY_NAME, new QueryImpl<TestEntity>().eq(ATTR_ID, entities.get(0).getIdValue()),
TestEntity.class);
assertEquals(found.get().count(), 1);
assertEquals(found.get().findFirst().get().getId(), entities.get(0).getIdValue());
=======
// FIXME
// List<Entity> entities = create(5);
// dataService.add(ENTITY_NAME, entities.stream());
// waitForIndexToBeStable(ENTITY_NAME);
// Supplier<Stream<TestEntity>> found = () -> dataService
// .findAll(ENTITY_NAME, new QueryImpl<TestEntity>().eq(ATTR_ID, entities.get(0).getIdValue()),
// TestEntity.class);
// assertEquals(found.get().count(), 1);
// assertEquals(found.get().findFirst().get().getId(), entities.get(0).getIdValue());
>>>>>>>
List<Entity> entities = create(5).collect(Collectors.toList());
dataService.add(ENTITY_NAME, entities.stream());
waitForIndexToBeStable(ENTITY_NAME);
Supplier<Stream<TestEntity>> found = () -> dataService
.findAll(ENTITY_NAME, new QueryImpl<TestEntity>().eq(ATTR_ID, entities.get(0).getIdValue()),
TestEntity.class);
assertEquals(found.get().count(), 1);
assertEquals(found.get().findFirst().get().getId(), entities.get(0).getIdValue());
<<<<<<<
Entity entity = create(1).findFirst().get();
dataService.add(ENTITY_NAME, Stream.of(entity));
waitForIndexToBeStable(ENTITY_NAME);
TestEntity testEntity = dataService.findOneById(ENTITY_NAME, entity.getIdValue(), TestEntity.class);
assertNotNull(testEntity);
assertEquals(testEntity.getId(), entity.getIdValue());
=======
// FIXME
// List<Entity> entities = create(1);
// dataService.add(ENTITY_NAME, entities.stream());
// waitForIndexToBeStable(ENTITY_NAME);
// TestEntity testEntity = dataService.findOneById(ENTITY_NAME, entities.get(0).getIdValue(), TestEntity.class);
// assertNotNull(testEntity);
// assertEquals(testEntity.getId(), entities.get(0).getIdValue());
>>>>>>>
Entity entity = create(1).findFirst().get();
dataService.add(ENTITY_NAME, Stream.of(entity));
waitForIndexToBeStable(ENTITY_NAME);
TestEntity testEntity = dataService.findOneById(ENTITY_NAME, entity.getIdValue(), TestEntity.class);
assertNotNull(testEntity);
assertEquals(testEntity.getId(), entity.getIdValue());
<<<<<<<
Entity entity = create(1).findFirst().get();
dataService.add(ENTITY_NAME, Stream.of(entity));
waitForIndexToBeStable(ENTITY_NAME);
TestEntity testEntity = dataService
.findOneById(ENTITY_NAME, entity.getIdValue(), new Fetch().field(ATTR_ID), TestEntity.class);
assertNotNull(testEntity);
assertEquals(testEntity.getId(), entity.getIdValue());
=======
// FIXME
// List<Entity> entities = create(1);
// dataService.add(ENTITY_NAME, entities.stream());
// waitForIndexToBeStable(ENTITY_NAME);
// TestEntity testEntity = dataService
// .findOneById(ENTITY_NAME, entities.get(0).getIdValue(), new Fetch().field(ATTR_ID), TestEntity.class);
// assertNotNull(testEntity);
// assertEquals(testEntity.getId(), entities.get(0).getIdValue());
>>>>>>>
Entity entity = create(1).findFirst().get();
dataService.add(ENTITY_NAME, Stream.of(entity));
waitForIndexToBeStable(ENTITY_NAME);
TestEntity testEntity = dataService
.findOneById(ENTITY_NAME, entity.getIdValue(), new Fetch().field(ATTR_ID), TestEntity.class);
assertNotNull(testEntity);
assertEquals(testEntity.getId(), entity.getIdValue());
<<<<<<<
Entity entity = create(1).findFirst().get();
dataService.add(ENTITY_NAME, Stream.of(entity));
waitForIndexToBeStable(ENTITY_NAME);
TestEntity testEntity = dataService
.findOne(ENTITY_NAME, new QueryImpl<TestEntity>().eq(ATTR_ID, entity.getIdValue()), TestEntity.class);
assertNotNull(testEntity);
assertEquals(testEntity.getId(), entity.getIdValue());
=======
// FIXME
// List<Entity> entities = create(1);
// dataService.add(ENTITY_NAME, entities.stream());
// waitForIndexToBeStable(ENTITY_NAME);
// TestEntity entity = dataService
// .findOne(ENTITY_NAME, new QueryImpl<TestEntity>().eq(ATTR_ID, entities.get(0).getIdValue()),
// TestEntity.class);
// assertNotNull(entity);
// assertEquals(entity.getId(), entities.get(0).getIdValue());
>>>>>>>
Entity entity = create(1).findFirst().get();
dataService.add(ENTITY_NAME, Stream.of(entity));
waitForIndexToBeStable(ENTITY_NAME);
TestEntity testEntity = dataService
.findOne(ENTITY_NAME, new QueryImpl<TestEntity>().eq(ATTR_ID, entity.getIdValue()), TestEntity.class);
assertNotNull(testEntity);
assertEquals(testEntity.getId(), entity.getIdValue());
<<<<<<<
List<Entity> refEntities = testHarness.createTestRefEntities(refEntityMetaData, 6);
runAsSystem(() -> dataService.add(REF_ENTITY_NAME, refEntities.stream()));
return testHarness.createTestEntities(entityMetaData, count, refEntities);
=======
return generate(this::create).limit(count).collect(toList());
}
private Entity create()
{
return null; // FIXME return new DefaultEntity(entityMetaData, dataService);
>>>>>>>
List<Entity> refEntities = testHarness.createTestRefEntities(refEntityMetaData, 6);
runAsSystem(() -> dataService.add(REF_ENTITY_NAME, refEntities.stream()));
return testHarness.createTestEntities(entityMetaData, count, refEntities); |
<<<<<<<
stdout.print(String.format("%8s %-12s %-12s %-4s %s\n", //
id(task.getTaskId()), start, startTime, "", format(task)));
=======
stdout.print(String.format(
"%8s %-12s %-8s %s\n",
id(taskInfo.getTaskId()), start, "",
taskInfo.getTaskString(taskNameWidth)));
>>>>>>>
stdout.print(String.format("%8s %-12s %-12s %-4s %s\n", //
id(taskInfo.getTaskId()), start, startTime, "",
taskInfo.getTaskString(taskNameWidth)));
<<<<<<<
stdout.print(String.format("%8s %-12s %-4s %s\n", //
id(task.getTaskId()), start, startTime, remoteName));
=======
stdout.print(String.format("%8s %-12s %-8s %s\n",
id(taskInfo.getTaskId()), start, "", remoteName));
>>>>>>>
stdout.print(String.format("%8s %-12s %-4s %s\n", //
id(taskInfo.getTaskId()), start, startTime, remoteName)); |
<<<<<<<
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashSet;
=======
import java.util.ArrayList;
>>>>>>>
import java.util.ArrayList;
import java.util.HashMap;
<<<<<<<
public synchronized void removeAttributeMetaData(AttributeMetaData attributeMetaData)
=======
@Override
public EditableEntityMetaData setBackend(String backend)
>>>>>>>
@Override
public EditableEntityMetaData setBackend(String backend)
<<<<<<<
public synchronized List<AttributeMetaData> getAttributes()
=======
public Iterable<AttributeMetaData> getAttributes()
>>>>>>>
public Iterable<AttributeMetaData> getAttributes()
<<<<<<<
public String getDescription(String languageCode)
{
String description = descriptionByLanguageCode.get(languageCode);
return description != null ? description : getDescription();
}
@Override
public EditableEntityMetaData setDescription(String description)
=======
public void addAttributeMetaData(AttributeMetaData attr)
>>>>>>>
public String getDescription(String languageCode)
{
String description = descriptionByLanguageCode.get(languageCode);
return description != null ? description : getDescription();
}
@Override
public void addAttributeMetaData(AttributeMetaData attr)
<<<<<<<
public EditableEntityMetaData setDescription(String languageCode, String description)
{
this.descriptionByLanguageCode.put(languageCode, description);
return this;
}
@Override
public Class<? extends Entity> getEntityClass()
=======
public void removeAttributeMetaData(AttributeMetaData attr)
>>>>>>>
public EditableEntityMetaData setDescription(String languageCode, String description)
{
this.descriptionByLanguageCode.put(languageCode, description);
return this;
}
@Override
public void removeAttributeMetaData(AttributeMetaData attr)
<<<<<<<
StringBuilder strBuilder = new StringBuilder("\nEntityMetaData(name='");
strBuilder.append(this.getName()).append('\'');
if (isAbstract()) strBuilder.append(" abstract='true'");
if (getExtends() != null) strBuilder.append(" extends='" + getExtends().getName()).append('\'');
if (getIdAttribute() != null) strBuilder.append(" idAttribute='").append(getIdAttribute().getName())
.append('\'');
if (getDescription() != null) strBuilder.append(" description='")
.append(getDescription().substring(0, Math.min(25, getDescription().length())))
.append(getDescription().length() > 25 ? "...'" : "'");
strBuilder.append(')');
for (AttributeMetaData att : this.getAttributes())
=======
this.labelAttrName = labelAttrName;
if (this.labelAttrName == null)
>>>>>>>
this.labelAttrName = labelAttrName;
if (this.labelAttrName == null) |
<<<<<<<
import javax.annotation.PostConstruct;
import javax.sql.DataSource;
=======
import javax.annotation.PostConstruct;
import javax.sql.DataSource;
import org.molgenis.DatabaseConfig;
import org.molgenis.data.Entity;
>>>>>>>
import javax.annotation.PostConstruct;
import javax.sql.DataSource;
import org.molgenis.data.Entity;
<<<<<<<
return new MolgenisRepositoryDecoratorFactory(entityManager(), entityAttributesValidator(), idGenerator,
appSettings(), dataService(), expressionValidator, repositoryDecoratorRegistry())
.createDecoratedRepository(repository);
=======
return new MolgenisRepositoryDecoratorFactory(entityManager(), transactionLogService,
entityAttributesValidator(), idGenerator(), appSettings(), dataService(), expressionValidator,
repositoryDecoratorRegistry()).createDecoratedRepository(repository);
>>>>>>>
return new MolgenisRepositoryDecoratorFactory(entityManager(), entityAttributesValidator(), idGenerator,
appSettings(), dataService(), expressionValidator, repositoryDecoratorRegistry())
.createDecoratedRepository(repository); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.AttributeMetaDataMetaData;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.semanticsearch.explain.bean.ExplainedAttributeMetaData;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.AttributeMetadata;
import org.molgenis.data.meta.model.EntityMetaData;
import org.molgenis.data.semanticsearch.explain.bean.ExplainedAttribute;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.AttributeMetadata;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.semanticsearch.explain.bean.ExplainedAttribute;
<<<<<<<
AttributeMetaData attribute = sourceEntityType
.getAttribute(attributeEntity.getString(AttributeMetaDataMetaData.NAME));
=======
Attribute attribute = sourceEntityMetaData
.getAttribute(attributeEntity.getString(AttributeMetadata.NAME));
>>>>>>>
Attribute attribute = sourceEntityType.getAttribute(attributeEntity.getString(AttributeMetadata.NAME));
<<<<<<<
String attributeId = attributeEntity.getString(AttributeMetaDataMetaData.IDENTIFIER);
String attributeName = attributeEntity.getString(AttributeMetaDataMetaData.NAME);
AttributeMetaData attribute = sourceEntityType.getAttribute(attributeName);
=======
String attributeId = attributeEntity.getString(AttributeMetadata.IDENTIFIER);
String attributeName = attributeEntity.getString(AttributeMetadata.NAME);
Attribute attribute = sourceEntityMetaData.getAttribute(attributeName);
>>>>>>>
String attributeId = attributeEntity.getString(AttributeMetadata.IDENTIFIER);
String attributeName = attributeEntity.getString(AttributeMetadata.NAME);
Attribute attribute = sourceEntityType.getAttribute(attributeName);
<<<<<<<
"The attributeMetaData : " + attributeName + " does not exsit in EntityType : "
+ sourceEntityType.getName());
=======
"The attribute : " + attributeName + " does not exsit in EntityMetaData : "
+ sourceEntityMetaData.getName());
>>>>>>>
"The attribute : " + attributeName + " does not exsit in EntityType : " + sourceEntityType
.getName());
<<<<<<<
Map<AttributeMetaData, Hit<OntologyTerm>> result = new LinkedHashMap<AttributeMetaData, Hit<OntologyTerm>>();
EntityType emd = metaDataService.getEntityType(entity);
for (AttributeMetaData amd : emd.getAtomicAttributes())
=======
Map<Attribute, Hit<OntologyTerm>> result = new LinkedHashMap<Attribute, Hit<OntologyTerm>>();
EntityMetaData emd = metaDataService.getEntityMetaData(entity);
for (Attribute amd : emd.getAtomicAttributes())
>>>>>>>
Map<Attribute, Hit<OntologyTerm>> result = new LinkedHashMap<Attribute, Hit<OntologyTerm>>();
EntityType emd = metaDataService.getEntityType(entity);
for (Attribute amd : emd.getAtomicAttributes()) |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
private EntityType entityType;
private AttributeMetaData idAttr;
=======
private EntityMetaData entityMeta;
private Attribute idAttr;
>>>>>>>
private EntityType entityType;
private Attribute idAttr;
<<<<<<<
entityType = mock(EntityType.class);
when(entityType.getName()).thenReturn(ENTITY_NAME);
idAttr = mock(AttributeMetaData.class);
=======
entityMeta = mock(EntityMetaData.class);
when(entityMeta.getName()).thenReturn(ENTITY_NAME);
idAttr = mock(Attribute.class);
>>>>>>>
entityType = mock(EntityType.class);
when(entityType.getName()).thenReturn(ENTITY_NAME);
idAttr = mock(Attribute.class);
<<<<<<<
Entity entity = new DynamicEntity(entityType);
AttributeMetaData attr0 = when(mock(AttributeMetaData.class).getName()).thenReturn("attr0").getMock();
AttributeMetaData attr1 = when(mock(AttributeMetaData.class).getName()).thenReturn("attr1").getMock();
when(entityType.getAtomicAttributes()).thenReturn(Arrays.asList(attr0, attr1));
=======
Entity entity = new DynamicEntity(entityMeta);
Attribute attr0 = when(mock(Attribute.class).getName()).thenReturn("attr0").getMock();
Attribute attr1 = when(mock(Attribute.class).getName()).thenReturn("attr1").getMock();
when(entityMeta.getAtomicAttributes()).thenReturn(Arrays.asList(attr0, attr1));
>>>>>>>
Entity entity = new DynamicEntity(entityType);
Attribute attr0 = when(mock(Attribute.class).getName()).thenReturn("attr0").getMock();
Attribute attr1 = when(mock(Attribute.class).getName()).thenReturn("attr1").getMock();
when(entityType.getAtomicAttributes()).thenReturn(Arrays.asList(attr0, attr1)); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
EntityType entityType = mock(EntityType.class);
AttributeMetaData idAttribute = mock(AttributeMetaData.class);
=======
EntityMetaData entityMetaData = mock(EntityMetaData.class);
Attribute idAttribute = mock(Attribute.class);
>>>>>>>
EntityType entityType = mock(EntityType.class);
Attribute idAttribute = mock(Attribute.class); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
import static org.molgenis.data.meta.model.AttributeMetaDataMetaData.ATTRIBUTE_META_DATA;
import static org.molgenis.data.meta.model.EntityTypeMetadata.ENTITY_META_DATA;
import static org.molgenis.data.support.EntityTypeUtils.isSingleReferenceType;
=======
import static org.molgenis.data.meta.model.AttributeMetadata.ATTRIBUTE_META_DATA;
import static org.molgenis.data.meta.model.EntityMetaDataMetaData.ENTITY_META_DATA;
import static org.molgenis.data.support.EntityMetaDataUtils.isSingleReferenceType;
>>>>>>>
import static org.molgenis.data.meta.model.AttributeMetadata.ATTRIBUTE_META_DATA;
import static org.molgenis.data.meta.model.EntityTypeMetadata.ENTITY_META_DATA;
import static org.molgenis.data.support.EntityTypeUtils.isSingleReferenceType; |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.AttributeMetaDataFactory;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.meta.model.EntityTypeFactory;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityMetaData;
import org.molgenis.data.meta.model.EntityMetaDataFactory;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.meta.model.EntityTypeFactory;
<<<<<<<
private final EntityTypeFactory entityTypeFactory;
private final AttributeMetaDataFactory attrMetaFactory;
=======
private final EntityMetaDataFactory entityMetaFactory;
private final AttributeFactory attrMetaFactory;
>>>>>>>
private final EntityTypeFactory entityTypeFactory;
private final AttributeFactory attrMetaFactory;
<<<<<<<
SortaJobExecutionFactory sortaJobExecutionFactory, EntityTypeFactory entityTypeFactory,
AttributeMetaDataFactory attrMetaFactory)
=======
SortaJobExecutionFactory sortaJobExecutionFactory, EntityMetaDataFactory entityMetaFactory,
AttributeFactory attrMetaFactory)
>>>>>>>
SortaJobExecutionFactory sortaJobExecutionFactory, EntityTypeFactory entityTypeFactory,
AttributeFactory attrMetaFactory)
<<<<<<<
EntityType sourceMetaData = dataService.getEntityType(sortaJobExecution.getSourceEntityName());
for (AttributeMetaData attributeMetaData : sourceMetaData.getAttributes())
=======
EntityMetaData sourceMetaData = dataService.getEntityMetaData(sortaJobExecution.getSourceEntityName());
for (Attribute attribute : sourceMetaData.getAttributes())
>>>>>>>
EntityType sourceMetaData = dataService.getEntityType(sortaJobExecution.getSourceEntityName());
for (Attribute attribute : sourceMetaData.getAttributes())
<<<<<<<
boolean containsName = StreamSupport.stream(repository.getEntityType().getAttributes().spliterator(), false)
.map(AttributeMetaData::getName)
=======
boolean containsName = StreamSupport.stream(repository.getEntityMetaData().getAttributes().spliterator(), false)
.map(Attribute::getName)
>>>>>>>
boolean containsName = StreamSupport.stream(repository.getEntityType().getAttributes().spliterator(), false)
.map(Attribute::getName)
<<<<<<<
boolean evaluation = StreamSupport.stream(repository.getEntityType().getAttributes().spliterator(), false)
.map(AttributeMetaData::getName).anyMatch(StringUtils::isNotBlank);
=======
boolean evaluation = StreamSupport.stream(repository.getEntityMetaData().getAttributes().spliterator(), false)
.map(Attribute::getName).anyMatch(StringUtils::isNotBlank);
>>>>>>>
boolean evaluation = StreamSupport.stream(repository.getEntityType().getAttributes().spliterator(), false)
.map(Attribute::getName).anyMatch(StringUtils::isNotBlank); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
import org.molgenis.data.meta.model.EntityMetaDataFactory;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
EntityType nlEntityType = mock(EntityType.class);
AttributeMetaData langCodeAtrr = when(mock(AttributeMetaData.class).getDataType()).thenReturn(STRING).getMock();
when(nlEntityType.getAttribute("languageCode")).thenReturn(langCodeAtrr);
DynamicEntity langEntity = new DynamicEntity(nlEntityType, of("languageCode", "nl"));
=======
EntityMetaData nlEntityMeta = mock(EntityMetaData.class);
Attribute langCodeAtrr = when(mock(Attribute.class).getDataType()).thenReturn(STRING).getMock();
when(nlEntityMeta.getAttribute("languageCode")).thenReturn(langCodeAtrr);
DynamicEntity langEntity = new DynamicEntity(nlEntityMeta, of("languageCode", "nl"));
>>>>>>>
EntityType nlEntityMeta = mock(EntityType.class);
Attribute langCodeAtrr = when(mock(Attribute.class).getDataType()).thenReturn(STRING).getMock();
when(nlEntityMeta.getAttribute("languageCode")).thenReturn(langCodeAtrr);
DynamicEntity langEntity = new DynamicEntity(nlEntityMeta, of("languageCode", "nl"));
<<<<<<<
AttributeMetaData nlAtrr = when(mock(AttributeMetaData.class).getDataType()).thenReturn(STRING).getMock();
EntityType languageMeta = mock(EntityType.class);
=======
Attribute nlAtrr = when(mock(Attribute.class).getDataType()).thenReturn(STRING).getMock();
EntityMetaData languageMeta = mock(EntityMetaData.class);
>>>>>>>
Attribute nlAtrr = when(mock(Attribute.class).getDataType()).thenReturn(STRING).getMock();
EntityType languageMeta = mock(EntityType.class); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.AttributeMetaDataFactory;
import org.molgenis.data.meta.model.EntityTypeFactory;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityMetaDataFactory;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityTypeFactory;
<<<<<<<
new HpoResultFilter(entityTypeFactory, attributeMetaDataFactory, this), dataService, resources,
=======
new HpoResultFilter(entityMetaDataFactory, attributeFactory, this), dataService, resources,
>>>>>>>
new HpoResultFilter(entityTypeFactory, attributeFactory, this), dataService, resources, |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
public static Set<AttributeMetaData> extractSourceAttributesFromAlgorithm(String algorithm,
EntityType sourceEntityType)
=======
public static Set<Attribute> extractSourceAttributesFromAlgorithm(String algorithm,
EntityMetaData sourceEntityMetaData)
>>>>>>>
public static Set<Attribute> extractSourceAttributesFromAlgorithm(String algorithm, EntityType sourceEntityType) |
<<<<<<<
throw new ResourceNotFoundException(String.format("Group %s not found", groupUuid));
} catch (DuplicateKeyException e) {
throw new ResourceConflictException("group with name " + newName + " already exists");
=======
throw new ResourceNotFoundException(String.format("Group %s not found", groupUuid), e);
} catch (OrmDuplicateKeyException e) {
throw new ResourceConflictException("group with name " + newName + " already exists", e);
>>>>>>>
throw new ResourceNotFoundException(String.format("Group %s not found", groupUuid), e);
} catch (DuplicateKeyException e) {
throw new ResourceConflictException("group with name " + newName + " already exists", e); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.meta.model.EntityTypeFactory;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
import org.molgenis.data.meta.model.EntityMetaDataFactory;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.meta.model.EntityTypeFactory;
<<<<<<<
AttributeMetaData attr = emxAttr.getAttr();
entityType.addAttribute(attr);
=======
Attribute attr = emxAttr.getAttr();
entityMeta.addAttribute(attr);
>>>>>>>
Attribute attr = emxAttr.getAttr();
entityType.addAttribute(attr); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
for (Pair<EntityType, List<AttributeMetaData>> pair : EntityUtils
.getReferencingEntityType(entityType, dataService))
=======
for (Pair<EntityMetaData, List<Attribute>> pair : EntityUtils
.getReferencingEntityMetaData(entityMetaData, dataService))
>>>>>>>
for (Pair<EntityType, List<Attribute>> pair : EntityUtils.getReferencingEntityType(entityType, dataService))
<<<<<<<
* @param referringEntityType {@link EntityType} of the referring documents
* @param referringAttributes {@link List} of {@link AttributeMetaData} of attributes that may reference the #referredEntity
=======
* @param referringEntityMetaData {@link EntityMetaData} of the referring documents
* @param referringAttributes {@link List} of {@link Attribute} of attributes that may reference the #referredEntity
>>>>>>>
* @param referringEntityType {@link EntityType} of the referring documents
* @param referringAttributes {@link List} of {@link Attribute} of attributes that may reference the #referredEntity
<<<<<<<
private Stream<Entity> findReferringDocuments(Entity referredEntity, EntityType referringEntityType,
List<AttributeMetaData> referringAttributes)
=======
private Stream<Entity> findReferringDocuments(Entity referredEntity, EntityMetaData referringEntityMetaData,
List<Attribute> referringAttributes)
>>>>>>>
private Stream<Entity> findReferringDocuments(Entity referredEntity, EntityType referringEntityType,
List<Attribute> referringAttributes)
<<<<<<<
AttributeMetaData xAttr = aggregateQuery.getAttributeX();
AttributeMetaData yAttr = aggregateQuery.getAttributeY();
AttributeMetaData distinctAttr = aggregateQuery.getAttributeDistinct();
SearchRequest searchRequest = new SearchRequest(entityType.getName(), q, xAttr, yAttr, distinctAttr);
=======
Attribute xAttr = aggregateQuery.getAttributeX();
Attribute yAttr = aggregateQuery.getAttributeY();
Attribute distinctAttr = aggregateQuery.getAttributeDistinct();
SearchRequest searchRequest = new SearchRequest(entityMetaData.getName(), q, xAttr, yAttr, distinctAttr);
>>>>>>>
Attribute xAttr = aggregateQuery.getAttributeX();
Attribute yAttr = aggregateQuery.getAttributeY();
Attribute distinctAttr = aggregateQuery.getAttributeDistinct();
SearchRequest searchRequest = new SearchRequest(entityType.getName(), q, xAttr, yAttr, distinctAttr); |
<<<<<<<
import org.molgenis.data.meta.SystemEntityType;
import org.molgenis.data.meta.model.Attribute;
=======
import org.molgenis.data.Sort;
import org.molgenis.data.meta.SystemEntityMetaData;
import org.molgenis.data.meta.model.AttributeMetaData;
>>>>>>>
import org.molgenis.data.Sort;
import org.molgenis.data.meta.SystemEntityType;
import org.molgenis.data.meta.model.Attribute;
<<<<<<<
import static org.molgenis.data.meta.model.EntityType.AttributeRole.ROLE_ID;
import static org.molgenis.data.meta.model.EntityType.AttributeRole.ROLE_LABEL;
=======
import static org.molgenis.data.Sort.Direction.DESC;
import static org.molgenis.data.meta.model.EntityMetaData.AttributeRole.ROLE_ID;
import static org.molgenis.data.meta.model.EntityMetaData.AttributeRole.ROLE_LABEL;
>>>>>>>
import static org.molgenis.data.Sort.Direction.DESC;
import static org.molgenis.data.meta.model.EntityType.AttributeRole.ROLE_ID;
import static org.molgenis.data.meta.model.EntityType.AttributeRole.ROLE_LABEL;
<<<<<<<
Attribute parentAttr = addAttribute(ATTR_PARENT).setDataType(XREF).setRefEntity(this).setNillable(false);
=======
AttributeMetaData parentAttr = addAttribute(ATTR_PARENT).setDataType(XREF).setRefEntity(this);
>>>>>>>
Attribute parentAttr = addAttribute(ATTR_PARENT).setDataType(XREF).setRefEntity(this); |
<<<<<<<
private final L1Cache l1Cache;
=======
private final EntityMetaDataMetaData entityMetaMeta;
private final I18nStringMetaData i18nStringMeta;
>>>>>>>
private final EntityMetaDataMetaData entityMetaMeta;
private final I18nStringMetaData i18nStringMeta;
private final L1Cache l1Cache;
<<<<<<<
AttributeMetaDataFactory attrMetaFactory, PasswordEncoder passwordEncoder, L1Cache l1Cache)
=======
AttributeMetaDataFactory attrMetaFactory, PasswordEncoder passwordEncoder,
EntityMetaDataMetaData entityMetaMeta, I18nStringMetaData i18nStringMeta)
>>>>>>>
AttributeMetaDataFactory attrMetaFactory, PasswordEncoder passwordEncoder,
EntityMetaDataMetaData entityMetaMeta, I18nStringMetaData i18nStringMeta, L1Cache l1Cache)
<<<<<<<
this.l1Cache = requireNonNull(l1Cache);
=======
this.entityMetaMeta = requireNonNull(entityMetaMeta);
this.i18nStringMeta = requireNonNull(i18nStringMeta);
>>>>>>>
this.entityMetaMeta = requireNonNull(entityMetaMeta);
this.i18nStringMeta = requireNonNull(i18nStringMeta);
this.l1Cache = requireNonNull(l1Cache); |
<<<<<<<
=======
import org.elasticsearch.common.collect.Lists;
import org.junit.BeforeClass;
>>>>>>>
import org.junit.BeforeClass; |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityMetaData;
import org.molgenis.data.meta.model.EntityMetaDataFactory;
=======
import org.molgenis.data.annotation.EffectsAnnotator;
>>>>>>>
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityMetaData;
import org.molgenis.data.meta.model.EntityMetaDataFactory;
import org.molgenis.data.annotation.EffectsAnnotator;
<<<<<<<
selectedAnnotator.getRequiredAttributes().stream()
.filter(requiredInputAttribute -> !areRequiredAttributesAvailable(
Lists.newArrayList(entityMetaData.getAtomicAttributes()),
Collections.singletonList(requiredInputAttribute)))
.forEachOrdered(requiredInputAttribute -> {
annotatorList.stream().filter(a -> !a.equals(selectedAnnotator)).collect(Collectors.toList())
.forEach(annotator -> resolveAnnotatorDependencies(selectedAnnotator, annotatorList,
annotatorQueue, entityMetaData, requiredInputAttribute, annotator));
});
=======
for (AttributeMetaData requiredInputAttribute : selectedAnnotator.getRequiredAttributes())
{
if (!areRequiredAttributesAvailable(Lists.newArrayList(entityMetaData.getAtomicAttributes()),
Arrays.asList(requiredInputAttribute)))
{
annotatorList.stream().filter(a -> !a.equals(selectedAnnotator)).collect(Collectors.toList())
.forEach(annotator -> resolveAnnotatorDependencies(selectedAnnotator, annotatorList,
annotatorQueue, entityMetaData, requiredInputAttribute, annotator));
}
}
>>>>>>>
selectedAnnotator.getRequiredAttributes().stream()
.filter(requiredInputAttribute -> !areRequiredAttributesAvailable(
Lists.newArrayList(entityMetaData.getAtomicAttributes()),
Collections.singletonList(requiredInputAttribute)))
.forEachOrdered(requiredInputAttribute -> {
annotatorList.stream().filter(a -> !a.equals(selectedAnnotator)).collect(Collectors.toList())
.forEach(annotator -> resolveAnnotatorDependencies(selectedAnnotator, annotatorList,
annotatorQueue, entityMetaData, requiredInputAttribute, annotator));
});
<<<<<<<
return availableAttribute.getDataType() == TEXT || availableAttribute.getDataType() == STRING;
=======
return requiredAttribute.getDataType().getEnumType().equals(MolgenisFieldTypes.FieldTypeEnum.TEXT)
|| requiredAttribute.getDataType().getEnumType()
.equals(MolgenisFieldTypes.FieldTypeEnum.STRING);
>>>>>>>
return availableAttribute.getDataType() == TEXT || availableAttribute.getDataType() == STRING; |
<<<<<<<
import static org.molgenis.data.meta.model.AttributeMetaDataMetaData.ATTRIBUTE_META_DATA;
import static org.molgenis.data.meta.model.EntityTypeMetadata.ATTRIBUTES;
import static org.molgenis.data.meta.model.EntityTypeMetadata.ENTITY_META_DATA;
=======
import static org.molgenis.data.meta.model.AttributeMetadata.ATTRIBUTE_META_DATA;
import static org.molgenis.data.meta.model.EntityMetaDataMetaData.ATTRIBUTES;
import static org.molgenis.data.meta.model.EntityMetaDataMetaData.ENTITY_META_DATA;
>>>>>>>
import static org.molgenis.data.meta.model.AttributeMetadata.ATTRIBUTE_META_DATA;
import static org.molgenis.data.meta.model.EntityTypeMetadata.ATTRIBUTES;
import static org.molgenis.data.meta.model.EntityTypeMetadata.ENTITY_META_DATA;
<<<<<<<
EntityType emd = entityTypeFactory.create().setName("org.molgenis.SNP");
AttributeMetaData attributeMetaData = attrFactory.create().setName("Chr");
=======
EntityMetaData emd = entityMetaFactory.create().setName("org.molgenis.SNP");
Attribute attribute = attrFactory.create().setName("Chr");
>>>>>>>
EntityType emd = entityTypeFactory.create().setName("org.molgenis.SNP");
Attribute attribute = attrFactory.create().setName("Chr");
<<<<<<<
EntityType emd = entityTypeFactory.create().setName("org.molgenis.SNP");
AttributeMetaData attributeMetaData = attrFactory.create().setName("Chr");
=======
EntityMetaData emd = entityMetaFactory.create().setName("org.molgenis.SNP");
Attribute attribute = attrFactory.create().setName("Chr");
>>>>>>>
EntityType emd = entityTypeFactory.create().setName("org.molgenis.SNP");
Attribute attribute = attrFactory.create().setName("Chr");
<<<<<<<
EntityType emd = entityTypeFactory.create().setName("test");
AttributeMetaData amd = attrFactory.create().setName("Chr");
=======
EntityMetaData emd = entityMetaFactory.create().setName("test");
Attribute amd = attrFactory.create().setName("Chr");
>>>>>>>
EntityType emd = entityTypeFactory.create().setName("test");
Attribute amd = attrFactory.create().setName("Chr"); |
<<<<<<<
=======
*
>>>>>>>
*
<<<<<<<
* <p>
* So we want to support this hypothetical example:
* 3 300 G A 0.2|23.1
* 3 300 G T -2.4|0.123
* 3 300 G X -0.002|2.3
* 3 300 G C 0.5|14.5
* 3 300 GC A 0.2|23.1
* 3 300 GC T -2.4|0.123
* 3 300 C GX -0.002|2.3
* 3 300 C GC 0.5|14.5
* <p>
=======
*
* So we want to support this hypothetical example: 3 300 G A 0.2|23.1 3 300 G T -2.4|0.123 3 300 G X -0.002|2.3 3
* 300 G C 0.5|14.5 3 300 GC A 0.2|23.1 3 300 GC T -2.4|0.123 3 300 C GX -0.002|2.3 3 300 C GC 0.5|14.5
*
>>>>>>>
* <p>
* So we want to support this hypothetical example:
* 3 300 G A 0.2|23.1
* 3 300 G T -2.4|0.123
* 3 300 G X -0.002|2.3
* 3 300 G C 0.5|14.5
* 3 300 GC A 0.2|23.1
* 3 300 GC T -2.4|0.123
* 3 300 C GX -0.002|2.3
* 3 300 C GC 0.5|14.5
* <p>
*
* So we want to support this hypothetical example: 3 300 G A 0.2|23.1 3 300 G T -2.4|0.123 3 300 G X -0.002|2.3 3
* 300 G C 0.5|14.5 3 300 GC A 0.2|23.1 3 300 GC T -2.4|0.123 3 300 C GX -0.002|2.3 3 300 C GC 0.5|14.5
*
<<<<<<<
* <p>
* 3 300 G A,T,X,C 0.2|23.1,-2.4|0.123,-0.002|2.3,0.5|14.5
* 3 300 GC A,T 0.2|23.1,-2.4|0.123
* 3 300 C GX,GC -0.002|2.3,0.5|14.5
* <p>
=======
*
* 3 300 G A,T,X,C 0.2|23.1,-2.4|0.123,-0.002|2.3,0.5|14.5 3 300 GC A,T 0.2|23.1,-2.4|0.123 3 300 C GX,GC
* -0.002|2.3,0.5|14.5
*
>>>>>>>
*
* 3 300 G A,T,X,C 0.2|23.1,-2.4|0.123,-0.002|2.3,0.5|14.5 3 300 GC A,T 0.2|23.1,-2.4|0.123 3 300 C GX,GC
* -0.002|2.3,0.5|14.5
*
* <p>
* 3 300 G A,T,X,C 0.2|23.1,-2.4|0.123,-0.002|2.3,0.5|14.5
* 3 300 GC A,T 0.2|23.1,-2.4|0.123
* 3 300 C GX,GC -0.002|2.3,0.5|14.5
* <p> |
<<<<<<<
AttributeMetaData attribute = entityType.getAttribute(queryRule.getField());
queryRule.setValue(restService.toEntityValue(attribute, queryRule.getValue()));
=======
AttributeMetaData attribute = entityMetaData.getAttribute(queryRule.getField());
if (queryRule.getOperator() == IN || queryRule.getOperator() == RANGE)
{
//noinspection unchecked
queryRule.setValue(stream(((Iterable<Object>) queryRule.getValue()).spliterator(), false)
.map(val -> restService.toEntityValue(attribute, val)).collect(toList()));
}
else
{
queryRule.setValue(restService.toEntityValue(attribute, queryRule.getValue()));
}
>>>>>>>
AttributeMetaData attribute = entityType.getAttribute(queryRule.getField());
if (queryRule.getOperator() == IN || queryRule.getOperator() == RANGE)
{
//noinspection unchecked
queryRule.setValue(stream(((Iterable<Object>) queryRule.getValue()).spliterator(), false)
.map(val -> restService.toEntityValue(attribute, val)).collect(toList()));
}
else
{
queryRule.setValue(restService.toEntityValue(attribute, queryRule.getValue()));
} |
<<<<<<<
public static final String HELP_HREF = "https://molgenis.gitbooks.io/molgenis/content/";
public static final String THEME_CSS_PATH = "/css/bootstrap-4/";
=======
public static final String HELP_HREF = "https://molgenis.gitbook.io/molgenis/";
>>>>>>>
public static final String HELP_HREF = "https://molgenis.gitbook.io/molgenis/";
public static final String THEME_CSS_PATH = "/css/bootstrap-4/"; |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaDataMetaData;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.meta.model.EntityTypeMetadata;
=======
import org.molgenis.data.meta.model.AttributeMetadata;
import org.molgenis.data.meta.model.EntityMetaData;
import org.molgenis.data.meta.model.EntityMetaDataMetaData;
>>>>>>>
import org.molgenis.data.meta.model.AttributeMetadata;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.meta.model.EntityTypeMetadata; |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
entityType = when(mock(EntityType.class).getName()).thenReturn("Person").getMock();
AttributeMetaData nameAttr = when(mock(AttributeMetaData.class).getName()).thenReturn("name").getMock();
=======
entityMetaData = when(mock(EntityMetaData.class).getName()).thenReturn("Person").getMock();
Attribute nameAttr = when(mock(Attribute.class).getName()).thenReturn("name").getMock();
>>>>>>>
entityType = when(mock(EntityType.class).getName()).thenReturn("Person").getMock();
Attribute nameAttr = when(mock(Attribute.class).getName()).thenReturn("name").getMock();
<<<<<<<
genderEntityType = when(mock(EntityType.class).getName()).thenReturn("Gender").getMock();
AttributeMetaData genderIdAttribute = when(mock(AttributeMetaData.class).getName()).thenReturn("id").getMock();
=======
genderEntityMetaData = when(mock(EntityMetaData.class).getName()).thenReturn("Gender").getMock();
Attribute genderIdAttribute = when(mock(Attribute.class).getName()).thenReturn("id").getMock();
>>>>>>>
genderEntityType = when(mock(EntityType.class).getName()).thenReturn("Gender").getMock();
Attribute genderIdAttribute = when(mock(Attribute.class).getName()).thenReturn("id").getMock();
<<<<<<<
when(genderEntityType.getIdAttribute()).thenReturn(genderIdAttribute);
AttributeMetaData genderAttr = when(mock(AttributeMetaData.class).getName()).thenReturn("gender").getMock();
=======
when(genderEntityMetaData.getIdAttribute()).thenReturn(genderIdAttribute);
Attribute genderAttr = when(mock(Attribute.class).getName()).thenReturn("gender").getMock();
>>>>>>>
when(genderEntityType.getIdAttribute()).thenReturn(genderIdAttribute);
Attribute genderAttr = when(mock(Attribute.class).getName()).thenReturn("gender").getMock(); |
<<<<<<<
import org.apache.commons.lang3.StringUtils;
import org.molgenis.data.DataService;
import org.molgenis.data.QueryRule;
import org.molgenis.data.QueryRule.Operator;
import org.molgenis.data.support.QueryImpl;
=======
import org.molgenis.framework.db.Database;
import org.molgenis.framework.db.DatabaseException;
import org.molgenis.framework.db.QueryRule;
import org.molgenis.framework.db.QueryRule.Operator;
>>>>>>>
import org.molgenis.data.DataService;
import org.molgenis.data.QueryRule;
import org.molgenis.data.QueryRule.Operator;
import org.molgenis.data.support.QueryImpl;
<<<<<<<
private final DataService dataService;
private final PasswordEncoder passwordEncoder;
=======
private final Database unsecuredDatabase;
>>>>>>>
private final DataService dataService;
<<<<<<<
public MolgenisUser findById(Integer userId)
{
return dataService.findOne(MolgenisUser.ENTITY_NAME, userId);
}
@Override
public void update(MolgenisUser molgenisUser)
{
MolgenisUser currentMolgenisUser = findById(molgenisUser.getId());
if (!currentMolgenisUser.getPassword().equals(molgenisUser.getPassword()))
{
String encryptedPassword = passwordEncoder.encode(molgenisUser.getPassword());
molgenisUser.setPassword(encryptedPassword);
}
dataService.update(MolgenisUser.ENTITY_NAME, molgenisUser);
}
@Override
public MolgenisUser getCurrentUser()
=======
public MolgenisUser getCurrentUser() throws DatabaseException
>>>>>>>
public MolgenisUser getCurrentUser() |
<<<<<<<
public Set<Operator> getQueryOperators()
{
if (!getCapabilities().contains(RepositoryCapability.QUERYABLE))
{
return Collections.emptySet();
}
else
{
return EnumSet.allOf(Operator.class);
}
}
@Override
public Query query()
=======
public Query<Entity> query()
>>>>>>>
public Set<Operator> getQueryOperators()
{
if (!getCapabilities().contains(RepositoryCapability.QUERYABLE))
{
return Collections.emptySet();
}
else
{
return EnumSet.allOf(Operator.class);
}
}
public Query<Entity> query() |
<<<<<<<
import com.google.common.collect.Lists;
import com.sun.tools.javac.util.List;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
=======
import static org.mockito.Mockito.atLeast;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;
import static org.molgenis.data.reindex.meta.ReindexActionMetaData.REINDEX_STATUS;
import static org.molgenis.data.reindex.meta.ReindexActionMetaData.ReindexStatus.FAILED;
import static org.molgenis.data.reindex.meta.ReindexActionMetaData.ReindexStatus.FINISHED;
import static org.molgenis.data.reindex.meta.ReindexActionRegisterConfig.BACKEND;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertSame;
import java.util.stream.Stream;
>>>>>>>
import com.google.common.collect.Lists;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
<<<<<<<
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static org.mockito.Mockito.*;
import static org.mockito.MockitoAnnotations.initMocks;
import static org.molgenis.data.reindex.meta.ReindexActionMetaData.REINDEX_STATUS;
import static org.molgenis.data.reindex.meta.ReindexActionMetaData.ReindexStatus.FAILED;
import static org.molgenis.data.reindex.meta.ReindexActionMetaData.ReindexStatus.FINISHED;
import static org.molgenis.data.reindex.meta.ReindexActionRegisterConfig.BACKEND;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertSame;
=======
import com.google.common.collect.Lists;
>>>>>>>
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static com.google.common.collect.Lists.newArrayList;
import static java.util.stream.Collectors.toList;
import static org.mockito.Mockito.*;
import static org.mockito.MockitoAnnotations.initMocks;
import static org.molgenis.data.reindex.meta.ReindexActionMetaData.REINDEX_STATUS;
import static org.molgenis.data.reindex.meta.ReindexActionMetaData.ReindexStatus.FAILED;
import static org.molgenis.data.reindex.meta.ReindexActionMetaData.ReindexStatus.FINISHED;
import static org.molgenis.data.reindex.meta.ReindexActionRegisterConfig.BACKEND;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertSame; |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
private static String getSqlConstraintPrimaryKey(EntityType entityType, AttributeMetaData attr)
=======
private static String getSqlConstraintPrimaryKey(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
private static String getSqlConstraintPrimaryKey(EntityType entityType, Attribute attr)
<<<<<<<
private static String getSqlForeignKey(EntityType entityType, AttributeMetaData attr)
=======
private static String getSqlForeignKey(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
private static String getSqlForeignKey(EntityType entityType, Attribute attr)
<<<<<<<
private static String getSqlUniqueKey(EntityType entityType, AttributeMetaData attr)
=======
private static String getSqlUniqueKey(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
private static String getSqlUniqueKey(EntityType entityType, Attribute attr)
<<<<<<<
private static String getSqlCheckConstraint(EntityType entityType, AttributeMetaData attr)
=======
private static String getSqlCheckConstraint(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
private static String getSqlCheckConstraint(EntityType entityType, Attribute attr)
<<<<<<<
static String getSqlCreateForeignKey(EntityType entityType, AttributeMetaData attr)
=======
static String getSqlCreateForeignKey(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
static String getSqlCreateForeignKey(EntityType entityType, Attribute attr)
<<<<<<<
static String getSqlDropForeignKey(EntityType entityType, AttributeMetaData attr)
=======
static String getSqlDropForeignKey(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
static String getSqlDropForeignKey(EntityType entityType, Attribute attr)
<<<<<<<
static String getSqlCreateUniqueKey(EntityType entityType, AttributeMetaData attr)
=======
static String getSqlCreateUniqueKey(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
static String getSqlCreateUniqueKey(EntityType entityType, Attribute attr)
<<<<<<<
static String getSqlDropUniqueKey(EntityType entityType, AttributeMetaData attr)
=======
static String getSqlDropUniqueKey(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
static String getSqlDropUniqueKey(EntityType entityType, Attribute attr)
<<<<<<<
static String getSqlCreateCheckConstraint(EntityType entityType, AttributeMetaData attr)
=======
static String getSqlCreateCheckConstraint(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
static String getSqlCreateCheckConstraint(EntityType entityType, Attribute attr)
<<<<<<<
static String getSqlDropCheckConstraint(EntityType entityType, AttributeMetaData attr)
=======
static String getSqlDropCheckConstraint(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
static String getSqlDropCheckConstraint(EntityType entityType, Attribute attr)
<<<<<<<
static String getSqlSetNotNull(EntityType entityType, AttributeMetaData attr)
=======
static String getSqlSetNotNull(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
static String getSqlSetNotNull(EntityType entityType, Attribute attr)
<<<<<<<
static String getSqlDropNotNull(EntityType entityType, AttributeMetaData attr)
=======
static String getSqlDropNotNull(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
static String getSqlDropNotNull(EntityType entityType, Attribute attr)
<<<<<<<
static String getSqlSetDataType(EntityType entityType, AttributeMetaData attr)
=======
static String getSqlSetDataType(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
static String getSqlSetDataType(EntityType entityType, Attribute attr)
<<<<<<<
static String getSqlAddColumn(EntityType entityType, AttributeMetaData attr)
=======
static String getSqlAddColumn(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
static String getSqlAddColumn(EntityType entityType, Attribute attr)
<<<<<<<
List<AttributeMetaData> persistedTableAttrs = getTableAttributes(entityType).collect(toList());
=======
List<Attribute> persistedTableAttrs = getTableAttributes(entityMeta).collect(toList());
>>>>>>>
List<Attribute> persistedTableAttrs = getTableAttributes(entityType).collect(toList());
<<<<<<<
AttributeMetaData attr = it.next();
sql.append(getSqlColumn(entityType, attr));
=======
Attribute attr = it.next();
sql.append(getSqlColumn(entityMeta, attr));
>>>>>>>
Attribute attr = it.next();
sql.append(getSqlColumn(entityType, attr));
<<<<<<<
static String getSqlCreateJunctionTable(EntityType entityType, AttributeMetaData attr)
=======
static String getSqlCreateJunctionTable(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
static String getSqlCreateJunctionTable(EntityType entityType, Attribute attr)
<<<<<<<
AttributeMetaData idAttr = entityType.getIdAttribute();
StringBuilder sql = new StringBuilder("CREATE TABLE ").append(getJunctionTableName(entityType, attr))
=======
Attribute idAttr = entityMeta.getIdAttribute();
StringBuilder sql = new StringBuilder("CREATE TABLE ").append(getJunctionTableName(entityMeta, attr))
>>>>>>>
Attribute idAttr = entityType.getIdAttribute();
StringBuilder sql = new StringBuilder("CREATE TABLE ").append(getJunctionTableName(entityType, attr))
<<<<<<<
static String getSqlDropJunctionTable(EntityType entityType, AttributeMetaData attr)
=======
static String getSqlDropJunctionTable(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
static String getSqlDropJunctionTable(EntityType entityType, Attribute attr)
<<<<<<<
static String getSqlDropColumn(EntityType entityType, AttributeMetaData attr)
=======
static String getSqlDropColumn(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
static String getSqlDropColumn(EntityType entityType, Attribute attr)
<<<<<<<
static String getSqlInsertJunction(EntityType entityType, AttributeMetaData attr)
=======
static String getSqlInsertJunction(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
static String getSqlInsertJunction(EntityType entityType, Attribute attr)
<<<<<<<
static String getSqlJunctionTableSelect(EntityType entityType, AttributeMetaData attr, int numOfIds)
=======
static String getSqlJunctionTableSelect(EntityMetaData entityMeta, Attribute attr, int numOfIds)
>>>>>>>
static String getSqlJunctionTableSelect(EntityType entityType, Attribute attr, int numOfIds)
<<<<<<<
AttributeMetaData attr = entityType.getAttribute(attrName);
=======
Attribute attr = entityMeta.getAttribute(attrName);
>>>>>>>
Attribute attr = entityType.getAttribute(attrName);
<<<<<<<
final AttributeMetaData idAttribute = entityType.getIdAttribute();
getPersistedAttributes(entityType).forEach(attr ->
=======
final Attribute idAttribute = entityMeta.getIdAttribute();
getPersistedAttributes(entityMeta).forEach(attr ->
>>>>>>>
final Attribute idAttribute = entityType.getIdAttribute();
getPersistedAttributes(entityType).forEach(attr ->
<<<<<<<
AttributeMetaData idAttribute = entityType.getIdAttribute();
=======
Attribute idAttribute = entityMeta.getIdAttribute();
>>>>>>>
Attribute idAttribute = entityType.getIdAttribute();
<<<<<<<
private static String getSqlColumn(EntityType entityType, AttributeMetaData attr)
=======
private static String getSqlColumn(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
private static String getSqlColumn(EntityType entityType, Attribute attr)
<<<<<<<
private static String getSqlColumnConstraints(EntityType entityType, AttributeMetaData attr)
=======
private static String getSqlColumnConstraints(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
private static String getSqlColumnConstraints(EntityType entityType, Attribute attr)
<<<<<<<
private static List<String> getSqlTableConstraints(EntityType entityType, AttributeMetaData attr)
=======
private static List<String> getSqlTableConstraints(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
private static List<String> getSqlTableConstraints(EntityType entityType, Attribute attr)
<<<<<<<
AttributeMetaData attr = entityType.getAttribute(o.getAttr());
=======
Attribute attr = entityMeta.getAttribute(o.getAttr());
>>>>>>>
Attribute attr = entityType.getAttribute(o.getAttr());
<<<<<<<
List<AttributeMetaData> mrefAttrsInQuery = getJunctionTableQueryAttrs(entityType, q);
StringBuilder from = new StringBuilder(" FROM ").append(getTableName(entityType)).append(" AS this");
AttributeMetaData idAttribute = entityType.getIdAttribute();
=======
List<Attribute> mrefAttrsInQuery = getJunctionTableQueryAttrs(entityMeta, q);
StringBuilder from = new StringBuilder(" FROM ").append(getTableName(entityMeta)).append(" AS this");
Attribute idAttribute = entityMeta.getIdAttribute();
>>>>>>>
List<Attribute> mrefAttrsInQuery = getJunctionTableQueryAttrs(entityType, q);
StringBuilder from = new StringBuilder(" FROM ").append(getTableName(entityType)).append(" AS this");
Attribute idAttribute = entityType.getIdAttribute();
<<<<<<<
private static String getPrimaryKeyName(EntityType entityType, AttributeMetaData attr)
=======
private static String getPrimaryKeyName(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
private static String getPrimaryKeyName(EntityType entityType, Attribute attr)
<<<<<<<
private static String getForeignKeyName(EntityType entityType, AttributeMetaData attr)
=======
private static String getForeignKeyName(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
private static String getForeignKeyName(EntityType entityType, Attribute attr)
<<<<<<<
private static String getUniqueKeyName(EntityType entityType, AttributeMetaData attr)
=======
private static String getUniqueKeyName(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
private static String getUniqueKeyName(EntityType entityType, Attribute attr)
<<<<<<<
private static String getCheckConstraintName(EntityType entityType, AttributeMetaData attr)
=======
private static String getCheckConstraintName(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
private static String getCheckConstraintName(EntityType entityType, Attribute attr)
<<<<<<<
private static String getConstraintName(EntityType entityType, AttributeMetaData attr, String constraintPostfix)
=======
private static String getConstraintName(EntityMetaData entityMeta, Attribute attr, String constraintPostfix)
>>>>>>>
private static String getConstraintName(EntityType entityType, Attribute attr, String constraintPostfix)
<<<<<<<
private static void getJunctionTableQueryAttrsRec(EntityType entityType, List<QueryRule> rules,
List<AttributeMetaData> junctionTableQueryAttrs)
=======
private static void getJunctionTableQueryAttrsRec(EntityMetaData entityMeta, List<QueryRule> rules,
List<Attribute> junctionTableQueryAttrs)
>>>>>>>
private static void getJunctionTableQueryAttrsRec(EntityType entityType, List<QueryRule> rules,
List<Attribute> junctionTableQueryAttrs)
<<<<<<<
AttributeMetaData attr = entityType.getAttribute(rule.getField());
=======
Attribute attr = entityMeta.getAttribute(rule.getField());
>>>>>>>
Attribute attr = entityType.getAttribute(rule.getField()); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
EntityType entityType = when(mock(EntityType.class).getName()).thenReturn("entity").getMock();
AttributeMetaData attr = when(mock(AttributeMetaData.class).getName()).thenReturn("attr").getMock();
assertEquals(PostgreSqlQueryUtils.getJunctionTableName(entityType, attr), "\"entity_attr\"");
=======
EntityMetaData entityMeta = when(mock(EntityMetaData.class).getName()).thenReturn("entity").getMock();
Attribute attr = when(mock(Attribute.class).getName()).thenReturn("attr").getMock();
assertEquals(PostgreSqlQueryUtils.getJunctionTableName(entityMeta, attr), "\"entity_attr\"");
>>>>>>>
EntityType entityType = when(mock(EntityType.class).getName()).thenReturn("entity").getMock();
Attribute attr = when(mock(Attribute.class).getName()).thenReturn("attr").getMock();
assertEquals(PostgreSqlQueryUtils.getJunctionTableName(entityType, attr), "\"entity_attr\"");
<<<<<<<
EntityType entityType = when(mock(EntityType.class).getName()).thenReturn("entity").getMock();
AttributeMetaData attr = when(mock(AttributeMetaData.class).getName()).thenReturn("attr").getMock();
=======
EntityMetaData entityMeta = when(mock(EntityMetaData.class).getName()).thenReturn("entity").getMock();
Attribute attr = when(mock(Attribute.class).getName()).thenReturn("attr").getMock();
>>>>>>>
EntityType entityType = when(mock(EntityType.class).getName()).thenReturn("entity").getMock();
Attribute attr = when(mock(Attribute.class).getName()).thenReturn("attr").getMock();
<<<<<<<
EntityType entityType = when(mock(EntityType.class).getName()).thenReturn("entity").getMock();
AttributeMetaData attr = when(mock(AttributeMetaData.class).getName()).thenReturn("attr").getMock();
AttributeMetaData idxAttr = when(mock(AttributeMetaData.class).getName()).thenReturn("idxAttr").getMock();
assertEquals(PostgreSqlQueryUtils.getJunctionTableIndexName(entityType, attr, idxAttr),
=======
EntityMetaData entityMeta = when(mock(EntityMetaData.class).getName()).thenReturn("entity").getMock();
Attribute attr = when(mock(Attribute.class).getName()).thenReturn("attr").getMock();
Attribute idxAttr = when(mock(Attribute.class).getName()).thenReturn("idxAttr").getMock();
assertEquals(PostgreSqlQueryUtils.getJunctionTableIndexName(entityMeta, attr, idxAttr),
>>>>>>>
EntityType entityType = when(mock(EntityType.class).getName()).thenReturn("entity").getMock();
Attribute attr = when(mock(Attribute.class).getName()).thenReturn("attr").getMock();
Attribute idxAttr = when(mock(Attribute.class).getName()).thenReturn("idxAttr").getMock();
assertEquals(PostgreSqlQueryUtils.getJunctionTableIndexName(entityType, attr, idxAttr), |
<<<<<<<
import org.molgenis.security.runas.RunAsSystem;
=======
import org.molgenis.security.user.MolgenisUserException;
>>>>>>>
import org.molgenis.security.runas.RunAsSystem;
import org.molgenis.security.user.MolgenisUserException;
<<<<<<<
@RunAsSystem
=======
@Autowired
private PasswordEncoder passwordEncoder;
>>>>>>>
@Autowired
private PasswordEncoder passwordEncoder;
@RunAsSystem
<<<<<<<
// add user to group
MolgenisGroup group = dataService.findOne(MolgenisGroup.ENTITY_NAME,
new QueryImpl().eq(MolgenisGroup.NAME, ALL_USER_GROUP));
if (group != null)
{
=======
unsecuredDatabase.add(molgenisUser);
// add user to group
Query<MolgenisGroup> groupQuery = unsecuredDatabase.query(MolgenisGroup.class);
groupQuery.equals(MolgenisGroup.NAME, ALL_USER_GROUP);
List<MolgenisGroup> allUserGroups = groupQuery.find();
if (allUserGroups.size() == 1)
{
MolgenisGroup group = allUserGroups.get(0);
>>>>>>>
// add user to group
MolgenisGroup group = dataService.findOne(MolgenisGroup.ENTITY_NAME,
new QueryImpl().eq(MolgenisGroup.NAME, ALL_USER_GROUP));
if (group != null)
{
<<<<<<<
molgenisUser.setPassword(newPassword);
dataService.update(MolgenisUser.ENTITY_NAME, molgenisUser);
=======
molgenisUser.setPassword(passwordEncoder.encode(newPassword));
unsecuredDatabase.update(molgenisUser);
>>>>>>>
molgenisUser.setPassword(newPassword);
molgenisUser.setPassword(passwordEncoder.encode(newPassword));
dataService.update(MolgenisUser.ENTITY_NAME, molgenisUser); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaDataFactory;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.meta.model.EntityTypeFactory;
=======
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityMetaData;
import org.molgenis.data.meta.model.EntityMetaDataFactory;
>>>>>>>
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.meta.model.EntityTypeFactory;
<<<<<<<
AnnotatorUtils.addAnnotatorMetaDataToRepositories(repo.getEntityType(), attributeMetaDataFactory,
=======
AnnotatorUtils.addAnnotatorMetaDataToRepositories(repo.getEntityMetaData(), attributeFactory,
>>>>>>>
AnnotatorUtils.addAnnotatorMetaDataToRepositories(repo.getEntityType(), attributeFactory, |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
public String generateAlgorithm(AttributeMetaData targetAttribute, EntityType targetEntityType,
List<AttributeMetaData> sourceAttributes, EntityType sourceEntityType)
=======
public String generateAlgorithm(Attribute targetAttribute, EntityMetaData targetEntityMetaData,
List<Attribute> sourceAttributes, EntityMetaData sourceEntityMetaData)
>>>>>>>
public String generateAlgorithm(Attribute targetAttribute, EntityType targetEntityType,
List<Attribute> sourceAttributes, EntityType sourceEntityType)
<<<<<<<
public void autoGenerateAlgorithm(EntityType sourceEntityType, EntityType targetEntityType,
EntityMapping mapping, AttributeMetaData targetAttribute)
=======
public void autoGenerateAlgorithm(EntityMetaData sourceEntityMetaData, EntityMetaData targetEntityMetaData,
EntityMapping mapping, Attribute targetAttribute)
>>>>>>>
public void autoGenerateAlgorithm(EntityType sourceEntityType, EntityType targetEntityType, EntityMapping mapping,
Attribute targetAttribute)
<<<<<<<
Map<AttributeMetaData, ExplainedAttributeMetaData> relevantAttributes = semanticSearchService
.decisionTreeToFindRelevantAttributes(sourceEntityType, targetAttribute, tagsForAttribute.values(),
=======
Map<Attribute, ExplainedAttribute> relevantAttributes = semanticSearchService
.decisionTreeToFindRelevantAttributes(sourceEntityMetaData, targetAttribute, tagsForAttribute.values(),
>>>>>>>
Map<Attribute, ExplainedAttribute> relevantAttributes = semanticSearchService
.decisionTreeToFindRelevantAttributes(sourceEntityType, targetAttribute, tagsForAttribute.values(),
<<<<<<<
Object value = eval(algorithm, entity, sourceEntityType);
return convert(value, attributeMapping.getTargetAttributeMetaData());
=======
Object value = eval(algorithm, entity, sourceEntityMetaData);
return convert(value, attributeMapping.getTargetAttribute());
>>>>>>>
Object value = eval(algorithm, entity, sourceEntityType);
return convert(value, attributeMapping.getTargetAttribute());
<<<<<<<
EntityType refEntityType = attributeMetaData.getRefEntity();
convertedValue = dataService.findAll(refEntityType.getName(), mrefIds.stream())
=======
EntityMetaData refEntityMeta = attribute.getRefEntity();
convertedValue = dataService.findAll(refEntityMeta.getName(), mrefIds.stream())
>>>>>>>
EntityType refEntityMeta = attribute.getRefEntity();
convertedValue = dataService.findAll(refEntityMeta.getName(), mrefIds.stream()) |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
AttributeMetaData attr = getAttribute(entityType, attributePath);
=======
Attribute attr = getAttribute(entityMetaData, attributePath);
>>>>>>>
Attribute attr = getAttribute(entityType, attributePath);
<<<<<<<
AttributeMetaData attr = getAttribute(entityType, attributePath);
=======
Attribute attr = getAttribute(entityMetaData, attributePath);
>>>>>>>
Attribute attr = getAttribute(entityType, attributePath);
<<<<<<<
AttributeMetaData attr = getAttribute(entityType, attributePath);
=======
Attribute attr = getAttribute(entityMetaData, attributePath);
>>>>>>>
Attribute attr = getAttribute(entityType, attributePath);
<<<<<<<
AttributeMetaData attr = getAttribute(entityType, attributePath);
=======
Attribute attr = getAttribute(entityMetaData, attributePath);
>>>>>>>
Attribute attr = getAttribute(entityType, attributePath);
<<<<<<<
AttributeMetaData attr = getAttribute(entityType, attributePath);
=======
Attribute attr = getAttribute(entityMetaData, attributePath);
>>>>>>>
Attribute attr = getAttribute(entityType, attributePath);
<<<<<<<
AttributeMetaData attr = getAttribute(entityType, attributePath);
=======
Attribute attr = getAttribute(entityMetaData, attributePath);
>>>>>>>
Attribute attr = getAttribute(entityType, attributePath);
<<<<<<<
AttributeMetaData attr = getAttribute(entityType, attributePath);
=======
Attribute attr = getAttribute(entityMetaData, attributePath);
>>>>>>>
Attribute attr = getAttribute(entityType, attributePath);
<<<<<<<
AttributeMetaData attr = getAttribute(entityType, attributePath);
=======
Attribute attr = getAttribute(entityMetaData, attributePath);
>>>>>>>
Attribute attr = getAttribute(entityType, attributePath);
<<<<<<<
AttributeMetaData attr = getAttribute(entityType, attributePath);
=======
Attribute attr = getAttribute(entityMetaData, attributePath);
>>>>>>>
Attribute attr = getAttribute(entityType, attributePath);
<<<<<<<
AttributeMetaData attr = getAttribute(entityType, attributePath);
=======
Attribute attr = getAttribute(entityMetaData, attributePath);
>>>>>>>
Attribute attr = getAttribute(entityType, attributePath);
<<<<<<<
AttributeMetaData attr = entityType.getAttribute(queryField);
=======
Attribute attr = entityMetaData.getAttribute(queryField);
>>>>>>>
Attribute attr = entityType.getAttribute(queryField);
<<<<<<<
AttributeMetaData attr = entityType.getAttribute(queryField);
=======
Attribute attr = entityMetaData.getAttribute(queryField);
>>>>>>>
Attribute attr = entityType.getAttribute(queryField);
<<<<<<<
private AttributeMetaData getAttribute(EntityType entityType, String[] attributePath)
=======
private Attribute getAttribute(EntityMetaData entityMetaData, String[] attributePath)
>>>>>>>
private Attribute getAttribute(EntityType entityType, String[] attributePath)
<<<<<<<
AttributeMetaData attr = entityType.getAttribute(attributePath[0]);
=======
Attribute attr = entityMetaData.getAttribute(attributePath[0]);
>>>>>>>
Attribute attr = entityType.getAttribute(attributePath[0]);
<<<<<<<
AttributeMetaData attr = entityType.getAttribute(attributePath[0]);
=======
Attribute attr = entityMetaData.getAttribute(attributePath[0]);
>>>>>>>
Attribute attr = entityType.getAttribute(attributePath[0]); |
<<<<<<<
import com.google.gerrit.extensions.api.accounts.AccountInput;
=======
import com.google.gerrit.extensions.api.accounts.AccountApi;
>>>>>>>
import com.google.gerrit.extensions.api.accounts.AccountApi;
import com.google.gerrit.extensions.api.accounts.AccountInput;
<<<<<<<
import java.util.concurrent.atomic.AtomicBoolean;
=======
import java.util.stream.Collectors;
import javax.servlet.http.HttpServletResponse;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.BasicCookieStore;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
>>>>>>>
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.Collectors;
import javax.servlet.http.HttpServletResponse;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.BasicCookieStore;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
<<<<<<<
private Config getAccountConfig(TestRepository<?> allUsersRepo) throws Exception {
Config ac = new Config();
try (TreeWalk tw =
TreeWalk.forPath(
allUsersRepo.getRepository(),
AccountConfig.ACCOUNT_CONFIG,
getHead(allUsersRepo.getRepository()).getTree())) {
assertThat(tw).isNotNull();
ac.fromText(
new String(
allUsersRepo
.getRevWalk()
.getObjectReader()
.open(tw.getObjectId(0), OBJ_BLOB)
.getBytes(),
UTF_8));
}
return ac;
}
private static class AccountIndexedCounter implements AccountIndexedListener {
private final AtomicLongMap<Integer> countsByAccount = AtomicLongMap.create();
@Override
public void onAccountIndexed(int id) {
countsByAccount.incrementAndGet(id);
}
void clear() {
countsByAccount.clear();
}
long getCount(Account.Id accountId) {
return countsByAccount.get(accountId.get());
}
void assertReindexOf(TestAccount testAccount) {
assertReindexOf(testAccount, 1);
}
void assertReindexOf(AccountInfo accountInfo) {
assertReindexOf(new Account.Id(accountInfo._accountId), 1);
}
void assertReindexOf(TestAccount testAccount, int expectedCount) {
assertThat(getCount(testAccount.id)).isEqualTo(expectedCount);
assertThat(countsByAccount).hasSize(1);
clear();
}
void assertReindexOf(Account.Id accountId, int expectedCount) {
assertThat(getCount(accountId)).isEqualTo(expectedCount);
countsByAccount.remove(accountId.get());
}
void assertNoReindex() {
assertThat(countsByAccount).isEmpty();
}
}
private static class RefUpdateCounter implements GitReferenceUpdatedListener {
private final AtomicLongMap<String> countsByProjectRefs = AtomicLongMap.create();
static String projectRef(Project.NameKey project, String ref) {
return projectRef(project.get(), ref);
}
static String projectRef(String project, String ref) {
return project + ":" + ref;
}
@Override
public void onGitReferenceUpdated(Event event) {
countsByProjectRefs.incrementAndGet(projectRef(event.getProjectName(), event.getRefName()));
}
void clear() {
countsByProjectRefs.clear();
}
long getCount(String projectRef) {
return countsByProjectRefs.get(projectRef);
}
void assertRefUpdateFor(String... projectRefs) {
Map<String, Integer> expectedRefUpdateCounts = new HashMap<>();
for (String projectRef : projectRefs) {
expectedRefUpdateCounts.put(projectRef, 1);
}
assertRefUpdateFor(expectedRefUpdateCounts);
}
void assertRefUpdateFor(Map<String, Integer> expectedProjectRefUpdateCounts) {
for (Map.Entry<String, Integer> e : expectedProjectRefUpdateCounts.entrySet()) {
assertThat(getCount(e.getKey())).isEqualTo(e.getValue());
}
assertThat(countsByProjectRefs).hasSize(expectedProjectRefUpdateCounts.size());
clear();
}
}
=======
private AccountApi accountIdApi() throws RestApiException {
return gApi.accounts().id("user");
}
private Set<String> getCookiesNames() {
Set<String> cookieNames =
httpCookieStore.getCookies().stream()
.map(cookie -> cookie.getName())
.collect(Collectors.toSet());
return cookieNames;
}
private void webLogin(Integer accountId) throws IOException, ClientProtocolException {
httpGetAndAssertStatus(
"login?account_id=" + accountId, HttpServletResponse.SC_MOVED_TEMPORARILY);
}
private void httpGetAndAssertStatus(String urlPath, int expectedHttpStatus)
throws ClientProtocolException, IOException {
HttpGet httpGet = new HttpGet(canonicalWebUrl.get() + urlPath);
HttpResponse loginResponse = httpclient.execute(httpGet);
assertThat(loginResponse.getStatusLine().getStatusCode()).isEqualTo(expectedHttpStatus);
}
>>>>>>>
private Config getAccountConfig(TestRepository<?> allUsersRepo) throws Exception {
Config ac = new Config();
try (TreeWalk tw =
TreeWalk.forPath(
allUsersRepo.getRepository(),
AccountConfig.ACCOUNT_CONFIG,
getHead(allUsersRepo.getRepository()).getTree())) {
assertThat(tw).isNotNull();
ac.fromText(
new String(
allUsersRepo
.getRevWalk()
.getObjectReader()
.open(tw.getObjectId(0), OBJ_BLOB)
.getBytes(),
UTF_8));
}
return ac;
}
private static class AccountIndexedCounter implements AccountIndexedListener {
private final AtomicLongMap<Integer> countsByAccount = AtomicLongMap.create();
@Override
public void onAccountIndexed(int id) {
countsByAccount.incrementAndGet(id);
}
void clear() {
countsByAccount.clear();
}
long getCount(Account.Id accountId) {
return countsByAccount.get(accountId.get());
}
void assertReindexOf(TestAccount testAccount) {
assertReindexOf(testAccount, 1);
}
void assertReindexOf(AccountInfo accountInfo) {
assertReindexOf(new Account.Id(accountInfo._accountId), 1);
}
void assertReindexOf(TestAccount testAccount, int expectedCount) {
assertThat(getCount(testAccount.id)).isEqualTo(expectedCount);
assertThat(countsByAccount).hasSize(1);
clear();
}
void assertReindexOf(Account.Id accountId, int expectedCount) {
assertThat(getCount(accountId)).isEqualTo(expectedCount);
countsByAccount.remove(accountId.get());
}
void assertNoReindex() {
assertThat(countsByAccount).isEmpty();
}
}
private static class RefUpdateCounter implements GitReferenceUpdatedListener {
private final AtomicLongMap<String> countsByProjectRefs = AtomicLongMap.create();
static String projectRef(Project.NameKey project, String ref) {
return projectRef(project.get(), ref);
}
static String projectRef(String project, String ref) {
return project + ":" + ref;
}
@Override
public void onGitReferenceUpdated(Event event) {
countsByProjectRefs.incrementAndGet(projectRef(event.getProjectName(), event.getRefName()));
}
void clear() {
countsByProjectRefs.clear();
}
long getCount(String projectRef) {
return countsByProjectRefs.get(projectRef);
}
void assertRefUpdateFor(String... projectRefs) {
Map<String, Integer> expectedRefUpdateCounts = new HashMap<>();
for (String projectRef : projectRefs) {
expectedRefUpdateCounts.put(projectRef, 1);
}
assertRefUpdateFor(expectedRefUpdateCounts);
}
void assertRefUpdateFor(Map<String, Integer> expectedProjectRefUpdateCounts) {
for (Map.Entry<String, Integer> e : expectedProjectRefUpdateCounts.entrySet()) {
assertThat(getCount(e.getKey())).isEqualTo(e.getValue());
}
assertThat(countsByProjectRefs).hasSize(expectedProjectRefUpdateCounts.size());
clear();
}
}
private AccountApi accountIdApi() throws RestApiException {
return gApi.accounts().id("user");
}
private Set<String> getCookiesNames() {
Set<String> cookieNames =
httpCookieStore.getCookies().stream()
.map(cookie -> cookie.getName())
.collect(Collectors.toSet());
return cookieNames;
}
private void webLogin(Integer accountId) throws IOException, ClientProtocolException {
httpGetAndAssertStatus(
"login?account_id=" + accountId, HttpServletResponse.SC_MOVED_TEMPORARILY);
}
private void httpGetAndAssertStatus(String urlPath, int expectedHttpStatus)
throws ClientProtocolException, IOException {
HttpGet httpGet = new HttpGet(canonicalWebUrl.get() + urlPath);
HttpResponse loginResponse = httpclient.execute(httpGet);
assertThat(loginResponse.getStatusLine().getStatusCode()).isEqualTo(expectedHttpStatus);
} |
<<<<<<<
import static org.molgenis.data.support.EntityTypeUtils.isMultipleReferenceType;
=======
import static org.molgenis.MolgenisFieldTypes.AttributeType.ONE_TO_MANY;
import static org.molgenis.data.support.EntityMetaDataUtils.isMultipleReferenceType;
>>>>>>>
import static org.molgenis.MolgenisFieldTypes.AttributeType.ONE_TO_MANY;
import static org.molgenis.data.support.EntityTypeUtils.isMultipleReferenceType;
<<<<<<<
if (attr.isMappedBy())
{
return '"' + attr.getRefEntity().getName() + '_' + attr.getMappedBy().getName() + '"';
}
else
{
return '"' + entityType.getName() + '_' + attr.getName() + '"';
}
=======
return '"' + entityMeta.getName() + '_' + attr.getName() + '"';
>>>>>>>
return '"' + entityType.getName() + '_' + attr.getName() + '"';
<<<<<<<
if (attr.isMappedBy())
{
return '"' + attr.getRefEntity().getName() + '_' + attr.getMappedBy().getName() + '_' + idxAttr.getName()
+ "_idx\"";
}
else
{
return '"' + entityType.getName() + '_' + attr.getName() + '_' + idxAttr.getName() + "_idx\"";
}
=======
return '"' + entityMeta.getName() + '_' + attr.getName() + '_' + idxAttr.getName() + "_idx\"";
>>>>>>>
return '"' + entityType.getName() + '_' + attr.getName() + '_' + idxAttr.getName() + "_idx\"";
<<<<<<<
return getPersistedAttributes(entityType)
.filter(attr -> isMultipleReferenceType(attr) || (attr.isInversedBy() && isMultipleReferenceType(
attr.getInversedBy())));
=======
return getPersistedAttributes(entityMeta)
.filter(attr -> isMultipleReferenceType(attr) && !(attr.getDataType() == ONE_TO_MANY && attr
.isMappedBy()));
>>>>>>>
return getPersistedAttributes(entityType)
.filter(attr -> isMultipleReferenceType(attr) && !(attr.getDataType() == ONE_TO_MANY && attr
.isMappedBy()));
<<<<<<<
return getPersistedAttributes(entityType)
.filter(attr -> !isMultipleReferenceType(attr) && !attr.isInversedBy());
=======
return getPersistedAttributes(entityMeta)
.filter(attr -> !isMultipleReferenceType(attr) && !(attr.getDataType() == ONE_TO_MANY && attr
.isMappedBy()));
>>>>>>>
return getPersistedAttributes(entityType)
.filter(attr -> !isMultipleReferenceType(attr) && !(attr.getDataType() == ONE_TO_MANY && attr
.isMappedBy())); |
<<<<<<<
private final L3Cache l3Cache;
=======
private final EntityMetaDataValidator entityMetaDataValidator;
>>>>>>>
private final EntityMetaDataValidator entityMetaDataValidator;
private final L3Cache l3Cache;
<<<<<<<
MolgenisPermissionService permissionService, L3Cache l3Cache)
=======
MolgenisPermissionService permissionService, EntityMetaDataValidator entityMetaDataValidator)
>>>>>>>
MolgenisPermissionService permissionService, EntityMetaDataValidator entityMetaDataValidator,
L3Cache l3Cache)
<<<<<<<
this.l3Cache = requireNonNull(l3Cache);
=======
this.entityMetaDataValidator = requireNonNull(entityMetaDataValidator);
>>>>>>>
this.entityMetaDataValidator = requireNonNull(entityMetaDataValidator);
this.l3Cache = requireNonNull(l3Cache); |
<<<<<<<
=======
import java.util.List;
import java.util.Map;
>>>>>>>
import java.util.List; |
<<<<<<<
import org.molgenis.data.meta.SystemEntityType;
import org.molgenis.data.meta.model.AttributeMetaData;
=======
import org.molgenis.data.meta.SystemEntityMetaData;
import org.molgenis.data.meta.model.Attribute;
>>>>>>>
import org.molgenis.data.meta.SystemEntityType;
import org.molgenis.data.meta.model.Attribute; |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType; |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
static String getJunctionTableName(EntityType entityType, AttributeMetaData attr)
=======
static String getJunctionTableName(EntityMetaData entityMeta, Attribute attr)
>>>>>>>
static String getJunctionTableName(EntityType entityType, Attribute attr)
<<<<<<<
static String getJunctionTableIndexName(EntityType entityType, AttributeMetaData attr, AttributeMetaData idxAttr)
=======
static String getJunctionTableIndexName(EntityMetaData entityMeta, Attribute attr,
Attribute idxAttr)
>>>>>>>
static String getJunctionTableIndexName(EntityType entityType, Attribute attr, Attribute idxAttr)
<<<<<<<
static Stream<AttributeMetaData> getPersistedAttributes(EntityType entityType)
=======
static Stream<Attribute> getPersistedAttributes(EntityMetaData entityMeta)
>>>>>>>
static Stream<Attribute> getPersistedAttributes(EntityType entityType)
<<<<<<<
static Stream<AttributeMetaData> getJunctionTableAttributes(EntityType entityType)
=======
static Stream<Attribute> getJunctionTableAttributes(EntityMetaData entityMeta)
>>>>>>>
static Stream<Attribute> getJunctionTableAttributes(EntityType entityType)
<<<<<<<
static Stream<AttributeMetaData> getTableAttributes(EntityType entityType)
=======
static Stream<Attribute> getTableAttributes(EntityMetaData entityMeta)
>>>>>>>
static Stream<Attribute> getTableAttributes(EntityType entityType) |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
for (AttributeMetaData attributeMetaData : StreamSupport
.stream(vcfEntity.getEntityType().getAllAttributes().spliterator(), false)
=======
for (Attribute attribute : StreamSupport
.stream(vcfEntity.getEntityMetaData().getAllAttributes().spliterator(), false)
>>>>>>>
for (Attribute attribute : StreamSupport
.stream(vcfEntity.getEntityType().getAllAttributes().spliterator(), false)
<<<<<<<
Iterable<AttributeMetaData> attributes = vcfEntity.getEntityType().getAllAttributes();
=======
Iterable<Attribute> attributes = vcfEntity.getEntityMetaData().getAllAttributes();
>>>>>>>
Iterable<Attribute> attributes = vcfEntity.getEntityType().getAllAttributes();
<<<<<<<
Iterable<AttributeMetaData> refAttributes = refEntity.getEntityType().getAttributes();
=======
Iterable<Attribute> refAttributes = refEntity.getEntityMetaData().getAttributes();
>>>>>>>
Iterable<Attribute> refAttributes = refEntity.getEntityType().getAttributes(); |
<<<<<<<
final Attribute idAttr = metaData.getIdAttribute();
List<Attribute> persistedAttrs = getPersistedAttributes(metaData).collect(toList());
final List<Attribute> persistedNonMrefAttrs = persistedAttrs.stream()
.filter(attr -> !isMultipleReferenceType(attr)).collect(toList());
final List<Attribute> persistedMrefAttrs = persistedAttrs.stream()
.filter(EntityMetaDataUtils::isMultipleReferenceType).collect(toList());
=======
final AttributeMetaData idAttr = metaData.getIdAttribute();
final List<AttributeMetaData> tableAttrs = getTableAttributes(metaData).collect(toList());
final List<AttributeMetaData> junctionTableAttrs = getJunctionTableAttributes(metaData).collect(toList());
>>>>>>>
final Attribute idAttr = metaData.getIdAttribute();
final List<Attribute> tableAttrs = getTableAttributes(metaData).collect(toList());
final List<Attribute> junctionTableAttrs = getJunctionTableAttributes(metaData).collect(toList());
<<<<<<<
for (Attribute attr : persistedNonMrefAttrs)
=======
for (AttributeMetaData attr : tableAttrs)
>>>>>>>
for (Attribute attr : tableAttrs)
<<<<<<<
for (Attribute attr : persistedMrefAttrs)
=======
for (AttributeMetaData attr : junctionTableAttrs)
>>>>>>>
for (Attribute attr : junctionTableAttrs)
<<<<<<<
for (Attribute attr : persistedMrefAttrs)
=======
for (AttributeMetaData attr : junctionTableAttrs)
>>>>>>>
for (Attribute attr : junctionTableAttrs)
<<<<<<<
final Attribute idAttr = metaData.getIdAttribute();
List<Attribute> persistedAttrs = getPersistedAttributes(metaData).collect(toList());
final List<Attribute> persistedNonMrefAttrs = persistedAttrs.stream()
.filter(attr -> !isMultipleReferenceType(attr)).collect(toList());
final List<Attribute> persistedMrefAttrs = persistedAttrs.stream()
.filter(EntityMetaDataUtils::isMultipleReferenceType).collect(toList());
=======
final AttributeMetaData idAttr = metaData.getIdAttribute();
final List<AttributeMetaData> tableAttrs = getTableAttributes(metaData).collect(toList());
final List<AttributeMetaData> junctionTableAttrs = getJunctionTableAttributes(metaData).collect(toList());
>>>>>>>
final Attribute idAttr = metaData.getIdAttribute();
final List<Attribute> tableAttrs = getTableAttributes(metaData).collect(toList());
final List<Attribute> junctionTableAttrs = getJunctionTableAttributes(metaData).collect(toList());
<<<<<<<
for (Attribute attr : persistedNonMrefAttrs)
=======
for (AttributeMetaData attr : tableAttrs)
>>>>>>>
for (Attribute attr : tableAttrs)
<<<<<<<
for (Attribute attr : persistedMrefAttrs)
=======
for (AttributeMetaData attr : junctionTableAttrs)
>>>>>>>
for (Attribute attr : junctionTableAttrs)
<<<<<<<
List<Object> ids = entitiesBatch.stream()
.map(entity -> PostgreSqlUtils.getPostgreSqlValue(entity, idAttr)).collect(toList());
for (Attribute attr : persistedMrefAttrs)
=======
List<Object> ids = entitiesBatch.stream().map(entity -> getPostgreSqlValue(entity, idAttr))
.collect(toList());
for (AttributeMetaData attr : junctionTableAttrs)
>>>>>>>
List<Object> ids = entitiesBatch.stream().map(entity -> getPostgreSqlValue(entity, idAttr))
.collect(toList());
for (Attribute attr : junctionTableAttrs)
<<<<<<<
Attribute idAttribute = metaData.getIdAttribute();
String insertMrefSql = getSqlInsertMref(metaData, attr, idAttribute);
=======
// database doesn't validate NOT NULL constraint for attribute values referencing multiple entities,
// so validate it ourselves
if (!attr.isNillable() && mrefs.isEmpty())
{
throw new MolgenisValidationException(new ConstraintViolation(
format("Entity [%s] attribute [%s] value cannot be null", metaData.getName(), attr.getName())));
}
final AttributeMetaData idAttr = metaData.getIdAttribute();
String insertMrefSql = getSqlInsertJunction(metaData, attr);
>>>>>>>
// database doesn't validate NOT NULL constraint for attribute values referencing multiple entities,
// so validate it ourselves
if (!attr.isNillable() && mrefs.isEmpty())
{
throw new MolgenisValidationException(new ConstraintViolation(
format("Entity [%s] attribute [%s] value cannot be null", metaData.getName(), attr.getName())));
}
final Attribute idAttr = metaData.getIdAttribute();
String insertMrefSql = getSqlInsertJunction(metaData, attr);
<<<<<<<
final Attribute idAttribute = metaData.getIdAttribute();
String deleteMrefSql = getSqlDelete(getJunctionTableName(metaData, attr), idAttribute);
=======
final AttributeMetaData idAttr = attr.isMappedBy() ? attr.getMappedBy() : metaData.getIdAttribute();
String deleteMrefSql = getSqlDelete(getJunctionTableName(metaData, attr), idAttr);
>>>>>>>
final Attribute idAttr = attr.isMappedBy() ? attr.getMappedBy() : metaData.getIdAttribute();
String deleteMrefSql = getSqlDelete(getJunctionTableName(metaData, attr), idAttr); |
<<<<<<<
import org.molgenis.data.meta.model.EntityMetaDataMetaData;
import org.molgenis.data.support.DynamicEntity;
=======
>>>>>>>
import org.molgenis.data.meta.model.EntityMetaDataMetaData;
import org.molgenis.data.support.DynamicEntity;
<<<<<<<
import java.util.ArrayList;
=======
import java.text.ParseException;
>>>>>>>
import java.util.ArrayList;
import java.text.ParseException;
<<<<<<<
writeTestRefEntityStatic, readTestRefEntityStatic, countTestRefEntityStatic, writeLanguageMetaData,
readLanguageMetaData, countLanguageMetaData, writeAttributeMetaDataMetaData, writeI18nStringMetaData, "ROLE_ENTITY_READ_SYS_MD_ENTITIES",
"ROLE_ENTITY_READ_SYS_MD_ATTRIBUTES", "ROLE_ENTITY_READ_SYS_MD_PACKAGES"));
}
private void createLanguages()
{
dataService.add(LanguageMetaData.LANGUAGE, languageFactory.create("en", "English"));
dataService.add(LanguageMetaData.LANGUAGE, languageFactory.create("nl", "Nederlands"));
}
@AfterClass
public void cleanUp() throws InterruptedException
{
// Give asyncTransactionLog time to stop gracefully
TimeUnit.SECONDS.sleep(1);
applicationContext.close();
SecurityContextHolder.getContext().setAuthentication(null);
try
{
// Delete molgenis home folder
FileUtils.deleteDirectory(new File(System.getProperty("molgenis.home")));
}
catch (IOException e)
{
LOG.error("Error removing molgenis home directory", e);
}
l2Cache.logStatistics();
cleanUpLanguages();
}
private void cleanUpLanguages()
{
List<AttributeMetaData> languageAttrs = new ArrayList<>();
for (AttributeMetaData attr : attributeMetaDataMetaData.getAttributes())
{
if (I18nUtils.isI18n(attr.getName()))
{
languageAttrs.add(attr);
}
}
languageAttrs.forEach(attributeMetaDataMetaData::removeAttribute);
languageAttrs.clear();
for (AttributeMetaData attr : entityMetaDataMetaData.getAttributes())
{
if (I18nUtils.isI18n(attr.getName()))
{
languageAttrs.add(attr);
}
}
languageAttrs.forEach(entityMetaDataMetaData::removeAttribute);
=======
writeTestRefEntityStatic, readTestRefEntityStatic, countTestRefEntityStatic,
"ROLE_ENTITY_READ_SYS_MD_ENTITIES", "ROLE_ENTITY_READ_SYS_MD_ATTRIBUTES",
"ROLE_ENTITY_READ_SYS_MD_PACKAGES"));
>>>>>>>
writeTestRefEntityStatic, readTestRefEntityStatic, countTestRefEntityStatic,
writeLanguageMetaData, readLanguageMetaData, countLanguageMetaData,
writeAttributeMetaDataMetaData, writeI18nStringMetaData, "ROLE_ENTITY_READ_SYS_MD_ENTITIES",
"ROLE_ENTITY_READ_SYS_MD_ATTRIBUTES", "ROLE_ENTITY_READ_SYS_MD_PACKAGES"));
}
private void createLanguages()
{
dataService.add(LanguageMetaData.LANGUAGE, languageFactory.create("en", "English"));
dataService.add(LanguageMetaData.LANGUAGE, languageFactory.create("nl", "Nederlands"));
}
@AfterClass
public void cleanUp() throws InterruptedException
{
// Give asyncTransactionLog time to stop gracefully
TimeUnit.SECONDS.sleep(1);
applicationContext.close();
SecurityContextHolder.getContext().setAuthentication(null);
try
{
// Delete molgenis home folder
FileUtils.deleteDirectory(new File(System.getProperty("molgenis.home")));
}
catch (IOException e)
{
LOG.error("Error removing molgenis home directory", e);
}
l2Cache.logStatistics();
cleanUpLanguages();
}
private void cleanUpLanguages()
{
List<AttributeMetaData> languageAttrs = new ArrayList<>();
for (AttributeMetaData attr : attributeMetaDataMetaData.getAttributes())
{
if (I18nUtils.isI18n(attr.getName()))
{
languageAttrs.add(attr);
}
}
languageAttrs.forEach(attributeMetaDataMetaData::removeAttribute);
languageAttrs.clear();
for (AttributeMetaData attr : entityMetaDataMetaData.getAttributes())
{
if (I18nUtils.isI18n(attr.getName()))
{
languageAttrs.add(attr);
}
}
languageAttrs.forEach(entityMetaDataMetaData::removeAttribute); |
<<<<<<<
import org.molgenis.data.meta.EntityMetaData;
=======
import org.molgenis.data.QueryRule.Operator;
>>>>>>>
import org.molgenis.data.QueryRule.Operator;
import org.molgenis.data.meta.EntityMetaData; |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.AttributeMetaDataMetaData;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.meta.model.EntityTypeMetadata;
=======
import org.molgenis.data.meta.model.*;
>>>>>>>
import org.molgenis.data.meta.model.*;
<<<<<<<
import static org.molgenis.data.meta.model.EntityTypeMetadata.ENTITY_META_DATA;
=======
import static org.molgenis.data.meta.model.EntityMetaData.AttributeCopyMode.DEEP_COPY_ATTRS;
import static org.molgenis.data.meta.model.EntityMetaDataMetaData.ENTITY_META_DATA;
>>>>>>>
import static org.molgenis.data.meta.model.EntityType.AttributeCopyMode.DEEP_COPY_ATTRS;
import static org.molgenis.data.meta.model.EntityTypeMetadata.ENTITY_META_DATA;
<<<<<<<
// Permissions refEntityTypeStatic.getName()
String writeTestRefEntityStatic = "ROLE_ENTITY_WRITE_" + refEntityTypeStatic.getName().toUpperCase();
String readTestRefEntityStatic = "ROLE_ENTITY_READ_" + refEntityTypeStatic.getName().toUpperCase();
String countTestRefEntityStatic = "ROLE_ENTITY_COUNT_" + refEntityTypeStatic.getName().toUpperCase();
// Permissions entityTypeStatic.getName()
String writeTestEntityStatic = "ROLE_ENTITY_WRITE_" + entityTypeStatic.getName().toUpperCase();
String readTestEntityStatic = "ROLE_ENTITY_READ_" + entityTypeStatic.getName().toUpperCase();
String countTestEntityStatic = "ROLE_ENTITY_COUNT_" + entityTypeStatic.getName().toUpperCase();
// Permissions entityTypeDynamic.getName()
String writeTestEntity = "ROLE_ENTITY_WRITE_" + entityTypeDynamic.getName().toUpperCase();
String readTestEntity = "ROLE_ENTITY_READ_" + entityTypeDynamic.getName().toUpperCase();
String countTestEntity = "ROLE_ENTITY_COUNT_" + entityTypeDynamic.getName().toUpperCase();
// Permissions refEntityTypeDynamic.getName()
String readTestRefEntity = "ROLE_ENTITY_READ_" + refEntityTypeDynamic.getName().toUpperCase();
String countTestRefEntity = "ROLE_ENTITY_COUNT_" + refEntityTypeDynamic.getName().toUpperCase();
// Permissions selfXrefEntityType.getName()
String writeSelfXrefEntity = "ROLE_ENTITY_WRITE_" + selfXrefEntityType.getName().toUpperCase();
String readSelfXrefEntity = "ROLE_ENTITY_READ_" + selfXrefEntityType.getName().toUpperCase();
String countSelfXrefEntity = "ROLE_ENTITY_COUNT_" + selfXrefEntityType.getName().toUpperCase();
// Permissions languageMetaData
String writeLanguageMetaData = "ROLE_ENTITY_WRITE_" + languageMetaData.getName().toUpperCase();
String readLanguageMetaData = "ROLE_ENTITY_READ_" + languageMetaData.getName().toUpperCase();
String countLanguageMetaData = "ROLE_ENTITY_COUNT_" + languageMetaData.getName().toUpperCase();
// Permissions attributeMetaDataMetaData
String writeAttributeMetaDataMetaData =
"ROLE_ENTITY_WRITE_" + attributeMetaDataMetaData.getName().toUpperCase();
String readAttributeMetaDataMetaData = "ROLE_ENTITY_READ_" + attributeMetaDataMetaData.getName().toUpperCase();
String countAttributeMetaDataMetaData =
"ROLE_ENTITY_COUNT_" + attributeMetaDataMetaData.getName().toUpperCase();
// Permissions i18nStringMetaData
String writeI18nStringMetaData = "ROLE_ENTITY_WRITE_" + i18nStringMetaData.getName().toUpperCase();
// EntityTypeMetadata
String writeEntityTypeMetaData = "ROLE_ENTITY_WRITE_" + entityTypeMetadata.getName().toUpperCase();
String readEntityTypeMetaData = "ROLE_ENTITY_READ_" + entityTypeMetadata.getName().toUpperCase();
String countEntityTypeMetaData = "ROLE_ENTITY_COUNT_" + entityTypeMetadata.getName().toUpperCase();
SecurityContextHolder.getContext().setAuthentication(
new TestingAuthenticationToken("user", "user", writeTestEntity, readTestEntity, readTestRefEntity,
countTestEntity, countTestRefEntity, writeSelfXrefEntity, readSelfXrefEntity,
countSelfXrefEntity, writeTestEntityStatic, readTestEntityStatic, countTestEntityStatic,
writeTestRefEntityStatic, readTestRefEntityStatic, countTestRefEntityStatic,
writeLanguageMetaData, readLanguageMetaData, countLanguageMetaData,
writeAttributeMetaDataMetaData, readAttributeMetaDataMetaData, countAttributeMetaDataMetaData,
writeI18nStringMetaData, writeEntityTypeMetaData, readEntityTypeMetaData,
countEntityTypeMetaData, "ROLE_ENTITY_READ_SYS_MD_ENTITIES",
"ROLE_ENTITY_READ_SYS_MD_ATTRIBUTES", "ROLE_ENTITY_READ_SYS_MD_PACKAGES"));
=======
List<GrantedAuthority> authorities = newArrayList();
if (write) authorities.add(new SimpleGrantedAuthority("ROLE_ENTITY_WRITE_" + entityName.toUpperCase()));
if (read) authorities.add(new SimpleGrantedAuthority("ROLE_ENTITY_READ_" + entityName.toUpperCase()));
if (count) authorities.add(new SimpleGrantedAuthority("ROLE_ENTITY_COUNT_" + entityName.toUpperCase()));
return authorities;
>>>>>>>
List<GrantedAuthority> authorities = newArrayList();
if (write) authorities.add(new SimpleGrantedAuthority("ROLE_ENTITY_WRITE_" + entityName.toUpperCase()));
if (read) authorities.add(new SimpleGrantedAuthority("ROLE_ENTITY_READ_" + entityName.toUpperCase()));
if (count) authorities.add(new SimpleGrantedAuthority("ROLE_ENTITY_COUNT_" + entityName.toUpperCase()));
return authorities;
<<<<<<<
languageAttrs.clear();
for (AttributeMetaData attr : entityTypeMetadata.getAttributes())
{
if (I18nUtils.isI18n(attr.getName()))
{
languageAttrs.add(attr);
}
}
languageAttrs.forEach(entityTypeMetadata::removeAttribute);
=======
SecurityContextHolder.getContext()
.setAuthentication(new TestingAuthenticationToken("user", "user", authorities));
>>>>>>>
SecurityContextHolder.getContext()
.setAuthentication(new TestingAuthenticationToken("user", "user", authorities));
<<<<<<<
@Test
public void testGetEntityType()
=======
@Test(singleThreaded = true)
public void testGetEntityMetaData()
>>>>>>>
@Test(singleThreaded = true)
public void testGetEntityType() |
<<<<<<<
=======
public Set<Operator> getQueryOperators()
{
return decoratedRepository.getQueryOperators();
}
@Override
public void create()
{
decoratedRepository.create();
}
@Override
public void drop()
{
decoratedRepository.drop();
}
@Override
>>>>>>>
public Set<Operator> getQueryOperators()
{
return decoratedRepository.getQueryOperators();
}
@Override |
<<<<<<<
import java.io.File;
=======
import java.util.Collections;
>>>>>>>
import java.io.File;
import java.util.Collections;
<<<<<<<
=======
import org.molgenis.data.RepositoryCapability;
import org.molgenis.data.elasticsearch.SearchService;
>>>>>>>
import org.molgenis.data.RepositoryCapability;
<<<<<<<
@Override
public String getUrl()
{
throw new UnsupportedOperationException();
}
/**
* @return the ontologyLoader
*/
public OntologyLoader getOntologyLoader()
{
return ontologyLoader;
}
/**
* @param ontologyLoader
* the ontologyLoader to set
*/
public void setOntologyLoader(OntologyLoader ontologyLoader)
{
this.ontologyLoader = ontologyLoader;
}
=======
>>>>>>>
@Override
public String getUrl()
{
throw new UnsupportedOperationException();
}
/**
* @return the ontologyLoader
*/
public OntologyLoader getOntologyLoader()
{
return ontologyLoader;
}
/**
* @param ontologyLoader
* the ontologyLoader to set
*/
public void setOntologyLoader(OntologyLoader ontologyLoader)
{
this.ontologyLoader = ontologyLoader;
} |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
Iterable<AttributeMetaData> attributes = targetEntityType.getAtomicAttributes();
=======
Iterable<Attribute> attributes = targetEntityMetaData.getAtomicAttributes();
>>>>>>>
Iterable<Attribute> attributes = targetEntityType.getAtomicAttributes();
<<<<<<<
AttributeMetaData targetAttr = targetEntityType.getAttribute(targetAttributeName);
=======
Attribute targetAttr = targetEntityMeta.getAttribute(targetAttributeName);
>>>>>>>
Attribute targetAttr = targetEntityType.getAttribute(targetAttributeName);
<<<<<<<
AttributeMetaData targetAttributeMetaData = entityMapping.getTargetEntityType()
.getAttribute(targetAttribute);
=======
Attribute targetAttribute = entityMapping.getTargetEntityMetaData()
.getAttribute(targetAttributeName);
>>>>>>>
Attribute targetAttribute = entityMapping.getTargetEntityType().getAttribute(targetAttributeName);
<<<<<<<
List<AttributeMetaData> sourceAttributes = generateAlgorithmRequest.getSourceAttributes().stream()
.map(name -> sourceEntityType.getAttribute(name)).collect(Collectors.toList());
=======
List<Attribute> sourceAttributes = generateAlgorithmRequest.getSourceAttributes().stream()
.map(name -> sourceEntityMetaData.getAttribute(name)).collect(Collectors.toList());
>>>>>>>
List<Attribute> sourceAttributes = generateAlgorithmRequest.getSourceAttributes().stream()
.map(name -> sourceEntityType.getAttribute(name)).collect(Collectors.toList());
<<<<<<<
EntityType refEntityType = attributeMapping.getTargetAttributeMetaData().getRefEntity();
if (refEntityType != null)
=======
EntityMetaData refEntityMetaData = attributeMapping.getTargetAttribute().getRefEntity();
if (refEntityMetaData != null)
>>>>>>>
EntityType refEntityType = attributeMapping.getTargetAttribute().getRefEntity();
if (refEntityType != null)
<<<<<<<
.getTagsForAttribute(entityMapping.getTargetEntityType(),
attributeMapping.getTargetAttributeMetaData());
=======
.getTagsForAttribute(entityMapping.getTargetEntityMetaData(),
attributeMapping.getTargetAttribute());
>>>>>>>
.getTagsForAttribute(entityMapping.getTargetEntityType(), attributeMapping.getTargetAttribute());
<<<<<<<
List<AttributeMetaData> sourceAttributes = sourceAttributeNames.stream()
.map(attributeName -> entityMapping.getSourceEntityType().getAttribute(attributeName))
=======
List<Attribute> sourceAttributes = sourceAttributeNames.stream()
.map(attributeName -> entityMapping.getSourceEntityMetaData().getAttribute(attributeName))
>>>>>>>
List<Attribute> sourceAttributes = sourceAttributeNames.stream()
.map(attributeName -> entityMapping.getSourceEntityType().getAttribute(attributeName))
<<<<<<<
AttributeMetaData targetAttr = dataService.getEntityType(target).getAttribute(targetAttribute);
=======
Attribute targetAttr = dataService.getEntityMetaData(target).getAttribute(targetAttribute);
>>>>>>>
Attribute targetAttr = dataService.getEntityType(target).getAttribute(targetAttribute);
<<<<<<<
AttributeMetaData sourceAttr = dataService.getEntityType(source).getAttribute(sourceAttribute);
=======
Attribute sourceAttr = dataService.getEntityMetaData(source).getAttribute(sourceAttribute);
>>>>>>>
Attribute sourceAttr = dataService.getEntityType(source).getAttribute(sourceAttribute);
<<<<<<<
EntityType targetEntityType = dataService
.getEntityType(mappingServiceRequest.getTargetEntityName());
AttributeMetaData targetAttribute = targetEntityType != null ? targetEntityType
=======
EntityMetaData targetEntityMetaData = dataService
.getEntityMetaData(mappingServiceRequest.getTargetEntityName());
Attribute targetAttribute = targetEntityMetaData != null ? targetEntityMetaData
>>>>>>>
EntityType targetEntityType = dataService.getEntityType(mappingServiceRequest.getTargetEntityName());
Attribute targetAttribute = targetEntityType != null ? targetEntityType
<<<<<<<
private void autoGenerateAlgorithms(EntityMapping mapping, EntityType sourceEntityType,
EntityType targetEntityType, Iterable<AttributeMetaData> attributes, MappingProject project)
=======
private void autoGenerateAlgorithms(EntityMapping mapping, EntityMetaData sourceEntityMetaData,
EntityMetaData targetEntityMetaData, Iterable<Attribute> attributes, MappingProject project)
>>>>>>>
private void autoGenerateAlgorithms(EntityMapping mapping, EntityType sourceEntityType, EntityType targetEntityType,
Iterable<Attribute> attributes, MappingProject project) |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType; |
<<<<<<<
import org.molgenis.data.Queryable;
import org.molgenis.data.Repository;
import org.molgenis.data.Writable;
=======
import org.molgenis.data.support.AbstractCrudRepository;
>>>>>>>
import org.molgenis.data.Queryable;
import org.molgenis.data.Repository;
import org.molgenis.data.Writable;
import org.molgenis.data.support.AbstractCrudRepository;
<<<<<<<
@Override
=======
return sql;
}
@Override
>>>>>>>
return sql;
}
@Override
<<<<<<<
@Override
=======
return sql.toString();
}
@Override
>>>>>>>
return sql.toString();
}
@Override
<<<<<<<
=======
@Override
protected void addInternal(Entity entity)
{
if (entity == null) throw new RuntimeException("MysqlRepository.add() failed: entity was null");
this.add(Arrays.asList(new Entity[]
{ entity }));
}
>>>>>>>
@Override
protected void addInternal(Entity entity)
{
if (entity == null) throw new RuntimeException("MysqlRepository.add() failed: entity was null");
this.add(Arrays.asList(new Entity[]
{ entity }));
} |
<<<<<<<
if (!dataService.hasRepository(entityTypeId))
=======
if(targetMetaData.getPackage() == null || systemPackageRegistry.containsPackage(targetMetaData.getPackage())){
targetMetaData.setPackage(defaultPackage);
}
String fullyQualifiedEntityName = targetMetaData.getFullyQualifiedName();
if (!dataService.hasRepository(fullyQualifiedEntityName))
>>>>>>>
if(targetMetaData.getPackage() == null || systemPackageRegistry.containsPackage(targetMetaData.getPackage())){
targetMetaData.setPackage(defaultPackage);
}
if (!dataService.hasRepository(entityTypeId))
<<<<<<<
targetRepo = dataService.getRepository(entityTypeId);
=======
targetRepo = dataService.getRepository(fullyQualifiedEntityName);
>>>>>>>
targetRepo = dataService.getRepository(entityTypeId); |
<<<<<<<
new EmxMetaDataParser(packageFactory, attributeMetaDataFactory, entityTypeFactory),
entityTypeFactory, attributeMetaDataFactory);
=======
new EmxMetaDataParser(packageFactory, attributeFactory, entityMetaDataFactory),
entityMetaDataFactory, attributeFactory);
>>>>>>>
new EmxMetaDataParser(packageFactory, attributeFactory, entityTypeFactory),
entityTypeFactory, attributeFactory);
<<<<<<<
List<AttributeMetaData> requiredAttributes = new ArrayList<>();
EntityType entityType = entityTypeFactory.create().setName(VARIANT);
List<AttributeMetaData> refAttributesList = Arrays
.asList(CaddAnnotator.getCaddScaledAttr(attributeMetaDataFactory),
ExacAnnotator.getExacAFAttr(attributeMetaDataFactory), vcfAttributes.getAltAttribute());
entityType.addAttributes(refAttributesList);
AttributeMetaData refAttr = attributeMetaDataFactory.create().setName(VARIANT).setDataType(XREF)
.setRefEntity(entityType).setDescription(
=======
List<Attribute> requiredAttributes = new ArrayList<>();
EntityMetaData entityMetaData = entityMetaDataFactory.create().setName(VARIANT);
List<Attribute> refAttributesList = Arrays
.asList(CaddAnnotator.getCaddScaledAttr(attributeFactory),
ExacAnnotator.getExacAFAttr(attributeFactory), vcfAttributes.getAltAttribute());
entityMetaData.addAttributes(refAttributesList);
Attribute refAttr = attributeFactory.create().setName(VARIANT).setDataType(XREF)
.setRefEntity(entityMetaData).setDescription(
>>>>>>>
List<Attribute> requiredAttributes = new ArrayList<>();
EntityType entityType = entityTypeFactory.create().setName(VARIANT);
List<Attribute> refAttributesList = Arrays
.asList(CaddAnnotator.getCaddScaledAttr(attributeFactory),
ExacAnnotator.getExacAFAttr(attributeFactory), vcfAttributes.getAltAttribute());
entityType.addAttributes(refAttributesList);
Attribute refAttr = attributeFactory.create().setName(VARIANT).setDataType(XREF)
.setRefEntity(entityType).setDescription( |
<<<<<<<
public static final String COMMENTS = "comments";
public static final String CADDS = "cadds";
public static final String VCFS = "vcfs";
public static final String ERRORS = "errors";
public static final String SKIPPEDS = "skippeds";
=======
public static final String INPUT_FILE_EXTENSION = "extension";
>>>>>>>
public static final String INPUT_FILE_EXTENSION = "extension";
public static final String COMMENTS = "comments";
public static final String CADDS = "cadds";
public static final String VCFS = "vcfs";
public static final String ERRORS = "errors";
public static final String SKIPPEDS = "skippeds";
<<<<<<<
addAttribute(COMMENTS).setDataType(INT).setNillable(true);
addAttribute(CADDS).setDataType(INT).setNillable(true);
addAttribute(VCFS).setDataType(INT).setNillable(true);
addAttribute(ERRORS).setDataType(INT).setNillable(true);
addAttribute(SKIPPEDS).setDataType(INT).setNillable(true);
=======
addAttribute(INPUT_FILE_EXTENSION).setDataType(STRING).setNillable(false);
>>>>>>>
addAttribute(INPUT_FILE_EXTENSION).setDataType(STRING).setNillable(false);
addAttribute(COMMENTS).setDataType(INT).setNillable(true);
addAttribute(CADDS).setDataType(INT).setNillable(true);
addAttribute(VCFS).setDataType(INT).setNillable(true);
addAttribute(ERRORS).setDataType(INT).setNillable(true);
addAttribute(SKIPPEDS).setDataType(INT).setNillable(true); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaDataFactory;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.meta.model.EntityTypeFactory;
=======
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityMetaData;
import org.molgenis.data.meta.model.EntityMetaDataFactory;
>>>>>>>
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityType;
import org.molgenis.data.meta.model.EntityTypeFactory;
<<<<<<<
private EntityTypeFactory entityTypeFactory;
private AttributeMetaDataFactory attrMetaFactory;
=======
private EntityMetaDataFactory entityMetaFactory;
private AttributeFactory attrMetaFactory;
>>>>>>>
private EntityTypeFactory entityTypeFactory;
private AttributeFactory attrMetaFactory; |
<<<<<<<
import org.molgenis.framework.ui.ScreenController;
=======
import org.molgenis.framework.server.TokenFactory;
import org.molgenis.omx.auth.service.MolgenisUserService;
import org.molgenis.omx.auth.util.PasswordHasher;
>>>>>>>
<<<<<<<
=======
/**
* {@inheritDoc}
*
* Note: Anonymous is automatically logged in but does not count as being authenticated
*/
>>>>>>>
<<<<<<<
public boolean canWrite(Entity entity) throws DatabaseException
{
// TODO Auto-generated method stub
return false;
}
@Override
public QueryRule getRowlevelSecurityFilters(Class<? extends Entity> klazz)
{
// TODO Auto-generated method stub
return null;
}
@Override
=======
>>>>>>>
public boolean canWrite(Entity entity) throws DatabaseException
{
// TODO Auto-generated method stub
return false;
}
@Override
public QueryRule getRowlevelSecurityFilters(Class<? extends Entity> klazz)
{
// TODO Auto-generated method stub
return null;
}
@Override
<<<<<<<
// TODO Auto-generated method stub
return null;
=======
return this.redirect;
}
/**
* Helper method to check if an entity is implementing the authorizable interface, i.e. to check if we should
* implement row-level security.
*
* @param entity
* @param interfaceName
* @return
*/
private boolean isImplementing(Entity entity, String interfaceName)
{
if (StringUtils.isEmpty(interfaceName)) return false;
Class<?>[] interfaces = entity.getClass().getInterfaces();
for (Class<?> interface_ : interfaces)
{
if (interface_.getName().equals(interfaceName)) return true;
}
return false;
>>>>>>>
// TODO Auto-generated method stub
return null; |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType; |
<<<<<<<
import static org.molgenis.data.postgresql.PostgreSqlRepositoryCollection.POSTGRESQL;
import static org.molgenis.data.support.EntityTypeUtils.*;
=======
import static org.molgenis.data.support.EntityMetaDataUtils.*;
>>>>>>>
import static org.molgenis.data.postgresql.PostgreSqlRepositoryCollection.POSTGRESQL;
import static org.molgenis.data.support.EntityTypeUtils.*;
<<<<<<<
Attribute foreignKeyAttr;
if (attr.isMappedBy())
{
foreignKeyAttr = attr.getRefEntity().getIdAttribute();
}
else
{
foreignKeyAttr = attr;
}
StringBuilder strBuilder = new StringBuilder("CONSTRAINT ").append(getForeignKeyName(entityType, attr))
.append(" FOREIGN KEY (").append(getColumnName(foreignKeyAttr)).append(") REFERENCES ")
=======
StringBuilder strBuilder = new StringBuilder("CONSTRAINT ").append(getForeignKeyName(entityMeta, attr))
.append(" FOREIGN KEY (").append(getColumnName(attr)).append(") REFERENCES ")
>>>>>>>
StringBuilder strBuilder = new StringBuilder("CONSTRAINT ").append(getForeignKeyName(entityType, attr))
.append(" FOREIGN KEY (").append(getColumnName(attr)).append(") REFERENCES ")
<<<<<<<
if (attr.getRefEntity().getName().equals(entityType.getName()) || attr.isInversedBy())
=======
if (attr.getRefEntity().getName().equals(entityMeta.getName()))
>>>>>>>
if (attr.getRefEntity().getName().equals(entityType.getName()))
<<<<<<<
String tableName;
if (attr.isMappedBy())
{
tableName = getJunctionTableName(entityType, attr);
}
else
{
tableName = getTableName(entityType);
}
return "ALTER TABLE " + tableName + " ADD " + getSqlForeignKey(entityType, attr);
=======
return "ALTER TABLE " + getTableName(entityMeta) + " ADD " + getSqlForeignKey(entityMeta, attr);
>>>>>>>
return "ALTER TABLE " + getTableName(entityType) + " ADD " + getSqlForeignKey(entityType, attr);
<<<<<<<
EntityType tableEntityType;
String columnSql;
boolean bidirectionalOneToMany = attr.getDataType() == ONE_TO_MANY && attr.isMappedBy();
if (bidirectionalOneToMany)
{
tableEntityType = attr.getRefEntity();
if (tableEntityType.getBackend().equals(POSTGRESQL))
{
columnSql = getSqlOrderColumn(attr);
}
else
{
return null;
}
}
else
{
tableEntityType = entityType;
columnSql = getSqlColumn(entityType, attr);
}
sql.append(getTableName(tableEntityType)).append(" ADD ").append(columnSql);
=======
String columnSql = getSqlColumn(entityMeta, attr);
sql.append(getTableName(entityMeta)).append(" ADD ").append(columnSql);
>>>>>>>
String columnSql = getSqlColumn(entityType, attr);
sql.append(getTableName(entityType)).append(" ADD ").append(columnSql);
<<<<<<<
if (attr.isMappedBy())
{
entityType = attr.getRefEntity();
attr = attr.getMappedBy();
}
Attribute idAttr = entityType.getIdAttribute();
StringBuilder sql = new StringBuilder("CREATE TABLE ").append(getJunctionTableName(entityType, attr))
=======
AttributeMetaData idAttr = entityMeta.getIdAttribute();
StringBuilder sql = new StringBuilder("CREATE TABLE ").append(getJunctionTableName(entityMeta, attr))
>>>>>>>
Attribute idAttr = entityType.getIdAttribute();
StringBuilder sql = new StringBuilder("CREATE TABLE ").append(getJunctionTableName(entityType, attr))
<<<<<<<
Attribute idAttr = attr.isMappedBy() ? attr.getRefEntity().getIdAttribute() : entityType.getIdAttribute();
String junctionTableName = getJunctionTableName(entityType, attr);
String junctionTableIndexName = getJunctionTableIndexName(entityType, attr, idAttr);
=======
AttributeMetaData idAttr = entityMeta.getIdAttribute();
String junctionTableName = getJunctionTableName(entityMeta, attr);
String junctionTableIndexName = getJunctionTableIndexName(entityMeta, attr, idAttr);
>>>>>>>
Attribute idAttr = entityType.getIdAttribute();
String junctionTableName = getJunctionTableName(entityType, attr);
String junctionTableIndexName = getJunctionTableIndexName(entityType, attr, idAttr);
<<<<<<<
String tableName, columnName;
if (attr.getDataType() == ONE_TO_MANY && attr.getMappedBy() != null)
{
tableName = getTableName(attr.getRefEntity());
columnName = getSequenceColumnName(attr);
}
else
{
tableName = getTableName(entityType);
columnName = getColumnName(attr);
}
return "ALTER TABLE " + tableName + " DROP COLUMN " + columnName;
=======
return "ALTER TABLE " + getTableName(entityMeta) + " DROP COLUMN " + getColumnName(attr);
>>>>>>>
return "ALTER TABLE " + getTableName(entityType) + " DROP COLUMN " + getColumnName(attr);
<<<<<<<
Attribute junctionAttr1;
if (attr.isMappedBy())
{
junctionAttr1 = attr.getRefEntity().getIdAttribute();
}
else
{
junctionAttr1 = entityType.getIdAttribute();
}
Attribute junctionAttr2;
if (attr.isMappedBy())
{
junctionAttr2 = attr.getMappedBy();
}
else
{
junctionAttr2 = attr;
}
String junctionTableName = getJunctionTableName(entityType, attr);
=======
String junctionTableName = getJunctionTableName(entityMeta, attr);
>>>>>>>
String junctionTableName = getJunctionTableName(entityType, attr);
<<<<<<<
private static boolean isJunctionTableAttribute(Attribute attr)
=======
/**
* Returns whether this attribute is stored in the entity table or another table such as a junction table or
* referenced entity table.
*
* @param attr attribute
* @return whether this attribute is stored in another table than the entity table
*/
private static boolean isPersistedInOtherTable(AttributeMetaData attr)
>>>>>>>
/**
* Returns whether this attribute is stored in the entity table or another table such as a junction table or
* referenced entity table.
*
* @param attr attribute
* @return whether this attribute is stored in another table than the entity table
*/
private static boolean isPersistedInOtherTable(AttributeMetaData attr)
<<<<<<<
String idColName, refIdColName;
if (attr.isMappedBy())
{
idColName = getColumnName(attr.getMappedBy());
refIdColName = getColumnName(attr.getRefEntity().getIdAttribute());
}
else
{
idColName = getColumnName(entityType.getIdAttribute());
refIdColName = getColumnName(attr);
}
=======
String idColName = getColumnName(entityMeta.getIdAttribute());
String refIdColName = getColumnName(attr);
>>>>>>>
String idColName = getColumnName(entityType.getIdAttribute());
String refIdColName = getColumnName(attr);
<<<<<<<
getJunctionTableName(entityType, attr), getColumnName(idAttribute));
=======
getJunctionTableName(entityMeta, attr), getColumnName(idAttribute));
select.append(mrefSelect);
>>>>>>>
getJunctionTableName(entityType, attr), getColumnName(idAttribute));
select.append(mrefSelect);
<<<<<<<
private static String getSqlOrderColumn(Attribute attr)
{
return getSequenceColumnName(attr) + " SERIAL";
}
/**
* Returns the name of the sequence column of the many to one attribute.
*
* @param attr many to one attribute
* @return sequence column name
*/
static String getSequenceColumnName(Attribute attr)
{
return getColumnName(attr.getMappedBy().getName() + "_order");
}
private static String getSqlColumn(EntityType entityType, Attribute attr)
=======
private static String getSqlColumn(EntityMetaData entityMeta, AttributeMetaData attr)
>>>>>>>
private static String getSqlColumn(EntityMetaData entityMeta, AttributeMetaData attr)
<<<<<<<
Attribute attr = entityType.getAttribute(o.getAttr());
if (isJunctionTableAttribute(attr))
=======
AttributeMetaData attr = entityMeta.getAttribute(o.getAttr());
if (isPersistedInOtherTable(attr))
>>>>>>>
Attribute attr = entityType.getAttribute(o.getAttr());
if (isPersistedInOtherTable(attr))
<<<<<<<
List<Attribute> mrefAttrsInQuery = getJunctionTableQueryAttrs(entityType, q);
StringBuilder from = new StringBuilder(" FROM ").append(getTableName(entityType)).append(" AS this");
=======
List<AttributeMetaData> mrefAttrsInQuery = getJoinQueryAttrs(entityMeta, q);
StringBuilder from = new StringBuilder(" FROM ").append(getTableName(entityMeta)).append(" AS this");
>>>>>>>
List<Attribute> mrefAttrsInQuery = getJoinQueryAttrs(entityMeta, q);
StringBuilder from = new StringBuilder(" FROM ").append(getTableName(entityMeta)).append(" AS this");
<<<<<<<
Attribute mrefAttr = mrefAttrsInQuery.get(i);
if (mrefAttr.isMappedBy())
=======
AttributeMetaData mrefAttr = mrefAttrsInQuery.get(i);
if (mrefAttr.getDataType() == ONE_TO_MANY && mrefAttr.isMappedBy())
>>>>>>>
Attribute mrefAttr = mrefAttrsInQuery.get(i);
if (mrefAttr.getDataType() == ONE_TO_MANY && mrefAttr.isMappedBy())
<<<<<<<
from.append(" LEFT JOIN ").append(getJunctionTableName(entityType, mrefAttr)).append(" AS ")
=======
from.append(" LEFT JOIN ").append(getTableName(mrefAttr.getRefEntity())).append(" AS ")
>>>>>>>
from.append(" LEFT JOIN ").append(getTableName(mrefAttr.getRefEntity())).append(" AS ")
<<<<<<<
static String getColumnName(Attribute attr)
=======
private static String getColumnName(AttributeMetaData attr)
>>>>>>>
private static String getColumnName(Attribute attr)
<<<<<<<
Attribute attr = entityType.getAttribute(rule.getField());
if (attr != null && isJunctionTableAttribute(attr))
=======
AttributeMetaData attr = entityMeta.getAttribute(rule.getField());
if (attr != null && isPersistedInOtherTable(attr))
>>>>>>>
Attribute attr = entityType.getAttribute(rule.getField());
if (attr != null && isPersistedInOtherTable(attr))
<<<<<<<
getJunctionTableQueryAttrsRec(entityType, rule.getNestedRules(), junctionTableQueryAttrs);
=======
getJoinQueryAttrsRec(entityMeta, rule.getNestedRules(), joinAttrs);
>>>>>>>
getJoinQueryAttrsRec(entityType, rule.getNestedRules(), joinAttrs); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
private AttributeMetaData violatedAttribute;
private EntityType entityType;
=======
private Attribute violatedAttribute;
private EntityMetaData entityMetaData;
>>>>>>>
private Attribute violatedAttribute;
private EntityType entityType;
<<<<<<<
public ConstraintViolation(String message, Object invalidValue, Entity entity, AttributeMetaData violatedAttribute,
EntityType entityType, Long rownr)
=======
public ConstraintViolation(String message, Object invalidValue, Entity entity, Attribute violatedAttribute,
EntityMetaData entityMetaData, Long rownr)
>>>>>>>
public ConstraintViolation(String message, Object invalidValue, Entity entity, Attribute violatedAttribute,
EntityType entityType, Long rownr) |
<<<<<<<
import org.molgenis.data.elasticsearch.reindex.ReindexActionRegisterService;
import org.molgenis.data.elasticsearch.reindex.ReindexActionRepositoryDecorator;
import org.molgenis.data.i18n.I18nStringDecorator;
import org.molgenis.data.i18n.Language;
import org.molgenis.data.i18n.LanguageRepositoryDecorator;
import org.molgenis.data.meta.AttributeMetaData;
import org.molgenis.data.meta.AttributeMetaDataRepositoryDecorator;
import org.molgenis.data.meta.EntityMetaData;
import org.molgenis.data.meta.EntityMetaDataImpl;
import org.molgenis.data.meta.EntityMetaDataRepositoryDecorator;
import org.molgenis.data.meta.Package;
import org.molgenis.data.meta.PackageRepositoryDecorator;
import org.molgenis.data.meta.system.SystemEntityMetaDataRegistry;
=======
import org.molgenis.data.elasticsearch.ElasticsearchRepositoryCollection;
import org.molgenis.data.elasticsearch.IndexedRepositoryDecorator;
import org.molgenis.data.elasticsearch.SearchService;
import org.molgenis.data.reindex.ReindexActionRegisterService;
import org.molgenis.data.reindex.ReindexActionRepositoryDecorator;
>>>>>>>
import org.molgenis.data.elasticsearch.IndexedRepositoryDecorator;
import org.molgenis.data.elasticsearch.reindex.ReindexActionRegisterService;
import org.molgenis.data.elasticsearch.reindex.ReindexActionRepositoryDecorator;
import org.molgenis.data.i18n.I18nStringDecorator;
import org.molgenis.data.i18n.Language;
import org.molgenis.data.i18n.LanguageRepositoryDecorator;
import org.molgenis.data.meta.AttributeMetaData;
import org.molgenis.data.meta.AttributeMetaDataRepositoryDecorator;
import org.molgenis.data.meta.EntityMetaData;
import org.molgenis.data.meta.EntityMetaDataImpl;
import org.molgenis.data.meta.EntityMetaDataRepositoryDecorator;
import org.molgenis.data.meta.Package;
import org.molgenis.data.meta.PackageRepositoryDecorator;
import org.molgenis.data.meta.system.SystemEntityMetaDataRegistry;
<<<<<<<
=======
private final ReindexActionRegisterService reindexActionRegisterService;
>>>>>>>
<<<<<<<
private final SystemEntityMetaDataRegistry systemEntityMetaDataRegistry;
private final MolgenisUserFactory molgenisUserFactory;
private final UserAuthorityFactory userAuthorityFactory;
private final ReindexActionRegisterService reindexActionRegisterService;
=======
private final SearchService searchService;
>>>>>>>
private final SystemEntityMetaDataRegistry systemEntityMetaDataRegistry;
private final MolgenisUserFactory molgenisUserFactory;
private final UserAuthorityFactory userAuthorityFactory;
private final ReindexActionRegisterService reindexActionRegisterService;
<<<<<<<
// 4. Index Transaction log decorator
decoratedRepository = new ReindexActionRepositoryDecorator(decoratedRepository, reindexActionRegisterService);
=======
>>>>>>> |
<<<<<<<
=======
>>>>>>> |
<<<<<<<
import org.molgenis.data.meta.SystemEntityType;
import org.molgenis.data.meta.model.AttributeMetaDataMetaData;
import org.molgenis.data.meta.model.EntityTypeMetadata;
=======
import org.molgenis.data.meta.SystemEntityMetaData;
import org.molgenis.data.meta.model.AttributeMetadata;
import org.molgenis.data.meta.model.EntityMetaDataMetaData;
>>>>>>>
import org.molgenis.data.meta.SystemEntityType;
import org.molgenis.data.meta.model.AttributeMetadata;
import org.molgenis.data.meta.model.EntityTypeMetadata;
<<<<<<<
EntityTypeMetadata entityTypeMeta = applicationContext.getBean(EntityTypeMetadata.class);
applicationContext.getBean(AttributeMetaDataMetaData.class).bootstrap(entityTypeMeta);
Map<String, SystemEntityType> systemEntityTypeMap = applicationContext
.getBeansOfType(SystemEntityType.class);
systemEntityTypeMap.values().forEach(systemEntityType -> systemEntityType.bootstrap(entityTypeMeta));
=======
EntityMetaDataMetaData entityMetaMeta = applicationContext.getBean(EntityMetaDataMetaData.class);
applicationContext.getBean(AttributeMetadata.class).bootstrap(entityMetaMeta);
Map<String, SystemEntityMetaData> systemEntityMetaMap = applicationContext
.getBeansOfType(SystemEntityMetaData.class);
systemEntityMetaMap.values().forEach(systemEntityMetaData -> systemEntityMetaData.bootstrap(entityMetaMeta));
>>>>>>>
EntityTypeMetadata entityTypeMeta = applicationContext.getBean(EntityTypeMetadata.class);
applicationContext.getBean(AttributeMetadata.class).bootstrap(entityTypeMeta);
Map<String, SystemEntityType> systemEntityMetaMap = applicationContext.getBeansOfType(SystemEntityType.class);
systemEntityMetaMap.values().forEach(systemEntityType -> systemEntityType.bootstrap(entityTypeMeta)); |
<<<<<<<
import org.molgenis.data.Repository;
=======
import org.molgenis.data.elasticsearch.SearchService;
import org.molgenis.data.support.AbstractRepository;
>>>>>>>
import org.molgenis.data.support.AbstractRepository; |
<<<<<<<
deleteAuthorsThenBooks(5);
deleteAuthorsThenBooks(6);
dataService.deleteAll(PersonMetaData1.NAME);
dataService.deleteAll(PersonMetaData2.NAME);
dataService.deleteAll(PersonMetaData3.NAME);
dataService.deleteAll(PersonMetaData4.NAME);
=======
>>>>>>>
dataService.deleteAll(PersonMetaData1.NAME);
dataService.deleteAll(PersonMetaData2.NAME);
dataService.deleteAll(PersonMetaData3.NAME);
dataService.deleteAll(PersonMetaData4.NAME);
<<<<<<<
@Test(groups = GROUPS_ONE_TO_MANY, dataProvider = "oneToManyTestCaseDataProvider")
public void testOneToManyAuthorAndBookInsert(int testCase)
=======
@Test(singleThreaded = true, groups = GROUPS_ONE_TO_MANY)
public void testOneToManyInsert()
>>>>>>>
@Test(singleThreaded = true, groups = GROUPS_ONE_TO_MANY, dataProvider = "oneToManyTestCaseDataProvider")
public void testOneToManyAuthorAndBookInsert(int testCase)
<<<<<<<
private List<Entity> importPersons(int testCase)
{
List<Entity> persons = oneToManyTestHarness.createPersonEntities(testCase);
runAsSystem(() ->
{
dataService.add(persons.get(0).getEntityMetaData().getName(), persons.stream());
waitForIndexToBeStable(persons.get(0).getEntityMetaData().getName(), indexService, LOG);
});
return persons;
}
@Test(groups = GROUPS_ONE_TO_MANY)
=======
@Test(singleThreaded = true, groups = GROUPS_ONE_TO_MANY)
>>>>>>>
private List<Entity> importPersons(int testCase)
{
List<Entity> persons = oneToManyTestHarness.createPersonEntities(testCase);
runAsSystem(() ->
{
dataService.add(persons.get(0).getEntityMetaData().getName(), persons.stream());
waitForIndexToBeStable(persons.get(0).getEntityMetaData().getName(), indexService, LOG);
});
return persons;
}
@Test(singleThreaded = true, groups = GROUPS_ONE_TO_MANY) |
<<<<<<<
case FILE:
EntityType refEntity = attr.getRefEntity();
=======
EntityMetaData refEntity = attr.getRefEntity();
>>>>>>>
EntityType refEntity = attr.getRefEntity(); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.EntityType;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityMetaData;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.EntityType;
<<<<<<<
EntityType entityType = when(mock(EntityType.class).getName()).thenReturn("entity").getMock();
when(entityType.getSimpleName()).thenReturn("entity");
AttributeMetaData idAttr = when(mock(AttributeMetaData.class).getName()).thenReturn("aString").getMock();
=======
EntityMetaData entityMeta = when(mock(EntityMetaData.class).getName()).thenReturn("entity").getMock();
when(entityMeta.getSimpleName()).thenReturn("entity");
Attribute idAttr = when(mock(Attribute.class).getName()).thenReturn("aString").getMock();
>>>>>>>
EntityType entityType = when(mock(EntityType.class).getName()).thenReturn("entity").getMock();
when(entityType.getSimpleName()).thenReturn("entity");
Attribute idAttr = when(mock(Attribute.class).getName()).thenReturn("aString").getMock();
<<<<<<<
EntityType entityType = when(mock(EntityType.class).getName()).thenReturn("entity").getMock();
when(entityType.getSimpleName()).thenReturn("entity");
AttributeMetaData idAttr = when(mock(AttributeMetaData.class).getName()).thenReturn("id").getMock();
=======
EntityMetaData entityMeta = when(mock(EntityMetaData.class).getName()).thenReturn("entity").getMock();
when(entityMeta.getSimpleName()).thenReturn("entity");
Attribute idAttr = when(mock(Attribute.class).getName()).thenReturn("id").getMock();
>>>>>>>
EntityType entityType = when(mock(EntityType.class).getName()).thenReturn("entity").getMock();
when(entityType.getSimpleName()).thenReturn("entity");
Attribute idAttr = when(mock(Attribute.class).getName()).thenReturn("id").getMock();
<<<<<<<
EntityType entityType = when(mock(EntityType.class).getName()).thenReturn("entity").getMock();
when(entityType.getSimpleName()).thenReturn("entity");
AttributeMetaData uniqueAttr = when(mock(AttributeMetaData.class).getName()).thenReturn("uniqueAttr").getMock();
=======
EntityMetaData entityMeta = when(mock(EntityMetaData.class).getName()).thenReturn("entity").getMock();
when(entityMeta.getSimpleName()).thenReturn("entity");
Attribute uniqueAttr = when(mock(Attribute.class).getName()).thenReturn("uniqueAttr").getMock();
>>>>>>>
EntityType entityType = when(mock(EntityType.class).getName()).thenReturn("entity").getMock();
when(entityType.getSimpleName()).thenReturn("entity");
Attribute uniqueAttr = when(mock(Attribute.class).getName()).thenReturn("uniqueAttr").getMock();
<<<<<<<
EntityType entityType = when(mock(EntityType.class).getName()).thenReturn("entity").getMock();
when(entityType.getSimpleName()).thenReturn("entity");
AttributeMetaData expressionAttr = when(mock(AttributeMetaData.class).getName()).thenReturn("expressionAttr")
=======
EntityMetaData entityMeta = when(mock(EntityMetaData.class).getName()).thenReturn("entity").getMock();
when(entityMeta.getSimpleName()).thenReturn("entity");
Attribute expressionAttr = when(mock(Attribute.class).getName()).thenReturn("expressionAttr")
>>>>>>>
EntityType entityType = when(mock(EntityType.class).getName()).thenReturn("entity").getMock();
when(entityType.getSimpleName()).thenReturn("entity");
Attribute expressionAttr = when(mock(Attribute.class).getName()).thenReturn("expressionAttr").getMock();
when(expressionAttr.getExpression()).thenReturn("$('id').value()");
when(expressionAttr.getDefaultValue()).thenReturn("5");
when(entityType.getAttributes()).thenReturn(singletonList(expressionAttr));
MetaValidationUtils.validateEntityType(entityType);
}
@Test
public void testValidateEntityTypeOkayAttributeWithDefaultValue()
{
EntityType entityType = when(mock(EntityType.class).getName()).thenReturn("entity").getMock();
when(entityType.getSimpleName()).thenReturn("entity");
Attribute attrWithDefaultValue = when(mock(Attribute.class).getName()).thenReturn("attrWithDefaultValue") |
<<<<<<<
checkIfEmxIdentifier(entityType, entityType.getPackage());
entityTypes.add(entityType);
=======
checkIfEmxEntityType(entityType);
entityTypes.put(entityType.getId(), entityType);
>>>>>>>
checkIfEmxIdentifier(entityType, entityType.getPackage());
entityTypes.add(entityType);
checkIfEmxEntityType(entityType);
entityTypes.put(entityType.getId(), entityType); |
<<<<<<<
import static org.molgenis.data.meta.model.EntityTypeMetadata.ENTITY_META_DATA;
import static org.molgenis.data.meta.model.EntityTypeMetadata.EXTENDS;
=======
import static org.molgenis.data.meta.model.EntityMetaDataMetaData.ENTITY_META_DATA;
import static org.molgenis.data.meta.model.EntityMetaDataMetaData.EXTENDS;
import static org.molgenis.data.postgresql.PostgreSqlRepositoryCollection.POSTGRESQL;
>>>>>>>
import static org.molgenis.data.meta.model.EntityTypeMetadata.ENTITY_META_DATA;
import static org.molgenis.data.meta.model.EntityTypeMetadata.EXTENDS;
import static org.molgenis.data.postgresql.PostgreSqlRepositoryCollection.POSTGRESQL;
<<<<<<<
when(entityType.getAttribute(attrName)).thenReturn(attr);
=======
when(attr.getDataType()).thenReturn(STRING);
when(entityMeta.getAttribute(attrName)).thenReturn(attr);
>>>>>>>
when(attr.getDataType()).thenReturn(STRING);
when(entityType.getAttribute(attrName)).thenReturn(attr);
<<<<<<<
EntityType entityType = when(mock(EntityType.class).getName()).thenReturn("entity").getMock();
when(entityType.getAttribute(attrName)).thenReturn(attr);
postgreSqlRepoCollection.deleteAttribute(entityType, attr);
=======
when(attr.getDataType()).thenReturn(STRING);
EntityMetaData entityMeta = when(mock(EntityMetaData.class).getName()).thenReturn("entity").getMock();
when(entityMeta.getAttribute(attrName)).thenReturn(attr);
postgreSqlRepoCollection.deleteAttribute(entityMeta, attr);
>>>>>>>
when(attr.getDataType()).thenReturn(STRING);
EntityType entityType = when(mock(EntityType.class).getName()).thenReturn("entity").getMock();
when(entityType.getAttribute(attrName)).thenReturn(attr);
postgreSqlRepoCollection.deleteAttribute(entityType, attr);
<<<<<<<
when(abstractEntityType.getAttribute(attrName)).thenReturn(attr);
=======
when(attr.getDataType()).thenReturn(STRING);
when(abstractEntityMeta.getAttribute(attrName)).thenReturn(attr);
>>>>>>>
when(attr.getDataType()).thenReturn(STRING);
when(abstractEntityType.getAttribute(attrName)).thenReturn(attr); |
<<<<<<<
import org.molgenis.data.meta.model.AttributeMetaData;
import org.molgenis.data.meta.model.AttributeMetaDataFactory;
import org.molgenis.data.meta.model.EntityTypeFactory;
=======
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityMetaDataFactory;
>>>>>>>
import org.molgenis.data.meta.model.Attribute;
import org.molgenis.data.meta.model.AttributeFactory;
import org.molgenis.data.meta.model.EntityTypeFactory; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.