robbin的自言自语

public class User extends ObjectEntity {
    /**
     * Name of "User" object. 
     */
    public static final String _ = "User";
    .......

    public User(Object... nameValue) {
        super(_);
        set(nameValue);
    }

    public static User load(long id, List<String> selectPropNames, Object... options) throws CoatException {
        return (User) AbstractNappy.load(User.class, com.qz.dcoat.util.N.asOid(ID, id), selectPropNames, options);
    }

    public static List<User> find(List<String> selectPropNames, Condition condition, Object... options) throws CoatException {
        return AbstractNappy.find(User.class, _, selectPropNames, condition, options);
    }

    public static int count(Condition condition, Object... options) throws CoatException {
        return AbstractNappy.count(_, condition, options);
    }

    .......
}

User user = new User(User.NAME, "newUser", User.DEPARTMENT, "dep");
user.store();

user.add(task);

public class richDomainObject implements richDomainObjectInterface{

 private domainObjectPO;
 private domainObjectDAO<richDomainObject>;
 private domainLogic1<richDomainObject>;  
 private domainLogic2<richDomainObject>;
 ...

}

public class action<richDomainObject>{}

public class Department {

	public static void employee(String name, String department) {
		User.create(name,department);
	}
	
}

@Entity
public class Kind {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	public int id = -1;

	public String name;

	public Kind(String name) {
		this.name = name;
	}

	public static Kind create(String name) {
		Kind kind = new Kind(name);
		Context.em.persist(kind);
		return kind;
	}

	public void addBatchTaskToUsers(String task) {
		List<User> users = users();
		for (User user : users) {
			Task taskEntity = new Task(task, this);
			Context.em.persist(taskEntity);
			user.applyTask(taskEntity);
		}
	}

	public List<User> users() {
		Query query = Context.em
				.createQuery("select distinct u from User as u inner join u.kinds as kind where kind = ?1");
		query.setParameter(1, this);
		return query.getResultList();
	}

}

@Entity
public class Task {
	public Task(String task,Kind kind) {
		this.kind = kind;
		this.task = task;
	}

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	public int id = -1;
	
	public Date startTime;
	
	public Date endTime;
	
	public String task;
	
	@ManyToOne
	public User owner;
	
	@ManyToOne
	public Kind kind;

	public static Task create(String name, Kind kind) {
		Task task = new Task(name,kind);
		Context.em.persist(task);
		return task;
	}

	private static Date getCurrentMonthBegin()
	{
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.DAY_OF_MONTH,0);
		Date begin = calendar.getTime();
		return begin;
	}
	
	public static Date getCurrentMonthEnd()
	{
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.DAY_OF_MONTH, calendar.getMaximum(Calendar.DAY_OF_MONTH));
		Date end = calendar.getTime();
		return end;
	}
	
	public static List<Task> allTask_CurrentMonth() {
		Date begin = getCurrentMonthBegin();
		Date end = getCurrentMonthEnd();
		Query query = Context.em.createQuery("from Task as t where t.startTime >= ?1 and t.startTime <= ?2");
		query.setParameter(1,begin);
		query.setParameter(2,end);
		return query.getResultList();
	}

	public static List<Task> processingTasks_CurrentMonth() {
		Date begin = getCurrentMonthBegin();
		Date end = getCurrentMonthEnd();
		Query query = Context.em.createQuery("from Task as t where t.startTime >= ?1 and t.startTime <= ?2 and t.endTime is null");
		query.setParameter(1,begin);
		query.setParameter(2,end);
		return query.getResultList();
	}

	public static List<Task> processedTasks_CurrentMonth() {
		Date begin = getCurrentMonthBegin();
		Date end = getCurrentMonthEnd();
		Query query = Context.em.createQuery("from Task as t where t.endTime >= ?1 and t.endTime <= ?2 ");
		query.setParameter(1,begin);
		query.setParameter(2,end);
		return query.getResultList();
	}
}

@Entity
public class User {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	public int id = -1;

	public String name;

	public String department;

	@OneToMany
	public List<Kind> kinds = new ArrayList<Kind>();

	public User(String name, String department) {
		this.name = name;
		this.department = department;
	}

	public Tasks tasks = new Tasks(this);

	class Tasks {
		private User user;

		public Tasks(User user) {
			this.user = user;
		}

		public Task find_by_name(String task) {
			Query query = Context.em
					.createQuery("from Task t where t.owner = ?1 and t.task = ?2");
			query.setParameter(1, user);
			query.setParameter(2, task);
			return (Task) query.getSingleResult();
		}

		public List<Task> processing_tasks() {
			Query query = Context.em
					.createQuery("from Task t where t.startTime <= ?1 and t.owner = ?2 and t.endTime is null");
			query.setParameter(1, new Date());
			query.setParameter(2, user);
			return query.getResultList();
		}

		public boolean detectProcessingTask(String task) {
			for(Task taskEntity:processing_tasks())
			{
				if(task.equals(taskEntity.task))
				{
					return true;
				}
			}
			return false;
		}
	}

	public static User find_By_Name_And_Department(String name,
			String department) {
		Query query = Context.em
				.createQuery("from User u where u.name = ?1 and u.department = ?2");
		query.setParameter(1, name);
		query.setParameter(2, department);
		return (User) query.getSingleResult();
	}

	public static User create(String name, String department) {
		User user = new User(name, department);
		Context.em.persist(user);
		return user;
	}

	public void applyTask(Task task) {
		task.owner = this;
		task.startTime = new Date();
		Context.em.persist(task);
	}

	public static List<Task> all_processing_tasks() {
		Query query = Context.em
				.createQuery("from Task t where t.startTime <= ?1  and t.endTime is null");
		query.setParameter(1, new Date());
		return query.getResultList();
	}

	public void endTask(Task task) {
		task.endTime = new Date();
	}
}

// Copyright 2004-2006 Castle Project - http://www.castleproject.org/
// 
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// 
//     http://www.apache.org/licenses/LICENSE-2.0
// 
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

namespace BlogSample
{
	using System;
	using System.Collections;

	using Castle.ActiveRecord;

	[ActiveRecord]
	public class Blog : ActiveRecordBase
	{
		private int id;
		private String name;
		private String author;
		private IList posts = new ArrayList();

		public Blog()
		{
		}

		public Blog(String name)
		{
			this.name = name;
		}

		[PrimaryKey]
		public int Id
		{
			get { return id; }
			set { id = value; }
		}

		[Property]
		public String Name
		{
			get { return name; }
			set { name = value; }
		}

		[Property]
		public String Author
		{
			get { return author; }
			set { author = value; }
		}

		[HasMany(typeof(Post), 
			Table="Posts", ColumnKey="blogid", 
			Inverse=true, Cascade=ManyRelationCascadeEnum.AllDeleteOrphan)]
		public IList Posts
		{
			get { return posts; }
			set { posts = value; }
		}

		public static void DeleteAll()
		{
			ActiveRecordBase.DeleteAll(typeof(Blog));
		}

		public static Blog[] FindAll()
		{
			return (Blog[]) ActiveRecordBase.FindAll(typeof(Blog));
		}

		public static Blog Find(int id)
		{
			return (Blog) ActiveRecordBase.FindByPrimaryKey(typeof(Blog), id);
		}
	}
}