ActiveRecord/Castle.ActiveRecord.Tests/Model/Entity.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.Tests.Model
  16 {
  17         using System;
  18
  19         [ActiveRecord("entity"), JoinedBase]
  20         public class Entity : ActiveRecordBase
  21         {
  22                 private int id;
  23                 private string name;
  24                 private string type;
  25
  26                 public Entity()
  27                 {
  28                 }
  29
  30                 [PrimaryKey]
  31                 public int Id
  32                 {
  33                         get { return id; }
  34                         set { id = value; }
  35                 }
  36
  37                 [Property]
  38                 public string Name
  39                 {
  40                         get { return name; }
  41                         set { name = value; }
  42                 }
  43
  44                 [Property]
  45                 public string Type
  46                 {
  47                         get { return type; }
  48                         set { type = value; }
  49                 }
  50
  51                 public static void DeleteAll()
  52                 {
  53                         ActiveRecordBase.DeleteAll( typeof(Entity) );
  54                 }
  55
  56                 public static Entity[] FindAll()
  57                 {
  58                         return (Entity[]) ActiveRecordBase.FindAll( typeof(Entity) );
  59                 }
  60
  61                 public static Entity Find(int id)
  62                 {
  63                         return (Entity) ActiveRecordBase.FindByPrimaryKey( typeof(Entity), id );
  64                 }
  65         }
  66
  67         [ActiveRecord("entitycompany")]
  68         public class CompanyEntity : Entity
  69         {
  70                 private byte company_type;
  71                 private int comp_id;
  72
  73                 [JoinedKey("comp_id")]
  74                 public int CompId
  75                 {
  76                         get { return comp_id; }
  77                         set { comp_id = value; }
  78                 }
  79
  80                 [Property("company_type")]
  81                 public byte CompanyType
  82                 {
  83                         get { return company_type; }
  84                         set { company_type = value; }
  85                 }
  86
  87                 public new static void DeleteAll()
  88                 {
  89                         ActiveRecordBase.DeleteAll( typeof(CompanyEntity) );
  90                 }
  91
  92                 public new static CompanyEntity[] FindAll()
  93                 {
  94                         return (CompanyEntity[]) ActiveRecordBase.FindAll( typeof(CompanyEntity) );
  95                 }
  96
  97                 public new static CompanyEntity Find(int id)
  98                 {
  99                         return (CompanyEntity) ActiveRecordBase.FindByPrimaryKey( typeof(CompanyEntity), id );
 100                 }
 101         }
 102
 103         [ActiveRecord("entityperson")]
 104         public class PersonEntity : Entity
 105         {
 106                 private int person_id;
 107
 108                 [JoinedKey]
 109                 public int Person_Id
 110                 {
 111                         get { return person_id; }
 112                         set { person_id = value; }
 113                 }
 114
 115                 private IManager manager;
 116
 117                 [Any(IdType = typeof(int), MetaType = typeof(string), IdColumn = "ManagerId", TypeColumn = "ManagerType")]
 118                 [Any.MetaValueAttribute("Manager", typeof(ManagerEntity))]
 119                 public virtual IManager Manager
 120                 {
 121                         get { return manager; }
 122                         set { manager = value; }
 123                 }
 124
 125                 public new static void DeleteAll()
 126                 {
 127                         ActiveRecordBase.DeleteAll( typeof(PersonEntity) );
 128                 }
 129
 130                 public new static PersonEntity[] FindAll()
 131                 {
 132                         return (PersonEntity[]) ActiveRecordBase.FindAll( typeof(PersonEntity) );
 133                 }
 134
 135                 public new static PersonEntity Find(int id)
 136                 {
 137                         return (PersonEntity) ActiveRecordBase.FindByPrimaryKey( typeof(PersonEntity), id );
 138                 }
 139         }
 140
 141         [ActiveRecord("entitymanager")]
 142         public class ManagerEntity : ActiveRecordBase, IManager
 143         {
 144                 private int id;
 145
 146                 [PrimaryKey]
 147                 public int Id
 148                 {
 149                         get { return id; }
 150                         set { id = value; }
 151                 }
 152
 153                 private string name;
 154
 155                 [Property]
 156                 public virtual string Name
 157                 {
 158                         get { return name; }
 159                         set { name = value; }
 160                 }
 161
 162                 public static void DeleteAll()
 163                 {
 164                         DeleteAll(typeof(ManagerEntity));
 165                 }
 166
 167                 public static ManagerEntity[] FindAll()
 168                 {
 169                         return (ManagerEntity[])FindAll(typeof(ManagerEntity));
 170                 }
 171
 172                 public static ManagerEntity Find(int id)
 173                 {
 174                         return (ManagerEntity)FindByPrimaryKey(typeof(ManagerEntity), id);
 175                 }
 176         }
 177
 178         public interface IManager
 179         {
 180                 int Id { get; set; }
 181                 string Name { get; set; }
 182         }
 183 }