Experiments/Attic/Generator/Castle.ActiveRecord.Generator.Components/RelationshipInferenceService.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.ActiveRecord.Generator.Components
  16 {
  17         using System;
  18         using System.Collections;
  19
  20         using Castle.ActiveRecord.Generator.Components.Database;
  21
  22
  23         public class RelationshipInferenceService : IRelationshipInferenceService
  24         {
  25                 private INamingService _namingService;
  26
  27                 public RelationshipInferenceService(INamingService namingService)
  28                 {
  29                         _namingService = namingService;
  30                 }
  31
  32                 #region IRelationShipInferenceService Members
  33
  34                 public ActiveRecordPropertyRelationDescriptor[] InferRelations(ActiveRecordDescriptor desc,
  35                         TableDefinition tableDef, BuildContext context)
  36                 {
  37                         if (desc == null) throw new ArgumentNullException("desc");
  38                         if (tableDef == null) throw new ArgumentNullException("tableDef");
  39                         if (context == null) throw new ArgumentNullException("context");
  40 //                      if (tableDef.RelatedDescriptor != null && tableDef.RelatedDescriptor != desc) {
  41 //                              throw new ArgumentException("Different descriptors");
  42 //                      }
  43
  44                         ArrayList list = new ArrayList();
  45
  46                         CreateHasManyRelations(desc, tableDef, list, context);
  47
  48                         CreateBelongsToRelations(desc, tableDef, list, context);
  49
  50                         return (ActiveRecordPropertyRelationDescriptor[]) list.ToArray( typeof(ActiveRecordPropertyRelationDescriptor) );
  51                 }
  52
  53                 private void CreateBelongsToRelations(ActiveRecordDescriptor desc, TableDefinition tableDef,
  54                         IList list, BuildContext context)
  55                 {
  56                         foreach(ColumnDefinition col in tableDef.Columns)
  57                         {
  58                                 if (col.RelatedTable != null)
  59                                 {
  60                                         bool pendentNecessary = false;
  61                                         String propertyName = _namingService.CreateClassName(col.RelatedTable.Name);
  62
  63                                         ActiveRecordDescriptor targetType = null;
  64
  65                                         if (col.RelatedTable.RelatedDescriptor == null && col.RelatedTable != tableDef)
  66                                         {
  67                                                 col.RelatedTable.RelatedDescriptor = new ActiveRecordDescriptor(col.RelatedTable);
  68
  69                                                 pendentNecessary = true;
  70                                         }
  71                                         else if (col.RelatedTable == tableDef)
  72                                         {
  73                                                 targetType = desc;
  74                                         }
  75
  76                                         if (targetType == null)
  77                                         {
  78                                                 targetType = col.RelatedTable.RelatedDescriptor;
  79                                         }
  80
  81                                         ActiveRecordBelongsToDescriptor belongsTo =
  82                                                 new ActiveRecordBelongsToDescriptor(col.Name,
  83                                                         propertyName, targetType);
  84
  85                                         list.Add(belongsTo);
  86
  87                                         if (pendentNecessary)
  88                                         {
  89                                                 context.AddPendentDescriptor(belongsTo, col.RelatedTable.RelatedDescriptor);
  90                                         }
  91                                 }
  92                         }
  93                 }
  94
  95                 private void CreateHasManyRelations(ActiveRecordDescriptor desc, TableDefinition tableDef,
  96                         IList list, BuildContext context)
  97                 {
  98                         foreach(TableDefinition fkTable in tableDef.TablesReferencedByHasRelation)
  99                         {
 100                                 String propertyName = _namingService.CreateRelationName(fkTable.Name);
 101                                 ActiveRecordDescriptor targetType = null;
 102                                 String colName = null;
 103                                 bool pendentNecessary = false;
 104                                 ColumnDefinition selectedCol = null;
 105
 106                                 foreach(ColumnDefinition col in fkTable.Columns)
 107                                 {
 108                                         if (col.RelatedTable == tableDef)
 109                                         {
 110                                                 colName = col.Name;
 111
 112                                                 if (col.RelatedTable.RelatedDescriptor == null && col.RelatedTable != fkTable)
 113                                                 {
 114                                                         col.RelatedTable.RelatedDescriptor = new ActiveRecordDescriptor(fkTable);
 115
 116                                                         pendentNecessary = true;
 117                                                 }
 118                                                 else if (col.RelatedTable == tableDef)
 119                                                 {
 120                                                         targetType = desc;
 121                                                 }
 122
 123                                                 if (targetType == null)
 124                                                 {
 125                                                         targetType = col.RelatedTable.RelatedDescriptor;
 126                                                 }
 127
 128                                                 selectedCol = col;
 129
 130                                                 break;
 131                                         }
 132                                 }
 133
 134                                 // Just to protect ourselves from awkward conditions
 135                                 if (colName == null) continue;
 136
 137                                 ActiveRecordHasManyDescriptor hasMany =
 138                                         new ActiveRecordHasManyDescriptor(colName, propertyName, targetType);
 139
 140                                 if (pendentNecessary)
 141                                 {
 142                                         context.AddPendentDescriptor(hasMany, selectedCol.RelatedTable.RelatedDescriptor);
 143                                 }
 144
 145                                 list.Add(hasMany);
 146                         }
 147                 }
 148
 149                 #endregion
 150         }
 151 }