Skip to Content

Client-Side _Entity.java Template

Version 18.1 by David Avendasora on 2008/03/06 09:55
Warning: For security reasons, the document is displayed in restricted mode as it is not the current version. There may be differences and errors due to this.

Unknown macro: color. Click on this message for details.

 Due to security concerns you cannot call FetchSpecifications from the client-side that use a Raw SQL Expression without implementing the delegate method distributionContextShouldFetchObjectsWithFetchSpecification which this code does NOT do.

Because of this, this template ignores any FetchSpecifications that are defined in the model that use a Raw SQL Expression.

If you try call these FetchSpecifications, you will get the following exception in the server log:

Unknown macro: color. Click on this message for details.

and the code addition to the Session class will return null to the client instead of the expected FetchSpecification.


// $ DO NOT EDIT.  Make changes to ${entity.classNameWithOptionalPackage}.java instead.
#if ($entity.superclassPackageName)
package $entity.superclassPackageName;

#end
import com.webobjects.eoaccess.*;
import com.webobjects.eocontrol.*;
import com.webobjects.foundation.*;
import java.math.*;
import java.util.*;
import org.apache.log4j.Logger;

@SuppressWarnings("all")
public abstract class ${entity.prefixClassNameWithoutPackage} extends #if ($entity.parentSet)${entity.parent.classNameWithDefault}#elseif ($EOGenericRecord)${EOGenericRecord}#else EOGenericRecord#end {

public static final String ENTITY_NAME = "$entity.name";

// Client-Side Attributes
#foreach ($attribute in $entity.sortedClassAttributes)
#if ($attribute.clientClassProperty)
public static final String ${attribute.uppercaseUnderscoreName}_KEY = "$attribute.name";
#end
#end

// Client-Side Relationships
#foreach ($relationship in $entity.sortedClassRelationships)
#if ($relationship.clientClassProperty)
public static final String ${relationship.uppercaseUnderscoreName}_KEY = "$relationship.name";
#end
#end

  private static Logger LOG = Logger.getLogger(${entity.prefixClassNameWithoutPackage}.class);

// Client-Side Attribute Getters and Setters
#foreach ($attribute in $entity.sortedClassAttributes)
#if (!$attribute.inherited)
#if ($attribute.clientClassProperty)
#if ($attribute.userInfo.ERXConstantClassName)
public $attribute.userInfo.ERXConstantClassName ${attribute.name}() {
Number value = (Number)storedValueForKey("$attribute.name");
return ($attribute.userInfo.ERXConstantClassName)value;
}

public void set${attribute.capitalizedName}($attribute.userInfo.ERXConstantClassName value) {
takeStoredValueForKey(value, "$attribute.name");
}
#else
public $attribute.javaClassName ${attribute.name}() {
return ($attribute.javaClassName) storedValueForKey("$attribute.name");
}

public void set${attribute.capitalizedName}($attribute.javaClassName value) {
if (${entity.prefixClassNameWithoutPackage}.LOG.isDebugEnabled()) {
${entity.prefixClassNameWithoutPackage}.LOG.debug( "updating $attribute.name from " + ${attribute.name}() + " to " + value);
}
takeStoredValueForKey(value, "$attribute.name");
}
#end
#end
#end
#end

// Client-Side To-One Relationship Getters and Setters
#foreach ($relationship in $entity.sortedClassToOneRelationships)
#if (!$relationship.inherited) 
#if ($relationship.clientClassProperty)
public $relationship.actualDestination.classNameWithDefault ${relationship.name}() {
return ($relationship.actualDestination.classNameWithDefault) storedValueForKey("$relationship.name");
}

public void set${relationship.capitalizedName}($relationship.actualDestination.classNameWithDefault value) {
   if (${entity.prefixClassNameWithoutPackage}.LOG.isDebugEnabled()) ${entity.prefixClassNameWithoutPackage}.LOG.debug("updating $relationship.name from " + ${relationship.name}() + " to " + value);
   takeStoredValueForKey(value, "$relationship.name");
   }
 
public void set${relationship.capitalizedName}Relationship($relationship.actualDestination.classNameWithDefault value) {
   if (${entity.prefixClassNameWithoutPackage}.LOG.isDebugEnabled()) ${entity.prefixClassNameWithoutPackage}.LOG.debug("updating $relationship.name from " + ${relationship.name}() + " to " + value);
   if (value == null) {
    if (${relationship.name}() != null) {
    removeObjectFromBothSidesOfRelationshipWithKey(${relationship.name}(), "$relationship.name");
    }
   } else {
    addObjectToBothSidesOfRelationshipWithKey(value, "$relationship.name");
   }
}

#end
#end
#end

// Client-Side To-Many Relationship Getters and Setters
#foreach ($relationship in $entity.sortedClassToManyRelationships)
#if (!$relationship.inherited) 
#if ($relationship.clientClassProperty)
public NSArray<${relationship.actualDestination.classNameWithDefault}> ${relationship.name}() {
return (NSArray<${relationship.actualDestination.classNameWithDefault}>)storedValueForKey("${relationship.name}");
}

#if (!$relationship.inverseRelationship || $relationship.flattened || !$relationship.inverseRelationship.clientClassProperty)
public NSArray<${relationship.actualDestination.classNameWithDefault}> ${relationship.name}(EOQualifier qualifier) {
return ${relationship.name}(qualifier, null);
}
#else
public NSArray<${relationship.actualDestination.classNameWithDefault}> ${relationship.name}(EOQualifier qualifier) {
return ${relationship.name}(qualifier, null, false);
}

public NSArray<${relationship.actualDestination.classNameWithDefault}> ${relationship.name}(EOQualifier qualifier, boolean fetch) {
return ${relationship.name}(qualifier, null, fetch);
}
#end

   public NSArray<${relationship.actualDestination.classNameWithDefault}> ${relationship.name}(EOQualifier qualifier, NSArray<EOSortOrdering> sortOrderings#if ($relationship.inverseRelationship && !$relationship.flattened && $relationship.inverseRelationship.classProperty), boolean fetch#end) {
   NSArray<${relationship.actualDestination.classNameWithDefault}> results;
#if ($relationship.inverseRelationship && !$relationship.flattened && $relationship.inverseRelationship.classProperty)
if (fetch) {
EOQualifier fullQualifier;
#if (${relationship.actualDestination.genericRecord})
EOQualifier inverseQualifier = new EOKeyValueQualifier("${relationship.inverseRelationship.name}", EOQualifier.QualifierOperatorEqual, this);
#else
       EOQualifier inverseQualifier = new EOKeyValueQualifier(${relationship.actualDestination.classNameWithDefault}.${relationship.inverseRelationship.uppercaseUnderscoreName}_KEY, EOQualifier.QualifierOperatorEqual, this);
#end
    
       if (qualifier == null) {
       fullQualifier = inverseQualifier;
       } else {
       NSMutableArray qualifiers = new NSMutableArray();
       qualifiers.addObject(qualifier);
       qualifiers.addObject(inverseQualifier);
       fullQualifier = new EOAndQualifier(qualifiers);
       }

#if (${relationship.actualDestination.genericRecord})
EOFetchSpecification fs = new EOFetchSpecification("${relationship.actualDestination.name}", qualifier, sortOrderings);
fs.setIsDeep(true);
results = (NSArray<${relationship.actualDestination.classNameWithDefault}>)editingContext().objectsWithFetchSpecification(fs);
#else
results = ${relationship.actualDestination.classNameWithDefault}.fetch${relationship.actualDestination.pluralName}(editingContext(), fullQualifier, sortOrderings);
#end
} else {
#end
results = ${relationship.name}();
if (qualifier != null) {
results = (NSArray<${relationship.actualDestination.classNameWithDefault}>)EOQualifier.filteredArrayWithQualifier(results, qualifier);
}
if (sortOrderings != null) {
results = (NSArray<${relationship.actualDestination.classNameWithDefault}>)EOSortOrdering.sortedArrayUsingKeyOrderArray(results, sortOrderings);
}
#if ($relationship.inverseRelationship && !$relationship.flattened && $relationship.inverseRelationship.classProperty)
}
#end
return results;
   }
 
   public void addTo${relationship.capitalizedName}Relationship($relationship.actualDestination.classNameWithDefault object) {
   if (${entity.prefixClassNameWithoutPackage}.LOG.isDebugEnabled()) ${entity.prefixClassNameWithoutPackage}.LOG.debug("adding " + object + " to ${relationship.name} relationship");
   addObjectToBothSidesOfRelationshipWithKey(object, "${relationship.name}");
   }

   public void removeFrom${relationship.capitalizedName}Relationship($relationship.actualDestination.classNameWithDefault object) {
   if (${entity.prefixClassNameWithoutPackage}.LOG.isDebugEnabled()) ${entity.prefixClassNameWithoutPackage}.LOG.debug("removing " + object + " from ${relationship.name} relationship");
   removeObjectFromBothSidesOfRelationshipWithKey(object, "${relationship.name}");
   }

   public $relationship.actualDestination.classNameWithDefault create${relationship.capitalizedName}Relationship() {
   EOClassDescription eoClassDesc = EOClassDescription.classDescriptionForEntityName("${relationship.actualDestination.name}");
   EOEnterpriseObject eo = eoClassDesc.createInstanceWithEditingContext(editingContext(), null);
   editingContext().insertObject(eo);
   addObjectToBothSidesOfRelationshipWithKey(eo, "${relationship.name}");
   return ($relationship.actualDestination.classNameWithDefault) eo;
   }

   public void delete${relationship.capitalizedName}Relationship($relationship.actualDestination.classNameWithDefault object) {
   removeObjectFromBothSidesOfRelationshipWithKey(object, "${relationship.name}");
#if (!$relationship.ownsDestination)
editingContext().deleteObject(object);
#end
   }

public void deleteAll${relationship.capitalizedName}Relationships() {
Enumeration objects = ${relationship.name}().immutableClone().objectEnumerator();
while (objects.hasMoreElements()) {
delete${relationship.capitalizedName}Relationship(($relationship.actualDestination.classNameWithDefault)objects.nextElement());
}
}
#end
#end
#end

public ${entity.classNameWithOptionalPackage} create${entity.name}(EOEditingContext ec
#foreach ($attribute in $entity.sortedClassAttributes)
#if ($attribute.clientClassProperty && !$attribute.allowsNull)
#set ($restrictingQualifierKey = 'false')
#foreach ($qualifierKey in $entity.restrictingQualifierKeys)
#if ($attribute.name == $qualifierKey)
#set ($restrictingQualifierKey = 'true')
#end
#end
#if ($restrictingQualifierKey == 'false')
#if ($attribute.userInfo.ERXConstantClassName)
, ${attribute.userInfo.ERXConstantClassName}
#else
, ${attribute.javaClassName}#end ${attribute.name}
#end
#end
#end
#foreach ($relationship in $entity.sortedClassToOneRelationships)
#if ($relationship.clientClassProperty && $relationship.mandatory && !($relationship.ownsDestination && $relationship.propagatesPrimaryKey))
, ${relationship.actualDestination.classNameWithDefault} ${relationship.name}
#end
#end
   ) {
${entity.classNameWithOptionalPackage} new${entity.name} = new ${entity.classNameWithOptionalPackage}();
ec.insertObject(new${entity.name});
   
#foreach ($attribute in $entity.sortedClassAttributes)
#if ($attribute.clientClassProperty && !$attribute.allowsNull)
#set ($restrictingQualifierKey = 'false')
#foreach ($qualifierKey in $entity.restrictingQualifierKeys) 
#if ($attribute.name == $qualifierKey)
#set ($restrictingQualifierKey = 'true')
#end
#end
#if ($restrictingQualifierKey == 'false')
new${entity.name}.set${attribute.capitalizedName}(${attribute.name});
#end
#end
#end
#foreach ($relationship in $entity.sortedClassToOneRelationships)
#if ($relationship.clientClassProperty && $relationship.mandatory && !($relationship.ownsDestination && $relationship.propagatesPrimaryKey))
new${entity.name}.set${relationship.capitalizedName}Relationship(${relationship.name});
#end
#end
     return new${entity.name};
}

public static NSArray<${entity.classNameWithOptionalPackage}> fetchAll${entity.pluralName}(EOEditingContext editingContext) {
return ${entity.prefixClassNameWithoutPackage}.fetchAll${entity.pluralName}(editingContext, null);
}

public static NSArray<${entity.classNameWithOptionalPackage}> fetchAll${entity.pluralName}(EOEditingContext editingContext, NSArray<EOSortOrdering> sortOrderings) {
return ${entity.prefixClassNameWithoutPackage}.fetch${entity.pluralName}(editingContext, null, sortOrderings);
}

public static NSArray<${entity.classNameWithOptionalPackage}> fetch${entity.pluralName}(EOEditingContext editingContext, EOQualifier qualifier, NSArray<EOSortOrdering> sortOrderings) {
EOFetchSpecification fetchSpec = new EOFetchSpecification(${entity.prefixClassNameWithoutPackage}.ENTITY_NAME, qualifier, sortOrderings);
fetchSpec.setIsDeep(true);
NSArray<${entity.classNameWithOptionalPackage}> eoObjects = (NSArray<${entity.classNameWithOptionalPackage}>)editingContext.objectsWithFetchSpecification(fetchSpec);
return eoObjects;
}

public static ${entity.classNameWithOptionalPackage} fetch${entity.name}(EOEditingContext editingContext, String keyName, Object value) {
return ${entity.prefixClassNameWithoutPackage}.fetch${entity.name}(editingContext, new EOKeyValueQualifier(keyName, EOQualifier.QualifierOperatorEqual, value));
}

public static ${entity.classNameWithOptionalPackage} fetch${entity.name}(EOEditingContext editingContext, EOQualifier qualifier) {
NSArray<${entity.classNameWithOptionalPackage}> eoObjects = ${entity.prefixClassNameWithoutPackage}.fetch${entity.pluralName}(editingContext, qualifier, null);
${entity.classNameWithOptionalPackage} eoObject;
int count = eoObjects.count();
if (count == 0) {
eoObject = null;
} else if (count == 1) {
eoObject = (${entity.classNameWithOptionalPackage})eoObjects.objectAtIndex(0);
} else {
throw new IllegalStateException("There was more than one ${entity.name} that matched the qualifier '" + qualifier + "'.");
}
return eoObject;
}

public static ${entity.classNameWithOptionalPackage} fetchRequired${entity.name}(EOEditingContext editingContext, String keyName, Object value) {
return ${entity.prefixClassNameWithoutPackage}.fetchRequired${entity.name}(editingContext, new EOKeyValueQualifier(keyName, EOQualifier.QualifierOperatorEqual, value));
}

public static ${entity.classNameWithOptionalPackage} fetchRequired${entity.name}(EOEditingContext editingContext, EOQualifier qualifier) {
${entity.classNameWithOptionalPackage} eoObject = ${entity.prefixClassNameWithoutPackage}.fetch${entity.name}(editingContext, qualifier);
if (eoObject == null) {
throw new NoSuchElementException("There was no ${entity.name} that matched the qualifier '" + qualifier + "'.");
}
return eoObject;
}

public static ${entity.classNameWithOptionalPackage} localInstanceIn(EOEditingContext editingContext, ${entity.classNameWithOptionalPackage} eo) {
${entity.classNameWithOptionalPackage} localInstance = (eo == null) ? null : (${entity.classNameWithOptionalPackage})EOUtilities.localInstanceOfObject(editingContext, eo);
if (localInstance == null && eo != null) {
throw new IllegalStateException("You attempted to localInstance " + eo + ", which has not yet committed.");
}
return localInstance;
}

// Fetch Specifications
#foreach ($fetchSpecification in $entity.sortedFetchSpecs)
public static NSArray<${entity.classNameWithDefault}> fetch${fetchSpecification.capitalizedName}(EOEditingContext ec#foreach ($binding in $fetchSpecification.distinctBindings), ${binding.javaClassName} ${binding.name}Binding#end) {
EOFetchSpecification fs = (EOFetchSpecification) _distributedObjectStore().invokeStatelessRemoteMethodWithKeyPath(
"session",
"clientSideRequestGetFetchSpecification",
new Class[] {String.class, String.class }, 
new String[] {"${fetchSpecification.name}", "${entity.classNameWithoutPackage}"});
#if ($fetchSpecification.distinctBindings.size() > 0)
NSMutableDictionary bindings = new NSMutableDictionary($fetchSpecification.distinctBindings.size());
#foreach ($binding in $fetchSpecification.distinctBindings)
bindings.takeValueForKey(${binding.name}Binding, "${binding.name}");
#end
     fs = fs.fetchSpecificationWithQualifierBindings(bindings);
#end
     return ec.objectsWithFetchSpecification(fs);
   }
 
public static ${entity.classNameWithOptionalPackage} fetchOne${fetchSpecification.capitalizedName}(EOEditingContext ec#foreach ($binding in $fetchSpecification.distinctBindings), ${binding.javaClassName} ${binding.name}Binding#end) {
NSArray fetch${fetchSpecification.capitalizedName}Results = fetch${fetchSpecification.capitalizedName}(ec#foreach ($binding in $fetchSpecification.distinctBindings), ${binding.name}Binding#end);
if (fetch${fetchSpecification.capitalizedName}Results.count() > 0) {
return (${entity.classNameWithoutPackage})fetch${fetchSpecification.capitalizedName}Results.objectAtIndex(0);
} else {
return null;
}
}

#end
}