litesoft
Subversion Repository Public Repository

litesoft

URLs

Copy to Clipboard
Explore
Commits

Diff Revisions 625 vs 948 for /trunk/Java/DATT/src/org/litesoft/datt/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,37 +444,31 @@
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( 80 ), //
541 461 DisplayLength.of( 40 ), //
542 462 Case.Ignored ) );
543 463 }
544 464
545 465 @Override
546 - public Object getValueOnPO( User pPO )
547 - {
466 + public Object getValueOnPO( User pPO ) {
548 467 return pPO.getLogonEmail();
549 468 }
550 469
551 470 @Override
552 - public void setValueOnPO( User pPO, Object pValue )
553 - {
471 + public void setValueOnPO( User pPO, Object pValue ) {
554 472 pPO.setLogonEmail( to_String( pValue ) );
555 473 }
556 474 }
  @@ -559,37 +477,31 @@
559 477
560 478 private String mMiddleInitial;
561 479
562 - public String getMiddleInitial()
563 - {
480 + public String getMiddleInitial() {
564 481 return mMiddleInitial;
565 482 }
566 483
567 - public void setMiddleInitial( String pMiddleInitial )
568 - {
484 + public void setMiddleInitial( String pMiddleInitial ) {
569 485 verifyMutability( CD_MiddleInitial, mMiddleInitial, pMiddleInitial );
570 486 mMiddleInitial = pMiddleInitial;
571 487 }
572 488
573 489 private static class AttributeAccessor_MiddleInitial
574 490 extends AttributeAccessorSCDsimplePersistedRegular<User>
575 - implements CharacterCaseIgnored
576 - {
577 - public AttributeAccessor_MiddleInitial()
578 - {
491 + implements CharacterCaseIgnored {
492 + public AttributeAccessor_MiddleInitial() {
579 493 super( "MiddleInitial", "MiddleInitial", false, _String.with( MaxLength.of( 1 ), //
580 494 DisplayLength.of( 2 ), //
581 495 Case.Ignored ) );
582 496 }
583 497
584 498 @Override
585 - public Object getValueOnPO( User pPO )
586 - {
499 + public Object getValueOnPO( User pPO ) {
587 500 return pPO.getMiddleInitial();
588 501 }
589 502
590 503 @Override
591 - public void setValueOnPO( User pPO, Object pValue )
592 - {
504 + public void setValueOnPO( User pPO, Object pValue ) {
593 505 pPO.setMiddleInitial( to_String( pValue ) );
594 506 }
595 507 }
  @@ -598,57 +510,47 @@
598 510
599 511 private String mPassword; // Encrypted
600 512
601 - public String getPassword()
602 - {
513 + public String getPassword() {
603 514 return fromEncrypted( LLgetPassword() );
604 515 }
605 516
606 - public String LLgetPassword()
607 - {
517 + public String LLgetPassword() {
608 518 return mPassword;
609 519 }
610 520
611 - public void setPassword( String pPassword )
612 - {
521 + public void setPassword( String pPassword ) {
613 522 LLsetPassword( toEncrypted( pPassword ) );
614 523 }
615 524
616 - protected void LLsetPassword( String pPassword )
617 - {
525 + protected void LLsetPassword( String pPassword ) {
618 526 verifyMutability( CD_Password, mPassword, pPassword );
619 527 mPassword = pPassword;
620 528 }
621 529
622 530 private static class AttributeAccessor_Password
623 - extends AttributeAccessorSCDsimplePersistedRegular<User>
624 - {
625 - public AttributeAccessor_Password()
626 - {
531 + extends AttributeAccessorSCDsimplePersistedRegular<User> {
532 + public AttributeAccessor_Password() {
627 533 super( "Password", "Password", false, _Password.with( MaxLength.of( 40 ), //
628 534 DisplayLength.of( 20 ) ) );
629 535 }
630 536
631 537 @Override
632 - public Object getValueOnPO( User pPO )
633 - {
538 + public Object getValueOnPO( User pPO ) {
634 539 return pPO.getPassword();
635 540 }
636 541
637 542 @Override
638 - public void setValueOnPO( User pPO, Object pValue )
639 - {
543 + public void setValueOnPO( User pPO, Object pValue ) {
640 544 pPO.setPassword( to_String( pValue ) );
641 545 }
642 546
643 547 @Override
644 - public Object db_getValueOnPO( User pPO )
645 - {
548 + public Object db_getValueOnPO( User pPO ) {
646 549 return pPO.LLgetPassword();
647 550 }
648 551
649 552 @Override
650 - public void db_setValueOnPO( User pPO, Object pValue )
651 - {
553 + public void db_setValueOnPO( User pPO, Object pValue ) {
652 554 pPO.LLsetPassword( to_String( pValue ) );
653 555 }
654 556 }
  @@ -657,37 +559,31 @@
657 559
658 560 private String mPhoneNumber;
659 561
660 - public String getPhoneNumber()
661 - {
562 + public String getPhoneNumber() {
662 563 return mPhoneNumber;
663 564 }
664 565
665 - public void setPhoneNumber( String pPhoneNumber )
666 - {
566 + public void setPhoneNumber( String pPhoneNumber ) {
667 567 verifyMutability( CD_PhoneNumber, mPhoneNumber, pPhoneNumber );
668 568 mPhoneNumber = pPhoneNumber;
669 569 }
670 570
671 571 private static class AttributeAccessor_PhoneNumber
672 572 extends AttributeAccessorSCDsimplePersistedRegular<User>
673 - implements CharacterCaseIgnored
674 - {
675 - public AttributeAccessor_PhoneNumber()
676 - {
573 + implements CharacterCaseIgnored {
574 + public AttributeAccessor_PhoneNumber() {
677 575 super( "PhoneNumber", "PhoneNumber", true, _String.with( MaxLength.of( 40 ), //
678 576 DisplayLength.of( 20 ), //
679 577 Case.Ignored ) );
680 578 }
681 579
682 580 @Override
683 - public Object getValueOnPO( User pPO )
684 - {
581 + public Object getValueOnPO( User pPO ) {
685 582 return pPO.getPhoneNumber();
686 583 }
687 584
688 585 @Override
689 - public void setValueOnPO( User pPO, Object pValue )
690 - {
586 + public void setValueOnPO( User pPO, Object pValue ) {
691 587 pPO.setPhoneNumber( to_String( pValue ) );
692 588 }
693 589 }
  @@ -697,42 +593,36 @@
697 593 private Boolean mResetPassword;
698 594
699 595 /**
700 - * 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.
596 + * 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
597 + * Managers and Super Admins.
701 598 */
702 - public Boolean getResetPassword()
703 - {
599 + public Boolean getResetPassword() {
704 600 return mResetPassword;
705 601 }
706 602
707 - public void setResetPassword( Boolean pResetPassword )
708 - {
603 + public void setResetPassword( Boolean pResetPassword ) {
709 604 verifyMutability( CD_ResetPassword, mResetPassword, pResetPassword );
710 605 mResetPassword = pResetPassword;
711 606 }
712 607
713 608 private static class AttributeAccessor_ResetPassword
714 - extends AttributeAccessorSCDsimplePersistedRegular<User>
715 - {
716 - public AttributeAccessor_ResetPassword()
717 - {
609 + extends AttributeAccessorSCDsimplePersistedRegular<User> {
610 + public AttributeAccessor_ResetPassword() {
718 611 super( "ResetPassword", "ResetPassword", true, _Boolean );
719 612 }
720 613
721 614 @Override
722 - public Object getDefault()
723 - {
615 + public Object getDefault() {
724 616 return false;
725 617 }
726 618
727 619 @Override
728 - public Object getValueOnPO( User pPO )
729 - {
620 + public Object getValueOnPO( User pPO ) {
730 621 return pPO.getResetPassword();
731 622 }
732 623
733 624 @Override
734 - public void setValueOnPO( User pPO, Object pValue )
735 - {
625 + public void setValueOnPO( User pPO, Object pValue ) {
736 626 pPO.setResetPassword( to_Boolean( pValue ) );
737 627 }
738 628 }
  @@ -744,40 +634,33 @@
744 634 /**
745 635 * Manage (create, delete ) RestrictedResources & create RestrictedResource Administrators & all rights of a RestrictedResource Administrator.
746 636 */
747 - public Boolean getRestrictedResourceManage()
748 - {
637 + public Boolean getRestrictedResourceManage() {
749 638 return mRestrictedResourceManage;
750 639 }
751 640
752 - public void setRestrictedResourceManage( Boolean pRestrictedResourceManage )
753 - {
641 + public void setRestrictedResourceManage( Boolean pRestrictedResourceManage ) {
754 642 verifyMutability( CD_RestrictedResourceManage, mRestrictedResourceManage, pRestrictedResourceManage );
755 643 mRestrictedResourceManage = pRestrictedResourceManage;
756 644 }
757 645
758 646 private static class AttributeAccessor_RestrictedResourceManage
759 - extends AttributeAccessorSCDsimplePersistedRegular<User>
760 - {
761 - public AttributeAccessor_RestrictedResourceManage()
762 - {
647 + extends AttributeAccessorSCDsimplePersistedRegular<User> {
648 + public AttributeAccessor_RestrictedResourceManage() {
763 649 super( "RestrictedResourceManage", "RestrictedResourceManage", true, _Boolean );
764 650 }
765 651
766 652 @Override
767 - public Object getDefault()
768 - {
653 + public Object getDefault() {
769 654 return false;
770 655 }
771 656
772 657 @Override
773 - public Object getValueOnPO( User pPO )
774 - {
658 + public Object getValueOnPO( User pPO ) {
775 659 return pPO.getRestrictedResourceManage();
776 660 }
777 661
778 662 @Override
779 - public void setValueOnPO( User pPO, Object pValue )
780 - {
663 + public void setValueOnPO( User pPO, Object pValue ) {
781 664 pPO.setRestrictedResourceManage( to_Boolean( pValue ) );
782 665 }
783 666 }
  @@ -789,40 +672,33 @@
789 672 /**
790 673 * Can create RestrictedResource Managers & Central Inventory Managers
791 674 */
792 - public Boolean getSuperAdmin()
793 - {
675 + public Boolean getSuperAdmin() {
794 676 return mSuperAdmin;
795 677 }
796 678
797 - public void setSuperAdmin( Boolean pSuperAdmin )
798 - {
679 + public void setSuperAdmin( Boolean pSuperAdmin ) {
799 680 verifyMutability( CD_SuperAdmin, mSuperAdmin, pSuperAdmin );
800 681 mSuperAdmin = pSuperAdmin;
801 682 }
802 683
803 684 private static class AttributeAccessor_SuperAdmin
804 - extends AttributeAccessorSCDsimplePersistedRegular<User>
805 - {
806 - public AttributeAccessor_SuperAdmin()
807 - {
685 + extends AttributeAccessorSCDsimplePersistedRegular<User> {
686 + public AttributeAccessor_SuperAdmin() {
808 687 super( "SuperAdmin", "SuperAdmin", true, _Boolean );
809 688 }
810 689
811 690 @Override
812 - public Object getDefault()
813 - {
691 + public Object getDefault() {
814 692 return false;
815 693 }
816 694
817 695 @Override
818 - public Object getValueOnPO( User pPO )
819 - {
696 + public Object getValueOnPO( User pPO ) {
820 697 return pPO.getSuperAdmin();
821 698 }
822 699
823 700 @Override
824 - public void setValueOnPO( User pPO, Object pValue )
825 - {
701 + public void setValueOnPO( User pPO, Object pValue ) {
826 702 pPO.setSuperAdmin( to_Boolean( pValue ) );
827 703 }
828 704 }
  @@ -835,559 +711,463 @@
835 711
836 712 abstract protected void LLsetVisibleToCurrentRestrictedResource( Boolean pVisibleToCurrentRestrictedResource );
837 713
838 - public void setVisibleToCurrentRestrictedResource( Boolean pVisibleToCurrentRestrictedResource )
839 - {
714 + public void setVisibleToCurrentRestrictedResource( Boolean pVisibleToCurrentRestrictedResource ) {
840 715 verifyMutability( CD_VisibleToCurrentRestrictedResource, getVisibleToCurrentRestrictedResource(), pVisibleToCurrentRestrictedResource );
841 - LLsetVisibleToCurrentRestrictedResource( pVisibleToCurrentRestrictedResource);
716 + LLsetVisibleToCurrentRestrictedResource( pVisibleToCurrentRestrictedResource );
842 717 }
843 718
844 719 private static class AttributeAccessor_VisibleToCurrentRestrictedResource
845 - extends AttributeAccessorSCDsimpleVirtualRegular<User>
846 - {
847 - public AttributeAccessor_VisibleToCurrentRestrictedResource()
848 - {
720 + extends AttributeAccessorSCDsimpleVirtualRegular<User> {
721 + public AttributeAccessor_VisibleToCurrentRestrictedResource() {
849 722 super( "VisibleToCurrentRestrictedResource", false, _Boolean );
850 723 }
851 724
852 725 @Override
853 - public Object getValueOnPO( User pPO )
854 - {
726 + public Object getValueOnPO( User pPO ) {
855 727 return pPO.getVisibleToCurrentRestrictedResource();
856 728 }
857 729
858 730 @Override
859 - public void setValueOnPO( User pPO, Object pValue )
860 - {
731 + public void setValueOnPO( User pPO, Object pValue ) {
861 732 pPO.setVisibleToCurrentRestrictedResource( to_Boolean( pValue ) );
862 733 }
863 734
864 735 @Override
865 - protected void LL_clearVirtualValueOnPO( User pPO )
866 - {
736 + protected void LL_clearVirtualValueOnPO( User pPO ) {
867 737 pPO.LLclearVisibleToCurrentRestrictedResource();
868 738 }
869 739 }
870 740
871 - public static final AttributeAccessorSCDtoManyRegular<User,Task> CD_CreatedTasks = new AttributeAccessor_CreatedTasks();
741 + public static final AttributeAccessorSCDtoManyRegular<User, Task> CD_CreatedTasks = new AttributeAccessor_CreatedTasks();
872 742
873 - protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,Task> mCreatedTasks = //
874 - new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,Task>( (User) this, CD_CreatedTasks );
743 + protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, Task> mCreatedTasks = //
744 + new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, Task>( (User) this, CD_CreatedTasks );
875 745
876 - public java.util.List<Task> getCreatedTasks()
877 - {
746 + public java.util.List<Task> getCreatedTasks() {
878 747 return processLazyLoadAccess( mCreatedTasks );
879 748 }
880 749
881 - public void setCreatedTasks( java.util.List<Task> pCreatedTasks )
882 - {
750 + public void setCreatedTasks( java.util.List<Task> pCreatedTasks ) {
883 751 processLazyLoadMutation( mCreatedTasks, pCreatedTasks );
884 752 }
885 753
886 - public void addCreatedTasks( Task pCreatedTasks )
887 - {
754 + public void addCreatedTasks( Task pCreatedTasks ) {
888 755 processLazyLoadMutationAdd( mCreatedTasks, pCreatedTasks );
889 756 }
890 757
891 - public void removeCreatedTasks( Task pCreatedTasks )
892 - {
758 + public void removeCreatedTasks( Task pCreatedTasks ) {
893 759 processLazyLoadMutationRemove( mCreatedTasks, pCreatedTasks );
894 760 }
895 761
896 762 private static class AttributeAccessor_CreatedTasks
897 - extends AttributeAccessorSCDtoManyRegular<User,Task>
898 - {
899 - public AttributeAccessor_CreatedTasks()
900 - {
763 + extends AttributeAccessorSCDtoManyRegular<User, Task> {
764 + public AttributeAccessor_CreatedTasks() {
901 765 super( "CreatedTasks", "ID", Task.class, "Creator", null, Mutability.RW, false, true );
902 766 }
903 767
904 768 @Override
905 - public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,Task> getValueHolder( User pPO )
906 - {
769 + public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, Task> getValueHolder( User pPO ) {
907 770 return pPO.mCreatedTasks;
908 771 }
909 772
910 773 @Override
911 - public Object getValueOnPO( User pPO )
912 - {
774 + public Object getValueOnPO( User pPO ) {
913 775 return pPO.getCreatedTasks();
914 776 }
915 777
916 778 @Override
917 - public void setValueOnPO( User pPO, Object pValue )
918 - {
779 + public void setValueOnPO( User pPO, Object pValue ) {
919 780 pPO.setCreatedTasks( to_POs( pPO, Task.class, pValue ) );
920 781 }
921 782
922 783 @Override
923 - public void addValueOnPO( User pPO, Object pValue )
924 - {
784 + public void addValueOnPO( User pPO, Object pValue ) {
925 785 pPO.addCreatedTasks( to_PO( pPO, Task.class, pValue ) );
926 786 }
927 787
928 788 @Override
929 - public void removeValueOnPO( User pPO, Object pValue )
930 - {
789 + public void removeValueOnPO( User pPO, Object pValue ) {
931 790 pPO.removeCreatedTasks( to_PO( pPO, Task.class, pValue ) );
932 791 }
933 792 }
934 793
935 - public static final AttributeAccessorSCDtoManyVariable<User,Email> CD_Emails = new AttributeAccessor_Emails();
794 + public static final AttributeAccessorSCDtoManyVariable<User, Email> CD_Emails = new AttributeAccessor_Emails();
936 795
937 - protected org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User,Email> mEmails = //
938 - new org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User,Email>( (User) this, CD_Emails );
796 + protected org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User, Email> mEmails = //
797 + new org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User, Email>( (User) this, CD_Emails );
939 798
940 - public java.util.List<Email> getEmails()
941 - {
799 + public java.util.List<Email> getEmails() {
942 800 return processLazyLoadAccess( mEmails );
943 801 }
944 802
945 - public void setEmails( java.util.List<Email> pEmails )
946 - {
803 + public void setEmails( java.util.List<Email> pEmails ) {
947 804 processLazyLoadMutation( mEmails, pEmails );
948 805 }
949 806
950 - public void addEmails( Email pEmails )
951 - {
807 + public void addEmails( Email pEmails ) {
952 808 processLazyLoadMutationAdd( mEmails, pEmails );
953 809 }
954 810
955 - public void removeEmails( Email pEmails )
956 - {
811 + public void removeEmails( Email pEmails ) {
957 812 processLazyLoadMutationRemove( mEmails, pEmails );
958 813 }
959 814
960 815 private static class AttributeAccessor_Emails
961 - extends AttributeAccessorSCDtoManyVariable<User,Email>
962 - {
963 - public AttributeAccessor_Emails()
964 - {
816 + extends AttributeAccessorSCDtoManyVariable<User, Email> {
817 + public AttributeAccessor_Emails() {
965 818 super( "Emails", Email.class, "Owner", null, true, false, Mutability.RW );
966 819 }
967 820
968 821 @Override
969 - public org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User,Email> getValueHolder( User pPO )
970 - {
822 + public org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User, Email> getValueHolder( User pPO ) {
971 823 return pPO.mEmails;
972 824 }
973 825
974 826 @Override
975 - public Object getValueOnPO( User pPO )
976 - {
827 + public Object getValueOnPO( User pPO ) {
977 828 return pPO.getEmails();
978 829 }
979 830
980 831 @Override
981 - public void setValueOnPO( User pPO, Object pValue )
982 - {
832 + public void setValueOnPO( User pPO, Object pValue ) {
983 833 pPO.setEmails( to_POs( pPO, Email.class, pValue ) );
984 834 }
985 835
986 836 @Override
987 - public void addValueOnPO( User pPO, Object pValue )
988 - {
837 + public void addValueOnPO( User pPO, Object pValue ) {
989 838 pPO.addEmails( to_PO( pPO, Email.class, pValue ) );
990 839 }
991 840
992 841 @Override
993 - public void removeValueOnPO( User pPO, Object pValue )
994 - {
842 + public void removeValueOnPO( User pPO, Object pValue ) {
995 843 pPO.removeEmails( to_PO( pPO, Email.class, pValue ) );
996 844 }
997 845 }
998 846
999 - public static final AttributeAccessorSCDtoManyVariable<User,Phone> CD_Phones = new AttributeAccessor_Phones();
847 + public static final AttributeAccessorSCDtoManyVariable<User, Phone> CD_Phones = new AttributeAccessor_Phones();
1000 848
1001 - protected org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User,Phone> mPhones = //
1002 - new org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User,Phone>( (User) this, CD_Phones );
849 + protected org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User, Phone> mPhones = //
850 + new org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User, Phone>( (User) this, CD_Phones );
1003 851
1004 - public java.util.List<Phone> getPhones()
1005 - {
852 + public java.util.List<Phone> getPhones() {
1006 853 return processLazyLoadAccess( mPhones );
1007 854 }
1008 855
1009 - public void setPhones( java.util.List<Phone> pPhones )
1010 - {
856 + public void setPhones( java.util.List<Phone> pPhones ) {
1011 857 processLazyLoadMutation( mPhones, pPhones );
1012 858 }
1013 859
1014 - public void addPhones( Phone pPhones )
1015 - {
860 + public void addPhones( Phone pPhones ) {
1016 861 processLazyLoadMutationAdd( mPhones, pPhones );
1017 862 }
1018 863
1019 - public void removePhones( Phone pPhones )
1020 - {
864 + public void removePhones( Phone pPhones ) {
1021 865 processLazyLoadMutationRemove( mPhones, pPhones );
1022 866 }
1023 867
1024 868 private static class AttributeAccessor_Phones
1025 - extends AttributeAccessorSCDtoManyVariable<User,Phone>
1026 - {
1027 - public AttributeAccessor_Phones()
1028 - {
869 + extends AttributeAccessorSCDtoManyVariable<User, Phone> {
870 + public AttributeAccessor_Phones() {
1029 871 super( "Phones", Phone.class, "Owner", null, true, false, Mutability.RW );
1030 872 }
1031 873
1032 874 @Override
1033 - public org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User,Phone> getValueHolder( User pPO )
1034 - {
875 + public org.litesoft.orsup.lazyload.LazyLoadToManyVariable<User, Phone> getValueHolder( User pPO ) {
1035 876 return pPO.mPhones;
1036 877 }
1037 878
1038 879 @Override
1039 - public Object getValueOnPO( User pPO )
1040 - {
880 + public Object getValueOnPO( User pPO ) {
1041 881 return pPO.getPhones();
1042 882 }
1043 883
1044 884 @Override
1045 - public void setValueOnPO( User pPO, Object pValue )
1046 - {
885 + public void setValueOnPO( User pPO, Object pValue ) {
1047 886 pPO.setPhones( to_POs( pPO, Phone.class, pValue ) );
1048 887 }
1049 888
1050 889 @Override
1051 - public void addValueOnPO( User pPO, Object pValue )
1052 - {
890 + public void addValueOnPO( User pPO, Object pValue ) {
1053 891 pPO.addPhones( to_PO( pPO, Phone.class, pValue ) );
1054 892 }
1055 893
1056 894 @Override
1057 - public void removeValueOnPO( User pPO, Object pValue )
1058 - {
895 + public void removeValueOnPO( User pPO, Object pValue ) {
1059 896 pPO.removePhones( to_PO( pPO, Phone.class, pValue ) );
1060 897 }
1061 898 }
1062 899
1063 - public static final AttributeAccessorSCDtoManyRegular<User,RestrictedResource> CD_PrimaryOwnedResources = new AttributeAccessor_PrimaryOwnedResources();
900 + public static final AttributeAccessorSCDtoManyRegular<User, RestrictedResource> CD_PrimaryOwnedResources = new AttributeAccessor_PrimaryOwnedResources();
1064 901
1065 - protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,RestrictedResource> mPrimaryOwnedResources = //
1066 - new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,RestrictedResource>( (User) this, CD_PrimaryOwnedResources );
902 + protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, RestrictedResource> mPrimaryOwnedResources = //
903 + new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, RestrictedResource>( (User) this, CD_PrimaryOwnedResources );
1067 904
1068 - public java.util.List<RestrictedResource> getPrimaryOwnedResources()
1069 - {
905 + public java.util.List<RestrictedResource> getPrimaryOwnedResources() {
1070 906 return processLazyLoadAccess( mPrimaryOwnedResources );
1071 907 }
1072 908
1073 - public void setPrimaryOwnedResources( java.util.List<RestrictedResource> pPrimaryOwnedResources )
1074 - {
909 + public void setPrimaryOwnedResources( java.util.List<RestrictedResource> pPrimaryOwnedResources ) {
1075 910 processLazyLoadMutation( mPrimaryOwnedResources, pPrimaryOwnedResources );
1076 911 }
1077 912
1078 - public void addPrimaryOwnedResources( RestrictedResource pPrimaryOwnedResources )
1079 - {
913 + public void addPrimaryOwnedResources( RestrictedResource pPrimaryOwnedResources ) {
1080 914 processLazyLoadMutationAdd( mPrimaryOwnedResources, pPrimaryOwnedResources );
1081 915 }
1082 916
1083 - public void removePrimaryOwnedResources( RestrictedResource pPrimaryOwnedResources )
1084 - {
917 + public void removePrimaryOwnedResources( RestrictedResource pPrimaryOwnedResources ) {
1085 918 processLazyLoadMutationRemove( mPrimaryOwnedResources, pPrimaryOwnedResources );
1086 919 }
1087 920
1088 921 private static class AttributeAccessor_PrimaryOwnedResources
1089 - extends AttributeAccessorSCDtoManyRegular<User,RestrictedResource>
1090 - {
1091 - public AttributeAccessor_PrimaryOwnedResources()
1092 - {
922 + extends AttributeAccessorSCDtoManyRegular<User, RestrictedResource> {
923 + public AttributeAccessor_PrimaryOwnedResources() {
1093 924 super( "PrimaryOwnedResources", "ID", RestrictedResource.class, "PrimaryOwner", null, Mutability.RW, false, true );
1094 925 }
1095 926
1096 927 @Override
1097 - public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,RestrictedResource> getValueHolder( User pPO )
1098 - {
928 + public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, RestrictedResource> getValueHolder( User pPO ) {
1099 929 return pPO.mPrimaryOwnedResources;
1100 930 }
1101 931
1102 932 @Override
1103 - public Object getValueOnPO( User pPO )
1104 - {
933 + public Object getValueOnPO( User pPO ) {
1105 934 return pPO.getPrimaryOwnedResources();
1106 935 }
1107 936
1108 937 @Override
1109 - public void setValueOnPO( User pPO, Object pValue )
1110 - {
938 + public void setValueOnPO( User pPO, Object pValue ) {
1111 939 pPO.setPrimaryOwnedResources( to_POs( pPO, RestrictedResource.class, pValue ) );
1112 940 }
1113 941
1114 942 @Override
1115 - public void addValueOnPO( User pPO, Object pValue )
1116 - {
943 + public void addValueOnPO( User pPO, Object pValue ) {
1117 944 pPO.addPrimaryOwnedResources( to_PO( pPO, RestrictedResource.class, pValue ) );
1118 945 }
1119 946
1120 947 @Override
1121 - public void removeValueOnPO( User pPO, Object pValue )
1122 - {
948 + public void removeValueOnPO( User pPO, Object pValue ) {
1123 949 pPO.removePrimaryOwnedResources( to_PO( pPO, RestrictedResource.class, pValue ) );
1124 950 }
1125 951 }
1126 952
1127 - public static final AttributeAccessorSCDtoManyRegular<User,UserXrefRestrictedResource> CD_RestrictedResources = new AttributeAccessor_RestrictedResources();
953 + public static final AttributeAccessorSCDtoManyRegular<User, UserXrefRestrictedResource> CD_RestrictedResources = new AttributeAccessor_RestrictedResources();
1128 954
1129 - protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,UserXrefRestrictedResource> mRestrictedResources = //
1130 - new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,UserXrefRestrictedResource>( (User) this, CD_RestrictedResources );
955 + protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, UserXrefRestrictedResource> mRestrictedResources = //
956 + new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, UserXrefRestrictedResource>( (User) this, CD_RestrictedResources );
1131 957
1132 - public java.util.List<UserXrefRestrictedResource> getRestrictedResources()
1133 - {
958 + public java.util.List<UserXrefRestrictedResource> getRestrictedResources() {
1134 959 return processLazyLoadAccess( mRestrictedResources );
1135 960 }
1136 961
1137 - public void setRestrictedResources( java.util.List<UserXrefRestrictedResource> pRestrictedResources )
1138 - {
962 + public void setRestrictedResources( java.util.List<UserXrefRestrictedResource> pRestrictedResources ) {
1139 963 processLazyLoadMutation( mRestrictedResources, pRestrictedResources );
1140 964 }
1141 965
1142 - public void addRestrictedResources( UserXrefRestrictedResource pRestrictedResources )
1143 - {
966 + public void addRestrictedResources( UserXrefRestrictedResource pRestrictedResources ) {
1144 967 processLazyLoadMutationAdd( mRestrictedResources, pRestrictedResources );
1145 968 }
1146 969
1147 - public void removeRestrictedResources( UserXrefRestrictedResource pRestrictedResources )
1148 - {
970 + public void removeRestrictedResources( UserXrefRestrictedResource pRestrictedResources ) {
1149 971 processLazyLoadMutationRemove( mRestrictedResources, pRestrictedResources );
1150 972 }
1151 973
1152 974 private static class AttributeAccessor_RestrictedResources
1153 - extends AttributeAccessorSCDtoManyRegular<User,UserXrefRestrictedResource>
1154 - {
1155 - public AttributeAccessor_RestrictedResources()
1156 - {
975 + extends AttributeAccessorSCDtoManyRegular<User, UserXrefRestrictedResource> {
976 + public AttributeAccessor_RestrictedResources() {
1157 977 super( "RestrictedResources", "ID", UserXrefRestrictedResource.class, "User", null, Mutability.RW, false, true );
1158 978 }
1159 979
1160 980 @Override
1161 - public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,UserXrefRestrictedResource> getValueHolder( User pPO )
1162 - {
981 + public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, UserXrefRestrictedResource> getValueHolder( User pPO ) {
1163 982 return pPO.mRestrictedResources;
1164 983 }
1165 984
1166 985 @Override
1167 - public Object getValueOnPO( User pPO )
1168 - {
986 + public Object getValueOnPO( User pPO ) {
1169 987 return pPO.getRestrictedResources();
1170 988 }
1171 989
1172 990 @Override
1173 - public void setValueOnPO( User pPO, Object pValue )
1174 - {
991 + public void setValueOnPO( User pPO, Object pValue ) {
1175 992 pPO.setRestrictedResources( to_POs( pPO, UserXrefRestrictedResource.class, pValue ) );
1176 993 }
1177 994
1178 995 @Override
1179 - public void addValueOnPO( User pPO, Object pValue )
1180 - {
996 + public void addValueOnPO( User pPO, Object pValue ) {
1181 997 pPO.addRestrictedResources( to_PO( pPO, UserXrefRestrictedResource.class, pValue ) );
1182 998 }
1183 999
1184 1000 @Override
1185 - public void removeValueOnPO( User pPO, Object pValue )
1186 - {
1001 + public void removeValueOnPO( User pPO, Object pValue ) {
1187 1002 pPO.removeRestrictedResources( to_PO( pPO, UserXrefRestrictedResource.class, pValue ) );
1188 1003 }
1189 1004 }
1190 1005
1191 - public static final AttributeAccessorSCDtoManyRegular<User,Story> CD_Stories = new AttributeAccessor_Stories();
1006 + public static final AttributeAccessorSCDtoManyRegular<User, Story> CD_Stories = new AttributeAccessor_Stories();
1192 1007
1193 - protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,Story> mStories = //
1194 - new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,Story>( (User) this, CD_Stories );
1008 + protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, Story> mStories = //
1009 + new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, Story>( (User) this, CD_Stories );
1195 1010
1196 - public java.util.List<Story> getStories()
1197 - {
1011 + public java.util.List<Story> getStories() {
1198 1012 return processLazyLoadAccess( mStories );
1199 1013 }
1200 1014
1201 - public void setStories( java.util.List<Story> pStories )
1202 - {
1015 + public void setStories( java.util.List<Story> pStories ) {
1203 1016 processLazyLoadMutation( mStories, pStories );
1204 1017 }
1205 1018
1206 - public void addStories( Story pStories )
1207 - {
1019 + public void addStories( Story pStories ) {
1208 1020 processLazyLoadMutationAdd( mStories, pStories );
1209 1021 }
1210 1022
1211 - public void removeStories( Story pStories )
1212 - {
1023 + public void removeStories( Story pStories ) {
1213 1024 processLazyLoadMutationRemove( mStories, pStories );
1214 1025 }
1215 1026
1216 1027 private static class AttributeAccessor_Stories
1217 - extends AttributeAccessorSCDtoManyRegular<User,Story>
1218 - {
1219 - public AttributeAccessor_Stories()
1220 - {
1028 + extends AttributeAccessorSCDtoManyRegular<User, Story> {
1029 + public AttributeAccessor_Stories() {
1221 1030 super( "Stories", "ID", Story.class, "Creator", null, Mutability.RW, false, true );
1222 1031 }
1223 1032
1224 1033 @Override
1225 - public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,Story> getValueHolder( User pPO )
1226 - {
1034 + public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, Story> getValueHolder( User pPO ) {
1227 1035 return pPO.mStories;
1228 1036 }
1229 1037
1230 1038 @Override
1231 - public Object getValueOnPO( User pPO )
1232 - {
1039 + public Object getValueOnPO( User pPO ) {
1233 1040 return pPO.getStories();
1234 1041 }
1235 1042
1236 1043 @Override
1237 - public void setValueOnPO( User pPO, Object pValue )
1238 - {
1044 + public void setValueOnPO( User pPO, Object pValue ) {
1239 1045 pPO.setStories( to_POs( pPO, Story.class, pValue ) );
1240 1046 }
1241 1047
1242 1048 @Override
1243 - public void addValueOnPO( User pPO, Object pValue )
1244 - {
1049 + public void addValueOnPO( User pPO, Object pValue ) {
1245 1050 pPO.addStories( to_PO( pPO, Story.class, pValue ) );
1246 1051 }
1247 1052
1248 1053 @Override
1249 - public void removeValueOnPO( User pPO, Object pValue )
1250 - {
1054 + public void removeValueOnPO( User pPO, Object pValue ) {
1251 1055 pPO.removeStories( to_PO( pPO, Story.class, pValue ) );
1252 1056 }
1253 1057 }
1254 1058
1255 - public static final AttributeAccessorSCDtoManyRegular<User,StoryUpdate> CD_StoryUpdates = new AttributeAccessor_StoryUpdates();
1059 + public static final AttributeAccessorSCDtoManyRegular<User, StoryUpdate> CD_StoryUpdates = new AttributeAccessor_StoryUpdates();
1256 1060
1257 - protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,StoryUpdate> mStoryUpdates = //
1258 - new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,StoryUpdate>( (User) this, CD_StoryUpdates );
1061 + protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, StoryUpdate> mStoryUpdates = //
1062 + new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, StoryUpdate>( (User) this, CD_StoryUpdates );
1259 1063
1260 - public java.util.List<StoryUpdate> getStoryUpdates()
1261 - {
1064 + public java.util.List<StoryUpdate> getStoryUpdates() {
1262 1065 return processLazyLoadAccess( mStoryUpdates );
1263 1066 }
1264 1067
1265 - public void setStoryUpdates( java.util.List<StoryUpdate> pStoryUpdates )
1266 - {
1068 + public void setStoryUpdates( java.util.List<StoryUpdate> pStoryUpdates ) {
1267 1069 processLazyLoadMutation( mStoryUpdates, pStoryUpdates );
1268 1070 }
1269 1071
1270 - public void addStoryUpdates( StoryUpdate pStoryUpdates )
1271 - {
1072 + public void addStoryUpdates( StoryUpdate pStoryUpdates ) {
1272 1073 processLazyLoadMutationAdd( mStoryUpdates, pStoryUpdates );
1273 1074 }
1274 1075
1275 - public void removeStoryUpdates( StoryUpdate pStoryUpdates )
1276 - {
1076 + public void removeStoryUpdates( StoryUpdate pStoryUpdates ) {
1277 1077 processLazyLoadMutationRemove( mStoryUpdates, pStoryUpdates );
1278 1078 }
1279 1079
1280 1080 private static class AttributeAccessor_StoryUpdates
1281 - extends AttributeAccessorSCDtoManyRegular<User,StoryUpdate>
1282 - {
1283 - public AttributeAccessor_StoryUpdates()
1284 - {
1081 + extends AttributeAccessorSCDtoManyRegular<User, StoryUpdate> {
1082 + public AttributeAccessor_StoryUpdates() {
1285 1083 super( "StoryUpdates", "ID", StoryUpdate.class, "ByWhom", null, Mutability.RW, false, true );
1286 1084 }
1287 1085
1288 1086 @Override
1289 - public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,StoryUpdate> getValueHolder( User pPO )
1290 - {
1087 + public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, StoryUpdate> getValueHolder( User pPO ) {
1291 1088 return pPO.mStoryUpdates;
1292 1089 }
1293 1090
1294 1091 @Override
1295 - public Object getValueOnPO( User pPO )
1296 - {
1092 + public Object getValueOnPO( User pPO ) {
1297 1093 return pPO.getStoryUpdates();
1298 1094 }
1299 1095
1300 1096 @Override
1301 - public void setValueOnPO( User pPO, Object pValue )
1302 - {
1097 + public void setValueOnPO( User pPO, Object pValue ) {
1303 1098 pPO.setStoryUpdates( to_POs( pPO, StoryUpdate.class, pValue ) );
1304 1099 }
1305 1100
1306 1101 @Override
1307 - public void addValueOnPO( User pPO, Object pValue )
1308 - {
1102 + public void addValueOnPO( User pPO, Object pValue ) {
1309 1103 pPO.addStoryUpdates( to_PO( pPO, StoryUpdate.class, pValue ) );
1310 1104 }
1311 1105
1312 1106 @Override
1313 - public void removeValueOnPO( User pPO, Object pValue )
1314 - {
1107 + public void removeValueOnPO( User pPO, Object pValue ) {
1315 1108 pPO.removeStoryUpdates( to_PO( pPO, StoryUpdate.class, pValue ) );
1316 1109 }
1317 1110 }
1318 1111
1319 - public static final AttributeAccessorSCDtoManyRegular<User,UserXrefTask> CD_Tasks = new AttributeAccessor_Tasks();
1112 + public static final AttributeAccessorSCDtoManyRegular<User, UserXrefTask> CD_Tasks = new AttributeAccessor_Tasks();
1320 1113
1321 - protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,UserXrefTask> mTasks = //
1322 - new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,UserXrefTask>( (User) this, CD_Tasks );
1114 + protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, UserXrefTask> mTasks = //
1115 + new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, UserXrefTask>( (User) this, CD_Tasks );
1323 1116
1324 - public java.util.List<UserXrefTask> getTasks()
1325 - {
1117 + public java.util.List<UserXrefTask> getTasks() {
1326 1118 return processLazyLoadAccess( mTasks );
1327 1119 }
1328 1120
1329 - public void setTasks( java.util.List<UserXrefTask> pTasks )
1330 - {
1121 + public void setTasks( java.util.List<UserXrefTask> pTasks ) {
1331 1122 processLazyLoadMutation( mTasks, pTasks );
1332 1123 }
1333 1124
1334 - public void addTasks( UserXrefTask pTasks )
1335 - {
1125 + public void addTasks( UserXrefTask pTasks ) {
1336 1126 processLazyLoadMutationAdd( mTasks, pTasks );
1337 1127 }
1338 1128
1339 - public void removeTasks( UserXrefTask pTasks )
1340 - {
1129 + public void removeTasks( UserXrefTask pTasks ) {
1341 1130 processLazyLoadMutationRemove( mTasks, pTasks );
1342 1131 }
1343 1132
1344 1133 private static class AttributeAccessor_Tasks
1345 - extends AttributeAccessorSCDtoManyRegular<User,UserXrefTask>
1346 - {
1347 - public AttributeAccessor_Tasks()
1348 - {
1134 + extends AttributeAccessorSCDtoManyRegular<User, UserXrefTask> {
1135 + public AttributeAccessor_Tasks() {
1349 1136 super( "Tasks", "ID", UserXrefTask.class, "User", null, Mutability.RW, false, true );
1350 1137 }
1351 1138
1352 1139 @Override
1353 - public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User,UserXrefTask> getValueHolder( User pPO )
1354 - {
1140 + public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<User, UserXrefTask> getValueHolder( User pPO ) {
1355 1141 return pPO.mTasks;
1356 1142 }
1357 1143
1358 1144 @Override
1359 - public Object getValueOnPO( User pPO )
1360 - {
1145 + public Object getValueOnPO( User pPO ) {
1361 1146 return pPO.getTasks();
1362 1147 }
1363 1148
1364 1149 @Override
1365 - public void setValueOnPO( User pPO, Object pValue )
1366 - {
1150 + public void setValueOnPO( User pPO, Object pValue ) {
1367 1151 pPO.setTasks( to_POs( pPO, UserXrefTask.class, pValue ) );
1368 1152 }
1369 1153
1370 1154 @Override
1371 - public void addValueOnPO( User pPO, Object pValue )
1372 - {
1155 + public void addValueOnPO( User pPO, Object pValue ) {
1373 1156 pPO.addTasks( to_PO( pPO, UserXrefTask.class, pValue ) );
1374 1157 }
1375 1158
1376 1159 @Override
1377 - public void removeValueOnPO( User pPO, Object pValue )
1378 - {
1160 + public void removeValueOnPO( User pPO, Object pValue ) {
1379 1161 pPO.removeTasks( to_PO( pPO, UserXrefTask.class, pValue ) );
1380 1162 }
1381 1163 }
1382 1164
1383 1165 static class MyMetaData
1384 - extends org.litesoft.orsup.nonpublic.PersistentObjectImplMetaData<User>
1385 - {
1166 + extends org.litesoft.orsup.nonpublic.PersistentObjectImplMetaData<User> {
1386 1167 public static final String OBJECT_NAME = "User";
1387 1168 public static final String TABLE_NAME = "ZUsers";
1388 1169
1389 - MyMetaData()
1390 - {
1170 + MyMetaData() {
1391 1171 super( OBJECT_NAME, TABLE_NAME, new AttributeAccessorKeySet( CD_ID ), //
1392 1172
1393 1173 CD_RecordVersion, /* .......................... */
  @@ -1435,32 +1215,27 @@
1435 1215 }
1436 1216
1437 1217 @Override
1438 - public Class getPOclass()
1439 - {
1218 + public Class getPOclass() {
1440 1219 return User.class;
1441 1220 }
1442 1221
1443 1222 @Override
1444 - public User createNew( Transaction pTransaction )
1445 - {
1223 + public User createNew( Transaction pTransaction ) {
1446 1224 return new User( pTransaction );
1447 1225 }
1448 1226
1449 1227 @Override
1450 - public User createPOfromFinder()
1451 - {
1228 + public User createPOfromFinder() {
1452 1229 return new User( CONSTRUCTION_CONTROL );
1453 1230 }
1454 1231
1455 1232 @Override
1456 - public String getDisplayValueFormat()
1457 - {
1233 + public String getDisplayValueFormat() {
1458 1234 return "${LastName}, ${FirstName} : ${PhoneNumber}";
1459 1235 }
1460 1236
1461 1237 @Override
1462 - public String getRecordVersionAttributeName()
1463 - {
1238 + public String getRecordVersionAttributeName() {
1464 1239 return CD_RecordVersion.getName();
1465 1240 }
1466 1241 }

View View this file contents

History View the full history

Feeds

Commits for /trunk/Java/DATT/src/org/litesoft/datt/server/pos/UserGO.java

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