protected void Application_Start(Object sender, EventArgs e)

{

     IdeaBlade.Core.IdeaBladeConfig.AssertNonDefaultVersion();

     ConfigureEntityManager();

}



private void ConfigureEntityManager()

{

     DomainModel.Utility.LocalEntityManager.DefaultManager = new DomainModel.DomainModelEntityManager();

     DomainModel.Utility.LocalEntityManager.DefaultManager.LoginAsync(null, args => LoginCallback(args, null), null);

}



private void LoginCallback(IdeaBlade.EntityModel.LoginEventArgs args, Action callback)

{

     if (args.Error != null)

          throw args.Error;

}

protected override IdeaBlade.EntityModel.EntityManager CreateEntityManagerCore()

{

     var em = new DomainModelEntityManager();

     LocalEntityManager.DefaultManager = em;

     var task = AsyncSerialTask.Create();

     var task1 = task.AddAsyncLogin(em, new LoginCredential(null, null, null));

     task1.AddExceptionHandler(CreateEntityManagerCoreAsyncSerialTaskExceptionHandler);

     var task2 = task1.AddAsyncAction<AsyncEventArgs>((loginEventArgs, callback) =>          

          LocalEntityManager.InitializeCacheAsync(callback, 

          Tools.AsyncSerialTaskParallelCallback));

     task2.AddExceptionHandler(CreateEntityManagerCoreAsyncSerialTaskExceptionHandler);

     task2.Execute(null, args => CreateEntityManagerCoreCallback(args));

     return em;

}



public void CreateEntityManagerCoreCallback(AsyncSerialTaskCompletedArgs<AsyncEventArgs> args)

{

     //TODO:  Do something cool here.  Like raise an event back to the VM to tell it we're done initializing the EM/cache.

}



public static void CreateEntityManagerCoreAsyncSerialTaskExceptionHandler(AsyncSerialTaskExceptionArgs args)

{

     //TODO:  This should do something much wiser, like

     //log the error and set an "Error" property

     throw args.Exception;

}

public static class LocalEntityManager

{



     private static DomainModelEntityManager _defaultManager;



     public static DomainModelEntityManager DefaultManager

     {

          get

          {

               return _defaultManager;

          }

          set

          {

               _defaultManager = value;

               _defaultManager.Saving += new EventHandler<IdeaBlade.EntityModel.EntitySavingEventArgs>(_defaultManager_Saving);

          }

     }



     public static void _defaultManager_Saving(object sender, IdeaBlade.EntityModel.EntitySavingEventArgs e)

     {

          VerifierResultCollection allResults = new VerifierResultCollection();

          foreach (Entity item in e.Entities)

          {

               var itemResults = ((BaseEntity)item).VerifyInstance();

               foreach (var result in itemResults) { allResults.Add(result); }

          }

          if (!allResults.AreOk)

          {

               e.Cancel = true;

               VerifierResults = allResults;

               string msg = String.Empty;

               foreach (var result in allResults)

               {

                    if (result.IsError)

                    {

                         if (!String.IsNullOrEmpty(msg))

                              msg += ", ";

                         msg += result.Description;

                    }

               }

               throw new VerifierException("Verifier Failure: " + msg);

          }

     }



     public static VerifierResultCollection VerifierResults { get; set; }



     #region InitializeCache



     public static void InitializeCache()

     {

          var queries = GetInitializationQueries();

          foreach (var item in queries)

          {

               _defaultManager.ExecuteQuery(item);

          }

     }



     /// <summary>

     /// Initialize the EntityManager cache asynchronously.  This method should be used 

     /// instead of the InitializeCacheAsync(AsyncCompletedCallback<AsyncEventArgs>

     /// serialCallback, Action<AsyncParallelTaskCompletedArgs> completionAction) version.

     /// That one was created to make the Initialize work as part of an AsyncSerialTask.

     /// </summary>

     /// <param name="completionAction">The Action to execute (call back to) to return 

     /// the results of this async call.</param>

     public static void InitializeCacheAsync(Action<AsyncParallelTaskCompletedArgs> completionAction)

     {

          InitializeCacheAsync(null, completionAction);

     }



     /// <summary>

     /// Initialize the EntityManager cache asynchronously.  This method can be called 

     /// inside an AsyncSerialTask because it carries the AsyncSerialTask's callback 

     /// through it.

     /// </summary>

     /// <param name="serialCallback">The callback to pass through so the Parallel

     /// completionAction can assemble an AsyncEventArgs toss it over to the Serial 

     /// serialCallback.</param>

     /// <param name="completionAction">The Action to execute (call back to) to 

     /// return the results of this async call.</param>

     public static void InitializeCacheAsync(AsyncCompletedCallback<AsyncEventArgs> serialCallback, Action<AsyncParallelTaskCompletedArgs> completionAction)

     {

          var task = AsyncParallelTask.Create();

          task.AddExceptionHandler(InitializationExceptionHandler);

          AddInitializationQueries(task);

          task.Execute(serialCallback, completionAction);

     }



     private static void AddInitializationQueries(AsyncParallelTask<object> task)

     {

          var queries = GetInitializationQueries();

          int i = 1;

          foreach (var item in queries)

          {

               IEntityQuery query = item;

               task.AddAsyncAction<EntityFetchedEventArgs>(i, (args, callback) =>

                    _defaultManager.ExecuteQueryAsync(query, callback, null), null);

               i++;

          }

     }



     private static IList<IEntityQuery> GetInitializationQueries()

     {

          var queries = new List<IEntityQuery>();

          queries.Add(_defaultManager.AccountingMonths);

          queries.Add(_defaultManager.DealTypes);



          return queries;

     }



     public static void InitializationExceptionHandler(AsyncParallelTaskExceptionArgs args)

     {

          throw args.Exception;

     }



     #endregion



}