source: branches/OaaS/HeuristicLab.Services.Optimization.Billing/DataAccess/BillingDao.cs @ 9602

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using HeuristicLab.Services.Optimization.Billing.Model;
namespace HeuristicLab.Services.Optimization.Billing.DataAccess {
  public class BillingDao {

    #region Context Creation and Execution

    private BillingContext CreateContext() {
      BillingContext context = new BillingContext("name=BillingContext");
      return context;
    }

    private delegate T ExecuteWithContextDelegate<T>(BillingContext context);
    private delegate void ExecuteWithContextDelegate(BillingContext context);

    private void ExecuteWithContext(ExecuteWithContextDelegate call) {
      BillingContext context = null;
      try {
        using (context = CreateContext()) {
          call(context);
        }
      }
      finally {
        if (context.Database.Connection.State == System.Data.ConnectionState.Open) {
          context.Database.Connection.Close();
        }
      }
    }

    private T ExecuteWithContext<T>(ExecuteWithContextDelegate<T> call) {
      BillingContext context = null;
      try {
        using (context = CreateContext()) {
          T result = call(context);
          return result;
        }
      }
      finally {
        if (context.Database.Connection.State == System.Data.ConnectionState.Open) {
          context.Database.Connection.Close();
        }
      }
    }

    #endregion

    #region Product Methods

    public Product FindProductById(long id) {
      return ExecuteWithContext<Product>((context) => {
        return context.Products.FirstOrDefault(prod => prod.ProductId == id);
      });
    }

    public IEnumerable<Product> FindProdcutBy(Expression<Func<Product, bool>> predicate) {
      using (var context = CreateContext()) {
        var products = context.Products.Where(predicate).ToList();
        return products;
      }
    }

    public IEnumerable<Product> FindAllProducts() {
      using (var context = CreateContext()) {
        var products = context.Products.ToList();
        return products;
      }
    }

    public void AddProduct(Product entity) {
      ExecuteWithContext((context) => {
        context.Products.Add(entity);
        context.SaveChanges();
      });
    }

    public void UpdateProduct(Product entity) {
      ExecuteWithContext((context) => {
        context.Products.Attach(entity);
        context.Entry(entity).State = System.Data.EntityState.Modified;
        context.SaveChanges();
      });
    }

    void DeleteProduct(Product entity) {
      ExecuteWithContext((context) => {
        context.Products.Remove(entity);
      });
    }

    #endregion

    #region Order Methods

    public void AddOrder(Order order) {
      ExecuteWithContext((context) => {
        context.Orders.Add(order);
        context.SaveChanges();
      });
    }

    public IEnumerable<Order> FindOrderBy(Expression<Func<Order, bool>> predicate) {
      using (var context = CreateContext()) {
        var orders = context.Orders.Where(predicate).ToList();
        return orders;
      }
    }

    #endregion

    #region OrderLine Methods

    public OrderLine FindOrderLineById(long id) {
      return ExecuteWithContext<OrderLine>((context) => {
        return context.OrderLines.FirstOrDefault(ol => ol.OrderLineId == id);
      });
    }

    public IEnumerable<OrderLine> FindOrderLineBy(Expression<Func<OrderLine, bool>> predicate) {
      using (var context = CreateContext()) {
        var orderLines = context.OrderLines.Where(predicate).ToList();
        return orderLines;
      }
    }

    public IEnumerable<OrderLine> FindAllOrderLines() {
      using (var context = CreateContext()) {
        var orderLines = context.OrderLines.ToList();
        return orderLines;
      }
    }

    public void AddOrderLine(OrderLine entity) {
      ExecuteWithContext((context) => {
        context.OrderLines.Add(entity);
        context.SaveChanges();
      });
    }

    public void UpdateOrderLine(OrderLine entity) {
      ExecuteWithContext((context) => {
        context.OrderLines.Attach(entity);
        context.Entry(entity).State = System.Data.EntityState.Modified;
        context.SaveChanges();
      });
    }

    void DeleteOrderLine(OrderLine entity) {
      ExecuteWithContext((context) => {
        context.OrderLines.Remove(entity);
      });
    }

    #endregion

    #region User Methods

    public User FindUserById(long id) {
      return ExecuteWithContext<User>((context) => {
        return context.Users.FirstOrDefault(user => user.UserId == id);
      });
    }

    public IEnumerable<User> FindUserBy(Expression<Func<User, bool>> predicate) {
      using (var context = CreateContext()) {
        var users = context.Users.Where(predicate).ToList();
        return users;
      }
    }

    public IEnumerable<User> FindAllUsers() {
      using (var context = CreateContext()) {
        var users = context.Users.ToList();
        return users;
      }
    }

    public void AddUser(User entity) {
      ExecuteWithContext((context) => {
        context.Users.Add(entity);
        context.SaveChanges();
      });
    }

    public void UpdateUser(User entity) {
      ExecuteWithContext((context) => {
        context.Users.Attach(entity);
        context.Entry(entity).State = System.Data.EntityState.Modified;
        context.SaveChanges();
      });
    }

    void DeleteUser(User entity) {
      ExecuteWithContext((context) => {
        context.Users.Remove(entity);
      });
    }

    #endregion

    #region UsageRecords Methods

    public UsageRecord FindUsageRecordById(long id) {
      return ExecuteWithContext<UsageRecord>((context) => {
        return context.UsageRecords.FirstOrDefault(prod => prod.ProductId == id);
      });
    }

    public IEnumerable<UsageRecord> FindUsageRecordsBy(Expression<Func<UsageRecord, bool>> predicate) {
      using (var context = CreateContext()) {
        var records = context.UsageRecords.Where(predicate).ToList();
        return records;
      }
    }

    public IEnumerable<UsageRecord> FindAllUsageRecords() {
      using (var context = CreateContext()) {
        var records = context.UsageRecords.ToList();
        return records;
      }
    }

    public void AddUsageRecord(UsageRecord entity) {
      ExecuteWithContext((context) => {
        context.UsageRecords.Add(entity);
        context.SaveChanges();
      });
    }

    public void UpdateUsageRecord(UsageRecord entity) {
      ExecuteWithContext((context) => {
        context.UsageRecords.Attach(entity);
        context.Entry(entity).State = System.Data.EntityState.Modified;
        context.SaveChanges();
      });
    }

    void DeleteUsageRecord(UsageRecord entity) {
      ExecuteWithContext((context) => {
        context.UsageRecords.Remove(entity);
      });
    }

    #endregion

    #region Invoice Methods

    public void AddInvoice(Invoice entity) {
      ExecuteWithContext((context) => {
        context.Invoices.Add(entity);
        context.SaveChanges();
      });
    }

    public IEnumerable<Invoice> FindInvoiceBy(Expression<Func<Invoice, bool>> predicate) {
      using (var context = CreateContext()) {
        var invoices = context.Invoices.Where(predicate).ToList();
        return invoices;
      }
    }

    #endregion
  }
}