Mini Kabibi Habibi
using DevExpress.Xpo;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.OleDb;
using System.Data.SqlClient;
using System.IO;
using System.Text;
using System.Xml;
using DevExpress.Xpf.Core;
using System.Windows;
using System.Windows.Input;
namespace PivotGridDemo.PivotGrid.Helpers {
public delegate void UpdateProgressCallback(int percents);
public delegate void DatabaseGeneratedCallback();
public delegate void DataSetFilledCallback(DataSet dataSet);
public static class DatabaseHelper {
readonly static Random random = new Random();
readonly static BackgroundWorker worker = new BackgroundWorker();
static readonly string[] Names = { "Julia", "Stephanie", "Alex", "John", "Curtis", "Keith", "Timothy", "Jack", "Miranda", "Alice" };
static readonly string[] LastNames = { "Black", "White", "Brown", "Smith", "Cooper", "Parker", "Walker", "Hunter", "Burton", "Douglas", "Fox", "Simpson" };
static readonly string[] Adjectives = { "Ancient", "Modern", "Mysterious", "Elegant", "Red", "Green", "Blue", "Amazing", "Wonderful", "Astonishing", "Lovely", "Beautiful", "Inexpensive", "Famous", "Magnificent", "Fancy" };
static readonly string[] ProductNames = { "Ice Cubes", "Bicycle", "Desk", "Hamburger", "Notebook", "Tea", "Cellphone", "Butter", "Frying Pan", "Napkin",
"Armchair", "Chocolate", "Yoghurt", "Statuette", "Keychain" };
static readonly string[] CategoryNames = { "Business", "Presents", "Accessories", "Home", "Hobby" };
static DatabaseHelper() {
worker.DoWork += GenerateDatabaseAsyncCore;
worker.WorkerReportsProgress = true;
worker.WorkerSupportsCancellation = true;
}
public static bool IsGenerating { get { return worker.IsBusy; } }
public static void GenerateDatabaseAsync(int rowsCount, UpdateProgressCallback updateProgressCallback, DatabaseGeneratedCallback databaseGeneratedCallback) {
worker.ProgressChanged += delegate(object sender, ProgressChangedEventArgs e) { updateProgressCallback(e.ProgressPercentage); };
worker.RunWorkerCompleted += delegate(object sender, RunWorkerCompletedEventArgs e) { databaseGeneratedCallback(); };
worker.RunWorkerAsync(rowsCount);
}
public static void CancelDatabaseGenerationAsync() {
worker.CancelAsync();
}
static void GenerateDatabaseAsyncCore(object sender, DoWorkEventArgs e) {
worker.ReportProgress(0);
int rowsCount = (int)e.Argument;
int rowsRemaining = rowsCount;
using(UnitOfWork uow = new UnitOfWork()) {
try {
uow.ClearDatabase();
} catch { }
int salesPersonCount = random.Next(10, 15);
int customersCount = random.Next(30, 50);
int productsCount = random.Next(80, 100);
List<string> peopleNames = GeneratePeopleNames(salesPersonCount + customersCount);
List<string> productNames = GenerateProductNames(productsCount);
int indexPersonName = 0;
XPCollection<SalesPerson> salesPeople = new XPCollection<SalesPerson>(uow);
for(int i = 0; i < salesPersonCount; i++)
salesPeople.Add(new SalesPerson(uow, peopleNames[indexPersonName++]));
XPCollection<Customer> customers = new XPCollection<Customer>(uow);
for(int i = 0; i < customersCount; i++)
customers.Add(new Customer(uow, peopleNames[indexPersonName++]));
XPCollection<Category> categories = new XPCollection<Category>(uow);
for(int i = 0; i < CategoryNames.Length; i++)
categories.Add(new Category(uow, CategoryNames[i]));
XPCollection<Product> products = new XPCollection<Product>(uow);
for(int i = 0; i < productsCount; i++)
products.Add(new Product(uow, productNames[i], categories[random.Next(categories.Count)], random.Next(500)));
do {
Order order = new Order(uow, salesPeople[random.Next(salesPeople.Count)], customers[random.Next(customers.Count)], GetDate());
int salesCount = rowsRemaining >= 5 ? random.Next(1, 6) : rowsRemaining;
for(int j = 0; j < salesCount; j++) {
Product product = products[random.Next(products.Count)];
new Sale(uow, order, product, random.Next(1, 100), GetProductPrice(product));
rowsRemaining--;
}
uow.CommitChanges();
worker.ReportProgress(rowsCount - rowsRemaining);
} while(!worker.CancellationPending && rowsRemaining > 0);
uow.FlushChanges();
}
}
static List<string> GeneratePeopleNames(int count) {
List<string> names = new List<string>(count);
while(names.Count < count) {
string name = GenerateName();
if(!names.Contains(name))
names.Add(name);
}
return names;
}
static List<string> GenerateProductNames(int count) {
List<string> names = new List<string>(count);
while(names.Count < count) {
string name = GenerateProductName();
if(!names.Contains(name))
names.Add(name);
}
return names;
}
static string GenerateName() {
return String.Format("{0} {1}", Names[random.Next(Names.Length)], LastNames[random.Next(LastNames.Length)]);
}
static string GenerateProductName() {
return String.Format("{0} {1}", Adjectives[random.Next(Adjectives.Length)], ProductNames[random.Next(ProductNames.Length)]);
}
static decimal GetProductPrice(Product product) {
return product.Price * (decimal)(0.5 + random.NextDouble());
}
static DateTime GetDate() {
return new DateTime(random.Next(2008, 2011), random.Next(1, 13), random.Next(1, 28));
}
public static void GetDataSetAsync(DataSetFilledCallback callback) {
BackgroundWorker workerDataSetFiller = new BackgroundWorker();
workerDataSetFiller.DoWork += GetDataSetAsyncCore;
workerDataSetFiller.RunWorkerCompleted += delegate(object s, RunWorkerCompletedEventArgs e) {
callback(e.Error == null ? (DataSet)e.Result : null);
};
workerDataSetFiller.RunWorkerAsync();
workerDataSetFiller.Dispose();
}
static void GetDataSetAsyncCore(object sender, DoWorkEventArgs e) {
OleDbConnection connection = new OleDbConnection("Provider=SQLOLEDB;" + ServerParameters.GetDBConnectionString());
OleDbDataAdapter adapter = new OleDbDataAdapter("select Orders.OID as OrderID, SalesPersonName, CustomerName, CategoryName, ProductName, Quantity, UnitPrice, OrderDate " +
"from orders " +
"join Sales on Sales.[Order] = Orders.OID " +
"join SalesPeople on Orders.SalesPerson = SalesPeople.OID " +
"join Customers on Orders.Customer = Customers.OID " +
"join Products on Sales.Product = Products.OID " +
"join Categories on Products.Category = Categories.OID", connection);
DataSet dataSet = new DataSet();
try {
adapter.Fill(dataSet, "orders");
e.Result = dataSet;
} catch(OleDbException) {
e.Result = null;
} finally {
connection.Dispose();
}
}
public static int CalculateRecordCount() {
try {
using(SqlConnection connection = new SqlConnection(ServerParameters.GetServerConnectionString())) {
connection.Open();
using(SqlCommand command = new SqlCommand(String.Format("select count(OID) as count from [{0}].[dbo].[Sales]", ServerParameters.DBName), connection)) {
using(SqlDataReader reader = command.ExecuteReader()) {
reader.Read();
return (int)reader["count"];
}
}
}
} catch {
return -1;
}
}
public static void TestConfiguration() {
ServerParameters.IsParametersCorrect();
}
}
public class ServerParameters {
#region Singleton
public
ServerParameters() { }
static ServerParameters fInstance;
static ServerParameters Instance {
get {
if(fInstance == null)
fInstance = new ServerParameters();
return fInstance;
}
}
#endregion
const string ServerParametersFileName = "PivotGridSQLParameters.xml";
string fServer = "(local)";
string fLogin = "sa";
string fPassword = string.Empty;
bool fUseWindowsAuthentication = true;
public static string DBName { get { return "PivotGridDemoDB"; } }
public static string Server {
get { return Instance.fServer; }
set { Instance.fServer = value; }
}
public static string Login {
get { return Instance.fLogin; }
set { Instance.fLogin = value; }
}
public static string Password {
get { return Instance.fPassword; }
set { Instance.fPassword = value; }
}
public static bool UseWindowsAuthentication {
get { return Instance.fUseWindowsAuthentication; }
set { Instance.fUseWindowsAuthentication = value; }
}
public static void LoadParameters() {
if(!File.Exists(ServerParametersFileName)) return;
XmlDocument doc = new XmlDocument();
try {
doc.Load(ServerParametersFileName);
if(doc.DocumentElement.Name == "Parameters") {
string[] parameters = doc.DocumentElement.InnerText.Split(new char[] { ';' });
Server = parameters[0];
UseWindowsAuthentication = Convert.ToBoolean(parameters[1]);
Login = parameters[2];
}
} catch { }
}
public static void SaveParameters() {
try {
using(XmlTextWriter writer = new XmlTextWriter(ServerParametersFileName, Encoding.UTF8)) {
writer.WriteElementString("Parameters", string.Format("{0};{1};{2}", Server, UseWindowsAuthentication, Login));
}
} catch { }
}
public static string GetServerConnectionString() {
if(UseWindowsAuthentication) {
return String.Format("data source={0};integrated security=SSPI;connection timeout=3", Server);
} else {
return String.Format("data source={0};user id={1};password={2};connection timeout=3", Server, Login, Password);
}
}
public static string GetDBConnectionString() {
return String.Format("{0};initial catalog={1}", GetServerConnectionString(), DBName);
}
public static bool IsParametersCorrect() {
Mouse.OverrideCursor = Cursors.Wait;
using(SqlConnection connection = new SqlConnection(GetServerConnectionString())) {
try {
connection.Open();
connection.Close();
} catch {
DXMessageBox.Show("Failed to connect to the server.", "Connection Error", MessageBoxButton.OK, MessageBoxImage.Error);
return false;
} finally {
Mouse.OverrideCursor = null;
}
}
return true;
}
}
#region XPOs
[Persistent("SalesPeople")]
public class SalesPerson : XPObject {
string name;
public SalesPerson(Session session)
: base(session) { }
public SalesPerson(Session session, string name)
: this(session) {
Name = name;
}
[Persistent("SalesPersonName")]
public string Name { get { return name; } set { SetPropertyValue("Name", ref name, value); } }
[Association("SalesPeople-Orders")]
public XPCollection<Order> Orders { get { return GetCollection<Order>("Orders"); } }
}
[Persistent("Customers")]
public class Customer : XPObject {
string name;
public Customer(Session session)
: base(session) { }
public Customer(Session session, string name)
: this(session) {
Name = name;
}
[Persistent("CustomerName")]
public string Name { get { return name; } set { SetPropertyValue("Name", ref name, value); } }
[Association("Customers-Orders")]
public XPCollection<Order> Orders { get { return GetCollection<Order>("Orders"); } }
}
[Persistent("Orders")]
public class Order : XPObject {
SalesPerson salesPerson;
Customer customer;
DateTime date;
public Order(Session session)
: base(session) { }
public Order(Session session, SalesPerson salesPerson, Customer customer, DateTime date)
: this(session) {
SalesPerson = salesPerson;
Customer = customer;
Date = date;
salesPerson.Orders.Add(this);
customer.Orders.Add(this);
}
[Association("SalesPeople-Orders")]
public SalesPerson SalesPerson { get { return salesPerson; } set { SetPropertyValue("SalesPerson", ref salesPerson, value); } }
[Association("Customers-Orders")]
public Customer Customer { get { return customer; } set { SetPropertyValue("Customer", ref customer, value); } }
[Association("Orders-Sales")]
public XPCollection<Sale> Sales { get { return GetCollection<Sale>("Sales"); } }
[Persistent("OrderDate")]
public DateTime Date { get { return date; } set { SetPropertyValue("Date", ref date, value); } }
}
[Persistent("Categories")]
public class Category : XPObject {
string name;
public Category(Session session)
: base(session) { }
public Category(Session session, string name)
: this(session) {
Name = name;
}
[Persistent("CategoryName")]
public string Name { get { return name; } set { SetPropertyValue("Name", ref name, value); } }
[Association("Category-Products")]
public XPCollection<Product> Products { get { return GetCollection<Product>("Products"); } }
}
[Persistent("Products")]
public class Product : XPObject {
string name;
Category category;
decimal price;
public Product(Session session)
: base(session) { }
public Product(Session session, string name, Category category, decimal price)
: this(session) {
Name = name;
Category = category;
Category.Products.Add(this);
Price = price;
}
[Persistent("ProductName")]
public string Name { get { return name; } set { SetPropertyValue("Name", ref name, value); } }
[Association("Category-Products")]
public Category Category { get { return category; } set { SetPropertyValue("Category", ref category, value); } }
[Association("Product-Sales")]
public XPCollection<Sale> Sales { get { return GetCollection<Sale>("Sales"); } }
[NonPersistent]
public decimal Price { get { return price; } set { price = value; } }
}
[Persistent("Sales")]
public class Sale : XPObject {
Order order;
Product product;
int quantity;
decimal unitPrice;
public Sale(Session session)
: base(session) { }
public Sale(Session session, Order order, Product product, int quantity, decimal unitPrice)
: this(session) {
Order = order;
Product = product;
Quantity = quantity;
UnitPrice = unitPrice;
order.Sales.Add(this);
product.Sales.Add(this);
}
[Association("Orders-Sales")]
public Order Order { get { return order; } set { SetPropertyValue("Order", ref order, value); } }
[Association("Product-Sales")]
public Product Product { get { return product; } set { SetPropertyValue("Product", ref product, value); } }
[Persistent("Quantity")]
public int Quantity { get { return quantity; } set { SetPropertyValue("Quantity", ref quantity, value); } }
[Persistent("UnitPrice")]
public decimal UnitPrice { get { return unitPrice; } set { SetPropertyValue("UnitPrice", ref unitPrice, value); } }
}
#endregion
}