litesoft
Subversion Repository Public Repository

litesoft

URLs

Copy to Clipboard
Explore
Commits

Diff Revisions 947 vs 948 for /trunk/GWT_Sandbox/InitFrom/src/org/litesoft/initfrom/server/pos/UserGO.java

Diff revisions: vs.
  @@ -9,25 +9,21 @@
9 9
10 10 public abstract class UserGO
11 11 extends org.litesoft.orsup.nonpublic.PersistentObjectImpl<User>
12 - implements HasAttributes
13 - {
12 + implements HasAttributes {
14 13 private static final ConstructionControl CONSTRUCTION_CONTROL = new ConstructionControl();
15 14
16 - public static SimpleFromIdentifier from()
17 - {
15 + public static SimpleFromIdentifier from() {
18 16 return UserMetaData.INSTANCE;
19 17 }
20 18
21 - protected UserGO( Transaction pTransaction )
22 - {
19 + protected UserGO( Transaction pTransaction ) {
23 20 super( UserMetaData.INSTANCE, pTransaction );
24 21 mID = getNextSequenceNumber( getClass() );
25 22 registerWithTransaction();
26 23 setDefaults();
27 24 }
28 25
29 - protected UserGO( ConstructionControl pConstructionControl )
30 - {
26 + protected UserGO( ConstructionControl pConstructionControl ) {
31 27 super( UserMetaData.INSTANCE, CONSTRUCTION_CONTROL, pConstructionControl );
32 28 }
33 29
  @@ -35,22 +31,18 @@
35 31
36 32 protected final RecordVersionHelper mRecordVersion = new RecordVersionHelper();
37 33
38 - public Long getRecordVersion()
39 - {
34 + public Long getRecordVersion() {
40 35 return mRecordVersion.getRecordVersion();
41 36 }
42 37
43 38 private static class AttributeAccessor_RecordVersion
44 - extends AttributeAccessorSCD_RecordVersion<User>
45 - {
46 - public AttributeAccessor_RecordVersion()
47 - {
39 + extends AttributeAccessorSCD_RecordVersion<User> {
40 + public AttributeAccessor_RecordVersion() {
48 41 super( "RecordVersion", "RecordVersion" );
49 42 }
50 43
51 44 @Override
52 - protected RecordVersionHelper getRecordVersionHelper( User pPO )
53 - {
45 + protected RecordVersionHelper getRecordVersionHelper( User pPO ) {
54 46 return pPO.mRecordVersion;
55 47 }
56 48 }
  @@ -59,35 +51,29 @@
59 51
60 52 private Long mID;
61 53
62 - public Long getID()
63 - {
54 + public Long getID() {
64 55 return mID;
65 56 }
66 57
67 - protected void LLsetID( Long pID )
68 - {
58 + protected void LLsetID( Long pID ) {
69 59 verifyMutability( CD_ID, mID, pID );
70 60 mID = pID;
71 61 }
72 62
73 63 private static class AttributeAccessor_ID
74 64 extends AttributeAccessorSCDsimplePersistedSysSetOnly<User>
75 - implements NonImportableFeature
76 - {
77 - public AttributeAccessor_ID()
78 - {
65 + implements NonImportableFeature {
66 + public AttributeAccessor_ID() {
79 67 super( "ID", "ID", false, _Long.AddOnly() );
80 68 }
81 69
82 70 @Override
83 - public Object getValueOnPO( User pPO )
84 - {
71 + public Object getValueOnPO( User pPO ) {
85 72 return pPO.getID();
86 73 }
87 74
88 75 @Override
89 - public void db_setValueOnPO( User pPO, Object pValue )
90 - {
76 + public void db_setValueOnPO( User pPO, Object pValue ) {
91 77 pPO.LLsetID( to_Long( pValue ) );
92 78 }
93 79 }
  @@ -96,73 +82,62 @@
96 82
97 83 private Boolean mActive;
98 84
99 - public Boolean getActive()
100 - {
85 + public Boolean getActive() {
101 86 return mActive;
102 87 }
103 88
104 - public void setActive( Boolean pActive )
105 - {
89 + public void setActive( Boolean pActive ) {
106 90 verifyMutability( CD_Active, mActive, pActive );
107 91 mActive = pActive;
108 92 }
109 93
110 94 private static class AttributeAccessor_Active
111 - extends AttributeAccessorSCDsimplePersistedRegular<User>
112 - {
113 - public AttributeAccessor_Active()
114 - {
95 + extends AttributeAccessorSCDsimplePersistedRegular<User> {
96 + public AttributeAccessor_Active() {
115 97 super( "Active", "Active", true, _Boolean );
116 98 }
117 99
118 100 @Override
119 - public Object getDefault()
120 - {
101 + public Object getDefault() {
121 102 return true;
122 103 }
123 104
124 105 @Override
125 - public Object getValueOnPO( User pPO )
126 - {
106 + public Object getValueOnPO( User pPO ) {
127 107 return pPO.getActive();
128 108 }
129 109
130 110 @Override
131 - public void setValueOnPO( User pPO, Object pValue )
132 - {
111 + public void setValueOnPO( User pPO, Object pValue ) {
133 112 pPO.setActive( to_Boolean( pValue ) );
134 113 }
135 114 }
136 115
137 - public static final AttributeAccessorSCDtoOneVirtual<User,UserXrefRestrictedResource> CD_CurrentRestrictedResource = new AttributeAccessor_CurrentRestrictedResource();
116 + public static final AttributeAccessorSCDtoOneVirtual<User, UserXrefRestrictedResource> CD_CurrentRestrictedResource =
117 + new AttributeAccessor_CurrentRestrictedResource();
138 118
139 119 abstract public UserXrefRestrictedResource getCurrentRestrictedResource();
140 120
141 121 abstract protected void LLclearCurrentRestrictedResource();
142 122
143 123 private static class AttributeAccessor_CurrentRestrictedResource
144 - extends AttributeAccessorSCDtoOneVirtual<User,UserXrefRestrictedResource>
145 - {
146 - public AttributeAccessor_CurrentRestrictedResource()
147 - {
124 + extends AttributeAccessorSCDtoOneVirtual<User, UserXrefRestrictedResource> {
125 + public AttributeAccessor_CurrentRestrictedResource() {
148 126 super( "CurrentRestrictedResource", UserXrefRestrictedResource.class, false, Mutability.RO );
149 127 }
150 128
151 129 @Override
152 - public Object getValueOnPO( User pPO )
153 - {
130 + public Object getValueOnPO( User pPO ) {
154 131 return pPO.getCurrentRestrictedResource();
155 132 }
156 133
157 134 @Override
158 - public void setValueOnPO( User pPO, Object pValue )
159 - {
135 + public void setValueOnPO( User pPO, Object pValue ) {
160 136 throw new UnsupportedOperationException( "'CurrentRestrictedResource' is Read Only" );
161 137 }
162 138
163 139 @Override
164 - protected void LL_clearVirtualValueOnPO( User pPO )
165 - {
140 + protected void LL_clearVirtualValueOnPO( User pPO ) {
166 141 pPO.LLclearCurrentRestrictedResource();
167 142 }
168 143 }
  @@ -170,29 +145,26 @@
170 145 public static final AttributeAccessorSCD CD_CurrentRestrictedResourceAllowedRoles = new AttributeAccessor_CurrentRestrictedResourceAllowedRoles();
171 146
172 147 /**
173 - * What are the allowed roles for this user at the current RestrictedResource.|Built up from all the relationships (e.g. Owners, Applicant, VendorEmployee, etc.)
148 + * What are the allowed roles for this user at the current RestrictedResource.|Built up from all the relationships (e.g. Owners, Applicant, VendorEmployee,
149 + * etc.)
174 150 */
175 151 abstract public org.litesoft.core.simpletypes.TextLines getCurrentRestrictedResourceAllowedRoles();
176 152
177 153 abstract protected void LLclearCurrentRestrictedResourceAllowedRoles();
178 154
179 155 private static class AttributeAccessor_CurrentRestrictedResourceAllowedRoles
180 - extends AttributeAccessorSCDsimpleVirtualReadOnly<User>
181 - {
182 - public AttributeAccessor_CurrentRestrictedResourceAllowedRoles()
183 - {
156 + extends AttributeAccessorSCDsimpleVirtualReadOnly<User> {
157 + public AttributeAccessor_CurrentRestrictedResourceAllowedRoles() {
184 158 super( "CurrentRestrictedResourceAllowedRoles", false, _TextLines.RO() );
185 159 }
186 160
187 161 @Override
188 - public Object getValueOnPO( User pPO )
189 - {
162 + public Object getValueOnPO( User pPO ) {
190 163 return pPO.getCurrentRestrictedResourceAllowedRoles();
191 164 }
192 165
193 166 @Override
194 - protected void LL_clearVirtualValueOnPO( User pPO )
195 - {
167 + protected void LL_clearVirtualValueOnPO( User pPO ) {
196 168 pPO.LLclearCurrentRestrictedResourceAllowedRoles();
197 169 }
198 170 }
  @@ -204,22 +176,18 @@
204 176 abstract protected void LLclearDemoUser();
205 177
206 178 private static class AttributeAccessor_DemoUser
207 - extends AttributeAccessorSCDsimpleVirtualReadOnly<User>
208 - {
209 - public AttributeAccessor_DemoUser()
210 - {
179 + extends AttributeAccessorSCDsimpleVirtualReadOnly<User> {
180 + public AttributeAccessor_DemoUser() {
211 181 super( "DemoUser", false, _Boolean.RO() );
212 182 }
213 183
214 184 @Override
215 - public Object getValueOnPO( User pPO )
216 - {
185 + public Object getValueOnPO( User pPO ) {
217 186 return pPO.getDemoUser();
218 187 }
219 188
220 189 @Override
221 - protected void LL_clearVirtualValueOnPO( User pPO )
222 - {
190 + protected void LL_clearVirtualValueOnPO( User pPO ) {
223 191 pPO.LLclearDemoUser();
224 192 }
225 193 }
  @@ -228,37 +196,31 @@
228 196
229 197 private String mFirstName;
230 198
231 - public String getFirstName()
232 - {
199 + public String getFirstName() {
233 200 return mFirstName;
234 201 }
235 202
236 - public void setFirstName( String pFirstName )
237 - {
203 + public void setFirstName( String pFirstName ) {
238 204 verifyMutability( CD_FirstName, mFirstName, pFirstName );
239 205 mFirstName = pFirstName;
240 206 }
241 207
242 208 private static class AttributeAccessor_FirstName
243 209 extends AttributeAccessorSCDsimplePersistedRegular<User>
244 - implements CharacterCaseIgnored
245 - {
246 - public AttributeAccessor_FirstName()
247 - {
210 + implements CharacterCaseIgnored {
211 + public AttributeAccessor_FirstName() {
248 212 super( "FirstName", "FirstName", true, _String.with( MaxLength.of( 60 ), //
249 213 DisplayLength.of( 20 ), //
250 214 Case.Ignored ) );
251 215 }
252 216
253 217 @Override
254 - public Object getValueOnPO( User pPO )
255 - {
218 + public Object getValueOnPO( User pPO ) {
256 219 return pPO.getFirstName();
257 220 }
258 221
259 222 @Override
260 - public void setValueOnPO( User pPO, Object pValue )
261 - {
223 + public void setValueOnPO( User pPO, Object pValue ) {
262 224 pPO.setFirstName( to_String( pValue ) );
263 225 }
264 226 }
  @@ -270,23 +232,19 @@
270 232 abstract protected void LLclearFullName();
271 233
272 234 private static class AttributeAccessor_FullName
273 - extends AttributeAccessorSCDsimpleVirtualReadOnly<User>
274 - {
275 - public AttributeAccessor_FullName()
276 - {
235 + extends AttributeAccessorSCDsimpleVirtualReadOnly<User> {
236 + public AttributeAccessor_FullName() {
277 237 super( "FullName", false, _String.RO().with( MaxLength.of( 60 ), //
278 238 DisplayLength.of( 40 ) ) );
279 239 }
280 240
281 241 @Override
282 - public Object getValueOnPO( User pPO )
283 - {
242 + public Object getValueOnPO( User pPO ) {
284 243 return pPO.getFullName();
285 244 }
286 245
287 246 @Override
288 - protected void LL_clearVirtualValueOnPO( User pPO )
289 - {
247 + protected void LL_clearVirtualValueOnPO( User pPO ) {
290 248 pPO.LLclearFullName();
291 249 }
292 250 }
  @@ -295,40 +253,33 @@
295 253
296 254 private Boolean mHelpDeskMember;
297 255
298 - public Boolean getHelpDeskMember()
299 - {
256 + public Boolean getHelpDeskMember() {
300 257 return mHelpDeskMember;
301 258 }
302 259
303 - public void setHelpDeskMember( Boolean pHelpDeskMember )
304 - {
260 + public void setHelpDeskMember( Boolean pHelpDeskMember ) {
305 261 verifyMutability( CD_HelpDeskMember, mHelpDeskMember, pHelpDeskMember );
306 262 mHelpDeskMember = pHelpDeskMember;
307 263 }
308 264
309 265 private static class AttributeAccessor_HelpDeskMember
310 - extends AttributeAccessorSCDsimplePersistedRegular<User>
311 - {
312 - public AttributeAccessor_HelpDeskMember()
313 - {
266 + extends AttributeAccessorSCDsimplePersistedRegular<User> {
267 + public AttributeAccessor_HelpDeskMember() {
314 268 super( "HelpDeskMember", "HelpDeskMember", true, _Boolean );
315 269 }
316 270
317 271 @Override
318 - public Object getDefault()
319 - {
272 + public Object getDefault() {
320 273 return false;
321 274 }
322 275
323 276 @Override
324 - public Object getValueOnPO( User pPO )
325 - {
277 + public Object getValueOnPO( User pPO ) {
326 278 return pPO.getHelpDeskMember();
327 279 }
328 280
329 281 @Override
330 - public void setValueOnPO( User pPO, Object pValue )
331 - {
282 + public void setValueOnPO( User pPO, Object pValue ) {
332 283 pPO.setHelpDeskMember( to_Boolean( pValue ) );
333 284 }
334 285 }
  @@ -344,36 +295,30 @@
344 295
345 296 abstract protected void LLsetHexPassword( String pHexPassword );
346 297
347 - public void setHexPassword( String pHexPassword )
348 - {
298 + public void setHexPassword( String pHexPassword ) {
349 299 verifyMutability( CD_HexPassword, getHexPassword(), pHexPassword );
350 - LLsetHexPassword( pHexPassword);
300 + LLsetHexPassword( pHexPassword );
351 301 }
352 302
353 303 private static class AttributeAccessor_HexPassword
354 - extends AttributeAccessorSCDsimpleVirtualRegular<User>
355 - {
356 - public AttributeAccessor_HexPassword()
357 - {
304 + extends AttributeAccessorSCDsimpleVirtualRegular<User> {
305 + public AttributeAccessor_HexPassword() {
358 306 super( "HexPassword", false, _String.with( MaxLength.of( 40 ), //
359 307 DisplayLength.of( 20 ) ) );
360 308 }
361 309
362 310 @Override
363 - public Object getValueOnPO( User pPO )
364 - {
311 + public Object getValueOnPO( User pPO ) {
365 312 return pPO.getHexPassword();
366 313 }
367 314
368 315 @Override
369 - public void setValueOnPO( User pPO, Object pValue )
370 - {
316 + public void setValueOnPO( User pPO, Object pValue ) {
371 317 pPO.setHexPassword( to_String( pValue ) );
372 318 }
373 319
374 320 @Override
375 - protected void LL_clearVirtualValueOnPO( User pPO )
376 - {
321 + protected void LL_clearVirtualValueOnPO( User pPO ) {
377 322 pPO.LLclearHexPassword();
378 323 }
379 324 }
  @@ -382,91 +327,76 @@
382 327
383 328 private String mLastName;
384 329
385 - public String getLastName()
386 - {
330 + public String getLastName() {
387 331 return mLastName;
388 332 }
389 333
390 - public void setLastName( String pLastName )
391 - {
334 + public void setLastName( String pLastName ) {
392 335 verifyMutability( CD_LastName, mLastName, pLastName );
393 336 mLastName = pLastName;
394 337 }
395 338
396 339 private static class AttributeAccessor_LastName
397 340 extends AttributeAccessorSCDsimplePersistedRegular<User>
398 - implements CharacterCaseIgnored
399 - {
400 - public AttributeAccessor_LastName()
401 - {
341 + implements CharacterCaseIgnored {
342 + public AttributeAccessor_LastName() {
402 343 super( "LastName", "LastName", true, _String.with( MaxLength.of( 60 ), //
403 344 DisplayLength.of( 20 ), //
404 345 Case.Ignored ) );
405 346 }
406 347
407 348 @Override
408 - public Object getValueOnPO( User pPO )
409 - {
349 + public Object getValueOnPO( User pPO ) {
410 350 return pPO.getLastName();
411 351 }
412 352
413 353 @Override
414 - public void setValueOnPO( User pPO, Object pValue )
415 - {
354 + public void setValueOnPO( User pPO, Object pValue ) {
416 355 pPO.setLastName( to_String( pValue ) );
417 356 }
418 357 }
419 358
420 - public static final AttributeAccessorSCDtoOneRegular<User,RestrictedResource> CD_LastRestrictedResource = new AttributeAccessor_LastRestrictedResource();
359 + public static final AttributeAccessorSCDtoOneRegular<User, RestrictedResource> CD_LastRestrictedResource = new AttributeAccessor_LastRestrictedResource();
421 360
422 - protected org.litesoft.orsup.lazyload.LazyLoadToOneRegular<User,RestrictedResource> mLastRestrictedResource = //
423 - new org.litesoft.orsup.lazyload.LazyLoadToOneRegular<User,RestrictedResource>( (User) this, CD_LastRestrictedResource );
361 + protected org.litesoft.orsup.lazyload.LazyLoadToOneRegular<User, RestrictedResource> mLastRestrictedResource = //
362 + new org.litesoft.orsup.lazyload.LazyLoadToOneRegular<User, RestrictedResource>( (User) this, CD_LastRestrictedResource );
424 363
425 - public RestrictedResource getLastRestrictedResource()
426 - {
364 + public RestrictedResource getLastRestrictedResource() {
427 365 return processLazyLoadAccess( mLastRestrictedResource );
428 366 }
429 367
430 - public void setLastRestrictedResource( RestrictedResource pLastRestrictedResource )
431 - {
368 + public void setLastRestrictedResource( RestrictedResource pLastRestrictedResource ) {
432 369 processLazyLoadMutation( mLastRestrictedResource, pLastRestrictedResource );
433 370 }
434 371
435 372 private static class AttributeAccessor_LastRestrictedResource
436 - extends AttributeAccessorSCDtoOneRegular<User,RestrictedResource>
437 - {
438 - public AttributeAccessor_LastRestrictedResource()
439 - {
373 + extends AttributeAccessorSCDtoOneRegular<User, RestrictedResource> {
374 + public AttributeAccessor_LastRestrictedResource() {
440 375 super( "LastRestrictedResource", "LastRestrictedResource_id", RestrictedResource.class, "ID", "LastUsers", false, false, Mutability.RW );
441 376 }
442 377
443 378 @Override
444 - public org.litesoft.orsup.lazyload.LazyLoadToOneRegular<User,RestrictedResource> getValueHolder( User pPO )
445 - {
379 + public org.litesoft.orsup.lazyload.LazyLoadToOneRegular<User, RestrictedResource> getValueHolder( User pPO ) {
446 380 return pPO.mLastRestrictedResource;
447 381 }
448 382
449 383 @Override
450 - public Object getValueOnPO( User pPO )
451 - {
384 + public Object getValueOnPO( User pPO ) {
452 385 return pPO.getLastRestrictedResource();
453 386 }
454 387
455 388 @Override
456 - public void setValueOnPO( User pPO, Object pValue )
457 - {
389 + public void setValueOnPO( User pPO, Object pValue ) {
458 390 pPO.setLastRestrictedResource( to_PO( pPO, RestrictedResource.class, pValue ) );
459 391 }
460 392
461 393 @Override
462 - public Object db_getValueOnPO( User pPO )
463 - {
394 + public Object db_getValueOnPO( User pPO ) {
464 395 return pPO.mLastRestrictedResource.db_getValue();
465 396 }
466 397
467 398 @Override
468 - public void db_setValueOnPO( User pPO, Object pValue )
469 - {
399 + public void db_setValueOnPO( User pPO, Object pValue ) {
470 400 pPO.mLastRestrictedResource.db_setValue( to_Long( pValue ) );
471 401 }
472 402 }
  @@ -482,36 +412,30 @@
482 412
483 413 abstract protected void LLsetLastRestrictedResourceRole( String pLastRestrictedResourceRole );
484 414
485 - public void setLastRestrictedResourceRole( String pLastRestrictedResourceRole )
486 - {
415 + public void setLastRestrictedResourceRole( String pLastRestrictedResourceRole ) {
487 416 verifyMutability( CD_LastRestrictedResourceRole, getLastRestrictedResourceRole(), pLastRestrictedResourceRole );
488 - LLsetLastRestrictedResourceRole( pLastRestrictedResourceRole);
417 + LLsetLastRestrictedResourceRole( pLastRestrictedResourceRole );
489 418 }
490 419
491 420 private static class AttributeAccessor_LastRestrictedResourceRole
492 - extends AttributeAccessorSCDsimpleVirtualRegular<User>
493 - {
494 - public AttributeAccessor_LastRestrictedResourceRole()
495 - {
421 + extends AttributeAccessorSCDsimpleVirtualRegular<User> {
422 + public AttributeAccessor_LastRestrictedResourceRole() {
496 423 super( "LastRestrictedResourceRole", false, _String.with( MaxLength.of( 40 ), //
497 424 DisplayLength.of( 20 ) ) );
498 425 }
499 426
500 427 @Override
501 - public Object getValueOnPO( User pPO )
502 - {
428 + public Object getValueOnPO( User pPO ) {
503 429 return pPO.getLastRestrictedResourceRole();
504 430 }
505 431
506 432 @Override
507 - public void setValueOnPO( User pPO, Object pValue )
508 - {
433 + public void setValueOnPO( User pPO, Object pValue ) {
509 434 pPO.setLastRestrictedResourceRole( to_String( pValue ) );
510 435 }
511 436
512 437 @Override
513 - protected void LL_clearVirtualValueOnPO( User pPO )
514 - {
438 + protected void LL_clearVirtualValueOnPO( User pPO ) {
515 439 pPO.LLclearLastRestrictedResourceRole();
516 440 }
517 441 }
  @@ -520,36 +444,30 @@
520 444
521 445 private String mLogonEmail;
522 446
523 - public String getLogonEmail()
524 - {
447 + public String getLogonEmail() {
525 448 return mLogonEmail;
526 449 }
527 450
528 - public void setLogonEmail( String pLogonEmail )
529 - {
451 + public void setLogonEmail( String pLogonEmail ) {
530 452 verifyMutability( CD_LogonEmail, mLogonEmail, pLogonEmail );
531 453 mLogonEmail = pLogonEmail;
532 454 }
533 455
534 456 private static class AttributeAccessor_LogonEmail
535 457 extends AttributeAccessorSCDsimplePersistedRegular<User>
536 - implements CharacterCaseIgnored
537 - {
538 - public AttributeAccessor_LogonEmail()
539 - {
458 + implements CharacterCaseIgnored {
459 + public AttributeAccessor_LogonEmail() {
540 460 super( "LogonEmail", "LogonEmail", true, _String.with( MaxLength.of( 40 ), //
541 461 Case.Ignored ) );
542 462 }
543 463
544 464 @Override
545 - public Object getValueOnPO( User pPO )
546 - {
465 + public Object getValueOnPO( User pPO ) {
547 466 return pPO.getLogonEmail();
548 467 }
549 468
550 469 @Override
551 - public void setValueOnPO( User pPO, Object pValue )
552 - {
470 + public void setValueOnPO( User pPO, Object pValue ) {
553 471 pPO.setLogonEmail( to_String( pValue ) );
554 472 }
555 473 }
  @@ -558,37 +476,31 @@
558 476
559 477 private String mMiddleInitial;
560 478
561 - public String getMiddleInitial()
562 - {
479 + public String getMiddleInitial() {
563 480 return mMiddleInitial;
564 481 }
565 482
566 - public void setMiddleInitial( String pMiddleInitial )
567 - {
483 + public void setMiddleInitial( String pMiddleInitial ) {
568 484 verifyMutability( CD_MiddleInitial, mMiddleInitial, pMiddleInitial );
569 485 mMiddleInitial = pMiddleInitial;
570 486 }
571 487
572 488 private static class AttributeAccessor_MiddleInitial
573 489 extends AttributeAccessorSCDsimplePersistedRegular<User>
574 - implements CharacterCaseIgnored
575 - {
576 - public AttributeAccessor_MiddleInitial()
577 - {
490 + implements CharacterCaseIgnored {
491 + public AttributeAccessor_MiddleInitial() {
578 492 super( "MiddleInitial", "MiddleInitial", false, _String.with( MaxLength.of( 1 ), //
579 493 DisplayLength.of( 2 ), //
580 494 Case.Ignored ) );
581 495 }
582 496
583 497 @Override
584 - public Object getValueOnPO( User pPO )
585 - {
498 + public Object getValueOnPO( User pPO ) {
586 499 return pPO.getMiddleInitial();
587 500 }
588 501
589 502 @Override
590 - public void setValueOnPO( User pPO, Object pValue )
591 - {
503 + public void setValueOnPO( User pPO, Object pValue ) {
592 504 pPO.setMiddleInitial( to_String( pValue ) );
593 505 }
594 506 }
  @@ -597,57 +509,47 @@
597 509
598 510 private String mPassword; // Encrypted
599 511
600 - public String getPassword()
601 - {
512 + public String getPassword() {
602 513 return fromEncrypted( LLgetPassword() );
603 514 }
604 515
605 - public String LLgetPassword()
606 - {
516 + public String LLgetPassword() {
607 517 return mPassword;
608 518 }
609 519
610 - public void setPassword( String pPassword )
611 - {
520 + public void setPassword( String pPassword ) {
612 521 LLsetPassword( toEncrypted( pPassword ) );
613 522 }
614 523
615 - protected void LLsetPassword( String pPassword )
616 - {
524 + protected void LLsetPassword( String pPassword ) {
617 525 verifyMutability( CD_Password, mPassword, pPassword );
618 526 mPassword = pPassword;
619 527 }
620 528
621 529 private static class AttributeAccessor_Password
622 - extends AttributeAccessorSCDsimplePersistedRegular<User>
623 - {
624 - public AttributeAccessor_Password()
625 - {
530 + extends AttributeAccessorSCDsimplePersistedRegular<User> {
531 + public AttributeAccessor_Password() {
626 532 super( "Password", "Password", false, _Password.with( MaxLength.of( 40 ), //
627 533 DisplayLength.of( 20 ) ) );
628 534 }
629 535
630 536 @Override
631 - public Object getValueOnPO( User pPO )
632 - {
537 + public Object getValueOnPO( User pPO ) {
633 538 return pPO.getPassword();
634 539 }
635 540
636 541 @Override
637 - public void setValueOnPO( User pPO, Object pValue )
638 - {
542 + public void setValueOnPO( User pPO, Object pValue ) {
639 543 pPO.setPassword( to_String( pValue ) );
640 544 }
641 545
642 546 @Override
643 - public Object db_getValueOnPO( User pPO )
644 - {
547 + public Object db_getValueOnPO( User pPO ) {
645 548 return pPO.LLgetPassword();
646 549 }
647 550
648 551 @Override
649 - public void db_setValueOnPO( User pPO, Object pValue )
650 - {
552 + public void db_setValueOnPO( User pPO, Object pValue ) {
651 553 pPO.LLsetPassword( to_String( pValue ) );
652 554 }
653 555 }
  @@ -656,37 +558,31 @@
656 558
657 559 private String mPhoneNumber;
658 560
659 - public String getPhoneNumber()
660 - {
561 + public String getPhoneNumber() {
661 562 return mPhoneNumber;
662 563 }
663 564
664 - public void setPhoneNumber( String pPhoneNumber )
665 - {
565 + public void setPhoneNumber( String pPhoneNumber ) {
666 566 verifyMutability( CD_PhoneNumber, mPhoneNumber, pPhoneNumber );
667 567 mPhoneNumber = pPhoneNumber;
668 568 }
669 569
670 570 private static class AttributeAccessor_PhoneNumber
671 571 extends AttributeAccessorSCDsimplePersistedRegular<User>
672 - implements CharacterCaseIgnored
673 - {
674 - public AttributeAccessor_PhoneNumber()
675 - {
572 + implements CharacterCaseIgnored {
573 + public AttributeAccessor_PhoneNumber() {
676 574 super( "PhoneNumber", "PhoneNumber", true, _String.with( MaxLength.of( 40 ), //
677 575 DisplayLength.of( 20 ), //
678 576 Case.Ignored ) );
679 577 }
680 578
681 579 @Override
682 - public Object getValueOnPO( User pPO )
683 - {
580 + public Object getValueOnPO( User pPO ) {
684 581 return pPO.getPhoneNumber();
685 582 }
686 583
687 584 @Override
688 - public void setValueOnPO( User pPO, Object pValue )
689 - {
585 + public void setValueOnPO( User pPO, Object pValue ) {
690 586 pPO.setPhoneNumber( to_String( pValue ) );
691 587 }
692 588 }
  @@ -696,42 +592,36 @@
696 592 private Boolean mResetPassword;
697 593
698 594 /**
699 - * If set than user must change their password on next logon. It is set to false after password is reset.|This is only available to RestrictedResource Managers and Super Admins.
595 + * If set than user must change their password on next logon. It is set to false after password is reset.|This is only available to RestrictedResource
596 + * Managers and Super Admins.
700 597 */
701 - public Boolean getResetPassword()
702 - {
598 + public Boolean getResetPassword() {
703 599 return mResetPassword;
704 600 }
705 601
706 - public void setResetPassword( Boolean pResetPassword )
707 - {
602 + public void setResetPassword( Boolean pResetPassword ) {
708 603 verifyMutability( CD_ResetPassword, mResetPassword, pResetPassword );
709 604 mResetPassword = pResetPassword;
710 605 }
711 606
712 607 private static class AttributeAccessor_ResetPassword
713 - extends AttributeAccessorSCDsimplePersistedRegular<User>
714 - {
715 - public AttributeAccessor_ResetPassword()
716 - {
608 + extends AttributeAccessorSCDsimplePersistedRegular<User> {
609 + public AttributeAccessor_ResetPassword() {
717 610 super( "ResetPassword", "ResetPassword", true, _Boolean );
718 611 }
719 612
720 613 @Override
721 - public Object getDefault()
722 - {
614 + public Object getDefault() {
723 615 return false;
724 616 }
725 617
726 618 @Override
727 - public Object getValueOnPO( User pPO )
728 - {
619 + public Object getValueOnPO( User pPO ) {
729 620 return pPO.getResetPassword();
730 621 }
731 622
732 623 @Override
733 - public void setValueOnPO( User pPO, Object pValue )
734 - {
624 + public void setValueOnPO( User pPO, Object pValue ) {
735 625 pPO.setResetPassword( to_Boolean( pValue ) );
736 626 }
737 627 }
  @@ -743,40 +633,33 @@
743 633 /**
744 634 * Manage (create, delete ) RestrictedResources & create RestrictedResource Administrators & all rights of a RestrictedResource Administrator.
745 635 */
746 - public Boolean getRestrictedResourceManage()
747 - {
636 + public Boolean getRestrictedResourceManage() {
748 637 return mRestrictedResourceManage;
749 638 }
750 639
751 - public void setRestrictedResourceManage( Boolean pRestrictedResourceManage )
752 - {
640 + public void setRestrictedResourceManage( Boolean pRestrictedResourceManage ) {
753 641 verifyMutability( CD_RestrictedResourceManage, mRestrictedResourceManage, pRestrictedResourceManage );
754 642 mRestrictedResourceManage = pRestrictedResourceManage;
755 643 }
756 644
757 645 private static class AttributeAccessor_RestrictedResourceManage
758 - extends AttributeAccessorSCDsimplePersistedRegular<User>
759 - {
760 - public AttributeAccessor_RestrictedResourceManage()
761 - {
646 + extends AttributeAccessorSCDsimplePersistedRegular<User> {
647 + public AttributeAccessor_RestrictedResourceManage() {
762 648 super( "RestrictedResourceManage", "RestrictedResourceManage", true, _Boolean );
763 649 }
764 650
765 651 @Override
766 - public Object getDefault()
767 - {
652 + public Object getDefault() {
768 653 return false;
769 654 }
770 655
771 656 @Override
772 - public Object getValueOnPO( User pPO )
773 - {
657 + public Object getValueOnPO( User pPO ) {
774 658 return pPO.getRestrictedResourceManage();
775 659 }
776 660
777 661 @Override
778 - public void setValueOnPO( User pPO, Object pValue )
779 - {
662 + public void setValueOnPO( User pPO, Object pValue ) {
780 663 pPO.setRestrictedResourceManage( to_Boolean( pValue ) );
781 664 }
782 665 }
  @@ -788,40 +671,33 @@
788 671 /**
789 672 * Can create RestrictedResource Managers & Central Inventory Managers
790 673 */
791 - public Boolean getSuperAdmin()
792 - {
674 + public Boolean getSuperAdmin() {
793 675 return mSuperAdmin;
794 676 }
795 677
796 - public void setSuperAdmin( Boolean pSuperAdmin )
797 - {
678 + public void setSuperAdmin( Boolean pSuperAdmin ) {
798 679 verifyMutability( CD_SuperAdmin, mSuperAdmin, pSuperAdmin );
799 680 mSuperAdmin = pSuperAdmin;
800 681 }
801 682
802 683 private static class AttributeAccessor_SuperAdmin
803 - extends AttributeAccessorSCDsimplePersistedRegular<User>
804 - {
805 - public AttributeAccessor_SuperAdmin()
806 - {
684 + extends AttributeAccessorSCDsimplePersistedRegular<User> {
685 + public AttributeAccessor_SuperAdmin() {
807 686 super( "SuperAdmin", "SuperAdmin", true, _Boolean );
808 687 }
809 688
810 689 @Override
811 - public Object getDefault()
812 - {
690 + public Object getDefault() {
813 691 return false;
814 692 }
815 693
816 694 @Override
817 - public Object getValueOnPO( User pPO )
818 - {
695 + public Object getValueOnPO( User pPO ) {
819 696 return pPO.getSuperAdmin();
820 697 }
821 698
822 699 @Override
823 - public void setValueOnPO( User pPO, Object pValue )
824 - {
700 + public void setValueOnPO( User pPO, Object pValue ) {
825 701 pPO.setSuperAdmin( to_Boolean( pValue ) );
826 702 }
827 703 }
  @@ -834,431 +710,357 @@
834 710
835 711 abstract protected void LLsetVisibleToCurrentRestrictedResource( Boolean pVisibleToCurrentRestrictedResource );
836 712
837 - public void setVisibleToCurrentRestrictedResource( Boolean pVisibleToCurrentRestrictedResource )
838 - {
713 + public void setVisibleToCurrentRestrictedResource( Boolean pVisibleToCurrentRestrictedResource ) {
839 714 verifyMutability( CD_VisibleToCurrentRestrictedResource, getVisibleToCurrentRestrictedResource(), pVisibleToCurrentRestrictedResource );
840 - LLsetVisibleToCurrentRestrictedResource( pVisibleToCurrentRestrictedResource);
715 + LLsetVisibleToCurrentRestrictedResource( pVisibleToCurrentRestrictedResource );
841 716 }
842 717
843 718 private static class AttributeAccessor_VisibleToCurrentRestrictedResource
844 - extends AttributeAccessorSCDsimpleVirtualRegular<User>
845 - {
846 - public AttributeAccessor_VisibleToCurrentRestrictedResource()
847 - {
719 + extends AttributeAccessorSCDsimpleVirtualRegular<User> {
720 + public AttributeAccessor_VisibleToCurrentRestrictedResource() {
848 721 super( "VisibleToCurrentRestrictedResource", false, _Boolean );
849 722 }
850 723
851 724 @Override
852 - public Object getValueOnPO( User pPO )
853 - {
725 + public Object getValueOnPO( User pPO ) {
854 726 return pPO.getVisibleToCurrentRestrictedResource();
855 727 }
856 728
857 729 @Override
858 - public void setValueOnPO( User pPO, Object pValue )
859 - {
730 + public void setValueOnPO( User pPO, Object pValue ) {
860 731 pPO.setVisibleToCurrentRestrictedResource( to_Boolean( pValue ) );
861 732 }
862 733
863 734 @Override
864 - protected void LL_clearVirtualValueOnPO( User pPO )
865 - {
735 + protected void LL_clearVirtualValueOnPO( User pPO ) {
866 736 pPO.LLclearVisibleToCurrentRestrictedResource();
867 737 }
868 738 }
869 739
870 - public static final AttributeAccessorSCDtoManyRegular<User,Task> CD_CreatedTasks = new AttributeAccessor_CreatedTasks();
740 + public static final AttributeAccessorSCDtoManyRegular<User, Task> CD_CreatedTasks = new AttributeAccessor_CreatedTasks();
871 741
872 - protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,Task> mCreatedTasks = //
873 - new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,Task>( (User) this, CD_CreatedTasks );
742 + protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, Task> mCreatedTasks = //
743 + new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, Task>( (User) this, CD_CreatedTasks );
874 744
875 - public java.util.List<Task> getCreatedTasks()
876 - {
745 + public java.util.List<Task> getCreatedTasks() {
877 746 return processLazyLoadAccess( mCreatedTasks );
878 747 }
879 748
880 - public void setCreatedTasks( java.util.List<Task> pCreatedTasks )
881 - {
749 + public void setCreatedTasks( java.util.List<Task> pCreatedTasks ) {
882 750 processLazyLoadMutation( mCreatedTasks, pCreatedTasks );
883 751 }
884 752
885 - public void addCreatedTasks( Task pCreatedTasks )
886 - {
753 + public void addCreatedTasks( Task pCreatedTasks ) {
887 754 processLazyLoadMutationAdd( mCreatedTasks, pCreatedTasks );
888 755 }
889 756
890 - public void removeCreatedTasks( Task pCreatedTasks )
891 - {
757 + public void removeCreatedTasks( Task pCreatedTasks ) {
892 758 processLazyLoadMutationRemove( mCreatedTasks, pCreatedTasks );
893 759 }
894 760
895 761 private static class AttributeAccessor_CreatedTasks
896 - extends AttributeAccessorSCDtoManyRegular<User,Task>
897 - {
898 - public AttributeAccessor_CreatedTasks()
899 - {
762 + extends AttributeAccessorSCDtoManyRegular<User, Task> {
763 + public AttributeAccessor_CreatedTasks() {
900 764 super( "CreatedTasks", "ID", Task.class, "Creator", null, Mutability.RW, false, true );
901 765 }
902 766
903 767 @Override
904 - public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,Task> getValueHolder( User pPO )
905 - {
768 + public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, Task> getValueHolder( User pPO ) {
906 769 return pPO.mCreatedTasks;
907 770 }
908 771
909 772 @Override
910 - public Object getValueOnPO( User pPO )
911 - {
773 + public Object getValueOnPO( User pPO ) {
912 774 return pPO.getCreatedTasks();
913 775 }
914 776
915 777 @Override
916 - public void setValueOnPO( User pPO, Object pValue )
917 - {
778 + public void setValueOnPO( User pPO, Object pValue ) {
918 779 pPO.setCreatedTasks( to_POs( pPO, Task.class, pValue ) );
919 780 }
920 781
921 782 @Override
922 - public void addValueOnPO( User pPO, Object pValue )
923 - {
783 + public void addValueOnPO( User pPO, Object pValue ) {
924 784 pPO.addCreatedTasks( to_PO( pPO, Task.class, pValue ) );
925 785 }
926 786
927 787 @Override
928 - public void removeValueOnPO( User pPO, Object pValue )
929 - {
788 + public void removeValueOnPO( User pPO, Object pValue ) {
930 789 pPO.removeCreatedTasks( to_PO( pPO, Task.class, pValue ) );
931 790 }
932 791 }
933 792
934 - public static final AttributeAccessorSCDtoManyVariable<User,Email> CD_Emails = new AttributeAccessor_Emails();
793 + public static final AttributeAccessorSCDtoManyVariable<User, Email> CD_Emails = new AttributeAccessor_Emails();
935 794
936 - protected org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User,Email> mEmails = //
937 - new org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User,Email>( (User) this, CD_Emails );
795 + protected org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User, Email> mEmails = //
796 + new org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User, Email>( (User) this, CD_Emails );
938 797
939 - public java.util.List<Email> getEmails()
940 - {
798 + public java.util.List<Email> getEmails() {
941 799 return processLazyLoadAccess( mEmails );
942 800 }
943 801
944 - public void setEmails( java.util.List<Email> pEmails )
945 - {
802 + public void setEmails( java.util.List<Email> pEmails ) {
946 803 processLazyLoadMutation( mEmails, pEmails );
947 804 }
948 805
949 - public void addEmails( Email pEmails )
950 - {
806 + public void addEmails( Email pEmails ) {
951 807 processLazyLoadMutationAdd( mEmails, pEmails );
952 808 }
953 809
954 - public void removeEmails( Email pEmails )
955 - {
810 + public void removeEmails( Email pEmails ) {
956 811 processLazyLoadMutationRemove( mEmails, pEmails );
957 812 }
958 813
959 814 private static class AttributeAccessor_Emails
960 - extends AttributeAccessorSCDtoManyVariable<User,Email>
961 - {
962 - public AttributeAccessor_Emails()
963 - {
815 + extends AttributeAccessorSCDtoManyVariable<User, Email> {
816 + public AttributeAccessor_Emails() {
964 817 super( "Emails", Email.class, "Owner", null, true, false, Mutability.RW );
965 818 }
966 819
967 820 @Override
968 - public org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User,Email> getValueHolder( User pPO )
969 - {
821 + public org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User, Email> getValueHolder( User pPO ) {
970 822 return pPO.mEmails;
971 823 }
972 824
973 825 @Override
974 - public Object getValueOnPO( User pPO )
975 - {
826 + public Object getValueOnPO( User pPO ) {
976 827 return pPO.getEmails();
977 828 }
978 829
979 830 @Override
980 - public void setValueOnPO( User pPO, Object pValue )
981 - {
831 + public void setValueOnPO( User pPO, Object pValue ) {
982 832 pPO.setEmails( to_POs( pPO, Email.class, pValue ) );
983 833 }
984 834
985 835 @Override
986 - public void addValueOnPO( User pPO, Object pValue )
987 - {
836 + public void addValueOnPO( User pPO, Object pValue ) {
988 837 pPO.addEmails( to_PO( pPO, Email.class, pValue ) );
989 838 }
990 839
991 840 @Override
992 - public void removeValueOnPO( User pPO, Object pValue )
993 - {
841 + public void removeValueOnPO( User pPO, Object pValue ) {
994 842 pPO.removeEmails( to_PO( pPO, Email.class, pValue ) );
995 843 }
996 844 }
997 845
998 - public static final AttributeAccessorSCDtoManyVariable<User,Phone> CD_Phones = new AttributeAccessor_Phones();
846 + public static final AttributeAccessorSCDtoManyVariable<User, Phone> CD_Phones = new AttributeAccessor_Phones();
999 847
1000 - protected org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User,Phone> mPhones = //
1001 - new org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User,Phone>( (User) this, CD_Phones );
848 + protected org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User, Phone> mPhones = //
849 + new org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User, Phone>( (User) this, CD_Phones );
1002 850
1003 - public java.util.List<Phone> getPhones()
1004 - {
851 + public java.util.List<Phone> getPhones() {
1005 852 return processLazyLoadAccess( mPhones );
1006 853 }
1007 854
1008 - public void setPhones( java.util.List<Phone> pPhones )
1009 - {
855 + public void setPhones( java.util.List<Phone> pPhones ) {
1010 856 processLazyLoadMutation( mPhones, pPhones );
1011 857 }
1012 858
1013 - public void addPhones( Phone pPhones )
1014 - {
859 + public void addPhones( Phone pPhones ) {
1015 860 processLazyLoadMutationAdd( mPhones, pPhones );
1016 861 }
1017 862
1018 - public void removePhones( Phone pPhones )
1019 - {
863 + public void removePhones( Phone pPhones ) {
1020 864 processLazyLoadMutationRemove( mPhones, pPhones );
1021 865 }
1022 866
1023 867 private static class AttributeAccessor_Phones
1024 - extends AttributeAccessorSCDtoManyVariable<User,Phone>
1025 - {
1026 - public AttributeAccessor_Phones()
1027 - {
868 + extends AttributeAccessorSCDtoManyVariable<User, Phone> {
869 + public AttributeAccessor_Phones() {
1028 870 super( "Phones", Phone.class, "Owner", null, true, false, Mutability.RW );
1029 871 }
1030 872
1031 873 @Override
1032 - public org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User,Phone> getValueHolder( User pPO )
1033 - {
874 + public org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User, Phone> getValueHolder( User pPO ) {
1034 875 return pPO.mPhones;
1035 876 }
1036 877
1037 878 @Override
1038 - public Object getValueOnPO( User pPO )
1039 - {
879 + public Object getValueOnPO( User pPO ) {
1040 880 return pPO.getPhones();
1041 881 }
1042 882
1043 883 @Override
1044 - public void setValueOnPO( User pPO, Object pValue )
1045 - {
884 + public void setValueOnPO( User pPO, Object pValue ) {
1046 885 pPO.setPhones( to_POs( pPO, Phone.class, pValue ) );
1047 886 }
1048 887
1049 888 @Override
1050 - public void addValueOnPO( User pPO, Object pValue )
1051 - {
889 + public void addValueOnPO( User pPO, Object pValue ) {
1052 890 pPO.addPhones( to_PO( pPO, Phone.class, pValue ) );
1053 891 }
1054 892
1055 893 @Override
1056 - public void removeValueOnPO( User pPO, Object pValue )
1057 - {
894 + public void removeValueOnPO( User pPO, Object pValue ) {
1058 895 pPO.removePhones( to_PO( pPO, Phone.class, pValue ) );
1059 896 }
1060 897 }
1061 898
1062 - public static final AttributeAccessorSCDtoManyRegular<User,UserXrefRestrictedResource> CD_RestrictedResources = new AttributeAccessor_RestrictedResources();
899 + public static final AttributeAccessorSCDtoManyRegular<User, UserXrefRestrictedResource> CD_RestrictedResources = new AttributeAccessor_RestrictedResources();
1063 900
1064 - protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,UserXrefRestrictedResource> mRestrictedResources = //
1065 - new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,UserXrefRestrictedResource>( (User) this, CD_RestrictedResources );
901 + protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, UserXrefRestrictedResource> mRestrictedResources = //
902 + new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, UserXrefRestrictedResource>( (User) this, CD_RestrictedResources );
1066 903
1067 - public java.util.List<UserXrefRestrictedResource> getRestrictedResources()
1068 - {
904 + public java.util.List<UserXrefRestrictedResource> getRestrictedResources() {
1069 905 return processLazyLoadAccess( mRestrictedResources );
1070 906 }
1071 907
1072 - public void setRestrictedResources( java.util.List<UserXrefRestrictedResource> pRestrictedResources )
1073 - {
908 + public void setRestrictedResources( java.util.List<UserXrefRestrictedResource> pRestrictedResources ) {
1074 909 processLazyLoadMutation( mRestrictedResources, pRestrictedResources );
1075 910 }
1076 911
1077 - public void addRestrictedResources( UserXrefRestrictedResource pRestrictedResources )
1078 - {
912 + public void addRestrictedResources( UserXrefRestrictedResource pRestrictedResources ) {
1079 913 processLazyLoadMutationAdd( mRestrictedResources, pRestrictedResources );
1080 914 }
1081 915
1082 - public void removeRestrictedResources( UserXrefRestrictedResource pRestrictedResources )
1083 - {
916 + public void removeRestrictedResources( UserXrefRestrictedResource pRestrictedResources ) {
1084 917 processLazyLoadMutationRemove( mRestrictedResources, pRestrictedResources );
1085 918 }
1086 919
1087 920 private static class AttributeAccessor_RestrictedResources
1088 - extends AttributeAccessorSCDtoManyRegular<User,UserXrefRestrictedResource>
1089 - {
1090 - public AttributeAccessor_RestrictedResources()
1091 - {
921 + extends AttributeAccessorSCDtoManyRegular<User, UserXrefRestrictedResource> {
922 + public AttributeAccessor_RestrictedResources() {
1092 923 super( "RestrictedResources", "ID", UserXrefRestrictedResource.class, "User", null, Mutability.RW, false, true );
1093 924 }
1094 925
1095 926 @Override
1096 - public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,UserXrefRestrictedResource> getValueHolder( User pPO )
1097 - {
927 + public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, UserXrefRestrictedResource> getValueHolder( User pPO ) {
1098 928 return pPO.mRestrictedResources;
1099 929 }
1100 930
1101 931 @Override
1102 - public Object getValueOnPO( User pPO )
1103 - {
932 + public Object getValueOnPO( User pPO ) {
1104 933 return pPO.getRestrictedResources();
1105 934 }
1106 935
1107 936 @Override
1108 - public void setValueOnPO( User pPO, Object pValue )
1109 - {
937 + public void setValueOnPO( User pPO, Object pValue ) {
1110 938 pPO.setRestrictedResources( to_POs( pPO, UserXrefRestrictedResource.class, pValue ) );
1111 939 }
1112 940
1113 941 @Override
1114 - public void addValueOnPO( User pPO, Object pValue )
1115 - {
942 + public void addValueOnPO( User pPO, Object pValue ) {
1116 943 pPO.addRestrictedResources( to_PO( pPO, UserXrefRestrictedResource.class, pValue ) );
1117 944 }
1118 945
1119 946 @Override
1120 - public void removeValueOnPO( User pPO, Object pValue )
1121 - {
947 + public void removeValueOnPO( User pPO, Object pValue ) {
1122 948 pPO.removeRestrictedResources( to_PO( pPO, UserXrefRestrictedResource.class, pValue ) );
1123 949 }
1124 950 }
1125 951
1126 - public static final AttributeAccessorSCDtoManyRegular<User,Story> CD_Stories = new AttributeAccessor_Stories();
952 + public static final AttributeAccessorSCDtoManyRegular<User, Story> CD_Stories = new AttributeAccessor_Stories();
1127 953
1128 - protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,Story> mStories = //
1129 - new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,Story>( (User) this, CD_Stories );
954 + protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, Story> mStories = //
955 + new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, Story>( (User) this, CD_Stories );
1130 956
1131 - public java.util.List<Story> getStories()
1132 - {
957 + public java.util.List<Story> getStories() {
1133 958 return processLazyLoadAccess( mStories );
1134 959 }
1135 960
1136 - public void setStories( java.util.List<Story> pStories )
1137 - {
961 + public void setStories( java.util.List<Story> pStories ) {
1138 962 processLazyLoadMutation( mStories, pStories );
1139 963 }
1140 964
1141 - public void addStories( Story pStories )
1142 - {
965 + public void addStories( Story pStories ) {
1143 966 processLazyLoadMutationAdd( mStories, pStories );
1144 967 }
1145 968
1146 - public void removeStories( Story pStories )
1147 - {
969 + public void removeStories( Story pStories ) {
1148 970 processLazyLoadMutationRemove( mStories, pStories );
1149 971 }
1150 972
1151 973 private static class AttributeAccessor_Stories
1152 - extends AttributeAccessorSCDtoManyRegular<User,Story>
1153 - {
1154 - public AttributeAccessor_Stories()
1155 - {
974 + extends AttributeAccessorSCDtoManyRegular<User, Story> {
975 + public AttributeAccessor_Stories() {
1156 976 super( "Stories", "ID", Story.class, "Creator", null, Mutability.RW, false, true );
1157 977 }
1158 978
1159 979 @Override
1160 - public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,Story> getValueHolder( User pPO )
1161 - {
980 + public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, Story> getValueHolder( User pPO ) {
1162 981 return pPO.mStories;
1163 982 }
1164 983
1165 984 @Override
1166 - public Object getValueOnPO( User pPO )
1167 - {
985 + public Object getValueOnPO( User pPO ) {
1168 986 return pPO.getStories();
1169 987 }
1170 988
1171 989 @Override
1172 - public void setValueOnPO( User pPO, Object pValue )
1173 - {
990 + public void setValueOnPO( User pPO, Object pValue ) {
1174 991 pPO.setStories( to_POs( pPO, Story.class, pValue ) );
1175 992 }
1176 993
1177 994 @Override
1178 - public void addValueOnPO( User pPO, Object pValue )
1179 - {
995 + public void addValueOnPO( User pPO, Object pValue ) {
1180 996 pPO.addStories( to_PO( pPO, Story.class, pValue ) );
1181 997 }
1182 998
1183 999 @Override
1184 - public void removeValueOnPO( User pPO, Object pValue )
1185 - {
1000 + public void removeValueOnPO( User pPO, Object pValue ) {
1186 1001 pPO.removeStories( to_PO( pPO, Story.class, pValue ) );
1187 1002 }
1188 1003 }
1189 1004
1190 - public static final AttributeAccessorSCDtoManyRegular<User,UserXrefTask> CD_Tasks = new AttributeAccessor_Tasks();
1005 + public static final AttributeAccessorSCDtoManyRegular<User, UserXrefTask> CD_Tasks = new AttributeAccessor_Tasks();
1191 1006
1192 - protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,UserXrefTask> mTasks = //
1193 - new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,UserXrefTask>( (User) this, CD_Tasks );
1007 + protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, UserXrefTask> mTasks = //
1008 + new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, UserXrefTask>( (User) this, CD_Tasks );
1194 1009
1195 - public java.util.List<UserXrefTask> getTasks()
1196 - {
1010 + public java.util.List<UserXrefTask> getTasks() {
1197 1011 return processLazyLoadAccess( mTasks );
1198 1012 }
1199 1013
1200 - public void setTasks( java.util.List<UserXrefTask> pTasks )
1201 - {
1014 + public void setTasks( java.util.List<UserXrefTask> pTasks ) {
1202 1015 processLazyLoadMutation( mTasks, pTasks );
1203 1016 }
1204 1017
1205 - public void addTasks( UserXrefTask pTasks )
1206 - {
1018 + public void addTasks( UserXrefTask pTasks ) {
1207 1019 processLazyLoadMutationAdd( mTasks, pTasks );
1208 1020 }
1209 1021
1210 - public void removeTasks( UserXrefTask pTasks )
1211 - {
1022 + public void removeTasks( UserXrefTask pTasks ) {
1212 1023 processLazyLoadMutationRemove( mTasks, pTasks );
1213 1024 }
1214 1025
1215 1026 private static class AttributeAccessor_Tasks
1216 - extends AttributeAccessorSCDtoManyRegular<User,UserXrefTask>
1217 - {
1218 - public AttributeAccessor_Tasks()
1219 - {
1027 + extends AttributeAccessorSCDtoManyRegular<User, UserXrefTask> {
1028 + public AttributeAccessor_Tasks() {
1220 1029 super( "Tasks", "ID", UserXrefTask.class, "User", null, Mutability.RW, false, true );
1221 1030 }
1222 1031
1223 1032 @Override
1224 - public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,UserXrefTask> getValueHolder( User pPO )
1225 - {
1033 + public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, UserXrefTask> getValueHolder( User pPO ) {
1226 1034 return pPO.mTasks;
1227 1035 }
1228 1036
1229 1037 @Override
1230 - public Object getValueOnPO( User pPO )
1231 - {
1038 + public Object getValueOnPO( User pPO ) {
1232 1039 return pPO.getTasks();
1233 1040 }
1234 1041
1235 1042 @Override
1236 - public void setValueOnPO( User pPO, Object pValue )
1237 - {
1043 + public void setValueOnPO( User pPO, Object pValue ) {
1238 1044 pPO.setTasks( to_POs( pPO, UserXrefTask.class, pValue ) );
1239 1045 }
1240 1046
1241 1047 @Override
1242 - public void addValueOnPO( User pPO, Object pValue )
1243 - {
1048 + public void addValueOnPO( User pPO, Object pValue ) {
1244 1049 pPO.addTasks( to_PO( pPO, UserXrefTask.class, pValue ) );
1245 1050 }
1246 1051
1247 1052 @Override
1248 - public void removeValueOnPO( User pPO, Object pValue )
1249 - {
1053 + public void removeValueOnPO( User pPO, Object pValue ) {
1250 1054 pPO.removeTasks( to_PO( pPO, UserXrefTask.class, pValue ) );
1251 1055 }
1252 1056 }
1253 1057
1254 1058 static class MyMetaData
1255 - extends org.litesoft.orsup.nonpublic.PersistentObjectImplMetaData<User>
1256 - {
1059 + extends org.litesoft.orsup.nonpublic.PersistentObjectImplMetaData<User> {
1257 1060 public static final String OBJECT_NAME = "User";
1258 1061 public static final String TABLE_NAME = "ZUsers";
1259 1062
1260 - MyMetaData()
1261 - {
1063 + MyMetaData() {
1262 1064 super( OBJECT_NAME, TABLE_NAME, new AttributeAccessorKeySet( CD_ID ), //
1263 1065
1264 1066 CD_RecordVersion, /* .......................... */
  @@ -1304,32 +1106,27 @@
1304 1106 }
1305 1107
1306 1108 @Override
1307 - public Class getPOclass()
1308 - {
1109 + public Class getPOclass() {
1309 1110 return User.class;
1310 1111 }
1311 1112
1312 1113 @Override
1313 - public User createNew( Transaction pTransaction )
1314 - {
1114 + public User createNew( Transaction pTransaction ) {
1315 1115 return new User( pTransaction );
1316 1116 }
1317 1117
1318 1118 @Override
1319 - public User createPOfromFinder()
1320 - {
1119 + public User createPOfromFinder() {
1321 1120 return new User( CONSTRUCTION_CONTROL );
1322 1121 }
1323 1122
1324 1123 @Override
1325 - public String getDisplayValueFormat()
1326 - {
1124 + public String getDisplayValueFormat() {
1327 1125 return "${LastName}, ${FirstName} : ${PhoneNumber}";
1328 1126 }
1329 1127
1330 1128 @Override
1331 - public String getRecordVersionAttributeName()
1332 - {
1129 + public String getRecordVersionAttributeName() {
1333 1130 return CD_RecordVersion.getName();
1334 1131 }
1335 1132 }

View View this file contents

History View the full history

Feeds

Commits for /trunk/GWT_Sandbox/InitFrom/src/org/litesoft/initfrom/server/pos/UserGO.java

Need assistance?   Get in touch, or head to our documentation site.