public Set<Sport> getSports() {
Set<Sport> sports = new HashSet<Sport>();
for (SeasonalTeam st : getSeasonalTeams()) {
Sport sport = Sport.getInstance(st);
if (!ObjectUtils.isBlank(sport)) {
sports.add(sport);
}
}
return sports;
}
public Long getEventsPlayedCount(Sport sport) {
if (ObjectUtils.isBlank(sport)) {
return null;
}
ObjectType seasonalAthleteType = ObjectType.getInstance(sport.getSeasonalAthleteClass());
Query<SeasonalAthlete> seasonalAthleteQuery =
Query.from(SeasonalAthlete.class)
.where("typeId = ? && athlete = ?", seasonalAthleteType, this);
return Query.from(Event.class).where("seasonalAthletes = ?", seasonalAthleteQuery).count();
}
public void beforeSave(Database database) {
if (ObjectUtils.isBlank(getNaturalKey()) && !ObjectUtils.isBlank(this.getSchool())) {
String schoolNaturalKey = this.getSchool().getNaturalKey();
this.setNaturalKey(schoolNaturalKey + "/" + getFirstLastNameNaturalDiscriminator());
}
}
/** Adds the given {@code type} to all type cache maps. */
public void add(ObjectType type) {
String className = type.getObjectClassName();
if (!ObjectUtils.isBlank(className)) {
byClassName.put(className.toLowerCase(Locale.ENGLISH), type);
}
byId.put(type.getId(), type);
String internalName = type.getInternalName();
if (!ObjectUtils.isBlank(internalName)) {
byName.put(internalName.toLowerCase(Locale.ENGLISH), type);
}
for (String group : type.getGroups()) {
if (group != null) {
group = group.toLowerCase(Locale.ENGLISH);
}
Set<ObjectType> groupTypes = byGroup.get(group);
if (groupTypes == null) {
groupTypes = new HashSet<ObjectType>();
byGroup.put(group, groupTypes);
}
groupTypes.remove(type);
groupTypes.add(type);
}
}
public List<SeasonalTeam> getSeasonalTeams() {
List<SeasonalTeam> seasonalTeams = new ArrayList<SeasonalTeam>();
for (SeasonalAthlete a : getAllSeasonalAthletes()) {
if (!ObjectUtils.isBlank(a) && !ObjectUtils.isBlank(a.getTeam())) {
seasonalTeams.add(a.getTeam());
}
}
return seasonalTeams;
}
public Image getAvatar() {
if (ObjectUtils.isBlank(avatar)) {
if (!ObjectUtils.isBlank(photo)) {
avatar = photo;
} else if (!ObjectUtils.isBlank(getSchool())
&& !ObjectUtils.isBlank(getSchool().getAvatar())) {
avatar = getSchool().getAvatar();
}
}
return avatar;
}
@Override
protected List<DynamicProperty> create() {
List<DynamicProperty> properties = new ArrayList<DynamicProperty>();
for (ObjectType type : getTypes()) {
if (type.getObjectClass() == null) {
continue;
}
String beanProperty = type.getJavaBeanProperty();
if (ObjectUtils.isBlank(beanProperty)) {
continue;
}
try {
properties.add(
new DynamicProperty(type, beanProperty, beanPropertyIndexes.get(beanProperty)));
} catch (Exception error) {
// Failed introspection so probably not a valid bean
// property.
}
}
return ImmutableList.copyOf(properties);
}
/** Returns a table of all the widgets with the given {@code positionName}. */
public List<List<Widget>> findWidgets(String positionName) {
Map<Double, Map<Double, Widget>> widgetsMap = new TreeMap<Double, Map<Double, Widget>>();
for (Widget widget : findPlugins(Widget.class)) {
for (Widget.Position position : widget.getPositions()) {
if (ObjectUtils.equals(position.getName(), positionName)) {
double column = position.getColumn();
Map<Double, Widget> widgets = widgetsMap.get(column);
if (widgets == null) {
widgets = new TreeMap<Double, Widget>();
widgetsMap.put(column, widgets);
}
widgets.put(position.getRow(), widget);
break;
}
}
}
List<List<Widget>> widgetsTable = new ArrayList<List<Widget>>();
for (Map<Double, Widget> map : widgetsMap.values()) {
List<Widget> widgets = new ArrayList<Widget>();
widgets.addAll(map.values());
widgetsTable.add(widgets);
}
return widgetsTable;
}
@Override
protected void doInitialize(String settingsKey, Map<String, Object> settings) {
String clusterName = ObjectUtils.to(String.class, settings.get(CLUSTER_NAME_SUB_SETTING));
Preconditions.checkNotNull(clusterName);
String indexName = ObjectUtils.to(String.class, settings.get(INDEX_NAME_SUB_SETTING));
Preconditions.checkNotNull(indexName);
String typeName = ObjectUtils.to(String.class, settings.get(TYPE_NAME_SUB_SETTING));
this.indexName = indexName;
this.typeName = typeName;
this.node = NodeBuilder.nodeBuilder().clusterName(clusterName).client(true).node();
}
@Override
public void format(HtmlWriter writer) throws IOException {
writer.writeStart("pre");
State state = getState();
ObjectType type = state.getType();
if (type != null) {
writer.writeHtml(type.getInternalName());
writer.writeHtml(": ");
}
writer.writeStart(
"a",
"target",
"_blank",
"href",
StringUtils.addQueryParameters(
"/_debug/query", "where", "id = " + state.getId(), "action", "Run"));
writer.writeHtml(getLabel());
writer.writeEnd();
writer.writeElement("br");
writer.writeHtml(ObjectUtils.toJson(state.getSimpleValues(), true));
writer.writeEnd();
}
public String getSchedulePermalink() {
String permalink = "/athlete/schedule/" + getId();
String key = getNaturalKey();
if (!ObjectUtils.isBlank(key)) {
permalink = getSeoFriendlyPermalink() + "/" + SCORES_SCHEDULES_PATH;
}
return permalink;
}
private boolean evaluateOne(State state, Object keyValue, List<Object> values) {
if (!(keyValue instanceof Recordable || keyValue instanceof UUID)) {
Class<?> keyValueClass = keyValue.getClass();
for (ListIterator<Object> i = values.listIterator(); i.hasNext(); ) {
i.set(ObjectUtils.to(keyValueClass, i.next()));
}
}
return compare(state, keyValue, values);
}
@Override
protected boolean compare(State state, Object keyValue, List<Object> values) {
for (Object value : values) {
if (ObjectUtils.compare(keyValue, value, false) > 0) {
return false;
}
}
return true;
}
public String getVideoMediaPermalink() {
String permalink = "/athlete/media/video/" + getId();
String key = getNaturalKey();
if (!ObjectUtils.isBlank(key)) {
permalink = getSeoFriendlyPermalink() + "/" + MEDIA_PATH;
}
return permalink;
}
public String getNewsPermalink() {
String permalink = "/athlete/news/" + getId();
String key = getNaturalKey();
if (!ObjectUtils.isBlank(key)) {
permalink = getSeoFriendlyPermalink() + "/" + NEWS_PATH;
}
return permalink;
}
public String getFollowersPermalink() {
String permalink = "/athlete/followers/" + getId();
String key = getNaturalKey();
if (!ObjectUtils.isBlank(key)) {
permalink = getSeoFriendlyPermalink() + "/" + FOLLOWERS_PATH;
}
return permalink;
}
@Override
public int compare(Object x, Object y) {
State xState = State.getInstance(x);
State yState = State.getInstance(y);
Object xValue = xState != null ? filter(xState.getByPath(field)) : null;
Object yValue = yState != null ? filter(yState.getByPath(field)) : null;
return ObjectUtils.compare(xValue, yValue, isNullGreatest);
}
/**
* Synchronizes the given {@code plugin} with the existing one in the database if it can be found.
*/
private void synchronizePlugin(Plugin plugin) {
State pluginState = plugin.getState();
Database database = getState().getDatabase();
pluginState.setDatabase(database);
UUID typeId = pluginState.getTypeId();
Tool tool = plugin.getTool();
String internalName = plugin.getInternalName();
for (Plugin p : getAllPlugins(database)) {
if (ObjectUtils.equals(typeId, p.getState().getTypeId())
&& ObjectUtils.equals(tool, p.getTool())
&& ObjectUtils.equals(internalName, p.getInternalName())) {
pluginState.setId(p.getId());
break;
}
}
}
public List<SeasonalAthlete> findSeasonalAthletes(Sport sport) {
if (ObjectUtils.isBlank(sport)) {
return null;
}
ObjectType seasonalAthleteType = ObjectType.getInstance(sport.getSeasonalAthleteClass());
return Query.from(SeasonalAthlete.class)
.where("typeId = ? && athlete = ?", seasonalAthleteType, this)
.selectAll();
}
public String getSeoTitle() {
String firstName = this.getFirstName();
String lastName = this.getLastName();
String schoolTitle = null;
if (!ObjectUtils.isBlank(this.getSchool())) {
schoolTitle = this.getSchool().createSeoTitle();
}
String discriminator = String.format("%1$s %2$s", firstName, lastName);
return discriminator;
}
/**
* Returns the main application object as determined by the {@value
* com.psddev.dari.db.Application#MAIN_CLASS_SETTING} {@linkplain Settings#get setting} within
* the given {@code database}.
*
* @return May be {@code null} if the setting is not set.
* @throws SettingsException If the class name in the setting is not valid.
*/
public static Application getMainUsing(Database database) {
String appClassName = Settings.get(String.class, MAIN_CLASS_SETTING);
if (ObjectUtils.isBlank(appClassName)) {
return null;
}
Class<?> objectClass = ObjectUtils.getClassByName(appClassName);
if (objectClass == null) {
throw new SettingsException(
MAIN_CLASS_SETTING, String.format("[%s] is not a valid class name!", appClassName));
}
if (Application.class.isAssignableFrom(objectClass)) {
@SuppressWarnings("unchecked")
Class<? extends Application> appClass = (Class<? extends Application>) objectClass;
return getInstanceUsing(appClass, database);
} else {
throw new SettingsException(
MAIN_CLASS_SETTING,
String.format("[%s] is not a [%s] class!", appClassName, Application.class.getName()));
}
}
/**
* Returns the singleton application object matching the given {@code applicationClass} within
* the given {@code database}.
*/
@SuppressWarnings("unchecked")
public static <T extends Application> T getInstanceUsing(
Class<T> applicationClass, Database database) {
ObjectType type = database.getEnvironment().getTypeByClass(applicationClass);
Query<T> query =
Query.from(applicationClass).where("_type = ?", type.getId()).using(database);
T app = query.first();
if (app == null) {
DistributedLock lock =
DistributedLock.Static.getInstance(database, applicationClass.getName());
lock.lock();
try {
app = query.clone().noCache().first();
if (app == null) {
app = (T) type.createObject(null);
app.setName(type.getDisplayName());
app.saveImmediately();
return app;
}
} finally {
lock.unlock();
}
}
String oldName = app.getName();
String newName = type.getDisplayName();
if (!ObjectUtils.equals(oldName, newName)) {
app.setName(newName);
app.save();
}
return app;
}
@Override
public String getLabel() {
String name = getName();
StringBuilder label = new StringBuilder();
if (ObjectUtils.isBlank(name)) {
Date triggerDate = getTriggerDate();
label.append(triggerDate != null ? triggerDate.toString() : getId().toString());
} else {
label.append(name);
}
long draftCount = Query.from(Draft.class).where("schedule = ?", this).count();
if (draftCount > 1) {
label.append(" (");
label.append(draftCount);
label.append(" items)");
}
return label.toString();
}
private void startQueryEvent(String event, Query<?> query) {
StackTraceElement caller = null;
Profiler.Static.pauseThreadEvent();
try {
StackTraceElement[] elements = new Throwable().getStackTrace();
for (int i = 2, length = elements.length; i < length; ++i) {
StackTraceElement element = elements[i];
String className = element.getClassName();
Class<?> c = ObjectUtils.getClassByName(className);
if (c == null || !(Database.class.isAssignableFrom(c) || Query.class.isAssignableFrom(c))) {
caller = element;
break;
}
}
} finally {
Profiler.Static.resumeThreadEvent();
}
Object resolving = query.getOptions().get(State.REFERENCE_RESOLVING_QUERY_OPTION);
if (resolving != null) {
Profiler.Static.startThreadEvent(
event + " (Reference Resolving)",
resolving,
query.getOptions().get(State.REFERENCE_FIELD_QUERY_OPTION),
caller);
} else {
Profiler.Static.startThreadEvent(event, caller, query);
}
}
protected void beforeSave() {
if (ObjectUtils.isBlank(getName()) && getTriggerDate() == null) {
throw new IllegalArgumentException("Must provide either the name or the trigger date!");
}
}
protected void writeTableHtml(Iterable<?> items) throws IOException {
HttpServletRequest request = page.getRequest();
page.putOverride(
Recordable.class,
(HtmlWriter writer, Recordable object) -> {
ToolPageContext page = (ToolPageContext) writer;
page.writeObjectLabel(object);
});
page.putOverride(
Metric.class,
(HtmlWriter writer, Metric object) -> {
writer.write(Double.toString(object.getSum()));
});
page.putOverride(
Content.class,
(HtmlWriter writer, Content content) -> {
ToolPageContext page = (ToolPageContext) writer;
page.writeStart(
"a", "href", page.objectUrl("/content/edit.jsp", content), "target", "_top");
page.writeObjectLabel(content);
page.writeEnd();
});
page.putOverride(
StorageItem.class,
(HtmlWriter writer, StorageItem item) -> {
ToolPageContext page = (ToolPageContext) writer;
page.writeElement(
"img",
"height",
100,
"src",
ImageEditor.Static.getDefault() != null
? new ImageTag.Builder(item).setHeight(100).toUrl()
: item.getPublicUrl());
});
page.writeStart("table", "class", "searchResultTable links table-striped pageThumbnails");
page.writeStart("thead");
page.writeStart("tr");
page.writeStart("th");
page.writeElement("input", "type", "checkbox", "class", "searchResult-checkAll");
page.writeEnd();
if (sortField != null && ObjectField.DATE_TYPE.equals(sortField.getInternalType())) {
page.writeStart("th", "colspan", 2);
page.writeHtml(sortField.getDisplayName());
page.writeEnd();
}
if (showSiteLabel) {
page.writeStart("th");
page.writeHtml(page.localize(ListSearchResultView.class, "label.site"));
page.writeEnd();
}
if (showTypeLabel) {
page.writeStart("th");
page.writeHtml(page.localize(ListSearchResultView.class, "label.type"));
page.writeEnd();
}
page.writeStart("th");
page.writeHtml(page.localize(ListSearchResultView.class, "label.label"));
page.writeEnd();
if (sortField != null && !ObjectField.DATE_TYPE.equals(sortField.getInternalType())) {
page.writeStart("th");
page.writeHtml(sortField.getDisplayName());
page.writeEnd();
}
ToolUser user = page.getUser();
if (user != null) {
ObjectType selectedType = search.getSelectedType();
List<String> fieldNames =
user.getSearchResultFieldsByTypeId()
.get(selectedType != null ? selectedType.getId().toString() : "");
if (fieldNames == null) {
for (Class<? extends SearchResultField> c :
ClassFinder.Static.findClasses(SearchResultField.class)) {
if (!c.isInterface() && !Modifier.isAbstract(c.getModifiers())) {
SearchResultField field = TypeDefinition.getInstance(c).newInstance();
if (field.isDefault(selectedType) && !ObjectUtils.equals(sortField, field)) {
field.writeTableHeaderCellHtml(page);
}
}
}
if (selectedType != null) {
for (ObjectField field : selectedType.getFields()) {
if (Boolean.TRUE.equals(field.as(ToolUi.class).getDefaultSearchResult())) {
writeHeaderCell(field);
}
}
}
} else {
for (String fieldName : fieldNames) {
Class<?> fieldNameClass = ObjectUtils.getClassByName(fieldName);
if (fieldNameClass != null && SearchResultField.class.isAssignableFrom(fieldNameClass)) {
@SuppressWarnings("unchecked")
SearchResultField field =
TypeDefinition.getInstance((Class<? extends SearchResultField>) fieldNameClass)
.newInstance();
if (field.isSupported(selectedType) && !ObjectUtils.equals(sortField, field)) {
field.writeTableHeaderCellHtml(page);
}
} else {
ObjectField field = null;
if (selectedType != null) {
field = selectedType.getField(fieldName);
}
if (field == null) {
field = Database.Static.getDefault().getEnvironment().getField(fieldName);
}
if (field != null && !ObjectUtils.equals(sortField, field)) {
writeHeaderCell(field);
}
}
}
}
}
page.writeEnd();
page.writeEnd();
page.writeStart("tbody");
for (Object item : items) {
State itemState = State.getInstance(item);
String permalink = itemState.as(Directory.ObjectModification.class).getPermalink();
Integer embedWidth = null;
if (ObjectUtils.isBlank(permalink)) {
ObjectType type = itemState.getType();
if (type != null) {
Renderer.TypeModification rendererData = type.as(Renderer.TypeModification.class);
int previewWidth = rendererData.getEmbedPreviewWidth();
if (previewWidth > 0 && !ObjectUtils.isBlank(rendererData.getEmbedPath())) {
permalink = "/_preview?_embed=true&_cms.db.previewId=" + itemState.getId();
embedWidth = 320;
}
}
}
page.writeStart(
"tr",
"data-preview-url",
permalink,
"data-preview-embed-width",
embedWidth,
"class",
State.getInstance(item).getId().equals(page.param(UUID.class, "id")) ? "selected" : null);
page.writeStart("td");
itemWriter.writeCheckboxHtml(page, search, item);
page.writeEnd();
if (sortField != null && ObjectField.DATE_TYPE.equals(sortField.getInternalType())) {
DateTime dateTime = page.toUserDateTime(itemState.getByPath(sortField.getInternalName()));
if (dateTime == null) {
page.writeStart("td", "colspan", 2);
page.writeHtml("N/A");
page.writeEnd();
} else {
String date = page.formatUserDate(dateTime);
page.writeStart("td", "class", "date");
if (!ObjectUtils.equals(date, request.getAttribute(PREVIOUS_DATE_ATTRIBUTE))) {
request.setAttribute(PREVIOUS_DATE_ATTRIBUTE, date);
page.writeHtml(date);
}
page.writeEnd();
page.writeStart("td", "class", "time");
page.writeHtml(page.formatUserTime(dateTime));
page.writeEnd();
}
}
if (showSiteLabel) {
page.writeStart("td");
page.writeObjectLabel(itemState.as(Site.ObjectModification.class).getOwner());
page.writeEnd();
}
if (showTypeLabel) {
page.writeStart("td");
page.writeTypeLabel(item);
page.writeEnd();
}
page.writeStart("td", "data-preview-anchor", "");
itemWriter.writeBeforeHtml(page, search, item);
page.writeObjectLabel(item);
itemWriter.writeAfterHtml(page, search, item);
page.writeEnd();
if (sortField != null && !ObjectField.DATE_TYPE.equals(sortField.getInternalType())) {
String sortFieldName = sortField.getInternalName();
Object value = itemState.getByPath(sortFieldName);
page.writeStart("td");
if (value instanceof Metric) {
page.writeStart("span", "style", page.cssString("white-space", "nowrap"));
Double maxSum = (Double) request.getAttribute(MAX_SUM_ATTRIBUTE);
if (maxSum == null) {
Object maxObject = search.toQuery(page.getSite()).sortDescending(sortFieldName).first();
maxSum =
maxObject != null
? ((Metric) State.getInstance(maxObject).get(sortFieldName)).getSum()
: 1.0;
request.setAttribute(MAX_SUM_ATTRIBUTE, maxSum);
}
Metric valueMetric = (Metric) value;
Map<DateTime, Double> sumEntries =
valueMetric.groupSumByDate(
new MetricInterval.Daily(),
new DateTime().dayOfMonth().roundFloorCopy().minusDays(7),
null);
double sum = valueMetric.getSum();
long sumLong = (long) sum;
if (sumLong == sum) {
page.writeHtml(String.format("%,2d ", sumLong));
} else {
page.writeHtml(String.format("%,2.2f ", sum));
}
if (!sumEntries.isEmpty()) {
long minMillis = Long.MAX_VALUE;
long maxMillis = Long.MIN_VALUE;
for (Map.Entry<DateTime, Double> sumEntry : sumEntries.entrySet()) {
long sumMillis = sumEntry.getKey().getMillis();
if (sumMillis < minMillis) {
minMillis = sumMillis;
}
if (sumMillis > maxMillis) {
maxMillis = sumMillis;
}
}
double cumulativeSum = 0.0;
StringBuilder path = new StringBuilder();
double xRange = maxMillis - minMillis;
int width = 35;
int height = 18;
for (Map.Entry<DateTime, Double> sumEntry : sumEntries.entrySet()) {
cumulativeSum += sumEntry.getValue();
path.append('L');
path.append((sumEntry.getKey().getMillis() - minMillis) / xRange * width);
path.append(',');
path.append(height - cumulativeSum / maxSum * height);
}
path.setCharAt(0, 'M');
page.writeStart(
"svg",
"xmlns",
"http://www.w3.org/2000/svg",
"width",
width,
"height",
height,
"style",
page.cssString(
"display", "inline-block",
"vertical-align", "middle"));
page.writeStart("path", "fill", "none", "stroke", "#444444", "d", path.toString());
page.writeEnd();
page.writeEnd();
}
page.writeEnd();
} else if (value instanceof Recordable) {
page.writeHtml(((Recordable) value).getState().getLabel());
} else {
for (Iterator<Object> i = CollectionUtils.recursiveIterable(value).iterator();
i.hasNext(); ) {
Object collectionValue = i.next();
page.writeObject(collectionValue);
if (i.hasNext()) {
page.writeHtml(", ");
}
}
}
page.writeEnd();
}
if (user != null) {
ObjectType selectedType = search.getSelectedType();
List<String> fieldNames =
user.getSearchResultFieldsByTypeId()
.get(selectedType != null ? selectedType.getId().toString() : "");
ObjectType itemType = itemState.getType();
if (fieldNames == null) {
for (Class<? extends SearchResultField> c :
ClassFinder.Static.findClasses(SearchResultField.class)) {
if (!c.isInterface() && !Modifier.isAbstract(c.getModifiers())) {
SearchResultField field = TypeDefinition.getInstance(c).newInstance();
if (field.isDefault(itemType) && !ObjectUtils.equals(sortField, field)) {
field.writeTableDataCellHtml(page, item);
}
}
}
if (selectedType != null) {
for (ObjectField field : selectedType.getFields()) {
if (Boolean.TRUE.equals(field.as(ToolUi.class).getDefaultSearchResult())) {
writeDataCell(itemState, field.getInternalName());
}
}
}
} else {
for (String fieldName : fieldNames) {
Class<?> fieldNameClass = ObjectUtils.getClassByName(fieldName);
if (fieldNameClass != null
&& SearchResultField.class.isAssignableFrom(fieldNameClass)) {
@SuppressWarnings("unchecked")
SearchResultField field =
TypeDefinition.getInstance((Class<? extends SearchResultField>) fieldNameClass)
.newInstance();
if (field.isSupported(itemState.getType()) && !ObjectUtils.equals(sortField, field)) {
field.writeTableDataCellHtml(page, item);
}
} else {
ObjectField field = itemState.getField(fieldName);
if (field == null) {
field = Database.Static.getDefault().getEnvironment().getField(fieldName);
}
if (field != null && !ObjectUtils.equals(sortField, field)) {
writeDataCell(itemState, fieldName);
}
}
}
}
}
page.writeEnd();
}
page.writeEnd();
page.writeEnd();
page.writeStart("div", "id", page.createId());
page.writeEnd();
page.writeStart("script", "type", "text/javascript");
page.writeRaw(
"$('#" + page.getId() + "').siblings('.searchResultTable').find('tr').each(function() {");
page.writeRaw(" if ($(this).find('td > a').size() > 1) {");
page.writeRaw(
" $(this).closest('.searchResultTable').addClass('multipleLinkedColumns');");
page.writeRaw(" return false;");
page.writeRaw(" }");
page.writeRaw(" });");
page.writeEnd();
}
public static void writeContents(
Database database,
BootstrapPackage pkg,
Set<ObjectType> additionalTypes,
Writer writer,
String projectName)
throws IOException {
boolean first = true;
boolean needsObjectTypeMap = false;
Set<ObjectType> typeMaps = new HashSet<ObjectType>();
ObjectType objType = database.getEnvironment().getTypeByClass(ObjectType.class);
Set<ObjectType> exportTypes = new HashSet<ObjectType>();
Query<?> query = Query.fromAll().using(database);
Set<ObjectType> allTypeMappableTypes = new HashSet<ObjectType>();
Set<UUID> concreteTypeIds = new HashSet<UUID>();
for (ObjectType type : database.getEnvironment().getTypes()) {
if (!type.as(TypeData.class).getTypeMappableGroups().isEmpty()
&& type.as(TypeData.class).getTypeMappableUniqueKey() != null) {
allTypeMappableTypes.add(type);
}
}
// Package:
writer.write(PACKAGE_NAME_HEADER + ": ");
writer.write(pkg.getName());
writer.write('\n');
// Project:
writer.write(PROJECT_HEADER + ": ");
writer.write(projectName);
writer.write('\n');
// Date:
writer.write(DATE_HEADER + ": ");
writer.write(new DateTime().toString("yyyy-MM-dd HH:mm:ss z"));
writer.write('\n');
// Types:
writer.write(TYPES_HEADER + ": ");
if (pkg.isInit()) {
writer.write(ALL_TYPES_HEADER_VALUE);
writer.write('\n');
} else {
exportTypes.addAll(getAllTypes(database, pkg));
exportTypes.addAll(getAllTypes(database, additionalTypes));
for (ObjectType typeMappableType : allTypeMappableTypes) {
GETTYPEMAPPABLETYPE:
for (ObjectType type : exportTypes) {
for (String group : typeMappableType.as(TypeData.class).getTypeMappableGroups()) {
if (type.getGroups().contains(group)) {
typeMaps.add(typeMappableType);
break GETTYPEMAPPABLETYPE;
}
}
}
}
GETOBJECTTYPE:
for (ObjectType type : exportTypes) {
for (ObjectField field : type.getFields()) {
if (field.getTypes().contains(objType)) {
needsObjectTypeMap = true;
break GETOBJECTTYPE;
}
}
}
for (ObjectType exportType : exportTypes) {
String clsName = exportType.getObjectClassName();
if (!ObjectUtils.isBlank(clsName)) {
for (ObjectType concreteType : database.getEnvironment().getTypesByGroup(clsName)) {
if (!concreteType.isAbstract()) {
concreteTypeIds.add(concreteType.getId());
}
}
}
}
if (exportTypes.contains(objType)) {
if (!first) {
writer.write(',');
} else {
first = false;
}
writer.write(objType.getInternalName());
}
for (ObjectType type : exportTypes) {
if (type.equals(objType)) {
continue;
}
if (!first) {
writer.write(',');
} else {
first = false;
}
writer.write(type.getInternalName());
}
writer.write('\n');
}
// Determine if there are any fields that need references followed
Map<UUID, Map<String, ObjectType>> followReferences =
new HashMap<UUID, Map<String, ObjectType>>();
if (!pkg.isInit()) {
for (ObjectType type : exportTypes) {
for (String fieldName : type.as(TypeData.class).getFollowReferencesFields()) {
ObjectField field = type.getField(fieldName);
if (field != null) {
for (ObjectType fieldType : field.getTypes()) {
if (!exportTypes.contains(fieldType)) {
if (!followReferences.containsKey(type.getId())) {
followReferences.put(type.getId(), new HashMap<String, ObjectType>());
}
followReferences.get(type.getId()).put(fieldName, fieldType);
}
}
}
}
}
}
if (!typeMaps.isEmpty()) {
for (ObjectType typeMapType : typeMaps) {
String clsName = typeMapType.getObjectClassName();
if (!ObjectUtils.isBlank(clsName)) {
for (ObjectType type : database.getEnvironment().getTypesByGroup(clsName)) {
concreteTypeIds.remove(type.getId());
}
}
}
}
// Mapping Types:
if (pkg.isInit() || needsObjectTypeMap || !typeMaps.isEmpty()) {
first = true;
writer.write(TYPE_MAP_HEADER + ": ");
if (pkg.isInit() || needsObjectTypeMap) {
writer.write(objType.getInternalName());
writer.write("/internalName");
first = false;
}
for (ObjectType typeMapType : typeMaps) {
if (!first) {
writer.write(',');
} else {
first = false;
}
writer.write(typeMapType.getInternalName());
writer.write('/');
writer.write(typeMapType.as(TypeData.class).getTypeMappableUniqueKey());
}
writer.write('\n');
}
// Row Count:
Long count = 0L;
try {
if (concreteTypeIds.isEmpty()) {
count = Query.fromAll().using(database).noCache().count();
} else {
for (UUID concreteTypeId : concreteTypeIds) {
long concreteCount =
Query.fromAll()
.using(database)
.noCache()
.where("_type = ?", concreteTypeId)
.count();
count = count + concreteCount;
}
if (needsObjectTypeMap) {
long objectCount =
Query.fromAll().using(database).noCache().where("_type = ?", objType).count();
count = count + objectCount;
}
if (!typeMaps.isEmpty()) {
for (ObjectType typeMapType : typeMaps) {
long typeMapCount =
Query.fromAll().using(database).noCache().where("_type = ?", typeMapType).count();
count = count + typeMapCount;
}
}
}
writer.write(ROW_COUNT_HEADER + ": ");
writer.write(ObjectUtils.to(String.class, count));
writer.write('\n');
} catch (RuntimeException e) {
// Count query timed out. Just don't write the row count header.
count = null;
}
// blank line between headers and data
writer.write('\n');
writer.flush();
// ObjectType records first
if (exportTypes.isEmpty() || exportTypes.contains(objType) || needsObjectTypeMap) {
for (Object r :
Query.fromType(objType)
.using(database)
.noCache()
.resolveToReferenceOnly()
.iterable(100)) {
writer.write(ObjectUtils.toJson(((Recordable) r).getState().getSimpleValues(true)));
writer.write('\n');
}
}
// Then other mapping types
for (ObjectType typeMapType : typeMaps) {
for (Object r :
Query.fromType(typeMapType)
.using(database)
.noCache()
.resolveToReferenceOnly()
.iterable(100)) {
writer.write(ObjectUtils.toJson(((Recordable) r).getState().getSimpleValues(true)));
writer.write('\n');
}
}
// Then everything else
if (pkg.isInit()) {
concreteTypeIds.clear(); // should already be empty
concreteTypeIds.add(null);
}
UUID lastTypeId = null;
Set<UUID> seenIds = new HashSet<UUID>();
query.getOptions().put(SqlDatabase.USE_JDBC_FETCH_SIZE_QUERY_OPTION, false);
for (UUID typeId : concreteTypeIds) {
Query<?> concreteQuery = query.clone();
if (typeId != null) {
concreteQuery.where("_type = ?", typeId);
}
for (Object o : concreteQuery.noCache().resolveToReferenceOnly().iterable(100)) {
if (o instanceof Recordable) {
Recordable r = (Recordable) o;
writer.write(ObjectUtils.toJson(r.getState().getSimpleValues(true)));
writer.write('\n');
if (!pkg.isInit()) {
if (lastTypeId == null || !lastTypeId.equals(r.getState().getTypeId())) {
seenIds.clear();
} else if (seenIds.size() > MAX_SEEN_REFERENCE_IDS_SIZE) {
seenIds.clear();
}
lastTypeId = r.getState().getTypeId();
Map<String, ObjectType> followReferencesFieldMap;
if ((followReferencesFieldMap = followReferences.get(r.getState().getTypeId()))
!= null) {
for (Map.Entry<String, ObjectType> entry : followReferencesFieldMap.entrySet()) {
Object reference = r.getState().getRawValue(entry.getKey());
Set<UUID> referenceIds = new HashSet<UUID>();
if (reference instanceof Collection) {
for (Object referenceObj : ((Collection<?>) reference)) {
if (referenceObj instanceof Recordable) {
UUID referenceUUID =
ObjectUtils.to(
UUID.class, ((Recordable) referenceObj).getState().getId());
if (referenceUUID != null) {
if (!seenIds.contains(referenceUUID)) {
referenceIds.add(referenceUUID);
}
}
}
}
} else if (reference instanceof Recordable) {
UUID referenceUUID =
ObjectUtils.to(UUID.class, ((Recordable) reference).getState().getId());
if (referenceUUID != null) {
if (!seenIds.contains(referenceUUID)) {
referenceIds.add(referenceUUID);
}
}
}
if (!referenceIds.isEmpty()) {
for (Object ref :
Query.fromType(entry.getValue())
.noCache()
.using(database)
.where("_id = ?", referenceIds)
.selectAll()) {
if (ref instanceof Recordable) {
Recordable refr = (Recordable) ref;
seenIds.add(refr.getState().getId());
writer.write(ObjectUtils.toJson(refr.getState().getSimpleValues(true)));
writer.write('\n');
}
}
}
}
}
}
}
}
}
writer.flush();
}
public String getTypeName() {
return !ObjectUtils.isBlank(typeName) ? typeName : "dari";
}
// Reads: key operator value
private Predicate readComparison(Queue<String> tokens, ParameterList parameters) {
String key = tokens.poll();
if (key == null) {
return null;
}
String realKey = Query.Static.getCanonicalKey(key);
if (realKey != null) {
key = realKey;
}
String operator = tokens.poll();
boolean isIgnoreCase = false;
if (operator == null) {
throw new IllegalArgumentException(String.format("No operator after [%s] key!", key));
} else {
operator = operator.toLowerCase(Locale.ENGLISH);
if (operator.endsWith("[c]")) {
operator = operator.substring(0, operator.length() - 3);
isIgnoreCase = true;
}
}
Object value = readValue(tokens);
if (value == null) {
throw new IllegalArgumentException(
String.format("No value after [%s] key and [%s] operator!", key, operator));
} else if (value instanceof String) {
String valueString = (String) value;
if (valueString.startsWith("?")) {
if (valueString.length() == 1) {
value = parameters.poll();
} else {
String path = valueString.substring(1);
int slashAt = path.indexOf('/');
String splitIndex;
String splitPath;
if (slashAt > -1) {
splitIndex = path.substring(0, slashAt);
splitPath = path.substring(slashAt + 1);
} else {
splitIndex = path;
splitPath = "";
}
Integer index = ObjectUtils.to(Integer.class, splitIndex);
if (index == null) {
index = 0;
} else {
path = splitPath;
}
value = index < parameters.size() ? parameters.get(index) : null;
if (value != null && path.length() > 0) {
if (value instanceof Recordable) {
value = ((Recordable) value).getState().getByPath(path);
} else {
value = CollectionUtils.getByPath(value, path);
}
}
}
} else if ("true".equalsIgnoreCase(valueString)) {
value = Boolean.TRUE;
} else if ("false".equalsIgnoreCase(valueString)) {
value = Boolean.FALSE;
} else if ("null".equalsIgnoreCase(valueString)) {
value = null;
} else if ("missing".equalsIgnoreCase(valueString)) {
value = Query.MISSING_VALUE;
}
}
String comparisonOperator = getComparisonOperators().get(operator);
if (comparisonOperator != null) {
return new ComparisonPredicate(
comparisonOperator, isIgnoreCase, key, ObjectUtils.to(Iterable.class, value));
} else {
throw new IllegalArgumentException(
String.format("[%s] isn't a valid comparison operator!", operator));
}
}
@Override
public int compareTo(Record other) {
return ObjectUtils.compare(getLabel(), other.getLabel(), true);
}