956 lines
30 KiB
C#
956 lines
30 KiB
C#
///////////////////////////////////////////////////////////
|
|
// Project.cs
|
|
// Implementation of Class Integration
|
|
// CSLA type: Editable Root
|
|
// Created on: 02-Feb-2006
|
|
// Object design: John
|
|
// Coded: John 02-Feb-2006
|
|
///////////////////////////////////////////////////////////
|
|
|
|
using System;
|
|
using System.Data;
|
|
using CSLA.Data;
|
|
using GZTW.Data;
|
|
using CSLA;
|
|
using System.Runtime.Serialization.Formatters.Binary;
|
|
using System.IO;
|
|
|
|
namespace GZTW.AyaNova.BLL
|
|
{
|
|
/// <summary>
|
|
/// Integration object
|
|
///
|
|
/// This object is used for assisting with integrating 3rd party and
|
|
/// AyaNova utility programs with AyaNova
|
|
///
|
|
/// It's primary function is to provide an API standard method
|
|
/// for storing and retrieving external program data in the AyaNova
|
|
/// database for the purposes of integration with AyaNova
|
|
///
|
|
/// It also contains a child collection for mapping external data
|
|
/// to AyaNova objects
|
|
///
|
|
/// The APPID GUID value must be set to uniquely identify the external
|
|
/// application. The APPVERSION field is used by the implementer for
|
|
/// version control of the data they are storing in AyaNova.
|
|
///
|
|
///
|
|
/// </summary>
|
|
[Serializable]
|
|
public class Integration : BusinessBase
|
|
{
|
|
|
|
#region Attributes
|
|
|
|
|
|
private Guid mID;
|
|
|
|
private SmartDate mCreated;
|
|
private SmartDate mModified;
|
|
private bool mActive;
|
|
private Guid mCreator;
|
|
private Guid mModifier;
|
|
private string mName = null;
|
|
private SmartDate mLastConnect;
|
|
private Guid mAppID = Guid.NewGuid();
|
|
private string mAppVersion = null;
|
|
private string mSyncCheckPoint = "";
|
|
|
|
private object mAIObject = null;
|
|
|
|
//Child collections
|
|
|
|
private IntegrationMaps mMaps;
|
|
|
|
//Not a read only type object, just kept for
|
|
//compatibility reasons
|
|
private bool bReadOnly = false;
|
|
#endregion
|
|
|
|
#region Constructor
|
|
|
|
/// <summary>
|
|
/// Private constructor to prevent direct instantiation
|
|
/// </summary>
|
|
private Integration()
|
|
{
|
|
|
|
|
|
|
|
|
|
//New ID
|
|
mID = Guid.NewGuid();
|
|
|
|
Active = true;
|
|
|
|
//Set record history to defaults
|
|
mCreated = new SmartDate(DBUtil.CurrentWorkingDateTime);
|
|
mModified = new SmartDate();
|
|
mCreator = Guid.Empty;
|
|
mModifier = Guid.Empty;
|
|
mMaps = IntegrationMaps.NewItems();
|
|
|
|
mLastConnect = new SmartDate();
|
|
AppID = Guid.Empty;
|
|
//pre-break name rule
|
|
Name = "";
|
|
AppVersion = "";
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Business properties
|
|
|
|
/// <summary>
|
|
/// Internal Unique GUID value of Integration record in database
|
|
/// </summary>
|
|
public Guid ID
|
|
{
|
|
get
|
|
{
|
|
return mID;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get created date
|
|
///
|
|
///
|
|
/// </summary>
|
|
public string Created
|
|
{
|
|
get
|
|
{
|
|
return mCreated.ToString();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get modified date
|
|
///
|
|
///
|
|
/// </summary>
|
|
public string Modified
|
|
{
|
|
get
|
|
{
|
|
return mModified.ToString();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get user record ID of person who created this record
|
|
///
|
|
///
|
|
/// </summary>
|
|
public Guid Creator
|
|
{
|
|
get
|
|
{
|
|
return mCreator;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get user ID of person who modified this record
|
|
///
|
|
///
|
|
/// </summary>
|
|
public Guid Modifier
|
|
{
|
|
get
|
|
{
|
|
return mModifier;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Collection of Integration data mappings
|
|
/// for this integration
|
|
///
|
|
/// This collection is used to map id values between an external
|
|
/// integration application and AyaNova.
|
|
///
|
|
/// For example the optional QuickBooks interface uses this
|
|
/// collection to map the AyaNova object type and ID of objects with
|
|
/// their counterpart in QuickBooks.
|
|
/// </summary>
|
|
public IntegrationMaps Maps
|
|
{
|
|
get
|
|
{
|
|
return mMaps;
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get /set active status of Integration
|
|
///
|
|
/// This is set by an AyaNova user to turn on or off integration
|
|
/// AyaNova does not and can not enforce this setting, it is up to the external
|
|
/// program developer to honour this setting if applicable.
|
|
///
|
|
/// It is intended to provide a method for the AyaNova user to temporarily
|
|
/// disable integration for a particular application
|
|
/// </summary>
|
|
public bool Active
|
|
{
|
|
get
|
|
{
|
|
return mActive;
|
|
}
|
|
set
|
|
{
|
|
if (bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if (mActive != value)
|
|
{
|
|
mActive = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// The name should be a descriptive name of the product
|
|
/// integrated with AyaNova. It is displayed to the user
|
|
/// through the user interface when viewing the integration log
|
|
/// and managing integration products.
|
|
///
|
|
/// For example the AyaNova add on QBI for integrating with QuickBooks
|
|
/// is identified as "AyaNova QBI" so users understand which application
|
|
/// they are dealing with.
|
|
///
|
|
/// This is a required field 1-255 Unicode characters
|
|
/// </summary>
|
|
public string Name
|
|
{
|
|
get
|
|
{
|
|
return mName;
|
|
}
|
|
set
|
|
{
|
|
if (bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if (mName != value)
|
|
{
|
|
mName = value;
|
|
|
|
BrokenRules.Assert("NameRequired",
|
|
"Error.Object.RequiredFieldEmpty,Integration.Label.Name",
|
|
"Name", value.Length == 0);
|
|
|
|
BrokenRules.Assert("NameLength",
|
|
"Error.Object.FieldLengthExceeded255,Integration.Label.Name",
|
|
"Name", value.Length > 255);
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// DateTime field indicating the last time integration was performed
|
|
/// Set by the external application.
|
|
///
|
|
/// Implementers may use this date as required however it is strongly recommended
|
|
/// that it be set to the last date and time that integration was performed as it will
|
|
/// be displayed to the end user and may assist in troubleshooting.
|
|
///
|
|
/// If a null or non existant date is desired set this value to
|
|
/// System.DateTime.MinValue as that is the standard used in AyaNova for null dates
|
|
///
|
|
/// </summary>
|
|
public DateTime LastConnect
|
|
{
|
|
get
|
|
{
|
|
|
|
return mLastConnect.Date;
|
|
}
|
|
set
|
|
{
|
|
if (bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if (mLastConnect.Date != value)
|
|
{
|
|
mLastConnect.Date = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Unique GUID application ID value
|
|
/// This required field identifies the integration application
|
|
/// uniquely. It should be a standard value used to identify the application
|
|
/// for all users. In other words always stick to the same AppID value don't generate
|
|
/// a unique one for each site using your integration application.
|
|
///
|
|
/// Use the separate AppVersion field for version control
|
|
/// </summary>
|
|
public Guid AppID
|
|
{
|
|
get
|
|
{
|
|
return mAppID;
|
|
}
|
|
set
|
|
{
|
|
if (bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if (mAppID != value)
|
|
{
|
|
mAppID = value;
|
|
BrokenRules.Assert("AppIDRequired",
|
|
"Error.Object.RequiredFieldEmpty,Integration.AppID",
|
|
"AppID", value == Guid.Empty);
|
|
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// The required AppVersion field is used for version control
|
|
/// by the external integrating application.
|
|
///
|
|
/// It is displayed to the user
|
|
/// through the user interface.
|
|
///
|
|
/// Typically this will be a version value such as 2.4.4
|
|
/// however you can put anything you want in this field so
|
|
/// "2008" is acceptible.
|
|
///
|
|
/// This is a required field 1-25 unicode characters
|
|
/// </summary>
|
|
public string AppVersion
|
|
{
|
|
get
|
|
{
|
|
return mAppVersion;
|
|
}
|
|
set
|
|
{
|
|
if (bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if (mAppVersion != value)
|
|
{
|
|
mAppVersion = value;
|
|
|
|
BrokenRules.Assert("AppVersionRequired",
|
|
"Error.Object.RequiredFieldEmpty,Integration.Label.AppVersion",
|
|
"AppVersion", value.Length == 0);
|
|
|
|
BrokenRules.Assert("AppVersionLength",
|
|
"Error.Object.FieldLengthExceeded,Integration.Label.AppVersion,25",
|
|
"AppVersion", value.Length > 25);
|
|
|
|
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// The SyncCheckPoint field is provided for the convenience of the
|
|
/// external program to maintain a checkpoint for syncronization
|
|
/// error recovery.
|
|
///
|
|
///
|
|
/// For example the AyaNova add on QBI for integrating with QuickBooks
|
|
/// uses this field for error recovery if there is an error processing
|
|
/// a request. It contains the last ID of the last message sent to QuickBooks
|
|
/// for processing so that recovery can be made in case of failure.
|
|
///
|
|
/// You can store any data you wish in this field, it is not displayed in the
|
|
/// user interface of AyaNova
|
|
///
|
|
///
|
|
/// This is an optional field 0-255 ASCII characters
|
|
/// </summary>
|
|
public string SyncCheckPoint
|
|
{
|
|
get
|
|
{
|
|
return mSyncCheckPoint;
|
|
}
|
|
set
|
|
{
|
|
if (bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if (mSyncCheckPoint != value)
|
|
{
|
|
mSyncCheckPoint = value;
|
|
|
|
BrokenRules.Assert("SyncCheckPointLength",
|
|
"Error.Object.FieldLengthExceeded255,Integration.Label.SyncCheckPoint",
|
|
"SyncCheckPoint", value.Length > 255);
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Object for use by integration application to persist user settings
|
|
///
|
|
/// You can store any data you wish in this object, it is
|
|
/// serialized to and from the database in a binary blob / image field.
|
|
///
|
|
/// Typically this would be used to persist an integrating applications
|
|
/// settings. I.E. create a serializable class or structure to contain
|
|
/// settings and store / retrieve via this field.
|
|
///
|
|
/// Don't go overboard with this setting it *is* stored in the database and
|
|
/// should not be used to store huge binary objects that do not change, this will
|
|
/// only slow down your application and bloat the users database un-necessarily.
|
|
///
|
|
/// 32k or less is a good rule of thumb
|
|
///
|
|
/// </summary>
|
|
public object AIObject
|
|
{
|
|
get
|
|
{
|
|
|
|
return mAIObject;
|
|
}
|
|
set
|
|
{
|
|
if (bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
// if (mAIObject != value)
|
|
// {
|
|
mAIObject = value;
|
|
MarkDirty();
|
|
|
|
// }
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Throw an error when a read only user
|
|
/// tries to set a property
|
|
/// (this should normally never be called unless someone is using the developer api since the UI
|
|
/// should prevent it from happening initially)
|
|
/// </summary>
|
|
private void ThrowSetError()
|
|
{
|
|
throw new System.Security.SecurityException
|
|
(
|
|
string.Format
|
|
(
|
|
LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToChange"),
|
|
LocalizedTextTable.GetLocalizedTextDirect("O.Integration")
|
|
)
|
|
);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region System.object overrides
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public override string ToString()
|
|
{
|
|
return "Integration" + mID.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="obj"></param>
|
|
/// <returns></returns>
|
|
public override bool Equals(Object obj)
|
|
{
|
|
if (obj == null || GetType() != obj.GetType()) return false;
|
|
Integration c = (Integration)obj;
|
|
return mID == c.mID;
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public override int GetHashCode()
|
|
{
|
|
return ("Integration" + mID).GetHashCode();
|
|
}
|
|
#endregion
|
|
|
|
#region Static methods
|
|
|
|
/// <summary>
|
|
/// Test for existance of integration for
|
|
/// specified app id.
|
|
///
|
|
/// Use this to ensure that your integration data
|
|
/// exists in the database before attempting to fetch it
|
|
/// or create it.
|
|
/// </summary>
|
|
/// <param name="AppID">Unique application ID</param>
|
|
/// <returns></returns>
|
|
public static bool IntegrationExists(Guid AppID)
|
|
{
|
|
return IntegrationExistanceChecker.IntegrationExists(AppID);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create new Integration
|
|
/// </summary>
|
|
/// <param name="AppID">Uniqe integrating application ID. This must never change once used.</param>
|
|
/// <returns>Empty integration object</returns>
|
|
public static Integration NewItem(Guid AppID)
|
|
{
|
|
Integration c;
|
|
c = new Integration();
|
|
c.AppID = AppID;
|
|
return c;
|
|
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fetch existing Integration
|
|
/// </summary>
|
|
/// <returns>Integration</returns>
|
|
/// <param name="ID">Integration Guid</param>
|
|
public static Integration GetItem(Guid ID)
|
|
{
|
|
return (Integration)DataPortal.Fetch(new Criteria(ID));
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete Integration
|
|
/// </summary>
|
|
/// <param name="ID">Integration applicationID</param>
|
|
public static void DeleteItem(Guid ID)
|
|
{
|
|
DataPortal.Delete(new Criteria(ID));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region DAL DATA ACCESS
|
|
|
|
#region Fetch
|
|
///
|
|
/// <param name="Criteria"></param>
|
|
protected override void DataPortal_Fetch(object Criteria)
|
|
{
|
|
|
|
|
|
Criteria crit = (Criteria)Criteria;
|
|
SafeDataReader dr = null;
|
|
|
|
try
|
|
{
|
|
dr = DBUtil.GetReaderFromSQLString("SELECT * FROM aIntegration WHERE AAPPID=@ID;", crit.ID);
|
|
if (!dr.Read())
|
|
DBUtil.ThrowFetchError("Integration ID: " + crit.ID.ToString());
|
|
|
|
//Standard fields
|
|
mID = dr.GetGuid("aID");
|
|
mCreated = DBUtil.ToLocal(dr.GetSmartDate("aCreated"));
|
|
mModified = DBUtil.ToLocal(dr.GetSmartDate("aModified"));
|
|
mCreator = dr.GetGuid("aCreator");
|
|
mModifier = dr.GetGuid("aModifier");
|
|
//Integration fields
|
|
mActive = dr.GetBoolean("AACTIVE");
|
|
AppID = dr.GetGuid("AAPPID");
|
|
Name = dr.GetString("aName");
|
|
AppVersion = dr.GetString("AAPPVERSION");
|
|
mSyncCheckPoint = dr.GetString("aSyncCheckPoint");
|
|
mLastConnect = DBUtil.ToLocal(dr.GetSmartDate("aLastConnect"));
|
|
|
|
//Get the AIObject
|
|
//Get the layout size
|
|
int mAIObjectSize = dr.GetInt32("aIObjectSize");
|
|
//Is there anything to load?
|
|
if (mAIObjectSize > 0)
|
|
{
|
|
BinaryFormatter bformatter = new BinaryFormatter();
|
|
bformatter.AssemblyFormat = System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Simple;
|
|
|
|
//Keeping this for future if necessary
|
|
//was considering it for RI but instead made IntegrationSimple
|
|
//bformatter.Binder = new CurrentAssemblyDeserializationBinder();
|
|
|
|
byte[] obData = new Byte[mAIObjectSize];
|
|
|
|
//retrieve the bytes
|
|
dr.GetBytes("aIObject", 0, obData, 0, mAIObjectSize);
|
|
MemoryStream mstream = new MemoryStream(obData);
|
|
|
|
//intentionally not wrapped in a try block as this should bubble to the caller app
|
|
this.mAIObject = (object)bformatter.Deserialize(mstream);
|
|
|
|
}
|
|
else
|
|
this.mAIObject = null;
|
|
|
|
|
|
|
|
if (dr != null) dr.Close();
|
|
|
|
//Load child collection objects
|
|
|
|
//Maps
|
|
dr = DBUtil.GetReaderFromSQLString(
|
|
"SELECT * " +
|
|
"FROM aIntegrationMap WHERE aIntegrationMap.aIntegrationID=@ID;"
|
|
, mID);
|
|
mMaps = IntegrationMaps.GetItems(dr);
|
|
if (dr != null) dr.Close();
|
|
|
|
|
|
}
|
|
finally
|
|
{
|
|
if (dr != null) dr.Close();
|
|
}
|
|
MarkOld();
|
|
|
|
IntegrationLog.Log(this.mID, "Fetch: " + this.Name + " " + this.mAppID.ToString());
|
|
|
|
}
|
|
|
|
#endregion fetch
|
|
|
|
#region Update
|
|
|
|
/// <summary>
|
|
/// Called by DataPortal to delete/add/update data into the database
|
|
/// </summary>
|
|
protected override void DataPortal_Update()
|
|
{
|
|
// If not a new record, check if record was modified
|
|
//by another user since original retrieval:
|
|
if (!IsNew)
|
|
DBUtil.CheckSafeToUpdate(this.mModified.Date, this.mID, "aIntegration");
|
|
|
|
#region Delete
|
|
if (IsDeleted)
|
|
{
|
|
if (!IsNew)
|
|
{
|
|
IntegrationLog.Log(this.mID, "Delete: " + this.Name + " " + this.mAppID.ToString());
|
|
|
|
//Delete object and child objects
|
|
DBCommandWrapper cmDelete = DBUtil.GetCommandFromSQL("DELETE FROM aIntegration WHERE AAPPID = @ID;");
|
|
cmDelete.AddInParameter("@ID", DbType.Guid, this.mAppID);
|
|
|
|
DBCommandWrapper cmDeleteMaps = DBUtil.GetCommandFromSQL("DELETE FROM aIntegrationMap WHERE aIntegrationID = @ID;");
|
|
cmDeleteMaps.AddInParameter("@ID", DbType.Guid, this.mID);//case 1287 was using appid here not integration id
|
|
|
|
using (IDbConnection connection = DBUtil.DB.GetConnection())
|
|
{
|
|
connection.Open();
|
|
IDbTransaction transaction = connection.BeginTransaction();
|
|
|
|
try
|
|
{
|
|
DBUtil.DB.ExecuteNonQuery(cmDeleteMaps, transaction);
|
|
DBUtil.DB.ExecuteNonQuery(cmDelete, transaction);
|
|
|
|
// Commit the transaction
|
|
transaction.Commit();
|
|
|
|
}
|
|
catch
|
|
{
|
|
// Rollback transaction
|
|
transaction.Rollback();
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
connection.Close();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------
|
|
}
|
|
MarkNew();
|
|
return;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Add / Update
|
|
/*
|
|
* AID D_GUID NOT NULL,
|
|
ACREATED TIMESTAMP,
|
|
AMODIFIED TIMESTAMP,
|
|
ACREATOR D_GUID,
|
|
AMODIFIER D_GUID,
|
|
AACTIVE D_BOOL NOT NULL CHECK (VALUE IN(0,1)),
|
|
ANAME VARCHAR(255) CHARACTER SET UNICODE_FSS NOT NULL COLLATE UNICODE_FSS,
|
|
ALASTCONNECT TIMESTAMP,
|
|
AIOBJECT BLOB SEGMENT SIZE 1,
|
|
AIOBJECTSIZE INTEGER,
|
|
AAPPID D_GUID NOT NULL,
|
|
AAPPVERSION VARCHAR(25) CHARACTER SET UNICODE_FSS NOT NULL COLLATE UNICODE_FSS,
|
|
ASYNCCHECKPOINT VARCHAR(255) CHARACTER SET ASCII COLLATE ASCII);
|
|
*/
|
|
//get modification time temporarily, if update succeeds then
|
|
//set to this time
|
|
System.DateTime dtModified = DBUtil.CurrentWorkingDateTime;
|
|
DBCommandWrapper cm = null;
|
|
if (IsNew)//Add or update?
|
|
cm = DBUtil.GetCommandFromSQL(
|
|
"INSERT INTO aIntegration (aID, AACTIVE, aCreated,aModified,aCreator,aModifier, " +
|
|
"aName,aLastConnect,aIObject,aIObjectSize,AAPPID,AAPPVERSION,aSyncCheckPoint) " +
|
|
"VALUES (@ID,@Active,@Created,@Modified,@CurrentUserID,@CurrentUserID, " +
|
|
"@Name,@LastConnect,@IObject,@IObjectSize,@AppID,@AppVersion,@SyncCheckPoint)"
|
|
);
|
|
else
|
|
cm = DBUtil.GetCommandFromSQL(
|
|
"UPDATE aIntegration SET aID=@ID, " +
|
|
"AACTIVE=@Active,aModified=@Modified,aModifier=@CurrentUserID,aName=@Name, " +
|
|
"aLastConnect=@LastConnect,aIObject=@IObject,aIObjectSize=@IObjectSize, " +
|
|
"AAPPID=@AppID,AAPPVERSION=@AppVersion,aSyncCheckPoint=@SyncCheckPoint " +
|
|
"WHERE AAPPID=@AppID"
|
|
);
|
|
|
|
|
|
//Integration fields
|
|
cm.AddInParameter("@ID", DbType.Guid, mID);
|
|
cm.AddInParameter("@Active", DbType.Boolean, mActive);
|
|
cm.AddInParameter("@Name", DbType.String, mName);
|
|
cm.AddInParameter("@LastConnect", DbType.DateTime, DBUtil.ToUTC(mLastConnect).DBValue);
|
|
cm.AddInParameter("@AppID", DbType.Guid, this.mAppID);
|
|
|
|
//AIObject serialize:
|
|
if (mAIObject != null)
|
|
{
|
|
MemoryStream ms = new MemoryStream();
|
|
BinaryFormatter b = new BinaryFormatter();
|
|
b.AssemblyFormat = System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Simple;
|
|
b.Serialize(ms, mAIObject);
|
|
cm.AddInParameter("@IObjectSize", DbType.Int32, ms.Length);
|
|
cm.AddInParameter("@IObject", DbType.Object, ms.GetBuffer());
|
|
}
|
|
else
|
|
{
|
|
cm.AddInParameter("@IObjectSize", DbType.Int32, 0);
|
|
cm.AddInParameter("@IObject", DbType.Object, new byte[1]);
|
|
|
|
}
|
|
|
|
|
|
|
|
cm.AddInParameter("@AppVersion", DbType.String, this.mAppVersion);
|
|
cm.AddInParameter("@SyncCheckPoint", DbType.String, this.mSyncCheckPoint);
|
|
|
|
|
|
|
|
//Standard fields
|
|
cm.AddInParameter("@CurrentUserID", DbType.Guid, CurrentUserID);
|
|
cm.AddInParameter("@Created", DbType.DateTime, DBUtil.ToUTC(mCreated).DBValue);
|
|
cm.AddInParameter("@Modified", DbType.DateTime, DBUtil.ToUTC(dtModified));
|
|
|
|
|
|
|
|
using (IDbConnection connection = DBUtil.DB.GetConnection())
|
|
{
|
|
connection.Open();
|
|
IDbTransaction transaction = connection.BeginTransaction();
|
|
|
|
try
|
|
{
|
|
|
|
DBUtil.DB.ExecuteNonQuery(cm, transaction);
|
|
|
|
//Update child objects
|
|
mMaps.Update(this, transaction);
|
|
|
|
|
|
MarkOld();//db is now synched with object
|
|
|
|
// Commit the transaction
|
|
transaction.Commit();
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
IntegrationLog.Log(this.mAppID, "Update exception: " + this.Name + " " + this.mAppID.ToString() + "\r\n" + ex.Message);
|
|
// Rollback transaction
|
|
transaction.Rollback();
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
connection.Close();
|
|
}
|
|
//Successful update so
|
|
//change modification time to match
|
|
this.mModified.Date = dtModified;
|
|
}
|
|
|
|
IntegrationLog.Log(this.mAppID, "Saved: " + this.Name + " " + this.mAppID.ToString());
|
|
#endregion
|
|
|
|
}
|
|
|
|
#endregion update
|
|
|
|
#region Delete
|
|
|
|
/// <summary>
|
|
/// Remove a Integration record .
|
|
/// </summary>
|
|
/// <param name="Criteria"></param>
|
|
protected override void DataPortal_Delete(object Criteria)
|
|
{
|
|
Criteria crit = (Criteria)Criteria;
|
|
|
|
|
|
//case 1981 changed from original block
|
|
IntegrationExistanceChecker exists = IntegrationExistanceChecker.IntegrationExistsEx(crit.ID);
|
|
if (!exists.Exists)
|
|
return;
|
|
Guid integrationInternalId = exists.InternalID;
|
|
|
|
|
|
//Delete object and child objects
|
|
DBCommandWrapper cmDelete = DBUtil.GetCommandFromSQL("DELETE FROM aIntegration WHERE AAPPID = @ID;");
|
|
cmDelete.AddInParameter("@ID", DbType.Guid, crit.ID);
|
|
|
|
DBCommandWrapper cmDeleteMaps = DBUtil.GetCommandFromSQL("DELETE FROM aIntegrationMap WHERE aIntegrationID = @ID;");
|
|
cmDeleteMaps.AddInParameter("@ID", DbType.Guid, integrationInternalId);//case 1287
|
|
|
|
|
|
using (IDbConnection connection = DBUtil.DB.GetConnection())
|
|
{
|
|
connection.Open();
|
|
IDbTransaction transaction = connection.BeginTransaction();
|
|
|
|
try
|
|
{
|
|
DBUtil.DB.ExecuteNonQuery(cmDeleteMaps, transaction);
|
|
DBUtil.DB.ExecuteNonQuery(cmDelete, transaction);
|
|
|
|
|
|
// Commit the transaction
|
|
transaction.Commit();
|
|
|
|
}
|
|
catch
|
|
{
|
|
// Rollback transaction
|
|
transaction.Rollback();
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
connection.Close();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion delete
|
|
|
|
#endregion
|
|
|
|
#region Override IsValid / IsDirty
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public override bool IsValid
|
|
{
|
|
get
|
|
{
|
|
return base.IsValid && mMaps.IsValid;
|
|
}
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public override bool IsDirty
|
|
{
|
|
get
|
|
{
|
|
return base.IsDirty || mMaps.IsDirty;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region criteria
|
|
/// <summary>
|
|
/// Criteria for identifying existing object
|
|
/// </summary>
|
|
[Serializable]
|
|
private class Criteria
|
|
{
|
|
public Guid ID;
|
|
public Criteria(Guid _ID)
|
|
{
|
|
ID = _ID;
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
|
|
}//end Integration
|
|
|
|
|
|
#region Deserializer helper
|
|
///// <summary>
|
|
///// Custom deserialization binder to handle version conflicts from the mistake of using binary formatter in the first place
|
|
///// </summary>
|
|
//public sealed class CurrentAssemblyDeserializationBinder : System.Runtime.Serialization.SerializationBinder
|
|
//{
|
|
// public override Type BindToType(string assemblyName, string typeName)
|
|
// {
|
|
// return Type.GetType(String.Format("{0}, {1}", typeName, System.Reflection.Assembly.GetExecutingAssembly().FullName));
|
|
// }
|
|
//}
|
|
#endregion
|
|
|
|
}//end namespace GZTW.AyaNova.BLL |