2526 lines
66 KiB
C#
2526 lines
66 KiB
C#
///////////////////////////////////////////////////////////
|
|
// Unit.cs
|
|
// Implementation of Class Unit
|
|
// CSLA type: Editable Root
|
|
// Created on: 07-Jun-2004 8:41:38 AM
|
|
// Object design: Joyce
|
|
// Coded: John 20-July-2004
|
|
///////////////////////////////////////////////////////////
|
|
|
|
using System;
|
|
using System.Data;
|
|
using CSLA.Data;
|
|
using GZTW.Data;
|
|
using CSLA;
|
|
using System.Threading;
|
|
using CSLA.Security;
|
|
|
|
namespace GZTW.AyaNova.BLL
|
|
{
|
|
/// <summary>
|
|
/// Unit - an item attributed to a specific client that is to be repaired or serviced
|
|
/// </summary>
|
|
[Serializable]
|
|
public class Unit : BusinessBase {
|
|
|
|
|
|
#region Attributes
|
|
|
|
private bool bReadOnly;
|
|
private Guid mID;
|
|
private SmartDate mCreated;
|
|
private SmartDate mModified;
|
|
private bool mActive;
|
|
private Guid mCreator;
|
|
private Guid mModifier;
|
|
private Address mGoToAddress;
|
|
private AssignedDocs mDocs;
|
|
private string mNotes="";
|
|
|
|
|
|
|
|
private string mSerial=null;
|
|
private Guid mUnitModelID;
|
|
private string mDescription="";
|
|
|
|
private Guid mClientID;
|
|
|
|
|
|
|
|
|
|
private bool mUnitHasOwnAddress;
|
|
private bool mBoughtHere;
|
|
private Guid mPurchasedFromID;
|
|
private string mReceipt="";
|
|
private SmartDate mPurchasedDate;
|
|
|
|
private Guid mReplacedByUnitID;
|
|
|
|
private bool mOverrideModelWarranty;
|
|
private string mWarrantyTerms="";
|
|
|
|
|
|
//ID of unit this unit is to be grouped as a child under
|
|
//can be null
|
|
private Guid mParentUnitID;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//Custom fields
|
|
private string mCustom1="";
|
|
private string mCustom2="";
|
|
private string mCustom3="";
|
|
private string mCustom4="";
|
|
private string mCustom5="";
|
|
private string mCustom6="";
|
|
private string mCustom7="";
|
|
private string mCustom8="";
|
|
private string mCustom9="";
|
|
private string mCustom0="";
|
|
|
|
private bool mUsesBanking;
|
|
|
|
private bool mMetered;
|
|
|
|
private int mWarrantyLength;
|
|
private bool mLifeTimeWarranty;
|
|
|
|
private string mText1 = "";
|
|
private string mText2 = "";
|
|
private string mText3 = "";
|
|
private string mText4 = "";
|
|
|
|
|
|
#endregion
|
|
|
|
#region Constructor
|
|
|
|
/// <summary>
|
|
/// Private constructor to prevent direct instantiation
|
|
/// </summary>
|
|
private Unit()
|
|
{
|
|
|
|
|
|
|
|
//Set to read / write initially so that properties
|
|
//can be set
|
|
bReadOnly=false;
|
|
|
|
//New ID
|
|
mID = Guid.NewGuid();
|
|
|
|
Active=true;
|
|
mPurchasedDate=new SmartDate();
|
|
|
|
|
|
//Set record history to defaults
|
|
mCreated = new SmartDate(DBUtil.CurrentWorkingDateTime);
|
|
mModified=new SmartDate();
|
|
mCreator=Guid.Empty;
|
|
mModifier=Guid.Empty;
|
|
|
|
mUsesBanking=false;
|
|
mMetered=false;
|
|
|
|
mOverrideModelWarranty=false;
|
|
mLifeTimeWarranty=false;
|
|
mWarrantyLength=0;
|
|
mDocs=AssignedDocs.NewItems();
|
|
|
|
//pre-break the client required rule
|
|
ClientID=Guid.NewGuid();
|
|
ClientID=Guid.Empty;
|
|
|
|
//pre-break the serial required rule
|
|
Serial = "";
|
|
|
|
}
|
|
|
|
#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>
|
|
/// Get /set active status of Unit
|
|
/// If active = true then Unit is selectable for workorders etc
|
|
/// If active = false then Unit in not selectable, but history can be viewed
|
|
/// </summary>
|
|
public bool Active
|
|
{
|
|
get
|
|
{
|
|
return mActive;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mActive!=value)
|
|
{
|
|
mActive = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get service address for this Unit
|
|
/// can be used to override client address
|
|
/// if unit is not at client's site
|
|
/// </summary>
|
|
public Address GoToAddress
|
|
{
|
|
get
|
|
{
|
|
return mGoToAddress;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Notes about unit
|
|
/// </summary>
|
|
public string Notes
|
|
{
|
|
get
|
|
{
|
|
return mNotes;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mNotes!=value)
|
|
{
|
|
mNotes = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Assigned documents collection for unit
|
|
/// </summary>
|
|
public AssignedDocs Docs
|
|
{
|
|
get
|
|
{
|
|
return mDocs;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Overrides any other warranty terms from unitmodel
|
|
/// </summary>
|
|
public bool OverrideModelWarranty
|
|
{
|
|
get
|
|
{
|
|
return mOverrideModelWarranty;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mOverrideModelWarranty!=value)
|
|
{
|
|
mOverrideModelWarranty = value;
|
|
//clear any override terms
|
|
if(value==false)
|
|
{
|
|
WarrantyTerms="";
|
|
LifeTimeWarranty=false;
|
|
WarrantyLength=0;
|
|
|
|
|
|
|
|
}
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Terms for the unit's warranty
|
|
/// </summary>
|
|
public string WarrantyTerms
|
|
{
|
|
get
|
|
{
|
|
return mWarrantyTerms;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mWarrantyTerms!=value)
|
|
{
|
|
mWarrantyTerms = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// <see cref="Client"/> unit assigned to
|
|
///
|
|
/// </summary>
|
|
public Guid ClientID
|
|
{
|
|
get
|
|
{
|
|
return mClientID;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mClientID!=value)
|
|
{
|
|
mClientID = value;
|
|
BrokenRules.Assert("ClientIDRequired",
|
|
"Error.Object.RequiredFieldEmpty,O.Client",
|
|
"ClientID",value==Guid.Empty);
|
|
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// <see cref="Vendor"/> where purchased from
|
|
/// </summary>
|
|
public Guid PurchasedFromID
|
|
{
|
|
get
|
|
{
|
|
return mPurchasedFromID;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mPurchasedFromID!=value)
|
|
{
|
|
mPurchasedFromID = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional <see cref="UnitModel"/> type for this unit
|
|
///
|
|
/// </summary>
|
|
public Guid UnitModelID
|
|
{
|
|
get
|
|
{
|
|
return mUnitModelID;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mUnitModelID!=value)
|
|
{
|
|
mUnitModelID = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// ID of unit this unit is to be grouped as a child under (null or empty id = no parent)
|
|
/// </summary>
|
|
public Guid ParentID
|
|
{
|
|
get
|
|
{
|
|
return mParentUnitID;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mParentUnitID!=value)
|
|
{
|
|
mParentUnitID = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// default is false
|
|
/// if true, unit address is specified in GoToAddress
|
|
/// </summary>
|
|
public bool UnitHasOwnAddress
|
|
{
|
|
get
|
|
{
|
|
return mUnitHasOwnAddress;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mUnitHasOwnAddress!=value)
|
|
{
|
|
mUnitHasOwnAddress = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Serial number of unit. This is the primary identifier in AyaNova however duplicates are allowed.
|
|
/// The UI presents a warning on duplicate entry, calling directly does not so be careful calling this in code.
|
|
/// </summary>
|
|
public string Serial
|
|
{
|
|
get
|
|
{
|
|
return mSerial;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mSerial!=value)
|
|
{
|
|
mSerial = value;
|
|
|
|
BrokenRules.Assert("SerialRequired",
|
|
"Error.Object.RequiredFieldEmpty,Unit.Label.Serial",
|
|
"Serial",value.Length==0);
|
|
|
|
BrokenRules.Assert("SerialLength",
|
|
"Error.Object.FieldLengthExceeded255,Unit.Label.Serial",
|
|
"Serial",value.Length>255);
|
|
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Original sales receipt number
|
|
/// </summary>
|
|
public string Receipt
|
|
{
|
|
get
|
|
{
|
|
return mReceipt;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mReceipt!=value)
|
|
{
|
|
mReceipt = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// default is true
|
|
/// if false, than select PurchasedFrom vendor id
|
|
/// </summary>
|
|
public bool BoughtHere
|
|
{
|
|
get
|
|
{
|
|
return mBoughtHere;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mBoughtHere!=value)
|
|
{
|
|
mBoughtHere = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Date unit was purchased
|
|
/// Utilized to determine warranty info
|
|
/// </summary>
|
|
public object PurchasedDate
|
|
{
|
|
get
|
|
{
|
|
return mPurchasedDate.DBValue;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if (!AyaBizUtils.SmartDateEquals(mPurchasedDate, value)) //Case 298
|
|
{
|
|
mPurchasedDate.DBValue = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Description of unit to display if no model chosen
|
|
/// </summary>
|
|
public string Description
|
|
{
|
|
get
|
|
{
|
|
return mDescription;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mDescription!=value)
|
|
{
|
|
mDescription = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// If a unit is replaced while in warranty (WorkorderItemOutsideService) sets this
|
|
/// unit to inactive, and enters in new units serialnumber that replaced it
|
|
/// </summary>
|
|
public Guid ReplacedByUnitID
|
|
{
|
|
get
|
|
{
|
|
return mReplacedByUnitID;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mReplacedByUnitID!=value)
|
|
{
|
|
mReplacedByUnitID = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#region CUSTOM FIELDS
|
|
|
|
/// <summary>
|
|
/// Custom1
|
|
/// </summary>
|
|
public string Custom1
|
|
{
|
|
get
|
|
{
|
|
return mCustom1;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mCustom1!=value)
|
|
{
|
|
mCustom1 = value;
|
|
BrokenRules.Assert("Custom1Length",
|
|
"Error.Object.FieldLengthExceeded500,Unit.Label.Custom1","Custom1",value.Length>500);
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Custom2
|
|
/// </summary>
|
|
public string Custom2
|
|
{
|
|
get
|
|
{
|
|
return mCustom2;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mCustom2!=value)
|
|
{
|
|
mCustom2 = value;
|
|
BrokenRules.Assert("Custom2Length",
|
|
"Error.Object.FieldLengthExceeded500,Unit.Label.Custom2","Custom2",value.Length>500);
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Custom3
|
|
/// </summary>
|
|
public string Custom3
|
|
{
|
|
get
|
|
{
|
|
return mCustom3;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mCustom3!=value)
|
|
{
|
|
mCustom3 = value;
|
|
BrokenRules.Assert("Custom3Length",
|
|
"Error.Object.FieldLengthExceeded500,Unit.Label.Custom3","Custom3",value.Length>500);
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Custom4
|
|
/// </summary>
|
|
public string Custom4
|
|
{
|
|
get
|
|
{
|
|
return mCustom4;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mCustom4!=value)
|
|
{
|
|
mCustom4 = value;
|
|
BrokenRules.Assert("Custom4Length",
|
|
"Error.Object.FieldLengthExceeded500,Unit.Label.Custom4","Custom4",value.Length>500);
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Custom5
|
|
/// </summary>
|
|
public string Custom5
|
|
{
|
|
get
|
|
{
|
|
return mCustom5;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mCustom5!=value)
|
|
{
|
|
mCustom5 = value;
|
|
BrokenRules.Assert("Custom5Length",
|
|
"Error.Object.FieldLengthExceeded500,Unit.Label.Custom5","Custom5",value.Length>500);
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Custom6
|
|
/// </summary>
|
|
public string Custom6
|
|
{
|
|
get
|
|
{
|
|
return mCustom6;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mCustom6!=value)
|
|
{
|
|
mCustom6 = value;
|
|
BrokenRules.Assert("Custom6Length",
|
|
"Error.Object.FieldLengthExceeded500,Unit.Label.Custom6","Custom6",value.Length>500);
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Custom7
|
|
/// </summary>
|
|
public string Custom7
|
|
{
|
|
get
|
|
{
|
|
return mCustom7;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mCustom7!=value)
|
|
{
|
|
mCustom7 = value;
|
|
BrokenRules.Assert("Custom7Length",
|
|
"Error.Object.FieldLengthExceeded500,Unit.Label.Custom7","Custom7",value.Length>500);
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Custom8
|
|
/// </summary>
|
|
public string Custom8
|
|
{
|
|
get
|
|
{
|
|
return mCustom8;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mCustom8!=value)
|
|
{
|
|
mCustom8 = value;
|
|
BrokenRules.Assert("Custom8Length",
|
|
"Error.Object.FieldLengthExceeded500,Unit.Label.Custom8","Custom8",value.Length>500);
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Custom9
|
|
/// </summary>
|
|
public string Custom9
|
|
{
|
|
get
|
|
{
|
|
return mCustom9;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mCustom9!=value)
|
|
{
|
|
mCustom9 = value;
|
|
BrokenRules.Assert("Custom9Length",
|
|
"Error.Object.FieldLengthExceeded500,Unit.Label.Custom9","Custom9",value.Length>500);
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Custom0
|
|
/// </summary>
|
|
public string Custom0
|
|
{
|
|
get
|
|
{
|
|
return mCustom0;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mCustom0!=value)
|
|
{
|
|
mCustom0 = value;
|
|
BrokenRules.Assert("Custom0Length",
|
|
"Error.Object.FieldLengthExceeded500,Unit.Label.Custom0","Custom0",value.Length>500);
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endregion custom fields
|
|
|
|
/// <summary>
|
|
/// If true then banked service is tracked
|
|
/// for this object (hours / money / incidents)
|
|
/// </summary>
|
|
public bool UsesBanking
|
|
{
|
|
get
|
|
{
|
|
return mUsesBanking;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mUsesBanking!=value)
|
|
{
|
|
mUsesBanking = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// If true then meter readings can be entered for this unit
|
|
/// </summary>
|
|
public bool Metered
|
|
{
|
|
get
|
|
{
|
|
return mMetered;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mMetered!=value)
|
|
{
|
|
mMetered = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Lifetime warranty which never expires
|
|
/// overrides all other warranty terms
|
|
///
|
|
/// </summary>
|
|
public bool LifeTimeWarranty
|
|
{
|
|
get
|
|
{
|
|
return mLifeTimeWarranty;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mLifeTimeWarranty!=value)
|
|
{
|
|
mLifeTimeWarranty = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Warranty length in months
|
|
/// Ignored if LifeTimeWarranty selected
|
|
/// </summary>
|
|
public int WarrantyLength
|
|
{
|
|
get
|
|
{
|
|
return mWarrantyLength;
|
|
}
|
|
set
|
|
{
|
|
if(bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if(mWarrantyLength!=value)
|
|
{
|
|
mWarrantyLength = value;
|
|
MarkDirty();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//========= Resolved warranty ===================
|
|
|
|
/// <summary>
|
|
/// Returns <see cref="WarrantyStatus"/> of this unit based on all possible influences on warranty
|
|
/// such as lifetime, purchase date vs length of warranty for this unit or model of unit etc.
|
|
/// </summary>
|
|
public WarrantyStatus WarrantyStatusResolved
|
|
{
|
|
get
|
|
{
|
|
//First possible warranty is the override warranty for this unit...
|
|
if(mOverrideModelWarranty)
|
|
{
|
|
//Does it have a lifetime warranty?
|
|
if(mLifeTimeWarranty) return WarrantyStatus.Active;
|
|
|
|
//Ok, at this point the only possible UNIT warranty left is the
|
|
//unit warranty length in months, so this depends upon age of unit
|
|
//which requires a purchase date to Process
|
|
if(mPurchasedDate.IsEmpty) return WarrantyStatus.None;
|
|
|
|
//Do we have a unit warranty length greater than zero?
|
|
if(mWarrantyLength<1) return WarrantyStatus.None;
|
|
|
|
|
|
//Ok, we have a purchase date and we have a Unit warranty length so
|
|
//see if it's still under warranty
|
|
|
|
//If the purchase date plus the months in the warranty is a date
|
|
//greater than right now, then it's still under warranty...
|
|
if (mPurchasedDate.Date.AddMonths(mWarrantyLength) > DBUtil.CurrentWorkingDateTime)
|
|
return WarrantyStatus.Active;
|
|
else
|
|
return WarrantyStatus.Expired;
|
|
|
|
}
|
|
|
|
//Ok, it doesn't have it's own specific warranty, only
|
|
//other possibility is a unit model warranty...
|
|
|
|
//Is there a unit model for this unit?
|
|
if(this.UnitModelID==Guid.Empty) return WarrantyStatus.None;
|
|
|
|
//Get it...
|
|
UnitModel m=UnitModel.GetItem(this.UnitModelID);
|
|
|
|
//Is it a lifetime warranty?
|
|
if(m.LifeTimeWarranty) return WarrantyStatus.Active;
|
|
|
|
//Ok, at this point the only possible warranty left is the
|
|
//unit model warranty length in months, so this depends upon age of unit
|
|
if(mPurchasedDate.IsEmpty) return WarrantyStatus.None;
|
|
|
|
//Do we have a unit model warranty length greater than zero?
|
|
if(m.WarrantyLength<1) return WarrantyStatus.None;
|
|
|
|
|
|
//Ok, we have a purchase date and we have a unitmodel warranty length so
|
|
//see if it's still under warranty
|
|
|
|
//If the purchase date plus the months in the warranty is a date
|
|
//greater than right now, then it's still under warranty...
|
|
if (mPurchasedDate.Date.AddMonths(m.WarrantyLength) > DBUtil.CurrentWorkingDateTime)
|
|
return WarrantyStatus.Active;
|
|
else
|
|
return WarrantyStatus.Expired;
|
|
|
|
|
|
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resolved warranty expiry date
|
|
/// (definitive date from either unit model or
|
|
/// this unit's overriden properties)
|
|
/// If there is a lifetime warranty it returns DateTime.MaxValue
|
|
/// If there is no warranty expiry date determineable then it returns null.
|
|
/// Otherwise it returns a DateTime set to warranty expiry date.
|
|
/// </summary>
|
|
public object WarrantyExpiryDateResolved
|
|
{
|
|
get
|
|
{
|
|
//First possible warranty date is the override warranty for this unit...
|
|
if(mOverrideModelWarranty)
|
|
{
|
|
if(mLifeTimeWarranty) return System.DateTime.MaxValue;
|
|
|
|
//Ok, at this point the only possible warranty left is the
|
|
//unit warranty length in months, so this depends upon age of unit
|
|
if(mPurchasedDate.IsEmpty) return null;
|
|
|
|
//Do we have a unit warranty length greater than zero?
|
|
if(mWarrantyLength<1) return null;
|
|
|
|
|
|
//Ok, we have a purchase date and we have a unit warranty length so
|
|
//calculate and return expiry date
|
|
return mPurchasedDate.Date.AddMonths(mWarrantyLength);
|
|
|
|
|
|
}
|
|
|
|
//Ok, it doesn't have a custom warranty, only
|
|
//other possibility is a unit model warranty...
|
|
|
|
//Is there a unit model for this unit?
|
|
if(this.UnitModelID==Guid.Empty) return null;
|
|
|
|
//Get it...
|
|
UnitModel m=UnitModel.GetItem(this.UnitModelID);
|
|
|
|
//Is it a lifetime warranty?
|
|
if(m.LifeTimeWarranty) return System.DateTime.MaxValue;
|
|
|
|
//Ok, at this point the only possible warranty left is the
|
|
//unit model warranty length in months, so this depends upon age of unit
|
|
if(mPurchasedDate.IsEmpty) return null;
|
|
|
|
//Do we have a unit model warranty length greater than zero?
|
|
if(m.WarrantyLength<1) return null;
|
|
|
|
|
|
//Ok, we have a purchase date and we have a unitmodel warranty length so
|
|
//calculate and return expiry date
|
|
return mPurchasedDate.Date.AddMonths(m.WarrantyLength);
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Warranty terms resolved
|
|
/// (either from unit model or this units
|
|
/// overriden warranty properties as required)
|
|
/// Returns text of warranty terms or an empty string if none found
|
|
/// or no warranty applicb
|
|
/// </summary>
|
|
public string WarrantyTermsResolved
|
|
{
|
|
get
|
|
{
|
|
//First possible warranty is the override warranty for this unit...
|
|
if(mOverrideModelWarranty)
|
|
{
|
|
return mWarrantyTerms;
|
|
}
|
|
|
|
//Ok, it doesn't have a custom warranty, only
|
|
//other possibility is a unit model warranty...
|
|
|
|
|
|
//Is there a unit model for this unit?
|
|
if(this.UnitModelID==Guid.Empty) return "";
|
|
|
|
//Get it...
|
|
UnitModel m=UnitModel.GetItem(this.UnitModelID);
|
|
return m.WarrantyTerms;
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Brief unit history for display on work orders
|
|
/// Includes last closed service workorder number and date
|
|
/// and
|
|
/// Purchase Date:
|
|
/// Purchased From:
|
|
/// Receipt Number:
|
|
/// (localized)
|
|
///
|
|
/// </summary>
|
|
public string History
|
|
{
|
|
get
|
|
{
|
|
UnitLastServiceWorkorderInfoFetcher f = UnitLastServiceWorkorderInfoFetcher.LastServiceInfo(mID);
|
|
System.Text.StringBuilder sb = new System.Text.StringBuilder();
|
|
|
|
sb.Append(LocalizedTextTable.GetLocalizedTextDirect("UI.Label.LastServiceDate"));
|
|
sb.Append(": ");
|
|
if (f.LastServiceWorkorderNumber != -1)
|
|
sb.Append(f.LastServiceDate.ToString());
|
|
else
|
|
sb.Append("-");
|
|
sb.Append("\r\n");
|
|
|
|
sb.Append(LocalizedTextTable.GetLocalizedTextDirect("UI.Label.LastWorkorder"));
|
|
sb.Append(": ");
|
|
if (f.LastServiceWorkorderNumber != -1)
|
|
sb.Append(f.LastServiceWorkorderNumber.ToString());
|
|
else
|
|
sb.Append("-");
|
|
sb.Append("\r\n");
|
|
|
|
if (!mPurchasedDate.IsEmpty)
|
|
{
|
|
sb.Append(LocalizedTextTable.GetLocalizedTextDirect("Unit.Label.PurchasedDate"));
|
|
sb.Append(": ");
|
|
sb.Append(mPurchasedDate.ToString());
|
|
sb.Append("\r\n");
|
|
}
|
|
|
|
if (mPurchasedFromID!=Guid.Empty)
|
|
{
|
|
if (VendorExistanceChecker.VendorExists(mPurchasedFromID, ""))
|
|
{
|
|
sb.Append(LocalizedTextTable.GetLocalizedTextDirect("Unit.Label.PurchaseFromID"));
|
|
sb.Append(": ");
|
|
sb.Append(NameFetcher.GetItem("VENDOR","NAME",mPurchasedFromID).RecordName);
|
|
sb.Append("\r\n");
|
|
}
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(mReceipt))
|
|
{
|
|
sb.Append(LocalizedTextTable.GetLocalizedTextDirect("Unit.Label.Receipt"));
|
|
sb.Append(": ");
|
|
sb.Append(mReceipt);
|
|
sb.Append("\r\n");
|
|
}
|
|
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Flag - indicates if current user can open the wiki page for this object
|
|
///
|
|
/// This is cached for the lifetime of this object
|
|
/// </summary>
|
|
public bool CanWiki//case 73
|
|
{
|
|
get
|
|
{
|
|
if (!bCanWiki.HasValue)
|
|
bCanWiki = WikiPage.ShowWikiLink(RootObjectTypes.Unit, mID);
|
|
return bCanWiki.Value;
|
|
}
|
|
|
|
}
|
|
//cache the result in case the UI calls this repeatedly
|
|
private bool? bCanWiki = null;
|
|
|
|
|
|
/// <summary>
|
|
/// Optional first extra text field
|
|
/// </summary>
|
|
public string Text1
|
|
{
|
|
get
|
|
{return mText1;}
|
|
set
|
|
{
|
|
if (bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if (mText1 != value)
|
|
{
|
|
mText1 = value;
|
|
BrokenRules.Assert("Text1Length",
|
|
"Error.Object.FieldLengthExceeded255,Unit.Label.Text1",
|
|
"Text1", value.Length > 255);
|
|
MarkDirty();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Optional second extra text field
|
|
/// </summary>
|
|
public string Text2
|
|
{
|
|
get
|
|
{ return mText2; }
|
|
set
|
|
{
|
|
if (bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if (mText2 != value)
|
|
{
|
|
mText2 = value;
|
|
BrokenRules.Assert("Text2Length",
|
|
"Error.Object.FieldLengthExceeded255,Unit.Label.Text2",
|
|
"Text2", value.Length > 255);
|
|
MarkDirty();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Optional third extra text field
|
|
/// </summary>
|
|
public string Text3
|
|
{
|
|
get
|
|
{ return mText3; }
|
|
set
|
|
{
|
|
if (bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if (mText3 != value)
|
|
{
|
|
mText3 = value;
|
|
BrokenRules.Assert("Text3Length",
|
|
"Error.Object.FieldLengthExceeded255,Unit.Label.Text3",
|
|
"Text3", value.Length > 255);
|
|
MarkDirty();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Optional fourth extra text field
|
|
/// </summary>
|
|
public string Text4
|
|
{
|
|
get
|
|
{ return mText4; }
|
|
set
|
|
{
|
|
if (bReadOnly)
|
|
ThrowSetError();
|
|
else
|
|
{
|
|
if (mText4 != value)
|
|
{
|
|
mText4 = value;
|
|
BrokenRules.Assert("Text4Length",
|
|
"Error.Object.FieldLengthExceeded255,Unit.Label.Text4",
|
|
"Text4", value.Length > 255);
|
|
MarkDirty();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates if item can be duplicated or not
|
|
/// Item can be duplicated if the current user
|
|
/// has write rights to this type of object and this item
|
|
/// is not dirty or new and IsValid
|
|
/// </summary>
|
|
public bool CanDuplicate
|
|
{
|
|
get
|
|
{
|
|
if (!AyaBizUtils.CanWrite(RootObjectTypes.Unit)) return false;
|
|
if (IsDirty || IsNew || (!IsValid)) return false;
|
|
return true;
|
|
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generates a duplicate of this item
|
|
/// and returns it.
|
|
///
|
|
/// Warning: Serial number is also duplicated to facilitate a user entering multiple items where the serial number only deviates slightly
|
|
/// to save editing. If calling this through code be aware of this potential for duplication of a critical identification field.
|
|
/// </summary>
|
|
/// <returns>A duplicated Unit</returns>
|
|
public Unit Duplicate()
|
|
{//case 839
|
|
Unit dest = Unit.NewItem();
|
|
dest.BoughtHere = BoughtHere;
|
|
dest.ClientID = ClientID;
|
|
dest.Custom0 = Custom0;
|
|
dest.Custom1 = Custom1;
|
|
dest.Custom2 = Custom2;
|
|
dest.Custom3 = Custom3;
|
|
dest.Custom4 = Custom4;
|
|
dest.Custom5 = Custom5;
|
|
dest.Custom6 = Custom6;
|
|
dest.Custom7 = Custom7;
|
|
dest.Custom8 = Custom8;
|
|
dest.Custom9 = Custom9;
|
|
dest.Description = Description;
|
|
dest.GoToAddress.City = GoToAddress.City;
|
|
dest.GoToAddress.Country = GoToAddress.Country;
|
|
dest.GoToAddress.CountryCode = GoToAddress.CountryCode;
|
|
dest.GoToAddress.DeliveryAddress = GoToAddress.DeliveryAddress;
|
|
dest.GoToAddress.LatHemisphere = GoToAddress.LatHemisphere;
|
|
dest.GoToAddress.Latitude = GoToAddress.Latitude;
|
|
dest.GoToAddress.LongHemisphere = GoToAddress.LongHemisphere;
|
|
dest.GoToAddress.Longitude = GoToAddress.Longitude;
|
|
dest.GoToAddress.Postal = GoToAddress.Postal;
|
|
dest.GoToAddress.StateProv = GoToAddress.StateProv;
|
|
dest.LifeTimeWarranty = LifeTimeWarranty;
|
|
dest.Metered = Metered;
|
|
dest.Notes = Notes;
|
|
dest.OverrideModelWarranty = OverrideModelWarranty;
|
|
dest.ParentID = ParentID;
|
|
dest.PurchasedDate = PurchasedDate;
|
|
dest.PurchasedFromID = PurchasedFromID;
|
|
dest.Receipt = Receipt;
|
|
dest.ReplacedByUnitID = ReplacedByUnitID;
|
|
dest.Serial = Serial;
|
|
dest.Text1 = Text1;
|
|
dest.Text2 = Text2;
|
|
dest.Text3 = Text3;
|
|
dest.Text4 = Text4;
|
|
dest.UnitHasOwnAddress = UnitHasOwnAddress;
|
|
dest.UnitModelID = UnitModelID;
|
|
dest.UsesBanking = UsesBanking;
|
|
dest.WarrantyLength = WarrantyLength;
|
|
dest.WarrantyTerms = WarrantyTerms;
|
|
|
|
return dest;
|
|
}
|
|
|
|
|
|
/// <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.Unit")
|
|
)
|
|
);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region System.object overrides
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public override string ToString()
|
|
{
|
|
return "Unit" + mID.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="obj"></param>
|
|
/// <returns></returns>
|
|
public override bool Equals(Object obj)
|
|
{
|
|
if ( obj == null || GetType ( ) != obj.GetType ( ) ) return false;
|
|
Unit c=(Unit)obj;
|
|
return mID==c.mID;
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public override int GetHashCode()
|
|
{
|
|
return ("Unit"+mID).GetHashCode();
|
|
}
|
|
#endregion
|
|
|
|
#region Searching
|
|
|
|
/// <summary>
|
|
/// Returns a search result object based on search terms
|
|
/// for the ID specified
|
|
/// </summary>
|
|
/// <param name="ID"></param>
|
|
/// <param name="searchTerms"></param>
|
|
/// <returns></returns>
|
|
public static SearchResult GetSearchResult(Guid ID, string[]searchTerms)
|
|
{
|
|
if(AyaBizUtils.Right("Object.Unit")<(int)SecurityLevelTypes.ReadOnly)
|
|
return new SearchResult();
|
|
|
|
SearchResult sr=new SearchResult();
|
|
System.Text.StringBuilder sb = new System.Text.StringBuilder();
|
|
|
|
SafeDataReader dr = null;
|
|
try
|
|
{
|
|
dr=DBUtil.GetReaderFromSQLString(
|
|
|
|
"SELECT aClientID, aCreated, aModified, aCreator, aModifier, aSerial, " +
|
|
" aNotes, aReceipt, aDescription, aWarrantyTerms, aCustom2, " +
|
|
" aCustom3, aCustom4, aCustom5, aCustom6, aCustom7, " +
|
|
"aCustom8, aCustom9, aCustom0, aCustom1, aText1, aText2, aText3, aText4 FROM aUnit WHERE " +
|
|
"(aID = @ID)"
|
|
,ID);
|
|
|
|
if(!dr.Read())
|
|
return new SearchResult();//DBUtil.ThrowFetchError("SearchResult for UnitID: " + ID.ToString());
|
|
|
|
if (
|
|
!AyaBizUtils.InYourRegion(
|
|
ObjectRegionIDFetcher.ObjectRegion(
|
|
new TypeAndID(
|
|
RootObjectTypes.Client, dr.GetGuid("aClientID")
|
|
)
|
|
)
|
|
)
|
|
) return new SearchResult();//case 58
|
|
|
|
|
|
sr.Description=dr.GetString("aSerial");
|
|
sb.Append(sr.Description);
|
|
sb.Append(" ");
|
|
|
|
sb.Append(dr.GetString("aDescription"));
|
|
sb.Append(" ");
|
|
|
|
sb.Append(dr.GetString("aNotes"));
|
|
sb.Append(" ");
|
|
|
|
sb.Append(dr.GetString("aReceipt"));
|
|
sb.Append(" ");
|
|
|
|
sb.Append(dr.GetString("aWarrantyTerms"));
|
|
sb.Append(" ");
|
|
|
|
sb.Append(dr.GetString("aCustom0"));
|
|
sb.Append(" ");
|
|
sb.Append(dr.GetString("aCustom1"));
|
|
sb.Append(" ");
|
|
sb.Append(dr.GetString("aCustom2"));
|
|
sb.Append(" ");
|
|
sb.Append(dr.GetString("aCustom3"));
|
|
sb.Append(" ");
|
|
sb.Append(dr.GetString("aCustom4"));
|
|
sb.Append(" ");
|
|
sb.Append(dr.GetString("aCustom5"));
|
|
sb.Append(" ");
|
|
sb.Append(dr.GetString("aCustom6"));
|
|
sb.Append(" ");
|
|
sb.Append(dr.GetString("aCustom7"));
|
|
sb.Append(" ");
|
|
sb.Append(dr.GetString("aCustom8"));
|
|
sb.Append(" ");
|
|
sb.Append(dr.GetString("aCustom9"));
|
|
|
|
sb.Append(" ");
|
|
sb.Append(dr.GetString("aText1"));
|
|
sb.Append(" ");
|
|
sb.Append(dr.GetString("aText2"));
|
|
sb.Append(" ");
|
|
sb.Append(dr.GetString("aText3"));
|
|
sb.Append(" ");
|
|
sb.Append(dr.GetString("aText4"));
|
|
|
|
sr.Created=DBUtil.ToLocal(dr.GetSmartDate("aCreated"));
|
|
sr.Modified=DBUtil.ToLocal(dr.GetSmartDate("aModified"));
|
|
sr.Creator=dr.GetGuid("aCreator");
|
|
sr.Modifier=dr.GetGuid("aModifier");
|
|
|
|
|
|
|
|
|
|
}
|
|
finally
|
|
{
|
|
if(dr!=null) dr.Close();
|
|
}
|
|
|
|
//Added 02-Aug-2006 was not returning address search results :(
|
|
#region Address block
|
|
try
|
|
{
|
|
dr = DBUtil.GetReaderFromSQLString(
|
|
"SELECT adeliveryaddress, acity, astateprov, acountrycode, acountry, apostal " +
|
|
"from aaddress " +
|
|
"where " +
|
|
"arootobjectid=@ID "
|
|
, ID);
|
|
|
|
while (dr.Read())
|
|
{
|
|
sb.Append(" ");
|
|
sb.Append(dr.GetString("adeliveryaddress"));
|
|
sb.Append(" ");
|
|
sb.Append(dr.GetString("acity"));
|
|
sb.Append(" ");
|
|
sb.Append(dr.GetString("astateprov"));
|
|
sb.Append(" ");
|
|
sb.Append(dr.GetString("acountrycode"));
|
|
sb.Append(" ");
|
|
sb.Append(dr.GetString("acountry"));
|
|
sb.Append(" ");
|
|
sb.Append(dr.GetString("apostal"));
|
|
|
|
|
|
}
|
|
|
|
}
|
|
finally
|
|
{
|
|
if (dr != null) dr.Close();
|
|
|
|
}
|
|
#endregion
|
|
|
|
//Formulate results
|
|
ExtractAndRank er = new ExtractAndRank();
|
|
er.Process(sb.ToString().Trim(),searchTerms);
|
|
sr.Extract=er.Extract;
|
|
sr.Rank=er.Ranking;
|
|
sr.AncestorRootObjectID=ID;
|
|
sr.AncestorRootObjectType=RootObjectTypes.Unit;
|
|
|
|
return sr;
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Static methods
|
|
|
|
/// <summary>
|
|
/// Return unitname in selected format
|
|
/// based on passed in data
|
|
/// </summary>
|
|
/// <param name="ModelNumber"></param>
|
|
/// <param name="Model"></param>
|
|
/// <param name="Vendor"></param>
|
|
/// <param name="Serial"></param>
|
|
/// <param name="Description"></param>
|
|
/// <param name="Format"></param>
|
|
/// <returns></returns>
|
|
public static string UnitNameFormatter(string ModelNumber, string Model, string Vendor, string Serial, string Description, UnitNameDisplayFormats Format)
|
|
{
|
|
switch(Format)
|
|
{
|
|
case UnitNameDisplayFormats.ModelSerial:
|
|
return AyaBizUtils.SS("",Model," - ") + Serial;
|
|
|
|
case UnitNameDisplayFormats.SerialOnly:
|
|
return Serial;
|
|
|
|
case UnitNameDisplayFormats.VendorModelSerial:
|
|
return AyaBizUtils.SS("",Vendor,": ") + AyaBizUtils.SS("",Model," - ") + Serial ;
|
|
|
|
case UnitNameDisplayFormats.VendorSerial:
|
|
return AyaBizUtils.SS("",Vendor,": ") + Serial;
|
|
|
|
case UnitNameDisplayFormats.SerialModel:
|
|
return AyaBizUtils.SS("",Serial," - ") + Model;
|
|
|
|
case UnitNameDisplayFormats.SerialModelVendor:
|
|
return AyaBizUtils.SS("",Serial,": ") + AyaBizUtils.SS("",Model," - ") + Vendor ;
|
|
|
|
case UnitNameDisplayFormats.ModelNumberModelSerial:
|
|
return AyaBizUtils.SS("", ModelNumber, ": ") + AyaBizUtils.SS("", Model, " - ") + Serial;
|
|
|
|
case UnitNameDisplayFormats.ModelModelNumberSerial:
|
|
return AyaBizUtils.SS("", Model, ": ") + AyaBizUtils.SS("", ModelNumber, " - ") + Serial;
|
|
|
|
//case 1519
|
|
case UnitNameDisplayFormats.VendorModelModelNumberSerial:
|
|
return AyaBizUtils.SS("", Vendor, ": ") + AyaBizUtils.SS("", Model, ", ") + AyaBizUtils.SS("", ModelNumber, " - ") + Serial;
|
|
|
|
//case 3150
|
|
case UnitNameDisplayFormats.SerialDescription:
|
|
return AyaBizUtils.SS("", Serial, " - ") + Description;
|
|
|
|
case UnitNameDisplayFormats.VendorSerialDescription:
|
|
return AyaBizUtils.SS("", Vendor, ": ") + AyaBizUtils.SS("", Serial, " - ") + Description;
|
|
|
|
|
|
default:
|
|
return Serial;
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return unitname in default (Global setting) format
|
|
/// based on passed in information
|
|
/// </summary>
|
|
/// <param name="Model"></param>
|
|
/// <param name="Vendor"></param>
|
|
/// <param name="Serial"></param>
|
|
/// <param name="Description"></param>
|
|
/// <param name="ModelName"></param>
|
|
/// <returns></returns>
|
|
public static string UnitNameFormatter(string ModelName, string Model, string Vendor, string Serial, string Description)
|
|
{
|
|
return UnitNameFormatter(ModelName,Model,Vendor,Serial, Description, AyaBizUtils.GlobalSettings.DefaultUnitNameDisplayFormat);
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Retrieves the name of the client that owns the passed in Unit ID
|
|
/// </summary>
|
|
/// <param name="UnitID"></param>
|
|
/// <returns></returns>
|
|
public static string GetOwnerNameForUnit(Guid UnitID)
|
|
{
|
|
Unit u=Unit.GetItemMRU(UnitID, false);
|
|
if(u.ClientID==Guid.Empty) return "";
|
|
return NameFetcher.GetItem("aClient","aName",u.ClientID).RecordName;
|
|
}
|
|
|
|
//case 1975
|
|
/// <summary>
|
|
/// Retrieves the ID of the client that owns the passed in Unit ID
|
|
/// </summary>
|
|
/// <param name="UnitID"></param>
|
|
/// <returns></returns>
|
|
public static Guid GetOwnerIDForUnit(Guid UnitID)
|
|
{
|
|
Unit u = Unit.GetItemMRU(UnitID, false);
|
|
return u.ClientID;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create new Unit
|
|
/// </summary>
|
|
/// <returns>Unit</returns>
|
|
public static Unit NewItem()
|
|
{
|
|
Unit c;
|
|
|
|
if(AyaBizUtils.Right("Object.Unit")>(int)SecurityLevelTypes.ReadOnly)
|
|
{
|
|
c = new Unit();
|
|
c.mGoToAddress=Address.NewItem();
|
|
c.mGoToAddress.RootObjectID=c.ID;
|
|
c.mGoToAddress.RootObjectType=RootObjectTypes.Unit;
|
|
c.mGoToAddress.AddressType=AddressTypes.Physical;
|
|
|
|
return c;
|
|
}
|
|
else
|
|
throw new System.Security.SecurityException(
|
|
string.Format(
|
|
LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToCreate"),
|
|
LocalizedTextTable.GetLocalizedTextDirect("O.Unit")));
|
|
|
|
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fetch existing Unit
|
|
/// </summary>
|
|
/// <returns>Unit</returns>
|
|
/// <param name="_ID">Unit Guid</param>
|
|
public static Unit GetItem(Guid _ID)
|
|
{
|
|
return GetItemMRU(_ID, true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get item with optional tracking of MRU
|
|
/// See <see cref="UserMRU"/>
|
|
/// </summary>
|
|
/// <param name="_ID"></param>
|
|
/// <param name="TrackMRU"></param>
|
|
/// <returns></returns>
|
|
public static Unit GetItemMRU(Guid _ID, bool TrackMRU)
|
|
{
|
|
if (_ID == AyaBizUtils.NewObjectGuid)
|
|
return NewItem();
|
|
|
|
if(AyaBizUtils.Right("Object.Unit")>(int)SecurityLevelTypes.NoAccess)
|
|
return (Unit)DataPortal.Fetch(new Criteria(_ID,TrackMRU));
|
|
else
|
|
throw new System.Security.SecurityException(
|
|
string.Format(
|
|
LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToRetrieve"),
|
|
LocalizedTextTable.GetLocalizedTextDirect("O.Unit")));
|
|
}
|
|
/// <summary>
|
|
/// Delete Unit
|
|
/// </summary>
|
|
/// <param name="_ID">Unit GUID</param>
|
|
public static void DeleteItem(Guid _ID)
|
|
{
|
|
|
|
if(AyaBizUtils.Right("Object.Unit")>(int)SecurityLevelTypes.ReadWrite)
|
|
DataPortal.Delete(new Criteria(_ID,true));
|
|
else
|
|
throw new System.Security.SecurityException(
|
|
string.Format(
|
|
LocalizedTextTable.GetLocalizedTextDirect("Error.Security.NotAuthorizedToDelete"),
|
|
LocalizedTextTable.GetLocalizedTextDirect("O.Unit")));
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Retrieves the last (most recent) meter reading of the passed in Unit
|
|
/// </summary>
|
|
/// <param name="_ID"></param>
|
|
/// <returns></returns>
|
|
public static long LastMeterReading(Guid _ID)
|
|
{
|
|
//Case 501
|
|
return UnitLastMeterReadingFetcher.LastMeterReading(_ID);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieves the metered status of a unit based on it's ID
|
|
/// </summary>
|
|
/// <param name="_ID"></param>
|
|
/// <returns>True=Unit is set to track meter readings, false=not metered</returns>
|
|
public static bool IsMetered(Guid _ID)
|
|
{
|
|
//Case 502
|
|
return UnitIsMeteredChecker.UnitIsMetered(_ID);
|
|
}
|
|
|
|
//Case 421:
|
|
/// <summary>
|
|
/// Check for the existance of a unit
|
|
/// in the database by ID OR by serialnumber
|
|
/// </summary>
|
|
/// <param name="ID">Guid of item</param>
|
|
/// <param name="SerialNumber">Serial number of item</param>
|
|
/// <returns></returns>
|
|
public static bool Exists(Guid ID, string SerialNumber)
|
|
{
|
|
//Case 503
|
|
return UnitExistanceChecker.UnitExists(ID, SerialNumber);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Determine internal ID of Unit from a serial number.
|
|
/// </summary>
|
|
/// <param name="SerialNumber">Text value</param>
|
|
/// <returns>Unit's Guid ID value or Guid.Empty if no match</returns>
|
|
public static Guid GetIDFromSerialNumber(string SerialNumber)
|
|
{
|
|
return GuidFetcher.GetItem("AUNIT", "ASERIAL", SerialNumber);
|
|
}
|
|
#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 aUnit WHERE aID=@ID;",crit.ID);
|
|
if(!dr.Read())
|
|
DBUtil.ThrowFetchError("Unit 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");
|
|
|
|
|
|
//Custom fields
|
|
mCustom1=dr.GetString("aCustom1");
|
|
mCustom2=dr.GetString("aCustom2");
|
|
mCustom3=dr.GetString("aCustom3");
|
|
mCustom4=dr.GetString("aCustom4");
|
|
mCustom5=dr.GetString("aCustom5");
|
|
mCustom6=dr.GetString("aCustom6");
|
|
mCustom7=dr.GetString("aCustom7");
|
|
mCustom8=dr.GetString("aCustom8");
|
|
mCustom9=dr.GetString("aCustom9");
|
|
mCustom0=dr.GetString("aCustom0");
|
|
|
|
//Unit fields
|
|
Active=dr.GetBoolean("AACTIVE");
|
|
mBoughtHere=dr.GetBoolean("aBoughtHere");
|
|
|
|
//Unbreak the client id rule
|
|
ClientID=dr.GetGuid("aClientID");
|
|
|
|
mOverrideModelWarranty=dr.GetBoolean("aOverrideModelWarranty");
|
|
mWarrantyTerms=dr.GetString("aWarrantyTerms");
|
|
|
|
mDescription=dr.GetString("aDescription");
|
|
mNotes=dr.GetString("aNotes");
|
|
mPurchasedDate=DBUtil.ToLocal(dr.GetSmartDate("aPurchasedDate"));
|
|
mPurchasedFromID=dr.GetGuid("aPurchasedFromID");
|
|
mReceipt=dr.GetString("aReceipt");
|
|
mReplacedByUnitID=dr.GetGuid("aReplacedByUnitID");
|
|
|
|
//Unbreak the serial rule
|
|
Serial=dr.GetString("aSerial");
|
|
|
|
mUnitHasOwnAddress=dr.GetBoolean("aUnitHasOwnAddress");
|
|
mUnitModelID=dr.GetGuid("aUnitModelID");
|
|
|
|
mParentUnitID=dr.GetGuid("aParentUnitID");
|
|
|
|
mUsesBanking=dr.GetBoolean("aUsesBanking");
|
|
|
|
mMetered=dr.GetBoolean("aMetered");
|
|
|
|
mWarrantyLength=dr.GetInt32("aWarrantyLength");
|
|
mLifeTimeWarranty=dr.GetBoolean("aLifeTimeWarranty");
|
|
|
|
mText1 = dr.GetString("aText1");
|
|
mText2 = dr.GetString("aText2");
|
|
mText3 = dr.GetString("aText3");
|
|
mText4 = dr.GetString("aText4");
|
|
|
|
if(dr!=null) dr.Close();
|
|
|
|
/*
|
|
* Load child collection objects
|
|
*/
|
|
|
|
//GoToAddress
|
|
dr=DBUtil.GetReaderFromSQLString("SELECT * " +
|
|
"FROM AADDRESS WHERE aRootObjectID=@ID AND " +
|
|
"aRootObjectType=7 AND AADDRESSTYPE=2",crit.ID);
|
|
if(dr.Read())
|
|
mGoToAddress=Address.GetItem(dr);
|
|
|
|
if(dr!=null) dr.Close();
|
|
|
|
|
|
//Docs
|
|
dr=DBUtil.GetReaderFromSQLString("SELECT * FROM AASSIGNEDDOC WHERE (aRootObjectID=@ID and aRootObjectType=7);",crit.ID);
|
|
mDocs = AssignedDocs.GetItems(dr, RootObjectTypes.Unit, RootObjectTypes.Unit);
|
|
if(dr!=null) dr.Close();
|
|
|
|
|
|
|
|
}
|
|
finally
|
|
{
|
|
if(dr!=null) dr.Close();
|
|
}
|
|
MarkOld();
|
|
if(crit.TrackMRU)
|
|
if(AyaBizUtils.AllowAutomaticMRUOnUpdate) AyaBizUtils.MRU.Add(RootObjectTypes.Unit, mID);
|
|
|
|
//Get access rights level
|
|
bReadOnly=AyaBizUtils.Right("Object.Unit")<(int)SecurityLevelTypes.ReadWrite;
|
|
|
|
}
|
|
#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,"aUnit");
|
|
|
|
#region Delete
|
|
if(IsDeleted)
|
|
{
|
|
if(!IsNew)
|
|
{
|
|
|
|
|
|
//Delete object and child objects
|
|
DBCommandWrapper cmDelete = DBUtil.GetCommandFromSQL("DELETE FROM aUnit WHERE aID = @ID;");
|
|
cmDelete.AddInParameter("@ID",DbType.Guid,this.mID);
|
|
|
|
//Delete all address record types with matching root object ID
|
|
DBCommandWrapper cmDeleteAddress = DBUtil.GetCommandFromSQL("DELETE FROM AADDRESS WHERE aRootObjectID = @ID;");
|
|
cmDeleteAddress.AddInParameter("@ID",DbType.Guid,this.mID);
|
|
|
|
//case 3597
|
|
//Delete all address record types with matching root object ID
|
|
DBCommandWrapper cmDeleteMeterReading = DBUtil.GetCommandFromSQL("DELETE FROM AUNITMETERREADING WHERE AUNITID = @ID;");
|
|
cmDeleteMeterReading.AddInParameter("@ID", DbType.Guid, this.mID);
|
|
|
|
//case 3605
|
|
DBCommandWrapper cmClearFromCSR = DBUtil.GetCommandFromSQL("UPDATE ACLIENTSERVICEREQUEST SET AUNITID = null WHERE AUNITID = @ID");
|
|
cmClearFromCSR.AddInParameter("@ID", DbType.Guid, this.mID);
|
|
|
|
|
|
using (IDbConnection connection = DBUtil.DB.GetConnection())
|
|
{
|
|
connection.Open();
|
|
IDbTransaction transaction = connection.BeginTransaction();
|
|
|
|
try
|
|
{
|
|
//case 3597
|
|
DBUtil.DB.ExecuteNonQuery(cmDeleteMeterReading, transaction);
|
|
|
|
//case 3605
|
|
DBUtil.DB.ExecuteNonQuery(cmClearFromCSR, transaction);
|
|
|
|
DBUtil.DB.ExecuteNonQuery(cmDelete, transaction);
|
|
DBUtil.DB.ExecuteNonQuery(cmDeleteAddress, transaction);
|
|
DBUtil.RemoveKeywords(transaction,RootObjectTypes.Unit,this.mID);
|
|
DBUtil.RemoveDocs(transaction,RootObjectTypes.Unit,this.mID);
|
|
|
|
// Commit the transaction
|
|
transaction.Commit();
|
|
|
|
}
|
|
catch
|
|
{
|
|
// Rollback transaction
|
|
transaction.Rollback();
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
connection.Close();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------
|
|
}
|
|
MarkNew();
|
|
return;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Add / Update
|
|
|
|
//ensure address is empty if set to not have own address
|
|
//otherwise it will linger if set to false
|
|
//after previously being entered
|
|
if(this.mUnitHasOwnAddress==false)
|
|
{
|
|
this.GoToAddress.City="";
|
|
this.GoToAddress.Country="";
|
|
this.GoToAddress.CountryCode="";
|
|
this.GoToAddress.DeliveryAddress="";
|
|
this.GoToAddress.Latitude=0;
|
|
this.GoToAddress.Longitude=0;
|
|
this.GoToAddress.Postal="";
|
|
this.GoToAddress.StateProv="";
|
|
|
|
}
|
|
|
|
if(this.mOverrideModelWarranty==false)
|
|
{
|
|
this.mWarrantyTerms="";
|
|
this.mLifeTimeWarranty=false;
|
|
this.mWarrantyLength=0;
|
|
}
|
|
if(this.mLifeTimeWarranty==true)
|
|
this.mWarrantyLength=0;
|
|
|
|
//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 aUnit (aID, AACTIVE, aSerial, aNotes, aClientID, " +
|
|
"aUnitModelID, aParentUnitID, aUnitHasOwnAddress, " +
|
|
"aOverrideModelWarranty, aBoughtHere, aPurchasedFromID, " +
|
|
"aReceipt, aPurchasedDate, aWarrantyTerms, aDescription, " +
|
|
"aReplacedByUnitID, aCreated,aModified,aCreator,aModifier, " +
|
|
"aCustom1, aCustom2, aCustom3, aCustom4, aCustom5, " +
|
|
"aCustom6, aCustom7, aCustom8, aCustom9, aCustom0, " +
|
|
"aUsesBanking, aMetered, aWarrantyLength, aLifeTimeWarranty,aText1, aText2, aText3, aText4) " +
|
|
"VALUES (@ID,@Active,@Serial,@Notes, " +
|
|
"@ClientID, " +
|
|
"@UnitModelID,@ParentUnitID,@UnitHasOwnAddress,@OverrideModelWarranty, " +
|
|
"@BoughtHere,@PurchasedFromID, " +
|
|
"@Receipt,@PurchasedDate,@WarrantyTerms, @Description, " +
|
|
"@ReplacedByUnitID,@Created,@Modified,@CurrentUserID,@CurrentUserID, " +
|
|
"@Custom1,@Custom2,@Custom3,@Custom4,@Custom5,@Custom6, " +
|
|
"@Custom7,@Custom8,@Custom9,@Custom0, @UsesBanking, " +
|
|
"@Metered,@WarrantyLength,@LifeTimeWarranty,@Text1,@Text2,@Text3,@Text4)"
|
|
);
|
|
else
|
|
cm=DBUtil.GetCommandFromSQL(
|
|
"UPDATE aUnit SET aID=@ID, AACTIVE=@Active, aSerial=@Serial, " +
|
|
"aNotes=@Notes, aClientID=@ClientID, " +
|
|
"aUnitModelID=@UnitModelID, " +
|
|
"aParentUnitID=@ParentUnitID, aUnitHasOwnAddress=@UnitHasOwnAddress, " +
|
|
"aOverrideModelWarranty=@OverrideModelWarranty, " +
|
|
"aWarrantyTerms=@WarrantyTerms, " +
|
|
"aBoughtHere=@BoughtHere, aPurchasedFromID=@PurchasedFromID, " +
|
|
"aReceipt=@Receipt, aPurchasedDate=@PurchasedDate, " +
|
|
"aDescription=@Description, aReplacedByUnitID=@ReplacedByUnitID, " +
|
|
"aModifier=@CurrentUserID, " +
|
|
"aModified=@Modified, " +
|
|
"aCustom1=@Custom1, " +
|
|
"aCustom2=@Custom2, aCustom3=@Custom3, aCustom4=@Custom4, " +
|
|
"aCustom5=@Custom5, aCustom6=@Custom6, " +
|
|
"aCustom7=@Custom7, aCustom8=@Custom8, aCustom9=@Custom9, " +
|
|
"aCustom0=@Custom0, aUsesBanking=@UsesBanking, " +
|
|
"aMetered=@Metered, aLifeTimeWarranty=@LifeTimeWarranty, " +
|
|
"aWarrantyLength=@WarrantyLength, " +
|
|
"aText1=@Text1, aText2=@Text2, aText3=@Text3, aText4=@Text4 " +
|
|
"WHERE aID=@ID"
|
|
);
|
|
|
|
|
|
|
|
|
|
//Unit specific fields
|
|
cm.AddInParameter("@ID",DbType.Guid,mID);
|
|
cm.AddInParameter("@Active",DbType.Boolean, mActive);
|
|
cm.AddLargeStringInParameter("@Notes", mNotes);
|
|
cm.AddInParameter("@Serial",DbType.String, mSerial);
|
|
cm.AddInParameter("@UsesBanking",DbType.Boolean, mUsesBanking);
|
|
cm.AddInParameter("@BoughtHere",DbType.Boolean,mBoughtHere);
|
|
cm.AddInParameter("@ClientID",DbType.Guid, mClientID);
|
|
cm.AddInParameter("@OverrideModelWarranty",DbType.Boolean,mOverrideModelWarranty);
|
|
cm.AddInParameter("@WarrantyTerms",DbType.String,mWarrantyTerms);
|
|
cm.AddInParameter("@Description",DbType.String,mDescription);
|
|
cm.AddInParameter("@PurchasedDate",DbType.DateTime,DBUtil.ToUTC(mPurchasedDate).DBValue);
|
|
cm.AddInParameter("@PurchasedFromID",DbType.Guid, mPurchasedFromID);
|
|
cm.AddInParameter("@Receipt",DbType.String,mReceipt);
|
|
cm.AddInParameter("@ReplacedByUnitID",DbType.Guid, mReplacedByUnitID);
|
|
cm.AddInParameter("@UnitHasOwnAddress",DbType.Boolean,mUnitHasOwnAddress);
|
|
cm.AddInParameter("@UnitModelID",DbType.Guid, mUnitModelID);
|
|
cm.AddInParameter("@ParentUnitID",DbType.Guid, mParentUnitID);
|
|
cm.AddInParameter("@Metered",DbType.Boolean,mMetered);
|
|
cm.AddInParameter("@WarrantyLength",DbType.Int32,mWarrantyLength);
|
|
cm.AddInParameter("@LifeTimeWarranty",DbType.Boolean,mLifeTimeWarranty);
|
|
|
|
//case 78
|
|
cm.AddInParameter("@Text1", DbType.String, mText1);
|
|
cm.AddInParameter("@Text2", DbType.String, mText2);
|
|
cm.AddInParameter("@Text3", DbType.String, mText3);
|
|
cm.AddInParameter("@Text4", DbType.String, mText4);
|
|
|
|
|
|
//Standard fields
|
|
//case 1687 need this to do a biz object update in the schema update
|
|
//because the user hasn't logged in yet and Unit table doesn't allow nulls in
|
|
//modified user id
|
|
Guid gCurrentUserId = CurrentUserID;
|
|
if (gCurrentUserId == Guid.Empty)
|
|
gCurrentUserId = User.AdministratorID;
|
|
|
|
cm.AddInParameter("@CurrentUserID", DbType.Guid, gCurrentUserId);
|
|
cm.AddInParameter("@Created",DbType.DateTime, DBUtil.ToUTC(mCreated).DBValue);
|
|
cm.AddInParameter("@Modified",DbType.DateTime, DBUtil.ToUTC(dtModified));
|
|
|
|
//Custom fields
|
|
cm.AddLargeStringInParameter("@Custom1", mCustom1);
|
|
cm.AddLargeStringInParameter("@Custom2", mCustom2);
|
|
cm.AddLargeStringInParameter("@Custom3", mCustom3);
|
|
cm.AddLargeStringInParameter("@Custom4", mCustom4);
|
|
cm.AddLargeStringInParameter("@Custom5", mCustom5);
|
|
cm.AddLargeStringInParameter("@Custom6", mCustom6);
|
|
cm.AddLargeStringInParameter("@Custom7", mCustom7);
|
|
cm.AddLargeStringInParameter("@Custom8", mCustom8);
|
|
cm.AddLargeStringInParameter("@Custom9", mCustom9);
|
|
cm.AddLargeStringInParameter("@Custom0", mCustom0);
|
|
|
|
|
|
using (IDbConnection connection = DBUtil.DB.GetConnection())
|
|
{
|
|
connection.Open();
|
|
IDbTransaction transaction = connection.BeginTransaction();
|
|
|
|
try
|
|
{
|
|
|
|
DBUtil.DB.ExecuteNonQuery(cm, transaction);
|
|
|
|
//Update child objects
|
|
//GoToAddress
|
|
mGoToAddress.Update(RootObjectTypes.Unit,mID,AddressTypes.Physical,transaction);
|
|
|
|
//Docs
|
|
mDocs.Update(transaction);
|
|
|
|
//Process keywords
|
|
DBUtil.ProcessKeywords(transaction,this.mID,RootObjectTypes.Unit,IsNew,AyaBizUtils.Break(false,
|
|
mGoToAddress.FullAddress,mNotes,mSerial,mDescription,mReceipt,mWarrantyTerms,
|
|
/*Custom fields*/
|
|
mCustom1,mCustom2,mCustom3,mCustom4,mCustom5,mCustom6,mCustom7,mCustom8,mCustom9,mCustom0, mText1, mText2, mText3, mText4));
|
|
|
|
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;
|
|
if(AyaBizUtils.AllowAutomaticMRUOnUpdate) AyaBizUtils.MRU.Add(RootObjectTypes.Unit, mID);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
#endregion update
|
|
|
|
#region Delete
|
|
|
|
/// <summary>
|
|
/// Remove a Unit record .
|
|
/// </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 aUnit WHERE aID = @ID;");
|
|
cmDelete.AddInParameter("@ID",DbType.Guid,crit.ID);
|
|
|
|
//Delete all address record types with matching root object ID
|
|
DBCommandWrapper cmDeleteAddress = DBUtil.GetCommandFromSQL("DELETE FROM AADDRESS WHERE aRootObjectID = @ID;");
|
|
cmDeleteAddress.AddInParameter("@ID",DbType.Guid,crit.ID);
|
|
|
|
|
|
//case 3597
|
|
//Delete all address record types with matching root object ID
|
|
DBCommandWrapper cmDeleteMeterReading = DBUtil.GetCommandFromSQL("DELETE FROM AUNITMETERREADING WHERE AUNITID = @ID;");
|
|
cmDeleteMeterReading.AddInParameter("@ID", DbType.Guid, crit.ID);
|
|
|
|
//case 3605
|
|
DBCommandWrapper cmClearFromCSR = DBUtil.GetCommandFromSQL("UPDATE ACLIENTSERVICEREQUEST SET AUNITID = null WHERE AUNITID = @ID");
|
|
cmClearFromCSR.AddInParameter("@ID", DbType.Guid, crit.ID);
|
|
|
|
|
|
using (IDbConnection connection = DBUtil.DB.GetConnection())
|
|
{
|
|
connection.Open();
|
|
IDbTransaction transaction = connection.BeginTransaction();
|
|
|
|
try
|
|
{
|
|
//case 3597
|
|
DBUtil.DB.ExecuteNonQuery(cmDeleteMeterReading, transaction);
|
|
|
|
//case 3605
|
|
DBUtil.DB.ExecuteNonQuery(cmClearFromCSR, transaction);
|
|
|
|
DBUtil.DB.ExecuteNonQuery(cmDelete, transaction);
|
|
DBUtil.DB.ExecuteNonQuery(cmDeleteAddress, transaction);
|
|
DBUtil.RemoveKeywords(transaction,RootObjectTypes.Unit,crit.ID);
|
|
DBUtil.RemoveDocs(transaction,RootObjectTypes.Unit,crit.ID);
|
|
|
|
// Commit the transaction
|
|
transaction.Commit();
|
|
|
|
}
|
|
catch
|
|
{
|
|
// Rollback transaction
|
|
transaction.Rollback();
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
connection.Close();
|
|
}
|
|
AyaBizUtils.MRU.Remove(RootObjectTypes.Unit, crit.ID);
|
|
|
|
}
|
|
}
|
|
#endregion delete
|
|
|
|
#endregion
|
|
|
|
#region Override IsValid / IsDirty
|
|
//Override base class version if there are child objects
|
|
/// <summary>
|
|
/// No broken rules
|
|
/// </summary>
|
|
public override bool IsValid
|
|
{
|
|
get
|
|
{
|
|
return base.IsValid && mGoToAddress.IsValid && mDocs.IsValid ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Has unsaved changes
|
|
/// </summary>
|
|
public override bool IsDirty
|
|
{
|
|
get
|
|
{
|
|
return base.IsDirty || mGoToAddress.IsDirty || mDocs.IsDirty ;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region criteria
|
|
/// <summary>
|
|
/// Criteria for identifying existing object
|
|
/// </summary>
|
|
[Serializable]
|
|
private class Criteria
|
|
{
|
|
public Guid ID;
|
|
public bool TrackMRU;
|
|
public Criteria(Guid _ID, bool _TrackMRU)
|
|
{
|
|
ID = _ID;
|
|
TrackMRU = _TrackMRU;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region Get current meter reading from unit id
|
|
//Case 501
|
|
//[Serializable(), System.ComponentModel.Browsable(false)]
|
|
// public class MeterHelper
|
|
//{
|
|
// long _Meter = 0;
|
|
// Guid _ID;
|
|
|
|
// public MeterHelper(Guid ID)
|
|
// {
|
|
// _ID=ID;
|
|
|
|
// }
|
|
|
|
// public static long GetMeter(Guid ID)
|
|
// { //todo fix for 425
|
|
// MeterHelper e=new MeterHelper(ID);
|
|
// DataPortal.Update(e);
|
|
// return e._Meter;
|
|
// }
|
|
|
|
// public void DataPortal_Update()
|
|
// {
|
|
|
|
// switch(DBUtil.DB.DBType)
|
|
// {
|
|
// case DataBaseType.FireBird:
|
|
// {
|
|
// this._Meter=DBUtil.ScalarToLong(
|
|
// DBUtil.GetScalarFromSQLString(
|
|
// "SELECT FIRST 1 aMeter FROM aUnitMeterReading WHERE " +
|
|
// "(aUnitMeterReading.aUnitID = @ID) " +
|
|
// "ORDER BY aCreated DESC ",_ID)
|
|
// );
|
|
// }
|
|
// break;
|
|
|
|
// case DataBaseType.MSSQL:
|
|
// {
|
|
// this._Meter=DBUtil.ScalarToLong(
|
|
// DBUtil.GetScalarFromSQLString(
|
|
// "SELECT TOP 1 aMeter FROM aUnitMeterReading WHERE " +
|
|
// "(aUnitMeterReading.aUnitID = @ID) " +
|
|
// "ORDER BY aCreated DESC ",_ID)
|
|
// );
|
|
// }
|
|
// break;
|
|
|
|
// default:
|
|
// throw new ApplicationException("UNKNOWN DB TYPE IN Unit.MeterHelper");
|
|
|
|
// }
|
|
|
|
|
|
|
|
// }
|
|
|
|
//}
|
|
|
|
#endregion
|
|
|
|
#region Get Unit metered status from unit id
|
|
//Case 502
|
|
////Added:25-Oct-2006 to support wbi
|
|
// [Serializable(), System.ComponentModel.Browsable(false)]
|
|
// public class MeteredHelper
|
|
// {
|
|
// bool _Metered = false;
|
|
// Guid _ID;
|
|
|
|
// public MeteredHelper(Guid ID)
|
|
// {
|
|
// _ID = ID;
|
|
// }
|
|
|
|
// public static bool GetMetered(Guid ID)
|
|
// { //todo fix for 425
|
|
// MeteredHelper e = new MeteredHelper(ID);
|
|
// DataPortal.Update(e);
|
|
// return e._Metered;
|
|
// }
|
|
|
|
// public void DataPortal_Update()
|
|
// {
|
|
|
|
// this._Metered = DBUtil.ScalarToBool(
|
|
// DBUtil.GetScalarFromSQLString(
|
|
// "SELECT aMetered FROM aUnit WHERE " +
|
|
// "(aUnit.aID = @ID) " , _ID)
|
|
// );
|
|
// }
|
|
// }
|
|
|
|
#endregion
|
|
|
|
#region Exists Case 421
|
|
//Case 503
|
|
|
|
//[Serializable(), System.ComponentModel.Browsable(false)]
|
|
//public class ExistsHelper
|
|
//{
|
|
// bool _Exists = false;
|
|
// Guid _ID;
|
|
// string _SerialNumber;
|
|
// public ExistsHelper(Guid ID, string SerialNumber)
|
|
// {
|
|
// _ID = ID;
|
|
// _SerialNumber = SerialNumber;
|
|
// }
|
|
|
|
// public static bool GetExists(Guid ID, string SerialNumber)
|
|
// { //todo fix for 425
|
|
// ExistsHelper e = new ExistsHelper(ID, SerialNumber);
|
|
// DataPortal.Update(e);
|
|
// return e._Exists;
|
|
// }
|
|
|
|
// public void DataPortal_Update()
|
|
// {
|
|
// if (!string.IsNullOrEmpty(_SerialNumber))
|
|
// {
|
|
// DBCommandWrapper dbCommandWrapper = DBUtil.DB.GetSqlStringCommandWrapper(
|
|
// "SELECT aID FROM aUnit WHERE " +
|
|
// "(aSerial = @SERIAL)"
|
|
// );
|
|
// dbCommandWrapper.AddInParameter("@SERIAL", DbType.String, _SerialNumber);
|
|
// if (DBUtil.ToGuid(DBUtil.DB.ExecuteScalar(dbCommandWrapper)) == Guid.Empty)
|
|
// this._Exists = false;
|
|
// else
|
|
// this._Exists = true;
|
|
|
|
|
|
// }
|
|
// else
|
|
// {
|
|
// if (DBUtil.ToGuid(DBUtil.GetScalarFromSQLString(
|
|
// "SELECT aID FROM aUnit WHERE " +
|
|
// "(aID = @ID)", _ID
|
|
// )) == Guid.Empty)
|
|
// this._Exists = false;
|
|
// else
|
|
// this._Exists = true;
|
|
// }
|
|
// }
|
|
|
|
//}
|
|
|
|
#endregion
|
|
|
|
}//end Unit
|
|
|
|
}//end namespace GZTW.AyaNova.BLL |