827 lines
20 KiB
C#
827 lines
20 KiB
C#
///////////////////////////////////////////////////////////
|
|
// Report.cs
|
|
// Implementation of Class Report
|
|
// CSLA type: Editable Root
|
|
// Created on: 21-March-2005
|
|
// Object design: John
|
|
// Coded: John 21-March-2005
|
|
///////////////////////////////////////////////////////////
|
|
|
|
|
|
using System;
|
|
using System.Data;
|
|
using CSLA.Data;
|
|
using GZTW.Data;
|
|
using CSLA;
|
|
using System.Threading;
|
|
using CSLA.Security;
|
|
//using log4net;
|
|
using System.IO;
|
|
//using System.Collections;
|
|
using System.Runtime.Serialization.Formatters.Binary;
|
|
using System.Runtime.Serialization;
|
|
|
|
|
|
namespace GZTW.AyaNova.BLL
|
|
{
|
|
#pragma warning disable 1591
|
|
|
|
/// <summary>
|
|
/// Report
|
|
/// </summary>
|
|
[Serializable]
|
|
public class Report : BusinessBase
|
|
{
|
|
|
|
// Create a logger for use in this class
|
|
//private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
|
|
#region Attributes
|
|
private bool bReadOnly;
|
|
private Guid mID;
|
|
private string mName=null;
|
|
private SmartDate mCreated;
|
|
private SmartDate mModified;
|
|
|
|
private Guid mCreator;
|
|
private Guid mModifier;
|
|
|
|
private string mReportKey=null;
|
|
private int mReportSize;
|
|
private byte[] mReportContent;
|
|
|
|
private bool mActive;
|
|
|
|
//case 58
|
|
private Guid mRegionID;
|
|
//case 36
|
|
private Guid mSecurityGroupID;
|
|
|
|
#endregion
|
|
|
|
#region Constructor
|
|
|
|
/// <summary>
|
|
/// Private constructor to prevent direct instantiation
|
|
/// </summary>
|
|
private Report()
|
|
{
|
|
////case 1039 //log.Debug("Report()");
|
|
|
|
|
|
|
|
//Set to read / write initially so that properties
|
|
//can be set
|
|
bReadOnly=false;
|
|
|
|
//New ID
|
|
mID = Guid.NewGuid();
|
|
//pre-break the rule
|
|
Name="";
|
|
ReportKey="";
|
|
mReportSize=0;
|
|
|
|
mActive=true;
|
|
|
|
//Set record history to defaults
|
|
mCreated = new SmartDate(DBUtil.CurrentWorkingDateTime);
|
|
mModified=new SmartDate();
|
|
mCreator=Guid.Empty;
|
|
mModifier=Guid.Empty;
|
|
|
|
//Built-in "Default" region
|
|
mRegionID = Region.DefaultRegionID;//case 58
|
|
|
|
//All groups
|
|
mSecurityGroupID = Guid.Empty;
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Business properties
|
|
/// <summary>
|
|
/// Get internal id number Read only property because it's set internally, not
|
|
/// externally
|
|
/// </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>
|
|
/// Set/get name
|
|
/// </summary>
|
|
public string Name
|
|
{
|
|
get
|
|
{
|
|
return mName;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mName!=value)
|
|
{
|
|
mName = value;
|
|
|
|
BrokenRules.Assert("NameRequired","Error.Object.RequiredFieldEmpty,Report.Label.Name","Name",value.Length==0);
|
|
|
|
BrokenRules.Assert("NameLength",
|
|
"Error.Object.FieldLengthExceeded255,Report.Label.Name","Name",value.Length>255);
|
|
|
|
MarkDirty();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set/get ReportKey
|
|
/// </summary>
|
|
public string ReportKey
|
|
{
|
|
get
|
|
{
|
|
return mReportKey;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mReportKey!=value)
|
|
{
|
|
mReportKey = value;
|
|
|
|
BrokenRules.Assert("ReportKeyRequired","Error.Object.RequiredFieldEmpty,Report.Label.ReportKey","ReportKey",value.Length==0);
|
|
|
|
BrokenRules.Assert("ReportKeyLength",
|
|
"Error.Object.FieldLengthExceeded255,Report.Label.ReportKey","ReportKey",value.Length>255);
|
|
|
|
MarkDirty();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Size of binary layout data content
|
|
/// </summary>
|
|
public int ReportSize
|
|
{
|
|
get
|
|
{
|
|
return mReportSize;
|
|
}
|
|
set
|
|
{
|
|
if(mReportSize!=value)
|
|
{
|
|
mReportSize=value;
|
|
MarkDirty();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public System.IO.MemoryStream GetReportContent()
|
|
{
|
|
////case 1039 //log.Debug("GetReportContent()");
|
|
return new System.IO.MemoryStream(mReportContent);
|
|
|
|
}
|
|
|
|
public void SetReportContent(System.IO.MemoryStream mStream)
|
|
{
|
|
mStream.Position=0;
|
|
byte[] bData=new byte[mStream.Length+1];
|
|
mStream.Read(bData,0,(int)mStream.Length);
|
|
ReportSize=(int)mStream.Length;
|
|
mReportContent=bData;
|
|
MarkDirty();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// True=reports are visible in print menu
|
|
/// False=reports are not shown in print menu
|
|
/// </summary>
|
|
public bool Active
|
|
{
|
|
get
|
|
{
|
|
return mActive;
|
|
}
|
|
set
|
|
{
|
|
if(mActive!=value)
|
|
{
|
|
mActive=value;
|
|
MarkDirty();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Limit to specific region or available to all regions using Region.DefaultRegionID
|
|
/// </summary>
|
|
public Guid RegionID
|
|
{
|
|
get
|
|
{
|
|
return mRegionID;
|
|
}
|
|
set
|
|
{
|
|
if (bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if (mRegionID != value)
|
|
{
|
|
mRegionID = value;
|
|
BrokenRules.Assert("RegionIDRequired",
|
|
"Error.Object.RequiredFieldEmpty,O.Region",
|
|
"RegionID", value == Guid.Empty);
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Limit to specific SecurityGroup or available to all if guid.empty
|
|
/// </summary>
|
|
public Guid SecurityGroupID
|
|
{
|
|
get
|
|
{
|
|
return mSecurityGroupID;
|
|
}
|
|
set
|
|
{
|
|
if (bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if (mSecurityGroupID != value)
|
|
{
|
|
mSecurityGroupID = 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.Report")
|
|
)
|
|
);
|
|
}
|
|
#endregion
|
|
|
|
#region System.Object overrides
|
|
|
|
public override string ToString()
|
|
{
|
|
return "Report" + mID.ToString();
|
|
}
|
|
|
|
///
|
|
/// <param name="obj"></param>
|
|
public override bool Equals(Object obj)
|
|
{
|
|
if ( obj == null || GetType ( ) != obj.GetType ( ) ) return false;
|
|
Report c=(Report)obj;
|
|
return mID==c.mID;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
return ("Report"+mID).GetHashCode();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Static methods
|
|
/// <summary>
|
|
/// True if current logged in user has sufficient
|
|
/// rights to view reports
|
|
/// (this does not necessarily indicate that they are allowed to edit them)
|
|
/// </summary>
|
|
public static bool UserCanViewReports
|
|
{
|
|
get
|
|
{
|
|
return (AyaBizUtils.Right("Object.Report") > (int)SecurityLevelTypes.NoAccess);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Create new Report
|
|
/// </summary>
|
|
public static Report NewItem()
|
|
{
|
|
|
|
|
|
if(AyaBizUtils.Right("Object.Report")>(int)SecurityLevelTypes.ReadOnly)
|
|
return new Report();
|
|
else
|
|
throw new System.Security.SecurityException(
|
|
string.Format(
|
|
LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToCreate"),
|
|
LocalizedTextTable.GetLocalizedTextDirect("O.Report")));
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fetch existing Report
|
|
/// </summary>
|
|
/// <param name="_ID">Client Guid</param>
|
|
public static Report GetItem(Guid _ID)
|
|
{
|
|
|
|
if(AyaBizUtils.Right("Object.Report")>(int)SecurityLevelTypes.NoAccess)
|
|
return (Report)DataPortal.Fetch(new Criteria(_ID));
|
|
else
|
|
throw new System.Security.SecurityException(
|
|
string.Format(
|
|
LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToRetrieve"),
|
|
LocalizedTextTable.GetLocalizedTextDirect("O.Report")));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete Report (if clients assigned to this group, should be notified)
|
|
/// </summary>
|
|
/// <param name="_ID">Client GUID</param>
|
|
public static void DeleteItem(Guid _ID)
|
|
{
|
|
|
|
if(AyaBizUtils.Right("Object.Report")>(int)SecurityLevelTypes.ReadWrite)
|
|
DataPortal.Delete(new Criteria(_ID));
|
|
else
|
|
throw new System.Security.SecurityException(
|
|
string.Format(
|
|
LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToDelete"),
|
|
LocalizedTextTable.GetLocalizedTextDirect("O.Report")));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieve internal ID from name.
|
|
///
|
|
/// </summary>
|
|
/// <param name="Name">Text value</param>
|
|
/// <returns>Guid ID value or Guid.Empty if no match</returns>
|
|
public static Guid GetIDFromName(string Name)
|
|
{
|
|
return GuidFetcher.GetItem("AREPORT", "ANAME", Name);
|
|
}
|
|
#endregion
|
|
|
|
#region Serialization
|
|
/// <summary>
|
|
/// Export layout to an AyaNova Transportable Report file (.AYR) at the path indicated
|
|
/// </summary>
|
|
/// <param name="ReportID">Guid of existing report in database</param>
|
|
/// <param name="Path">Full path (including file name) to export to. NOTE: By convention, all AyaNova report file names end in the extension .AYR</param>
|
|
public static void ExportLayout(Guid ReportID, string Path)
|
|
{
|
|
Report r=Report.GetItem(ReportID);
|
|
ReportLayout rl=new ReportLayout();
|
|
rl.ID=r.ID;
|
|
|
|
rl.Name=r.Name;
|
|
rl.ReportContent=r.mReportContent;
|
|
rl.ReportKey=r.ReportKey;
|
|
rl.ReportSize=r.ReportSize;
|
|
|
|
FileStream fs = new FileStream(Path, FileMode.Create);
|
|
|
|
// Construct a BinaryFormatter and use it to serialize the data to the stream.
|
|
BinaryFormatter formatter = new BinaryFormatter();
|
|
formatter.AssemblyFormat=System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Simple;
|
|
try
|
|
{
|
|
formatter.Serialize(fs, rl);
|
|
}
|
|
catch
|
|
{
|
|
//Console.WriteLine("Failed to serialize. Reason: " + e.Message);
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
fs.Close();
|
|
}
|
|
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Import layout from an AyaNova Transportable Report file (.AYR) at the path indicated
|
|
/// </summary>
|
|
/// <param name="Path">Full path (including file name) to import. NOTE: By convention, all AyaNova report file names end in the extension .AYR</param>
|
|
/// <returns>False if report with that ID already exists, true for any other result</returns>
|
|
public static bool ImportLayout(string Path)
|
|
{
|
|
ReportLayout rl=null;
|
|
FileStream fs = new FileStream(Path, FileMode.Open);
|
|
try
|
|
{
|
|
// Construct a BinaryFormatter and use it to de-serialize the data from the stream.
|
|
BinaryFormatter formatter = new BinaryFormatter();
|
|
formatter.AssemblyFormat=System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Simple;
|
|
|
|
rl=(ReportLayout)formatter.Deserialize(fs);
|
|
}
|
|
catch
|
|
{
|
|
//Console.WriteLine("Failed to serialize. Reason: " + e.Message);
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
fs.Close();
|
|
}
|
|
|
|
//See if a report with that id already exists
|
|
if(ReportExistanceChecker.ReportExists(rl.ID))
|
|
return false;
|
|
|
|
Report r=Report.NewItem();
|
|
r.mID=rl.ID;
|
|
r.mCreator=User.CurrentThreadUserID;
|
|
r.mModifier=r.mCreator;
|
|
r.mModified=r.mCreated;
|
|
|
|
|
|
r.Name=rl.Name;
|
|
r.mReportContent=rl.ReportContent;
|
|
r.ReportKey=rl.ReportKey;
|
|
r.mReportSize=rl.ReportSize;
|
|
|
|
r.Save();
|
|
|
|
return true;
|
|
|
|
}
|
|
#endregion
|
|
|
|
#region DAL DATA ACCESS
|
|
|
|
#region Fetch
|
|
///
|
|
/// <param name="Criteria"></param>
|
|
protected override void DataPortal_Fetch(object Criteria)
|
|
{
|
|
//set to false to load items initially
|
|
bReadOnly=false;
|
|
Criteria crit = (Criteria)Criteria;
|
|
SafeDataReader dr = null;
|
|
try
|
|
{
|
|
dr=DBUtil.GetReaderFromSQLString("SELECT * FROM aReport WHERE aID=@ID;",crit.ID);
|
|
if(!dr.Read())
|
|
DBUtil.ThrowFetchError("Report 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");
|
|
|
|
//Report fields
|
|
|
|
//Important: use property not internal field
|
|
//so that initial broken rule is unbroken on fetch
|
|
Name=dr.GetString("aName");
|
|
ReportKey=dr.GetString("aReportKey");
|
|
|
|
//case 58
|
|
mRegionID = dr.GetGuid("aRegionID");
|
|
|
|
//case 36
|
|
mSecurityGroupID = dr.GetGuid("ASECURITYGROUPID");
|
|
|
|
mActive=dr.GetBoolean("AACTIVE");
|
|
//Get the layout size
|
|
mReportSize=dr.GetInt32("aReportSize");
|
|
//Get the number of bytes
|
|
mReportContent=new Byte[mReportSize];
|
|
//retrieve the bytes
|
|
dr.GetBytes("aReportContent",0,mReportContent,0,mReportContent.Length);
|
|
|
|
}
|
|
finally
|
|
{
|
|
if(dr!=null) dr.Close();
|
|
}
|
|
MarkOld();
|
|
|
|
|
|
|
|
//Get access rights level
|
|
bReadOnly=AyaBizUtils.Right("Object.Report")<(int)SecurityLevelTypes.ReadWrite;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#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,"aReport");
|
|
|
|
#region Delete
|
|
if(IsDeleted)
|
|
{
|
|
if(!IsNew)
|
|
{
|
|
|
|
|
|
//Delete object
|
|
DBCommandWrapper cmDelete = DBUtil.GetCommandFromSQL("DELETE FROM aReport WHERE aID = @ID;");
|
|
cmDelete.AddInParameter("@ID",DbType.Guid,this.mID);
|
|
|
|
using (IDbConnection connection = DBUtil.DB.GetConnection())
|
|
{
|
|
connection.Open();
|
|
IDbTransaction transaction = connection.BeginTransaction();
|
|
|
|
try
|
|
{
|
|
|
|
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
|
|
|
|
//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 aReport (aID, aReportKey, aName, aReportSize, aReportContent, " +
|
|
"AACTIVE, aCreated,aModified,aCreator,aModifier, aRegionID, ASECURITYGROUPID) " +
|
|
"VALUES (@ID,@ReportKey,@Name,@ReportSize,@ReportContent," +
|
|
"@Active,@Created,@Modified,@CurrentUserID,@CurrentUserID,@RegionID,@SecurityGroupID);"
|
|
);
|
|
else
|
|
cm=DBUtil.GetCommandFromSQL(
|
|
"UPDATE aReport SET aID=@ID, aReportKey=@ReportKey, " +
|
|
"aName=@Name, AACTIVE=@Active, aReportSize=@ReportSize, aReportContent=@ReportContent, " +
|
|
"aModifier=@CurrentUserID, " +
|
|
"aModified=@Modified, aRegionID=@RegionID, ASECURITYGROUPID=@SecurityGroupID WHERE aReport.aID=@ID"
|
|
);
|
|
|
|
|
|
|
|
cm.AddInParameter("@ID",DbType.Guid,mID);
|
|
cm.AddInParameter("@Name",DbType.String, mName);
|
|
|
|
cm.AddInParameter("@RegionID", DbType.Guid, mRegionID);//case 58
|
|
|
|
cm.AddInParameter("@SecurityGroupID", DbType.Guid, mSecurityGroupID);//case 36
|
|
|
|
cm.AddInParameter("@Active",DbType.Boolean,mActive);
|
|
cm.AddInParameter("@ReportKey",DbType.String, mReportKey);
|
|
cm.AddInParameter("@ReportContent",DbType.Object,mReportContent);
|
|
cm.AddInParameter("@ReportSize",DbType.Int32,mReportSize);
|
|
|
|
//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);
|
|
|
|
|
|
MarkOld();//db is now synched with object
|
|
|
|
// Commit the transaction
|
|
transaction.Commit();
|
|
|
|
}
|
|
catch
|
|
{
|
|
// Rollback transaction
|
|
transaction.Rollback();
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
connection.Close();
|
|
}
|
|
//Successful update so
|
|
//change modification time to match
|
|
this.mModified.Date=dtModified;
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Delete
|
|
/// <summary>
|
|
/// Remove a Report record from the database
|
|
/// </summary>
|
|
/// <param name="Criteria"></param>
|
|
protected override void DataPortal_Delete(object Criteria)
|
|
{
|
|
Criteria crit = (Criteria)Criteria;
|
|
|
|
//Delete object and child objects
|
|
DBCommandWrapper cmDelete = DBUtil.GetCommandFromSQL("DELETE FROM aReport WHERE aID = @ID ;");
|
|
cmDelete.AddInParameter("@ID",DbType.Guid,crit.ID);
|
|
|
|
using (IDbConnection connection = DBUtil.DB.GetConnection())
|
|
{
|
|
connection.Open();
|
|
IDbTransaction transaction = connection.BeginTransaction();
|
|
|
|
try
|
|
{
|
|
DBUtil.DB.ExecuteNonQuery(cmDelete, transaction);
|
|
// Commit the transaction
|
|
transaction.Commit();
|
|
}
|
|
catch
|
|
{ // Rollback transaction
|
|
transaction.Rollback();
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
connection.Close();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion delete
|
|
|
|
#endregion dal data access
|
|
|
|
#region Override IsValid / IsDirty
|
|
//Override base class version if there are child objects
|
|
|
|
public override bool IsValid
|
|
{
|
|
get
|
|
{
|
|
return base.IsValid;
|
|
}
|
|
}
|
|
public override bool IsDirty
|
|
{
|
|
get
|
|
{
|
|
return base.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 Task
|
|
#pragma warning restore 1591
|
|
}//end namespace GZTW.AyaNova.BLL |