379 lines
14 KiB
C#
379 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using FluentNHibernate.Cfg;
|
|
using FluentNHibernate.Cfg.Db;
|
|
using NHibernate;
|
|
using NHibernate.Cfg;
|
|
using NHibernate.Tool.hbm2ddl;
|
|
using log4net;
|
|
using TracingDB.Entities;
|
|
|
|
namespace TracingDB
|
|
{
|
|
public static class DB
|
|
{
|
|
static readonly ILog log = LogManager.GetLogger(typeof(DB));
|
|
|
|
/// <summary>
|
|
/// Current session factory for the last used connection string or null
|
|
/// </summary>
|
|
public static ISessionFactory SessionFactory;
|
|
|
|
public static ISession Session;
|
|
|
|
/// <summary> Connection string for all sessions </summary>
|
|
static string connectionString;
|
|
///
|
|
public static string ConnectionString
|
|
{
|
|
get { return connectionString; }
|
|
set
|
|
{
|
|
if (value != connectionString)
|
|
{
|
|
connectionString = value;
|
|
SessionFactory = null; /// Clear SessionFactory on connection string change
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// NHibernate session factory (to create the database session 'SessionFactory')
|
|
/// </summary>
|
|
/// <returns>A database session</returns>
|
|
static ISessionFactory CreateSessionFactory()
|
|
{
|
|
return CreateSessionFactory(false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// NHibernate session factory (to create the database session 'SessionFactory')
|
|
/// </summary>
|
|
/// <returns>A database session</returns>
|
|
public static ISessionFactory CreateSessionFactory(bool createDB)
|
|
{
|
|
FluentConfiguration cfg = Fluently
|
|
.Configure()
|
|
.Database(MySQLConfiguration.Standard.ConnectionString(connectionString))
|
|
.Mappings(m => m.FluentMappings.AddFromAssemblyOf<Process>());
|
|
|
|
if (createDB)
|
|
{
|
|
return cfg.ExposeConfiguration(BuildSchemaCreate).BuildSessionFactory();
|
|
}
|
|
else
|
|
{
|
|
return cfg.ExposeConfiguration(BuildSchema).BuildSessionFactory();
|
|
}
|
|
}
|
|
|
|
public delegate void BuildSchemaDlgt(Configuration config);
|
|
|
|
public static void BuildSchema(Configuration config)
|
|
{
|
|
/// This NHibernate tool takes a configuration (with mapping info in)
|
|
/// and exports a database schema from it
|
|
new SchemaExport(config).SetOutputFile("db_schema");
|
|
}
|
|
|
|
static void BuildSchemaCreate(Configuration config)
|
|
{
|
|
/// This NHibernate tool takes a configuration (with mapping info in)
|
|
/// and exports a database schema from it
|
|
new SchemaExport(config).Create(true, true);
|
|
}
|
|
|
|
/// Create a NHibernate session for the given database
|
|
public static ISession CreateSession(string connectionString)
|
|
{
|
|
ConnectionString = connectionString; /// Clears session factory on connction string change
|
|
|
|
if (SessionFactory == null)
|
|
SessionFactory = CreateSessionFactory();
|
|
|
|
return SessionFactory.OpenSession();
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Create an empty database.
|
|
/// Database contains only the user 'admin' and the control board component 'CB'.
|
|
/// </summary>
|
|
/// <param name="dbType">DBType.SQLite or DBType.MySql</param>
|
|
/// <param name="connectionString">Connection string</param>
|
|
/// <returns>true=success, false=error</returns>
|
|
public static bool CreateEmptyDB(string connectionString)
|
|
{
|
|
ConnectionString = connectionString;
|
|
|
|
ISessionFactory sessionFactory = CreateSessionFactory(true);
|
|
if (sessionFactory == null) return false;
|
|
|
|
/// Populate the database
|
|
using (var session = sessionFactory.OpenSession())
|
|
{
|
|
//using (var transaction = session.BeginTransaction())
|
|
//{
|
|
// var part1 = new Part("flow tube", CodeType.UniqueNr, CodeForm.QRCode, 0);
|
|
// session.SaveOrUpdate(part1);
|
|
// transaction.Commit();
|
|
//}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Save a reference record and related records into the database.
|
|
/// </summary>
|
|
/// <param name="session">DB session</param>
|
|
/// <param name="refRecord">Referece record</param>
|
|
public static void SaveRecords(ISession session, ReferenceRecord refRecord)
|
|
{
|
|
log.Info("Saving data to MySQL database");
|
|
|
|
session.SaveOrUpdate(refRecord);
|
|
log.InfoFormat(" ReferenceRecord : {0}", refRecord);
|
|
|
|
foreach (var r in refRecord.Records)
|
|
{
|
|
session.SaveOrUpdate(r);
|
|
log.InfoFormat(" Record : {0}", r);
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Delete a reference record and related records from the database.
|
|
/// </summary>
|
|
/// <param name="session">DB session</param>
|
|
/// <param name="refRecord">Reference record</param>
|
|
public static void DeleteRecords(ISession session, ReferenceRecord refRecord)
|
|
{
|
|
log.Info("Deleting data from MySQL database");
|
|
|
|
foreach (var r in refRecord.Records)
|
|
{
|
|
session.Delete(r);
|
|
log.InfoFormat(" Record : {0}", r);
|
|
}
|
|
|
|
session.Delete(refRecord);
|
|
log.InfoFormat(" ReferenceRecord : {0}", refRecord);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Get process of the last record with the reference part code equal to 'pcbNumber'
|
|
/// </summary>
|
|
/// <param name="session">DB session</param>
|
|
/// <param name="pcbNumber">PCB number (code)</param>
|
|
/// <returns>Process</returns>
|
|
public static Process GetProcess(ISession session, string pcbNumber)
|
|
{
|
|
if (string.IsNullOrEmpty(pcbNumber)) return null;
|
|
|
|
try
|
|
{
|
|
/// Read all already existing reference records with Code==pcbNumber, referenceRecords[0] will be the most recent one
|
|
var referenceRecords = session.QueryOver<ReferenceRecord>()
|
|
.Where(rr => (rr.Code == pcbNumber))
|
|
.OrderBy(rr => rr.TimeStamp).Desc
|
|
.List();
|
|
|
|
if (referenceRecords.Count == 0) return null; /// Returns an empty list if no such ref. record found
|
|
|
|
return referenceRecords[0].Process;
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Finds a workstep and a part to be verified (typically a previous workstep and one of its parts).
|
|
/// Updates this.verifiedWorkstep, this.verifiedPart and this.verifyReferencePart.
|
|
/// Returns false if there is no workstep or part to be verified.
|
|
/// </summary>
|
|
/// <param name="dbSession">MySQL DB session</param>
|
|
/// <param name="process">Process to be analyzed</param>
|
|
/// <param name="workstep">Workstep to be analyzed</param>
|
|
/// <returns>true if there is a verified workstep and part</returns>
|
|
public static bool AnalyzeProcess(ISession dbSession, Process process, Workstep workstep, out Workstep verifiedWorkstep, out bool verifyReferencePart, out Part verifiedPart)
|
|
{
|
|
verifiedWorkstep = null; /// Disable any verification
|
|
verifyReferencePart = true;
|
|
verifiedPart = null;
|
|
|
|
if (process == null || workstep == null) return false;
|
|
|
|
try
|
|
{
|
|
if (workstep.ReferencePart != null)
|
|
{
|
|
IList<Workstep> worksteps = dbSession.QueryOver<Workstep>()
|
|
.Where(x => (x.Process == process))
|
|
.Where(x => (x.WorkstepNr < workstep.WorkstepNr))
|
|
.OrderBy(x => x.WorkstepNr).Asc
|
|
.List<Workstep>();
|
|
|
|
for (int i = worksteps.Count - 1; i >= 0; i--)
|
|
{
|
|
if (worksteps[i].ReferencePart != null)
|
|
{
|
|
if (worksteps[i].ReferencePart.Id == workstep.ReferencePart.Id)
|
|
{
|
|
/// Enable checking reference part
|
|
verifiedWorkstep = worksteps[i];
|
|
verifiedPart = workstep.ReferencePart;
|
|
verifyReferencePart = true;
|
|
return true;
|
|
}
|
|
|
|
foreach (var thisStepPart in workstep.Parts)
|
|
{
|
|
if (worksteps[i].ReferencePart.Id == thisStepPart.Id)
|
|
{
|
|
verifiedWorkstep = worksteps[i];
|
|
verifiedPart = worksteps[i].ReferencePart;
|
|
verifyReferencePart = true;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (var part in worksteps[i].Parts)
|
|
{
|
|
bool isUnique = (part.CodeLocation == CodeLocation.OnPart) && ((part.CodeType == CodeType.UniqueNr)
|
|
|| (part.CodeType == CodeType.FlowtubeNr)
|
|
|| (part.CodeType == CodeType.FlowtubeNrLU));
|
|
|
|
if (isUnique)
|
|
{
|
|
if (part.Id == workstep.ReferencePart.Id)
|
|
{
|
|
/// Enable checking reference part
|
|
verifiedWorkstep = worksteps[i];
|
|
verifiedPart = part;
|
|
verifyReferencePart = false;
|
|
log.ErrorFormat("AnalyzeProcess(session , {0}, {1}) returned 'true' : verWorkstep = {2}, verPart = {3}, verRefPart = {4}",
|
|
process.Name, workstep.Name);
|
|
return true;
|
|
}
|
|
|
|
foreach (var thisStepPart in workstep.Parts)
|
|
{
|
|
if (part.Id == thisStepPart.Id)
|
|
{
|
|
verifiedWorkstep = worksteps[i];
|
|
verifiedPart = part;
|
|
verifyReferencePart = false;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
log.ErrorFormat("AnalyzeProcess(session , {0}, {1}) returned 'false'", process.Name, workstep.Name);
|
|
return false;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
log.ErrorFormat("AnalyzeProcess(session , {0}, {1}) failed : {2}", process.Name, workstep.Name, exc.Message);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Obsolete, use WorkplaceRegistration class instead
|
|
/// </summary>
|
|
public static bool RegisterWorkplace(ISession session, string workplace, string user, string ipAddress, string processName, string workstepName, DateTime valiUntil)
|
|
{
|
|
try
|
|
{
|
|
IList<WorkplaceRegistration> wpRegs = session
|
|
.QueryOver<WorkplaceRegistration>()
|
|
.Where(x => (x.Workplace == workplace))
|
|
.List();
|
|
|
|
if (wpRegs.Count == 0)
|
|
{
|
|
WorkplaceRegistration wpReg = new WorkplaceRegistration(workplace, user, ipAddress, processName, workstepName);
|
|
wpRegs.Add(wpReg);
|
|
session.SaveOrUpdate(wpReg);
|
|
log.InfoFormat("RegisterWorkplace(., {0}, {1}, ...) successful (new)", workplace, user);
|
|
return true;
|
|
}
|
|
else if (wpRegs.Count == 1)
|
|
{
|
|
WorkplaceRegistration wpReg = wpRegs[0];
|
|
|
|
wpReg.Active = true;
|
|
wpReg.TimeStamp = DateTime.Now;
|
|
wpReg.ValidUntil = valiUntil;
|
|
wpReg.UserName = user;
|
|
wpReg.IPAddress = ipAddress;
|
|
wpReg.ProcessName = processName;
|
|
wpReg.WorkstepName = workstepName;
|
|
|
|
session.SaveOrUpdate(wpReg);
|
|
log.InfoFormat("RegisterWorkplace(., {0}, {1}, ...) successful", workplace, user);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
log.ErrorFormat("RegisterWorkplace(., {0}, {1}, ...) failed", workplace, user);
|
|
return false;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
log.ErrorFormat("RegisterWorkplace(., {0}, {1}, ...) exception: {2}", workplace, user, e.Message);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Obsolete, use WorkplaceRegistration class instead
|
|
/// </summary>
|
|
public static bool UnregisterWorkplace(ISession session, string workplace)
|
|
{
|
|
try
|
|
{
|
|
IList<WorkplaceRegistration> wpRegs = session
|
|
.QueryOver<WorkplaceRegistration>()
|
|
.Where(x => (x.Workplace == workplace))
|
|
.List();
|
|
|
|
if (wpRegs.Count == 1)
|
|
{
|
|
WorkplaceRegistration wpReg = wpRegs[0];
|
|
|
|
wpReg.Active = false;
|
|
wpReg.TimeStamp = DateTime.Now;
|
|
|
|
session.SaveOrUpdate(wpReg);
|
|
log.InfoFormat("UnregisterWorkplace(., {0}) successful", workplace);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
log.ErrorFormat("UnregisterWorkplace(., {0}) failed", workplace);
|
|
return false;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
log.ErrorFormat("UnregisterWorkplace(., {0}) exception: {1}", workplace, e.Message);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|