source: branches/DeploymentServer Prototype/HeuristicLab.Services/HeuristicLab.Services.Deployment.DataAccess/PluginStore.cs @ 2771

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.Common;
using System.Transactions;
using System.Data.SqlClient;

namespace HeuristicLab.Services.Deployment.DataAccess {
  public class PluginStore {

    public PluginStore() {
    }

    #region context creating members
    public IEnumerable<ProductDescription> Products {
      get {
        using (var ctx = new PluginStoreClassesDataContext()) {
          return (from p in ctx.Products
                  let plugins = from pair in ctx.ProductPlugins
                                from plugin in ctx.Plugins
                                where pair.ProductId == p.Id
                                where plugin.Id == pair.PluginId
                                select plugin
                  select MakeProductDescription(ctx, p, plugins)).ToList();
        }
      }
    }

    public IEnumerable<PluginDescription> Plugins {
      get {
        using (var ctx = new PluginStoreClassesDataContext()) {
          return (from plugin in ctx.Plugins
                  select MakePluginDescription(ctx, plugin)).ToList();
        }
      }
    }

    public byte[] PluginFile(PluginDescription pluginDescription) {
      using (var ctx = new PluginStoreClassesDataContext()) {
        return GetExistingPlugin(ctx, pluginDescription.Name, pluginDescription.Version).PluginPackage.Data.ToArray();
      }
    }

    public void Persist(PluginDescription pluginDescription, byte[] pluginPackage) {
      using (var ctx = new PluginStoreClassesDataContext()) {
        try {
          using (var transaction = new TransactionScope()) {
            Plugin pluginEntity = InsertOrUpdatePlugin(ctx, pluginDescription);
            if (pluginEntity.PluginPackage == null) {
              // insert
              pluginEntity.PluginPackage = MakePluginPackage(pluginDescription, pluginPackage);
            } else {
              // update
              pluginEntity.PluginPackage.Data = pluginPackage;
            }
            ctx.SubmitChanges();
            transaction.Complete();
          }
        }
        catch (SqlException ex) {
          throw new ArgumentException("Something went wrong while trying to persist plugin", ex);
        }
        catch (InvalidOperationException ex) {
          throw new ArgumentException("Something went wrong while trying to persist plugin", ex);
        }
      }
    }

    public void Persist(ProductDescription product) {
      using (var ctx = new PluginStoreClassesDataContext()) {
        try {
          using (var transaction = new TransactionScope()) {
            foreach (var plugin in product.Plugins) {
              var pluginEntity = GetExistingPlugin(ctx, plugin.Name, plugin.Version);
              UpdatePlugin(ctx, pluginEntity, plugin);
            }
            InsertOrUpdateProduct(ctx, product);
            ctx.SubmitChanges();
            transaction.Complete();
          }
        }
        catch (SqlException ex) {
          throw new ArgumentException("Something went wrong while trying to persist product", ex);
        }
        catch (InvalidOperationException ex) {
          throw new ArgumentException("Something went wrong while trying to persist product", ex);
        }
      }
    }

    #endregion

    #region insert/update product
    private void InsertOrUpdateProduct(PluginStoreClassesDataContext ctx, ProductDescription product) {
      var productEntity = (from p in ctx.Products
                           where p.Name == product.Name
                           where p.Version == product.Version.ToString()
                           select p).FirstOrDefault() ?? MakeProductFromDescription(product);

      if (productEntity.Id <= 0) {
        ctx.Products.InsertOnSubmit(productEntity);
        ctx.SubmitChanges();
      }

      product.Id = productEntity.Id;

      DeleteOldPlugins(ctx, productEntity);

      foreach (var plugin in product.Plugins) {
        var existingPlugin = GetExistingPlugin(ctx, plugin.Name, plugin.Version);
        ProductPlugin prodPlugin = new ProductPlugin();
        prodPlugin.PluginId = existingPlugin.Id;
        prodPlugin.ProductId = product.Id;
        ctx.ProductPlugins.InsertOnSubmit(prodPlugin);
      }
    }

    private void DeleteOldPlugins(PluginStoreClassesDataContext ctx, Product productEntity) {
      var oldPlugins = (from p in ctx.ProductPlugins
                        where p.ProductId == productEntity.Id
                        select p).ToList();
      ctx.ProductPlugins.DeleteAllOnSubmit(oldPlugins);
      ctx.SubmitChanges();
    }
    #endregion

    #region insert/update plugins
    private Plugin InsertOrUpdatePlugin(PluginStoreClassesDataContext ctx, PluginDescription pluginDescription) {
      var pluginEntity = (from p in ctx.Plugins
                          where p.Name == pluginDescription.Name
                          where p.Version == pluginDescription.Version.ToString()
                          select p).FirstOrDefault() ?? MakePluginFromDescription(pluginDescription);

      if (pluginEntity.Id <= 0) {
        ctx.Plugins.InsertOnSubmit(pluginEntity);
        ctx.SubmitChanges();
      }

      UpdatePlugin(ctx, pluginEntity, pluginDescription);
      return pluginEntity;
    }

    private void UpdatePlugin(PluginStoreClassesDataContext ctx, Plugin pluginEntity, PluginDescription pluginDescription) {
      // delete cached entry
      if (pluginDescriptions.ContainsKey(pluginEntity)) pluginDescriptions.Remove(pluginEntity);

      pluginDescription.Id = pluginEntity.Id;

      DeleteOldDependencies(ctx, pluginEntity);

      foreach (var dependency in pluginDescription.Dependencies) {
        var dependencyEntity = GetExistingPlugin(ctx, dependency.Name, dependency.Version);
        Dependency d = new Dependency();
        d.PluginId = pluginDescription.Id;
        d.DependencyId = dependencyEntity.Id;
        ctx.Dependencies.InsertOnSubmit(d);
      }
    }



    private void DeleteOldDependencies(PluginStoreClassesDataContext ctx, Plugin pluginEntity) {
      var oldDependencies = (from dep in ctx.Dependencies
                             where dep.PluginId == pluginEntity.Id
                             select dep).ToList();

      ctx.Dependencies.DeleteAllOnSubmit(oldDependencies);
      ctx.SubmitChanges();
    }
    #endregion

    #region product <-> productDescription transformation
    private ProductDescription MakeProductDescription(PluginStoreClassesDataContext ctx, Product p, IQueryable<Plugin> plugins) {
      var desc = new ProductDescription(p.Id, p.Name, new Version(p.Version), from plugin in plugins
                                                                              select MakePluginDescription(ctx, plugin));
      return desc;
    }
    private Product MakeProductFromDescription(ProductDescription desc) {
      var product = new Product();
      product.Id = desc.Id;
      product.Name = desc.Name;
      product.Version = desc.Version.ToString();
      return product;
    }
    #endregion

    #region plugin <-> pluginDescription transformation
    // cache for plugin descriptions
    private Dictionary<Plugin, PluginDescription> pluginDescriptions = new Dictionary<Plugin, PluginDescription>();
    private PluginDescription MakePluginDescription(PluginStoreClassesDataContext ctx, Plugin plugin) {
      if (!pluginDescriptions.ContainsKey(plugin)) {
        // no cached description -> create new
        var desc = new PluginDescription(plugin.Id, plugin.Name, new Version(plugin.Version), from dep in GetDependencies(ctx, plugin)
                                                                                              select MakePluginDescription(ctx, dep));
        pluginDescriptions[plugin] = desc;
      }
      return pluginDescriptions[plugin];
    }

    private Plugin MakePluginFromDescription(PluginDescription pluginDescription) {
      var plugin = new Plugin();
      plugin.Id = pluginDescription.Id;
      plugin.Name = pluginDescription.Name;
      plugin.Version = pluginDescription.Version.ToString();
      return plugin;
    }

    private PluginPackage MakePluginPackage(PluginDescription pluginDescription, byte[] pluginPackage) {
      var package = new PluginPackage();
      package.Data = pluginPackage;
      package.PluginId = pluginDescription.Id;
      package.FileName = string.Empty;
      return package;
    }

    #endregion

    #region helper queries
    private Plugin GetExistingPlugin(PluginStoreClassesDataContext ctx, string name, Version version) {
      return (from p in ctx.Plugins
              where p.Name == name
              where p.Version == version.ToString()
              select p).Single();
    }

    private IEnumerable<Plugin> GetDependencies(PluginStoreClassesDataContext ctx, Plugin plugin) {
      return from pair in ctx.Dependencies
             from dependency in ctx.Plugins
             where pair.PluginId == plugin.Id
             where pair.DependencyId == dependency.Id
             select dependency;
    }
    #endregion
  }
}