Customer extent.exists((c : Customer) : Boolean { c.vip })

    attribute price : Double
        (* Price mustbe $50 at least. *)
        invariant above_minimum { self.price >= 50.0 }
        (* Price cannot be above $500. *)
        invariant below_maximum { self.price <= 500.0 };

    attribute year : Integer
        (* Year must be later than 1990 *)
        invariant above_minimum { (self.year > 1990) }
        (* Year cannot be in the future *)
        invariant below_maximum { self.year <= Date#today().year() };

        return q().all([
            q().then(function() {
                return Examples.car();
            }), ...

        return q().all([
            Examples.car(),
            ...
        ])...

readonly attribute returned : Date;
derived readonly attribute inProgress : Boolean := {
    self.returned == null
};
static query currentForCustomer(c : Customer) : Rental;
begin
    return Rental extent.\any((l : Rental) : Boolean {
        (l.customer == c) and l.inProgress
    });
end;

rentalSchema.virtual('inProgress').get(function () {
    return this['returned'] == null;
});

rentalSchema.statics.currentForCustomer = function (c) {
    var me = this;
    return Q().then(function() {
        return Q.npost(me.model('Rental').find().where({
            $and : [ 
                { customer : c },
                { 'inProgress' : true }
            ]
        }).findOne(), 'exec', [  ]);
    });
};

rentalSchema.statics.currentForCustomer = function (c) {
    var me = this;
    return Q().then(function() {
        return Q.npost(me.model('Rental').find().where({
            $and : [ 
                { customer : c },
                { 'returned' : null }
            ]
        }).findOne(), 'exec', [  ]);
    });
};

operation rentalHistory();
begin
    var car, customer;
    begin
        car := Examples#newCar();
        customer := Examples#newCustomer();
        customer.rent(car);
        Assert#areEqual(1, customer.rentals.size());
        customer.finishRental();
    end;
    begin
        customer.rent(car);
        Assert#areEqual(2, customer.rentals.size());
    end;
end;

test('rentalHistory', function(done) {
    var behavior = function() {
        var car;
        var customer;
        return q().all([
            Examples.newCar().then(function(call_newCar) {
                car = call_newCar;
            }), 
            Examples.newCustomer().then(function(call_newCustomer) {
                customer = call_newCustomer;
            })
        ]).then(function() {
            customer.rent(car);
        }).then(function() {
            return Rental.findOne({ _id : customer.rentals }).exec();
        }).then(function(read_rentals) {
            assert.equal(1, /*TBD*/count);
        }).then(function() {
            customer.finishRental();
        }).then(function() {
            customer.rent(car);
        }).then(function() {
            return Rental.findOne({ _id : customer.rentals }).exec();
        }).then(function(read_rentals) {
            assert.equal(2, /*TBD*/count);
        });
    };
    behavior().then(done, done);
});

test('rentalHistory', function(done) {
    var behavior = function() {
        var car;
        var customer;
        return q().all([
            q().then(function() {
                return Examples.newCar();
            }), q().then(function() {
                return Examples.newCustomer();
            }).then(function(call_newCustomer) {
                customer = call_newCustomer;
            }), q().then(function() {
                customer.rent(car);
            }), q().then(function() {
                return Rental.findOne({ _id : customer.rentals }).exec();
            }).then(function(read_rentals) {
                assert.equal(1, /*TBD*/count);
            }), q().then(function() {
                customer.finishRental();
            }), q().all([
                q().then(function() {
                    customer.rent(car);
                }), q().then(function() {
                    return Rental.findOne({ _id : customer.rentals }).exec();
                }).then(function(read_rentals) {
                    assert.equal(2, /*TBD*/count);
                })
            ]).spread(function(call_rent, call_areEqual) {
                /*sink*/;
                /*sink*/;
            })
        ]).spread(function(call_newCar, add_customer, call_rent, call_areEqual, call_finishRental, block) {
            car = call_newCar;
            /*sink*/;
            /*sink*/;
            /*sink*/;
            /*sink*/;
            /*sink*/;
        });
    };
    behavior().then(done, done);
});

customerSchema.methods.rent = function (car) {
    var rental;
    var me = this;
    return Q().then(function() {
        return Q().then(function() {
            console.log("rental = new Rental();\n");
            rental = new Rental();
        });
    }).then(function() {
        return Q().then(function() {
            console.log("rental.customer = me._id;\nme.rentals.push(rental._id);\n");
            rental.customer = me._id;
            me.rentals.push(rental._id);
        });
    }).then(function() {
        return Q().then(function() {
            console.log("rental.car = car._id;\ncar.rentals.push(rental._id);\n");
            rental.car = car._id;
            car.rentals.push(rental._id);
        });
    }).then(function() {
        return Q().then(function() {
            console.log("car.carRented();\n");
            car.carRented();
        });
    }).then(function() {
        return Q.npost(me, 'save', [  ]).then(function(saveResult) {
            return saveResult[0];
        });
    });
};

 cloudfier run-tests .
✘ cities_tests.Tests.populousStates
    Cause: java.lang.RuntimeException: Error finding converter for cities::State to convert cities::State#38 = {values: {name=California, acronym=CA} - children: {} - related: {}}
✔ cities_tests.Tests.statePopulation

    (* Book a taxi that is currently available *)
    operation book(toRent : Taxi)
        (* No taxis available *)
        precondition {
            Taxi extent.exists((t : Taxi) : Boolean { not t.full })
        }
    ...

    static query openExpenseCountPerCategory() : { category : Category, count : Integer }[*];
    begin
        return Expense extent.select((e : Expense) : Boolean {
            e.status == Status#Submitted
        }).groupBy(
            (e : Expense) : Category { e.category }
        ).groupCollect((group : Expense[*]) : { category : Category, count : Integer } {
            {
                category := group.one().category,
                count := group.size()
            }
        });
    end;

    public Collection<Tuple> openExpenseCountPerCategory() {
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        CriteriaQuery<Tuple> cq = cb.createTupleQuery();
        Root<Expense> expense_ = cq.from(Expense.class);
        TypedQuery<Tuple> query = entityManager.createQuery(
            cq.multiselect(
                expense_.get("category").get("id").alias("category"), 
                cb.count(expense_).alias("count")
            )
            .where(cb.equal(expense_.get("status"), Expense.Status.Submitted))
            .groupBy(expense_.get("category").get("id"))
        );
        return query.getResultList();
    }

model crm;
class Customer
    attribute name : String;
    attribute title : String;              
    query countByTitle() : {title : String, customerCount : Integer} [*];
    begin
        return Customer extent.groupBy((c : Customer) : String {
            c.title
        }).groupCollect((group : Customer[*]) : {title:String, customerCount : Integer} {
            { 
                title := group.one().title,
                customerCount := group.size()
            }   
        }).select((counted : {title:String, customerCount : Integer}) : Boolean {
            counted.customerCount > 100
        });
    end;
end;
end.

cq
    .groupBy(customer_.get("title"))
    .multiselect(customer_.get("title"), cb.count(customer_))
    .having(cb.greaterThan(cb.count(customer_), cb.literal(100)))

    static query expenseDetails() : { reporter : Employee, category: String, expenseAmount : Double }[*];
    begin
        return Expense extent.collect((e : Expense) : { reporter : Employee, category : String, expenseAmount : Double } {
            {
                reporter := e.employee,
                category := e.category.name,
                expenseAmount := e.amount
            }
        });
    end;

class Article
    attribute title : String;
    attribute body : Memo;    
    attribute tags : String[*];
end;

Assert#isTrue(not car.available);

assert.strictEqual(car['available'], true);

derived attribute available : Boolean := {
    self.status == Status#Available
};

ERROR] 
ERROR:  SubQueryActionGenerator.xtend - 
41: The method generateTraverseRelationshipAction(InputPin, Property) of type SubQueryActionGenerator must override a superclass method.

car.model = newModel._id
                ;

    derived attribute population  : Integer := { self.computePopulation() };
    query computePopulation() : Integer;
    begin
        return (self.cities.sum((c : City) : Integer { c.population }) as Integer);
    end;

/*************************** DERIVED PROPERTIES ****************/

stateSchema.methods.getPopulation = function () {
    var me = this;
    return Q().then(function() {
        return me.computePopulation();
    }).then(function(computePopulationResult) {
        return computePopulationResult;
    });
};

        return City extent.groupBy((c : City) : State {
            c.cityState
        }).groupCollect((cities : City[*]) : { : String,  : Integer} {
            {
                cityState := cities.one().cityState.abbreviation, 
                statePopulation := cities.sum((c : City) : Integer {
                    c.population
                })
            }
        }).select((aggregated : { cityState : String, statePopulation : Integer}) : Boolean {
            aggregated.statePopulation > threshold
        }).collect((aggregated : { acronym : String, statePopulation : Integer}) : String {
            aggregated.acronym
        });

        }).collect((aggregated : { cityState : String, statePopulation : Integer}) : String {
            aggregated.cityState
        });

    operation availableUponReturn();
    begin
        var car, customer;
        begin
            car := Examples#newCar();
            customer := Examples#newCustomer();
        end;
        begin
            Assert#isTrue(car.available);
            customer.rent(car);
        end;
        begin
            Assert#isTrue(not car.available);
            customer.finishRental();
        end;
        begin
            Assert#isTrue(car.available);
        end;
    end;

    public Collection<Customer>  findByName(String firstName, String lastName) {
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        CriteriaQuery<Customer> cq = cb.createQuery(Customer.class);
        Root<Customer> customer_ = cq.from(Customer.class);
        return entityManager.createQuery(
            cq.select(customer_).distinct(true).where(
                cb.or(
                    cb.equal(
                        cb.parameter(String.class, "lastName"),
                        person_.get("lastName")
                    ),
                    cb.equal(
                        cb.parameter(String.class, "firstName"),
                        person_.get("firstName")
                    )
                )
            )
        ).setParameter("firstName", firstName).setParameter("lastName", lastName).getResultList();
    }