I have 2 domain classes which are mapped by many-to-many relationship. I followed the instruction of Grails documentation, but I still have some problem when processing data on those domains. Here are my 2 domain classes:
class User {
String name
int age
String job
static hasMany = [groups : Group]
static belongsTo = [org : Organization]
}
class Group {
String groupName
String code
static hasMany = [members : User]
}
My problems are:
1. The above relationship require one class hold belongsTo to be the "owner" of the relationship. In this context, the User belongs to the Group, but I do not know how to put the belongsTo to User class, because the standard syntax that Grails suggest is static belongsTo = [Group] (just specify the owner class name), so I cannot:
- put it into the exist belongsTo like this: static belongsTo = [org : Organization, Group]
- or define another belongsTo like this: static belongsTo = [Group]
Is below example right:
class Book {
String title
static belongsTo = Author
static hasMany = [authors:Author]
static mapping = {
authors joinTable:[name:"mm_author_books", key:'mm_book_id' ]
}
}
class Author {
String name
static hasMany = [books:Book]
static mapping = {
books joinTable:[name:"mm_author_books", key:'mm_author_id']
}
}
(Ref link: Many-to-Many link tables in grails (GORM) / hibernate)
I mean that do we need to specify the name of foreign key of the join table for each class?
If I want to find all User that are members of a specified Group whose name is "ABC", how can I use the DynamicFinder of Grails?
Thank you so much
It is very rare that m2m relationships have an owning side, so I've always found it odd to have to specify one for GORM to work correctly. Because of this, I don't do it this way. I create the join table as a domain. Then things get really simple.
class UserGroup implements Serializable {
User user
Group group
boolean equals(other) {
if (!(other instanceof UserGroup)) {
return false
}
other.user?.id == user?.id &&
other.group?.id == group?.id
}
int hashCode() {
def builder = new HashCodeBuilder()
if (user) builder.append(user.id)
if (group) builder.append(group.id)
builder.toHashCode()
}
static UserGroup get(long userId, long groupId) {
find 'from UserGroup where user.id=:userId and group.id=:groupId',
[userId: userId, groupId: groupId]
}
static UserGroup create(User user, Group group, boolean flush = false) {
new UserGroup(user: user, group: group).save(flush: flush, insert: true)
}
static boolean remove(User user, Group group, boolean flush = false) {
UserGroup instance = UserGroup.findByUserAndGroup(user, group)
instance ? instance.delete(flush: flush) : false
}
static void removeAll(User user) {
executeUpdate 'DELETE FROM UserGroup WHERE user=:user', [user: user]
}
static void removeAll(Group group) {
executeUpdate 'DELETE FROM UserGroup WHERE group=:group', [group: group]
}
static mapping = {
id composite: ['group', 'user']
version false
}
}
Then you just need to create the getters in your User and Group class. You won't have User user or Group group in either class. There is no need to map them with hasMany/belongsTo because all that will do is create the join table, which you've done by creating the UserGroup domain.
class User {
Set<Group> getGroups() {
UserGroup.findAllByUser(this).collect { it.group } as Set
}
}
class Group {
Set<User> getUsers() {
UserGroup.findAllByGroup(this).collect { it.user } as Set
}
}
Once you have these in place you can use the methods you created in the UserGroup domain and/or you can use finders on it...
def userGroupInstance = UserGroup.findByUserAndGroup(userInstance, groupInstance)
def userGroups = UserGroup.findAllByUser(userInstance)
def userGroupInstance = UserGroup.get(userId, groupId)
You get the idea. This presentation by Burt Beckwith sheds more light on why this is a good approach along with some other great tips for performance increases.
belongsTo will create another M:1 relationship (field) - you tell if there is a "main group" for a User in your case. If I wished only to enforce at least one group, I'd go with a custom validator for User.groups checking it's not empty.
(I'm not sure here) - I believe yes, if the key name differs from default Hibernat/GORM "userId"/"groupId".
findBy*() methods won't work here, you need a CriteriaBuilder, like here.
Related
I am new to grails. I have 3 classes as follws
class Cycle
{
int year
int quarter
}
class User
{
String username, password
}
class Role
{
String roleName
}
The User and Role tables are independent and they stores details of all employees and Available roles respectively.
An employee can have many roles in each cycle. so i want a mapping table like
to find what all roles belongs to an employee in a particular cycle.
How do i set proper relation between these classes to solve this scenario so that if i have a cyle and a user , i can find out what all roles the user has in that cycle
also if i have a user i can find which all cycles he involved an his roles in each of these cycles
Following the comment.
You should create a table between User and Cycle
class UserCycle
{
User user
Cycle cycle
static hasMany = [roles: Role]
}
Role class should look like this:
class Role
{
String roleName
UserCycle userCycle
}
and in code You can refer to that like:
UserCycle uc = ...
def roles = uc.roles.list(params) //list of roles
def cycle = uc.cycle
def user = uc.user
to add
uc.addToRoles(/*Your role*/)
to remove
uc.removeFromRoles(/*Your role*/)
You'll need to add a join table (domain class) that stores the mapping between users and roles in a particular cycle. Here's an example of such a class with some helper methods that may be useful
class UserRole implements Serializable {
User user
Role role
Cycle cycle
static UserRole create(User user, Role role, Cycle cycle, boolean flush = false) {
new UserRole(user: user, role: role, cycle: cycle).save(flush: flush, insert: true)
}
static boolean remove(User user, Role role, Cycle cycle, boolean flush = false) {
UserRole instance = UserRole.findByUserAndRoleAndCycle(user, role, cycle)
if (!instance) {
return false
}
instance.delete(flush: flush)
true
}
static void removeAll(User user) {
executeUpdate 'DELETE FROM UserRole WHERE user=:user', [user: user]
}
static void removeAll(Role role) {
executeUpdate 'DELETE FROM UserRole WHERE role=:role', [role: role]
}
static void removeAll(Cycle cycle) {
executeUpdate 'DELETE FROM UserRole WHERE cycle=:cycle', [cycle: cycle]
}
static mapping = {
id composite: ['role', 'user', 'cycle']
version false
}
}
I have a user class as a grails domain class. I would like to establish constraints for a String list that is declared in a hasMany relationship.
class User {
String name
static hasMany = [interests: String]
}
How could I specify an inList constraint for each interest?
you could use an Enum instead, so your inList Constraint will be handled automatically?
The solution could look like this:
class User {
String name
static hasMany = [interests: Interest]
}
Enum Interest {
FOO('foo'),
BAR('bar')
final String id
Interest(String id) { this.id = id }
}
I have following domain classes:
class UserGroup {
String name
String description
static hasMany = [users:User]
}
class User {
String name
static hasMany = [userGroups:UserGroup]
static belongsTo = UserGroup
}
Here User and UserGroup have many to many relationaship.but when I save user to usergroup,the user is not updated with that usergroup.Is there a mapping I can use to do that?I am using following code to add users to group:
static def addUserToGroups(def user){
def userGroups = UserGroup.findAll()
userGroups.each {
if(/** condition **/){
it.addToUsers(user)
it.save(flush:true,failOnError:true)
}
}
}
I am working with legacy database and have a many-to-many association with a join-table that I have resolved to a large extent as the mappings are working fine. But there is an additional column and in case of Book, Author model lets say that the nm_author_books contain a field called 'royalty'. Question is how do I access this field from any direction?
class Book {
String title
static belongsTo = Author
static hasMany = [authors: Author]
static mapping = { authors joinTable: [name: "mm_author_books", key: 'mm_book_id' ] }
}
class Author {
String name
static hasMany = [books: Book]
static mapping = { books joinTable: [name: "mm_author_books", key: 'mm_author_id'] }
}
If the nm_author_book table has [nm_book_id, nm_author_id, royalty] what is the way to access the royalty?
The basic idea is change from 1 many-to-many to 2 many-to-one: a Book has many BookAuthorDetail and a Author has many BookAuthorDetail
class Book {
String title
static hasMany = [details: BookAuthorDetail]
}
class Author {
String name
static hasMany = [details: BookAuthorDetail]
}
class BookAuthorDetail {
String royalty
static belongsTo = [book: Book, author: Author]
}
to access royalty by BookAuthorDetail, you can do: BookAuthorDetail.findAllByBookAndAuthor(bookInstance, authorInstance)
You could make a domain object that models that join table so instead of changing the mapping for Book and Author you have them point to the AuthorBookRoyalty domain.
Class AuthorBookRoyalty {
Author author
Book book
Long royalty
}
class Book {
String title
static belongsTo =Author
Static hasMany[authors: AuthorBookRoyalty]
}
Do similar for Author and you can now deal with the royalties. You may need to adjust the mapping on the join table to make it map to your current database.
Another option is to access these additional fields directly from the mapped entity of the join table:
class Book {
String title
static belongsTo = Author
static hasMany = [authors: Author]
static mapping = { authors joinTable: [name: "mm_author_books", key: 'mm_book_id' ] }
}
class Author {
String name
static hasMany = [books: Book]
static mapping = { books joinTable: [name: "mm_author_books", key: 'mm_author_id'] }
}
class AuthorBooks {
Author author
Book book
Long royalty
static mapping = {
table name: "mm_author_books"
author column: "mm_author_id"
book column: "mm_book_id"
}
}
You can access royalty with the following code, for instance:
AuthorBooks.findAllByBookAndAuthor(bookInstance, authorInstance)*.royalty
Hello I have two domain classes as following
class Users {
String password
String firstName
String lastName
String emailAddress
String username
Company company
.....
static hasMany = [projects:Projects];
}
Another class
class Projects {
String projectName
String description
Users projectLead
Date dateCreated
Date lastUpdated
static belongsTo = Users
}
These classes obviously has one to many relationship but now I want to change it to many to many relationship by adding "ProjectMembership" class but the problem I have is that my application has already gone into production and there are people who are already using the app. In such a case they already have one user->many projects in the the db. In such a case how can I migrate this existing data and change my prod app to have m2m relationship which will looks like following.
class Users {
String password
String firstName
String lastName
String emailAddress
String username
Company company
.....
static hasMany = [projectMemberships:ProjectMemberships];
}
Another class
class Projects {
String projectName
String description
Users projectLead
Date dateCreated
Date lastUpdated
static hasMany = [projectMemberships:ProjectMemberships];
}
and
class ProjectMemberships{
Users u
Projects p
}
This is best done with a migration tool like Liquibase, and the http://grails.org/plugin/database-migration plugin is probably your best be in Grails since it uses Liquibase and is tightly integrated with GORM. But this one's easy enough to do by hand.
I wouldn't use hasMany since you can easily manage everything from the ProjectMemberships class, so your Users and Projects classes would be
class Users {
String password
String firstName
String lastName
String emailAddress
String username
Company company
.....
}
and
class Projects {
String projectName
String description
Date dateCreated
Date lastUpdated
}
I'd go with a ProjectMemberships class that uses a composite key, which requires that it implement Serializable and have a good hashCode and equals:
import org.apache.commons.lang.builder.HashCodeBuilder
class ProjectMemberships implements Serializable {
Users u
Projects p
boolean equals(other) {
if (!(other instanceof ProjectMemberships)) {
return false
}
other.u?.id == u?.id && other.p?.id == p?.id
}
int hashCode() {
def builder = new HashCodeBuilder()
if (u) builder.append(u.id)
if (p) builder.append(p.id)
builder.toHashCode()
}
static ProjectMemberships get(long userId, long projectId) {
find 'from ProjectMemberships where u.id=:userId and p.id=:projectId',
[userId: userId, projectId: projectId]
}
static ProjectMemberships create(Users u, Projects p, boolean flush = false) {
new ProjectMemberships(u: u, p: p).save(flush: flush, insert: true)
}
static boolean remove(Users u, Projects p, boolean flush = false) {
ProjectMemberships instance = ProjectMemberships.findByUsersAndProjects(u, p)
if (!instance) {
return false
}
instance.delete(flush: flush)
true
}
static void removeAll(Users u) {
executeUpdate 'DELETE FROM ProjectMemberships WHERE u=:u', [u: u]
}
static void removeAll(Projects p) {
executeUpdate 'DELETE FROM ProjectMemberships WHERE p=:p', [p: p]
}
static mapping = {
id composite: ['p', 'u']
version false
}
}
Use ProjectMemberships.create() to add a relationship between a user and a project, and ProjectMemberships.remove() to remove it.
Run grails schema-export to see the updated DDL (it'll be in target/ddl.sql). Run the create table statement for the project_memberships table, e.g.
create table project_memberships (
p_id bigint not null,
u_id bigint not null,
primary key (p_id, u_id)
)
Then populate it with this SQL (depending on your database you might need a slightly different syntax):
insert into project_memberships(p_id, u_id) select id, project_lead_id from projects
and finally drop the project_lead_id column from the projects table.
Of course do a database backup before making any changes.
You can get a user's projects with
def projects = ProjectMemberships.findAllByUsers(user)*.p
and similarly a project's users with
def users = ProjectMemberships.findAllByProjects(project)*.u