<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.0" assembly="Data.Hibernate" namespace="Data.Hibernate.Domain">
  <class name="Tmodel" table="tmodel">
    <id name="TmodelKey" type="string">
      <column name="tmodel_key" length="41" />
      <generator class="uuid.hex">
        <param name="format">P</param>
        <param name="seperator">-</param>
      </generator>
    </id>
    <property name="AuthorizedName" type="string">
      <column name="authorized_name" not-null="true"/>
    </property>
    <property name="PublisherId" type="string">
      <column name="publisher_id" length="20"/>
    </property>
    <property name="Operator" type="string">
      <column name="operator" not-null="true"/>
    </property>
    <property name="Name" type="string">
      <column name="name" not-null="true"/>
    </property>
    <property name="OverviewUrl" type="string">
      <column name="overview_url"/>
    </property>
    <property name="DeletionDate" type="DateTime">
      <column name="deletion_date" />
    </property>
    <property name="LastUpdate" type="DateTime">
      <column name="last_update" not-null="true"/>
    </property>
    <bag name="TmodelCategories" inverse="true" cascade="all-delete-orphan" lazy="true">
      <key>
        <column name="tmodel_key" length="41" not-null="true"/>
      </key>
      <one-to-many class="TmodelCategory" />
    </bag>
    <bag name="TmodelDocDescrs" inverse="true" cascade="all-delete-orphan" lazy="true">
      <key>
        <column name="tmodel_key" length="41" not-null="true"/>
      </key>
      <one-to-many class="TmodelDocDescr" />
    </bag>
    <bag name="TmodelDescrs" inverse="true" cascade="all-delete-orphan" lazy="true">
      <key>
        <column name="tmodel_key" length="41" not-null="true"/>
      </key>
      <one-to-many class="TmodelDescr" />
    </bag>
    <bag name="TmodelIdentifiers" inverse="true" cascade="all-delete-orphan" lazy="true">
      <key>
        <column name="tmodel_key" length="41" not-null="true"/>
      </key>
      <one-to-many class="TmodelIdentifier" />
    </bag>
  </class>
</hibernate-mapping>

<hibernate-mapping xmlns="urn:nhibernate-mapping-2.0" assembly="Data.Hibernate" namespace="Data.Hibernate.Domain">
    <class name="TmodelCategory" table="tmodel_category">
        <id name="TmodelCategoryId" type="int">
            <column name="tmodel_category_id" />
            <generator class="native" />
        </id>
        <many-to-one name="Tmodel" class="Tmodel" fetch="select">
            <column name="tmodel_key" length="41" not-null="true"/>
        </many-to-one>
        <property name="TmodelKeyRef" type="string">
            <column name="tmodel_key_ref"/>
        </property>
        <property name="KeyName" type="string">
            <column name="key_name"/>
        </property>
        <property name="KeyValue" type="string">
            <column name="key_value" not-null="true"/>
        </property>
    </class>
</hibernate-mapping>

if (categoryBag != null && categoryBag.keyedReference != null && categoryBag.keyedReference.Length > 0) {

   // Delegate method to fetch tmodel categories on a single set of criteria
   KeyedReferenceQuery fetchCategories = delegate(string tModelKey, string keyName, string keyValue) {

      ICriteria tModelCriteria = tModelDao.NHibernateSession.CreateCriteria(typeof(Tmodel));
      tModelCriteria.AddOrder(nameOrder);
      ICriteria categoryCriteria = tModelCriteria.CreateCriteria("TmodelCategories");               
      
      //  the keyValues are identical
      categoryCriteria.Add(Expression.Eq("KeyValue", keyValue).IgnoreCase());

      //  The tModelKeys refer to the same tModel.
      categoryCriteria.Add(Expression.Eq("TmodelKeyRef", tModelKey).IgnoreCase());

      //  If the tModelKey involved is that of uddi-org:general_keywords, the keyNames are identical
      if (tModelKey.ToUpper().Equals(Core.Datatype.TModel.GENERAL_KEYWORDS_TMODEL_KEY.ToUpper())) {
         categoryCriteria.Add(Expression.Eq("KeyName", keyName).IgnoreCase());
      }
      
      return (ArrayList)categoryCriteria.List();
      
   };

   ListSet categorySet = (ListSet)getQualifiedKeyedReference(categoryBag.keyedReference, "andAllKeys", fetchCategories);

   if (categorySet.Count == 0) {
      return new Core.Datatype.TModel[0];
   }
                              
   //   The name field is optional - if it was not specified, then the targetSet will still
   //   be empty in which case the categorySet should be the base result
   if (targetSet.Count == 0)   {
      targetSet = categorySet;
   } else {
      //   Overall result at this point is the intersection of both name + category                                    
      targetSet = targetSet.Intersect(categorySet);
      if (targetSet.Count == 0) {
         //   there is no intersection - early bath
         return new Core.Datatype.TModel[0];
      }
   }
}

internal ISet getQualifiedKeyedReference(Core.Datatype.KeyedReference[] keyedReferences, string searchQualifier, KeyedReferenceQuery fetchDelegate) {
   Dictionary<string, ISet> orLikeKeysDictionary = new Dictionary<string, ISet>();
   ISet targetSet = new ListSet();

   // Iterate through the KeyedReference array to find entities matching each of those specified           
   foreach (Core.Datatype.KeyedReference keyedReference in keyedReferences) {

      //  Use the passed delegate to perform the actual query
      ArrayList resultList = fetchDelegate(keyedReference.tModelKey, keyedReference.keyName, keyedReference.keyValue);

      if (searchQualifier.Equals("orAllKeys")) {
         //  ----------------------------------------------------------------------------------------
         //  This changes the behavior for tModelBag and categoryBag to OR keys rather than AND them.
         //  This qualifier negates any AND treatment as well as the effect of orLikeKeys. Applies to:
         //  find_binding, find_business, find_service, and find_tModel.
         //  ----------------------------------------------------------------------------------------

         //  Add each result to a single set (because this is orAllKeys we can disregard it if there
         //   are no results
         targetSet.AddAll(resultList);
      } else if (searchQualifier.Equals("orLikeKeys")) {
         //  ----------------------------------------------------------------------------------------
         //  When a bag contains multiple keyedReference elements (i.e., categoryBag or
         //  identifierBag), any keyedReference filters that come from the same namespace (e.g. have
         //  the same tModelKey value) are OR’d together rather than AND’d.  This allows one to say “any
         //  of these four values from this namespace, and any of these two values from this namespace”.
         //  ----------------------------------------------------------------------------------------                 

         //  Create a seperate result set for each unique tModelKey in the bag.
         if (orLikeKeysDictionary.ContainsKey(keyedReference.tModelKey.ToLower())) {
            //  this key has already been met in the bag - Add the result to the
            //  existing result set grouped by the key
            orLikeKeysDictionary[keyedReference.tModelKey.ToLower()].AddAll(new ListSet(resultList));
         } else {
            //  this key has NOT already been met in the bag - create a new keyed set
            //  and add the results to it
            orLikeKeysDictionary.Add(keyedReference.tModelKey.ToLower(), new ListSet(resultList));
         }
      } else if (searchQualifier.Equals("andAllKeys")) {
         //  ----------------------------------------------------------------------------------------
         //  Elements matching all of the keyedReferences passed (logical AND by default).                   
         //  ----------------------------------------------------------------------------------------

         //  if the ANDing then there must be a result and that result must also intersect with all
         //   prior results
         if (resultList.Count > 0) {
            if (targetSet.Count > 0) {
               targetSet = targetSet.Intersect((ISet)new ListSet(resultList));
               if (targetSet.Count < 1) return new ListSet();
            } else {
               targetSet.AddAll(resultList);
            }
         } else {
            return new ListSet();
         }
      }
   }
   //   orLikeKeys - the result is the intersection between each individual keyed set if any set
   //   is empty then as expected, the intersection will have 0 elements
   if (searchQualifier.Equals("orLikeKeys")) {
      foreach (ListSet keyedSet in orLikeKeysDictionary.Values) {
         if (keyedSet.Count > 0) {
            if (targetSet.Count > 0) {
               targetSet = targetSet.Intersect(keyedSet);
               if (targetSet.Count < 1) return new ListSet();
            } else {
               targetSet.AddAll(keyedSet);
            }
         } else {
            return new ListSet();
         }
      }            
   }
   return targetSet;      
}