rendered paste body
namespace Pixco.Framework.AssetManagement.Data
{
using System;
using System.Data;
using System.Collections;
using System.Collections.Generic;
using Weborb.Data.Management;
using System.Data.SqlClient;
public partial class AMF_devDb:TDatabase<SqlConnection,SqlTransaction,SqlCommand>
{
public AMF_devDb()
{
InitConnectionString("AMF_dev");
}
public Asset create(Asset asset)
{
AssetDataMapper dataMapper = new AssetDataMapper(this);
return dataMapper.create(asset);
}
public Asset update(Asset asset)
{
AssetDataMapper dataMapper = new AssetDataMapper(this);
return dataMapper.update(asset);
}
public Asset remove(Asset asset)
{
AssetDataMapper dataMapper = new AssetDataMapper(this);
return dataMapper.remove(asset);
}
public AssetFormat create(AssetFormat assetFormat)
{
AssetFormatDataMapper dataMapper = new AssetFormatDataMapper(this);
return dataMapper.create(assetFormat);
}
public AssetFormat update(AssetFormat assetFormat)
{
AssetFormatDataMapper dataMapper = new AssetFormatDataMapper(this);
return dataMapper.update(assetFormat);
}
public AssetFormat remove(AssetFormat assetFormat)
{
AssetFormatDataMapper dataMapper = new AssetFormatDataMapper(this);
return dataMapper.remove(assetFormat);
}
public AssetFormatAttribute create(AssetFormatAttribute assetFormatAttribute)
{
AssetFormatAttributeDataMapper dataMapper = new AssetFormatAttributeDataMapper(this);
return dataMapper.create(assetFormatAttribute);
}
public AssetFormatAttribute update(AssetFormatAttribute assetFormatAttribute)
{
AssetFormatAttributeDataMapper dataMapper = new AssetFormatAttributeDataMapper(this);
return dataMapper.update(assetFormatAttribute);
}
public AssetFormatAttribute remove(AssetFormatAttribute assetFormatAttribute)
{
AssetFormatAttributeDataMapper dataMapper = new AssetFormatAttributeDataMapper(this);
return dataMapper.remove(assetFormatAttribute);
}
public AssetStore create(AssetStore assetStore)
{
AssetStoreDataMapper dataMapper = new AssetStoreDataMapper(this);
return dataMapper.create(assetStore);
}
public AssetStore update(AssetStore assetStore)
{
AssetStoreDataMapper dataMapper = new AssetStoreDataMapper(this);
return dataMapper.update(assetStore);
}
public AssetStore remove(AssetStore assetStore)
{
AssetStoreDataMapper dataMapper = new AssetStoreDataMapper(this);
return dataMapper.remove(assetStore);
}
public AssetTechnicalFormat create(AssetTechnicalFormat assetTechnicalFormat)
{
AssetTechnicalFormatDataMapper dataMapper = new AssetTechnicalFormatDataMapper(this);
return dataMapper.create(assetTechnicalFormat);
}
public AssetTechnicalFormat update(AssetTechnicalFormat assetTechnicalFormat)
{
AssetTechnicalFormatDataMapper dataMapper = new AssetTechnicalFormatDataMapper(this);
return dataMapper.update(assetTechnicalFormat);
}
public AssetTechnicalFormat remove(AssetTechnicalFormat assetTechnicalFormat)
{
AssetTechnicalFormatDataMapper dataMapper = new AssetTechnicalFormatDataMapper(this);
return dataMapper.remove(assetTechnicalFormat);
}
public AssetType create(AssetType assetType)
{
AssetTypeDataMapper dataMapper = new AssetTypeDataMapper(this);
return dataMapper.create(assetType);
}
public AssetType update(AssetType assetType)
{
AssetTypeDataMapper dataMapper = new AssetTypeDataMapper(this);
return dataMapper.update(assetType);
}
public AssetType remove(AssetType assetType)
{
AssetTypeDataMapper dataMapper = new AssetTypeDataMapper(this);
return dataMapper.remove(assetType);
}
public AssetTypeAssetTechnicalFormat create(AssetTypeAssetTechnicalFormat assetTypeAssetTechnicalFormat)
{
AssetTypeAssetTechnicalFormatDataMapper dataMapper = new AssetTypeAssetTechnicalFormatDataMapper(this);
return dataMapper.create(assetTypeAssetTechnicalFormat);
}
public AssetTypeAssetTechnicalFormat update(AssetTypeAssetTechnicalFormat assetTypeAssetTechnicalFormat)
{
AssetTypeAssetTechnicalFormatDataMapper dataMapper = new AssetTypeAssetTechnicalFormatDataMapper(this);
return dataMapper.update(assetTypeAssetTechnicalFormat);
}
public AssetTypeAssetTechnicalFormat remove(AssetTypeAssetTechnicalFormat assetTypeAssetTechnicalFormat)
{
AssetTypeAssetTechnicalFormatDataMapper dataMapper = new AssetTypeAssetTechnicalFormatDataMapper(this);
return dataMapper.remove(assetTypeAssetTechnicalFormat);
}
public AssetTypeMetadataElementDefinition create(AssetTypeMetadataElementDefinition assetTypeMetadataElementDefinition)
{
AssetTypeMetadataElementDefinitionDataMapper dataMapper = new AssetTypeMetadataElementDefinitionDataMapper(this);
return dataMapper.create(assetTypeMetadataElementDefinition);
}
public AssetTypeMetadataElementDefinition update(AssetTypeMetadataElementDefinition assetTypeMetadataElementDefinition)
{
AssetTypeMetadataElementDefinitionDataMapper dataMapper = new AssetTypeMetadataElementDefinitionDataMapper(this);
return dataMapper.update(assetTypeMetadataElementDefinition);
}
public AssetTypeMetadataElementDefinition remove(AssetTypeMetadataElementDefinition assetTypeMetadataElementDefinition)
{
AssetTypeMetadataElementDefinitionDataMapper dataMapper = new AssetTypeMetadataElementDefinitionDataMapper(this);
return dataMapper.remove(assetTypeMetadataElementDefinition);
}
public Converter create(Converter converter)
{
ConverterDataMapper dataMapper = new ConverterDataMapper(this);
return dataMapper.create(converter);
}
public Converter update(Converter converter)
{
ConverterDataMapper dataMapper = new ConverterDataMapper(this);
return dataMapper.update(converter);
}
public Converter remove(Converter converter)
{
ConverterDataMapper dataMapper = new ConverterDataMapper(this);
return dataMapper.remove(converter);
}
public ConverterAttribute create(ConverterAttribute converterAttribute)
{
ConverterAttributeDataMapper dataMapper = new ConverterAttributeDataMapper(this);
return dataMapper.create(converterAttribute);
}
public ConverterAttribute update(ConverterAttribute converterAttribute)
{
ConverterAttributeDataMapper dataMapper = new ConverterAttributeDataMapper(this);
return dataMapper.update(converterAttribute);
}
public ConverterAttribute remove(ConverterAttribute converterAttribute)
{
ConverterAttributeDataMapper dataMapper = new ConverterAttributeDataMapper(this);
return dataMapper.remove(converterAttribute);
}
public MetadataElementDefinition create(MetadataElementDefinition metadataElementDefinition)
{
MetadataElementDefinitionDataMapper dataMapper = new MetadataElementDefinitionDataMapper(this);
return dataMapper.create(metadataElementDefinition);
}
public MetadataElementDefinition update(MetadataElementDefinition metadataElementDefinition)
{
MetadataElementDefinitionDataMapper dataMapper = new MetadataElementDefinitionDataMapper(this);
return dataMapper.update(metadataElementDefinition);
}
public MetadataElementDefinition remove(MetadataElementDefinition metadataElementDefinition)
{
MetadataElementDefinitionDataMapper dataMapper = new MetadataElementDefinitionDataMapper(this);
return dataMapper.remove(metadataElementDefinition);
}
public MetadataElementDefinitionGroup create(MetadataElementDefinitionGroup metadataElementDefinitionGroup)
{
MetadataElementDefinitionGroupDataMapper dataMapper = new MetadataElementDefinitionGroupDataMapper(this);
return dataMapper.create(metadataElementDefinitionGroup);
}
public MetadataElementDefinitionGroup update(MetadataElementDefinitionGroup metadataElementDefinitionGroup)
{
MetadataElementDefinitionGroupDataMapper dataMapper = new MetadataElementDefinitionGroupDataMapper(this);
return dataMapper.update(metadataElementDefinitionGroup);
}
public MetadataElementDefinitionGroup remove(MetadataElementDefinitionGroup metadataElementDefinitionGroup)
{
MetadataElementDefinitionGroupDataMapper dataMapper = new MetadataElementDefinitionGroupDataMapper(this);
return dataMapper.remove(metadataElementDefinitionGroup);
}
public MetadataElementDefinitionMetadataElementOption create(MetadataElementDefinitionMetadataElementOption metadataElementDefinitionMetadataElementOption)
{
MetadataElementDefinitionMetadataElementOptionDataMapper dataMapper = new MetadataElementDefinitionMetadataElementOptionDataMapper(this);
return dataMapper.create(metadataElementDefinitionMetadataElementOption);
}
public MetadataElementDefinitionMetadataElementOption update(MetadataElementDefinitionMetadataElementOption metadataElementDefinitionMetadataElementOption)
{
MetadataElementDefinitionMetadataElementOptionDataMapper dataMapper = new MetadataElementDefinitionMetadataElementOptionDataMapper(this);
return dataMapper.update(metadataElementDefinitionMetadataElementOption);
}
public MetadataElementDefinitionMetadataElementOption remove(MetadataElementDefinitionMetadataElementOption metadataElementDefinitionMetadataElementOption)
{
MetadataElementDefinitionMetadataElementOptionDataMapper dataMapper = new MetadataElementDefinitionMetadataElementOptionDataMapper(this);
return dataMapper.remove(metadataElementDefinitionMetadataElementOption);
}
public MetadataElementInstance create(MetadataElementInstance metadataElementInstance)
{
MetadataElementInstanceDataMapper dataMapper = new MetadataElementInstanceDataMapper(this);
return dataMapper.create(metadataElementInstance);
}
public MetadataElementInstance update(MetadataElementInstance metadataElementInstance)
{
MetadataElementInstanceDataMapper dataMapper = new MetadataElementInstanceDataMapper(this);
return dataMapper.update(metadataElementInstance);
}
public MetadataElementInstance remove(MetadataElementInstance metadataElementInstance)
{
MetadataElementInstanceDataMapper dataMapper = new MetadataElementInstanceDataMapper(this);
return dataMapper.remove(metadataElementInstance);
}
public MetadataElementInstanceValue create(MetadataElementInstanceValue metadataElementInstanceValue)
{
MetadataElementInstanceValueDataMapper dataMapper = new MetadataElementInstanceValueDataMapper(this);
return dataMapper.create(metadataElementInstanceValue);
}
public MetadataElementInstanceValue update(MetadataElementInstanceValue metadataElementInstanceValue)
{
MetadataElementInstanceValueDataMapper dataMapper = new MetadataElementInstanceValueDataMapper(this);
return dataMapper.update(metadataElementInstanceValue);
}
public MetadataElementInstanceValue remove(MetadataElementInstanceValue metadataElementInstanceValue)
{
MetadataElementInstanceValueDataMapper dataMapper = new MetadataElementInstanceValueDataMapper(this);
return dataMapper.remove(metadataElementInstanceValue);
}
public MetadataElementOption create(MetadataElementOption metadataElementOption)
{
MetadataElementOptionDataMapper dataMapper = new MetadataElementOptionDataMapper(this);
return dataMapper.create(metadataElementOption);
}
public MetadataElementOption update(MetadataElementOption metadataElementOption)
{
MetadataElementOptionDataMapper dataMapper = new MetadataElementOptionDataMapper(this);
return dataMapper.update(metadataElementOption);
}
public MetadataElementOption remove(MetadataElementOption metadataElementOption)
{
MetadataElementOptionDataMapper dataMapper = new MetadataElementOptionDataMapper(this);
return dataMapper.remove(metadataElementOption);
}
public Region create(Region region)
{
RegionDataMapper dataMapper = new RegionDataMapper(this);
return dataMapper.create(region);
}
public Region update(Region region)
{
RegionDataMapper dataMapper = new RegionDataMapper(this);
return dataMapper.update(region);
}
public Region remove(Region region)
{
RegionDataMapper dataMapper = new RegionDataMapper(this);
return dataMapper.remove(region);
}
public RegionAvailability create(RegionAvailability regionAvailability)
{
RegionAvailabilityDataMapper dataMapper = new RegionAvailabilityDataMapper(this);
return dataMapper.create(regionAvailability);
}
public RegionAvailability update(RegionAvailability regionAvailability)
{
RegionAvailabilityDataMapper dataMapper = new RegionAvailabilityDataMapper(this);
return dataMapper.update(regionAvailability);
}
public RegionAvailability remove(RegionAvailability regionAvailability)
{
RegionAvailabilityDataMapper dataMapper = new RegionAvailabilityDataMapper(this);
return dataMapper.remove(regionAvailability);
}
public DataSet Sp_alterdiagram(
String
diagramname,int
owner_id,int
version,byte[]
definition)
{
DataSet dataSet = new DataSet();
using (DatabaseConnectionMonitor databaseConnectionMonitor = new DatabaseConnectionMonitor(this))
{
using (SqlCommand sqlCommand = new SqlCommand("sp_alterdiagram", Connection))
{
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@diagramname",
diagramname);
sqlCommand.Parameters.AddWithValue("@owner_id",
owner_id);
sqlCommand.Parameters.AddWithValue("@version",
version);
sqlCommand.Parameters.AddWithValue("@definition",
definition);
SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand);
sqlDataAdapter.Fill(dataSet);
}
}
return dataSet;
}
public DataSet Sp_creatediagram(
String
diagramname,int
owner_id,int
version,byte[]
definition)
{
DataSet dataSet = new DataSet();
using (DatabaseConnectionMonitor databaseConnectionMonitor = new DatabaseConnectionMonitor(this))
{
using (SqlCommand sqlCommand = new SqlCommand("sp_creatediagram", Connection))
{
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@diagramname",
diagramname);
sqlCommand.Parameters.AddWithValue("@owner_id",
owner_id);
sqlCommand.Parameters.AddWithValue("@version",
version);
sqlCommand.Parameters.AddWithValue("@definition",
definition);
SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand);
sqlDataAdapter.Fill(dataSet);
}
}
return dataSet;
}
public DataSet Sp_dropdiagram(
String
diagramname,int
owner_id)
{
DataSet dataSet = new DataSet();
using (DatabaseConnectionMonitor databaseConnectionMonitor = new DatabaseConnectionMonitor(this))
{
using (SqlCommand sqlCommand = new SqlCommand("sp_dropdiagram", Connection))
{
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@diagramname",
diagramname);
sqlCommand.Parameters.AddWithValue("@owner_id",
owner_id);
SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand);
sqlDataAdapter.Fill(dataSet);
}
}
return dataSet;
}
public DataSet Sp_helpdiagramdefinition(
String
diagramname,int
owner_id)
{
DataSet dataSet = new DataSet();
using (DatabaseConnectionMonitor databaseConnectionMonitor = new DatabaseConnectionMonitor(this))
{
using (SqlCommand sqlCommand = new SqlCommand("sp_helpdiagramdefinition", Connection))
{
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@diagramname",
diagramname);
sqlCommand.Parameters.AddWithValue("@owner_id",
owner_id);
SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand);
sqlDataAdapter.Fill(dataSet);
}
}
return dataSet;
}
public DataSet Sp_helpdiagrams(
String
diagramname,int
owner_id)
{
DataSet dataSet = new DataSet();
using (DatabaseConnectionMonitor databaseConnectionMonitor = new DatabaseConnectionMonitor(this))
{
using (SqlCommand sqlCommand = new SqlCommand("sp_helpdiagrams", Connection))
{
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@diagramname",
diagramname);
sqlCommand.Parameters.AddWithValue("@owner_id",
owner_id);
SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand);
sqlDataAdapter.Fill(dataSet);
}
}
return dataSet;
}
public DataSet Sp_renamediagram(
String
diagramname,int
owner_id,String
new_diagramname)
{
DataSet dataSet = new DataSet();
using (DatabaseConnectionMonitor databaseConnectionMonitor = new DatabaseConnectionMonitor(this))
{
using (SqlCommand sqlCommand = new SqlCommand("sp_renamediagram", Connection))
{
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@diagramname",
diagramname);
sqlCommand.Parameters.AddWithValue("@owner_id",
owner_id);
sqlCommand.Parameters.AddWithValue("@new_diagramname",
new_diagramname);
SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand);
sqlDataAdapter.Fill(dataSet);
}
}
return dataSet;
}
public DataSet Sp_upgraddiagrams(
)
{
DataSet dataSet = new DataSet();
using (DatabaseConnectionMonitor databaseConnectionMonitor = new DatabaseConnectionMonitor(this))
{
using (SqlCommand sqlCommand = new SqlCommand("sp_upgraddiagrams", Connection))
{
sqlCommand.CommandType = CommandType.StoredProcedure;
SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand);
sqlDataAdapter.Fill(dataSet);
}
}
return dataSet;
}
}
public partial class Asset: DomainObject
{
protected int _iD;
protected String _name;
protected int _version;
protected String _originalName;
protected int _statusID;
protected DateTime? _validFrom;
protected DateTime? _validUntil;
protected DateTime _logicalCreationDate;
protected int? _createBy;
protected DateTime? _createDate;
protected int? _modifyBy;
protected DateTime? _modifyDate;
// parent tables
protected AssetStore _relatedAssetStore
= new AssetStore()
;
// parent tables
protected AssetTechnicalFormat _relatedAssetTechnicalFormat
= new AssetTechnicalFormat()
;
// parent tables
protected AssetType _relatedAssetType
= new AssetType()
;
public Asset(){}
public Asset(
int
iD,int
assetTypeID,String
name,int
version,String
originalName,int
statusID,int
originalTechnicalFormatID,DateTime
validFrom,DateTime
validUntil,DateTime
logicalCreationDate,int
originalAssetStoreID,int
createBy,DateTime
createDate,int
modifyBy,DateTime
modifyDate
)
{
this.ID = iD;
this.AssetTypeID = assetTypeID;
this.Name = name;
this.Version = version;
this.OriginalName = originalName;
this.StatusID = statusID;
this.OriginalTechnicalFormatID = originalTechnicalFormatID;
this.ValidFrom = validFrom;
this.ValidUntil = validUntil;
this.LogicalCreationDate = logicalCreationDate;
this.OriginalAssetStoreID = originalAssetStoreID;
this.CreateBy = createBy;
this.CreateDate = createDate;
this.ModifyBy = modifyBy;
this.ModifyDate = modifyDate;
}
public override String getUri()
{
String uri = "AMF_dev.Asset."
+ ID.ToString()
;
return uri;
}
public int ID
{
get { return _iD;}
set
{
_iD = value;
}
}
public int AssetTypeID
{
get
{
if(_relatedAssetType != null)
return _relatedAssetType.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedAssetType == null)
_relatedAssetType = new AssetType();
_relatedAssetType.ID = value;
}
}
public String Name
{
get { return _name;}
set
{
_name = value;
}
}
public int Version
{
get { return _version;}
set
{
_version = value;
}
}
public String OriginalName
{
get { return _originalName;}
set
{
_originalName = value;
}
}
public int StatusID
{
get { return _statusID;}
set
{
_statusID = value;
}
}
public int OriginalTechnicalFormatID
{
get
{
if(_relatedAssetTechnicalFormat != null)
return _relatedAssetTechnicalFormat.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedAssetTechnicalFormat == null)
_relatedAssetTechnicalFormat = new AssetTechnicalFormat();
_relatedAssetTechnicalFormat.ID = value;
}
}
public DateTime? ValidFrom
{
get { return _validFrom;}
set
{
_validFrom = value;
}
}
public DateTime? ValidUntil
{
get { return _validUntil;}
set
{
_validUntil = value;
}
}
public DateTime LogicalCreationDate
{
get { return _logicalCreationDate;}
set
{
_logicalCreationDate = value;
}
}
public int OriginalAssetStoreID
{
get
{
if(_relatedAssetStore != null)
return _relatedAssetStore.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedAssetStore == null)
_relatedAssetStore = new AssetStore();
_relatedAssetStore.ID = value;
}
}
public int? CreateBy
{
get { return _createBy;}
set
{
_createBy = value;
}
}
public DateTime? CreateDate
{
get { return _createDate;}
set
{
_createDate = value;
}
}
public int? ModifyBy
{
get { return _modifyBy;}
set
{
_modifyBy = value;
}
}
public DateTime? ModifyDate
{
get { return _modifyDate;}
set
{
_modifyDate = value;
}
}
public AssetStore RelatedAssetStore
{
get { return _relatedAssetStore;}
set { _relatedAssetStore = value; }
}
public AssetTechnicalFormat RelatedAssetTechnicalFormat
{
get { return _relatedAssetTechnicalFormat;}
set { _relatedAssetTechnicalFormat = value; }
}
public AssetType RelatedAssetType
{
get { return _relatedAssetType;}
set { _relatedAssetType = value; }
}
public override DomainObject extractSingleObject()
{
Asset asset = new Asset();
asset.ID = this.ID;
asset.AssetTypeID = this.AssetTypeID;
asset.Name = this.Name;
asset.Version = this.Version;
asset.OriginalName = this.OriginalName;
asset.StatusID = this.StatusID;
asset.OriginalTechnicalFormatID = this.OriginalTechnicalFormatID;
asset.ValidFrom = this.ValidFrom;
asset.ValidUntil = this.ValidUntil;
asset.LogicalCreationDate = this.LogicalCreationDate;
asset.OriginalAssetStoreID = this.OriginalAssetStoreID;
asset.CreateBy = this.CreateBy;
asset.CreateDate = this.CreateDate;
asset.ModifyBy = this.ModifyBy;
asset.ModifyDate = this.ModifyDate;
asset.ActiveRecordId = this.ActiveRecordId;
return asset;
}
// one to many relation
private List<MetadataElementInstance> _relatedMetadataElementInstance;
public List<MetadataElementInstance> relatedMetadataElementInstance
{
get { return _relatedMetadataElementInstance;}
set { _relatedMetadataElementInstance = value; }
}
// one to many relation
private List<RegionAvailability> _relatedRegionAvailability;
public List<RegionAvailability> relatedRegionAvailability
{
get { return _relatedRegionAvailability;}
set { _relatedRegionAvailability = value; }
}
}
public partial class AssetDataMapper:TDataMapper<Asset,SqlConnection,AMF_devDb, Weborb.Data.Management.MSSql.CommandBuilder, SqlTransaction, SqlCommand>
{
public AssetDataMapper(){}
public AssetDataMapper(AMF_devDb database):
base(database){}
public override String TableName
{
get
{
return "[Asset].[Asset]";
}
}
public override Hashtable getRelation(string tableName)
{
throw new Exception("Not yet implemented");
}
private const String SqlCreate = @"Insert Into [Asset].[Asset] (
AssetTypeID,Name,Version,OriginalName,StatusID,OriginalTechnicalFormatID,ValidFrom,ValidUntil,LogicalCreationDate,OriginalAssetStoreID,CreateBy,CreateDate,ModifyBy,ModifyDate) Values (
@AssetTypeID,
@Name,
@Version,
@OriginalName,
@StatusID,
@OriginalTechnicalFormatID,
@ValidFrom,
@ValidUntil,
@LogicalCreationDate,
@OriginalAssetStoreID,
@CreateBy,
@CreateDate,
@ModifyBy,
@ModifyDate);
select scope_identity();
";
[TransactionRequired]
[Synchronized]
public override Asset create( Asset asset )
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
{
sqlCommand.Parameters.AddWithValue("@AssetTypeID", asset.AssetTypeID);
sqlCommand.Parameters.AddWithValue("@Name", asset.Name);
sqlCommand.Parameters.AddWithValue("@Version", asset.Version);
sqlCommand.Parameters.AddWithValue("@OriginalName", asset.OriginalName);
sqlCommand.Parameters.AddWithValue("@StatusID", asset.StatusID);
sqlCommand.Parameters.AddWithValue("@OriginalTechnicalFormatID", asset.OriginalTechnicalFormatID);
if(asset.ValidFrom.HasValue)
sqlCommand.Parameters.AddWithValue("@ValidFrom", asset.ValidFrom);
else
sqlCommand.Parameters.AddWithValue("@ValidFrom", DBNull.Value);
if(asset.ValidUntil.HasValue)
sqlCommand.Parameters.AddWithValue("@ValidUntil", asset.ValidUntil);
else
sqlCommand.Parameters.AddWithValue("@ValidUntil", DBNull.Value);
sqlCommand.Parameters.AddWithValue("@LogicalCreationDate", asset.LogicalCreationDate);
sqlCommand.Parameters.AddWithValue("@OriginalAssetStoreID", asset.OriginalAssetStoreID);
if(asset.CreateBy.HasValue)
sqlCommand.Parameters.AddWithValue("@CreateBy", asset.CreateBy);
else
sqlCommand.Parameters.AddWithValue("@CreateBy", DBNull.Value);
if(asset.CreateDate.HasValue)
sqlCommand.Parameters.AddWithValue("@CreateDate", asset.CreateDate);
else
sqlCommand.Parameters.AddWithValue("@CreateDate", DBNull.Value);
if(asset.ModifyBy.HasValue)
sqlCommand.Parameters.AddWithValue("@ModifyBy", asset.ModifyBy);
else
sqlCommand.Parameters.AddWithValue("@ModifyBy", DBNull.Value);
if(asset.ModifyDate.HasValue)
sqlCommand.Parameters.AddWithValue("@ModifyDate", asset.ModifyDate);
else
sqlCommand.Parameters.AddWithValue("@ModifyDate", DBNull.Value);
asset.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
}
}
if(asset.relatedMetadataElementInstance != null
&& asset.relatedMetadataElementInstance.Count > 0)
{
MetadataElementInstanceDataMapper dataMapper = new MetadataElementInstanceDataMapper(Database);
foreach(MetadataElementInstance item in asset.relatedMetadataElementInstance)
dataMapper.create(item);
}
if(asset.relatedRegionAvailability != null
&& asset.relatedRegionAvailability.Count > 0)
{
RegionAvailabilityDataMapper dataMapper = new RegionAvailabilityDataMapper(Database);
foreach(RegionAvailability item in asset.relatedRegionAvailability)
dataMapper.create(item);
}
raiseAffected(asset,DataMapperOperation.create);
return registerRecord(asset);
}
private const String SqlSelectByPk = @"Select
ID,AssetTypeID,Name,Version,OriginalName,StatusID,OriginalTechnicalFormatID,ValidFrom,ValidUntil,LogicalCreationDate,OriginalAssetStoreID,CreateBy,CreateDate,ModifyBy,ModifyDate
From [Asset].[Asset]
Where
ID = @ID
";
public Asset findByPrimaryKey(
int iD
)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", iD);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
if(dataReader.Read())
return doLoad(dataReader);
}
}
}
throw new DataNotFoundException("Asset not found, search by primary key");
}
public bool exists(Asset asset)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", asset.ID);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
return dataReader.Read();
}
}
}
}
private const string CheckInSql = @"
[Asset].[ID] = @CheckInID";
protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
{
Asset _Asset = (Asset)domainObject;
SqlCommand sqlCommand = Database.CreateCommand(ModifyQueryForCheckIn(sqlQuery,CheckInSql));
sqlCommand.Parameters.AddWithValue("@CheckInID", _Asset.ID);
return sqlCommand;
}
protected override Asset doLoad(IDataReader dataReader)
{
Asset asset = new Asset();
asset.ID = (int) dataReader.GetValue(0);
asset.AssetTypeID = (int) dataReader.GetValue(1);
asset.Name = (String) dataReader.GetValue(2);
asset.Version = (int) dataReader.GetValue(3);
asset.OriginalName = (String) dataReader.GetValue(4);
asset.StatusID = (int) dataReader.GetValue(5);
asset.OriginalTechnicalFormatID = (int) dataReader.GetValue(6);
if(!dataReader.IsDBNull(7))
asset.ValidFrom = (DateTime) dataReader.GetValue(7);
if(!dataReader.IsDBNull(8))
asset.ValidUntil = (DateTime) dataReader.GetValue(8);
asset.LogicalCreationDate = (DateTime) dataReader.GetValue(9);
asset.OriginalAssetStoreID = (int) dataReader.GetValue(10);
if(!dataReader.IsDBNull(11))
asset.CreateBy = (int) dataReader.GetValue(11);
if(!dataReader.IsDBNull(12))
asset.CreateDate = (DateTime) dataReader.GetValue(12);
if(!dataReader.IsDBNull(13))
asset.ModifyBy = (int) dataReader.GetValue(13);
if(!dataReader.IsDBNull(14))
asset.ModifyDate = (DateTime) dataReader.GetValue(14);
return registerRecord(asset);
}
protected override Asset doLoad(Hashtable hashtable)
{
Asset asset = new Asset();
if(hashtable.ContainsKey("ID"))
asset.ID = ( int)hashtable["ID"];
if(hashtable.ContainsKey("AssetTypeID"))
asset.AssetTypeID = ( int)hashtable["AssetTypeID"];
if(hashtable.ContainsKey("Name"))
asset.Name = ( String)hashtable["Name"];
if(hashtable.ContainsKey("Version"))
asset.Version = ( int)hashtable["Version"];
if(hashtable.ContainsKey("OriginalName"))
asset.OriginalName = ( String)hashtable["OriginalName"];
if(hashtable.ContainsKey("StatusID"))
asset.StatusID = ( int)hashtable["StatusID"];
if(hashtable.ContainsKey("OriginalTechnicalFormatID"))
asset.OriginalTechnicalFormatID = ( int)hashtable["OriginalTechnicalFormatID"];
if(hashtable.ContainsKey("ValidFrom"))
asset.ValidFrom = ( DateTime)hashtable["ValidFrom"];
if(hashtable.ContainsKey("ValidUntil"))
asset.ValidUntil = ( DateTime)hashtable["ValidUntil"];
if(hashtable.ContainsKey("LogicalCreationDate"))
asset.LogicalCreationDate = ( DateTime)hashtable["LogicalCreationDate"];
if(hashtable.ContainsKey("OriginalAssetStoreID"))
asset.OriginalAssetStoreID = ( int)hashtable["OriginalAssetStoreID"];
if(hashtable.ContainsKey("CreateBy"))
asset.CreateBy = ( int)hashtable["CreateBy"];
if(hashtable.ContainsKey("CreateDate"))
asset.CreateDate = ( DateTime)hashtable["CreateDate"];
if(hashtable.ContainsKey("ModifyBy"))
asset.ModifyBy = ( int)hashtable["ModifyBy"];
if(hashtable.ContainsKey("ModifyDate"))
asset.ModifyDate = ( DateTime)hashtable["ModifyDate"];
return asset;
}
protected override List<Asset> fill(SqlCommand sqlCommand, int offset, int limit)
{
List<Asset> resultList = new List<Asset>();
using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
{
DataTable dataTable = new DataTable();
sqlDataAdapter.Fill(offset,limit,dataTable);
foreach(DataRow dataRow in dataTable.Rows)
{
Asset item = new Asset();
item.ID = ( int)dataRow["ID"] ;
item.AssetTypeID = ( int)dataRow["AssetTypeID"] ;
item.Name = ( String)dataRow["Name"] ;
item.Version = ( int)dataRow["Version"] ;
item.OriginalName = ( String)dataRow["OriginalName"] ;
item.StatusID = ( int)dataRow["StatusID"] ;
item.OriginalTechnicalFormatID = ( int)dataRow["OriginalTechnicalFormatID"] ;
if(!dataRow.IsNull("ValidFrom"))
item.ValidFrom = ( DateTime)dataRow["ValidFrom"] ;
if(!dataRow.IsNull("ValidUntil"))
item.ValidUntil = ( DateTime)dataRow["ValidUntil"] ;
item.LogicalCreationDate = ( DateTime)dataRow["LogicalCreationDate"] ;
item.OriginalAssetStoreID = ( int)dataRow["OriginalAssetStoreID"] ;
if(!dataRow.IsNull("CreateBy"))
item.CreateBy = ( int)dataRow["CreateBy"] ;
if(!dataRow.IsNull("CreateDate"))
item.CreateDate = ( DateTime)dataRow["CreateDate"] ;
if(!dataRow.IsNull("ModifyBy"))
item.ModifyBy = ( int)dataRow["ModifyBy"] ;
if(!dataRow.IsNull("ModifyDate"))
item.ModifyDate = ( DateTime)dataRow["ModifyDate"] ;
registerRecord(item);
resultList.Add(item);
}
}
return resultList;
}
#region Delete
private const String SqlDelete = @"Delete From [Asset].[Asset]
Where
ID = @ID";
[Synchronized]
public Asset remove(Asset asset)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
{
sqlCommand.Parameters.AddWithValue("@ID", asset.ID);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(asset,DataMapperOperation.delete);
return registerRecord(asset);
}
#endregion
[Synchronized]
[TransactionRequired]
public Asset save( Asset asset )
{
if(exists(asset))
return update(asset);
return create(asset);
}
const String SqlUpdate = @"Update [Asset].[Asset] Set
AssetTypeID = @AssetTypeID,Name = @Name,Version = @Version,OriginalName = @OriginalName,StatusID = @StatusID,OriginalTechnicalFormatID = @OriginalTechnicalFormatID,ValidFrom = @ValidFrom,ValidUntil = @ValidUntil,LogicalCreationDate = @LogicalCreationDate,OriginalAssetStoreID = @OriginalAssetStoreID,CreateBy = @CreateBy,CreateDate = @CreateDate,ModifyBy = @ModifyBy,ModifyDate = @ModifyDate
Where
ID = @ID";
[TransactionRequired]
[Synchronized]
public Asset update(Asset asset)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
{
sqlCommand.Parameters.AddWithValue("@ID", asset.ID);
sqlCommand.Parameters.AddWithValue("@AssetTypeID", asset.AssetTypeID);
sqlCommand.Parameters.AddWithValue("@Name", asset.Name);
sqlCommand.Parameters.AddWithValue("@Version", asset.Version);
sqlCommand.Parameters.AddWithValue("@OriginalName", asset.OriginalName);
sqlCommand.Parameters.AddWithValue("@StatusID", asset.StatusID);
sqlCommand.Parameters.AddWithValue("@OriginalTechnicalFormatID", asset.OriginalTechnicalFormatID);
if(asset.ValidFrom.HasValue)
sqlCommand.Parameters.AddWithValue("@ValidFrom", asset.ValidFrom);
else
sqlCommand.Parameters.AddWithValue("@ValidFrom", DBNull.Value);
if(asset.ValidUntil.HasValue)
sqlCommand.Parameters.AddWithValue("@ValidUntil", asset.ValidUntil);
else
sqlCommand.Parameters.AddWithValue("@ValidUntil", DBNull.Value);
sqlCommand.Parameters.AddWithValue("@LogicalCreationDate", asset.LogicalCreationDate);
sqlCommand.Parameters.AddWithValue("@OriginalAssetStoreID", asset.OriginalAssetStoreID);
if(asset.CreateBy.HasValue)
sqlCommand.Parameters.AddWithValue("@CreateBy", asset.CreateBy);
else
sqlCommand.Parameters.AddWithValue("@CreateBy", DBNull.Value);
if(asset.CreateDate.HasValue)
sqlCommand.Parameters.AddWithValue("@CreateDate", asset.CreateDate);
else
sqlCommand.Parameters.AddWithValue("@CreateDate", DBNull.Value);
if(asset.ModifyBy.HasValue)
sqlCommand.Parameters.AddWithValue("@ModifyBy", asset.ModifyBy);
else
sqlCommand.Parameters.AddWithValue("@ModifyBy", DBNull.Value);
if(asset.ModifyDate.HasValue)
sqlCommand.Parameters.AddWithValue("@ModifyDate", asset.ModifyDate);
else
sqlCommand.Parameters.AddWithValue("@ModifyDate", DBNull.Value);
sqlCommand.ExecuteNonQuery();
}
}
if(asset.relatedMetadataElementInstance != null
&& asset.relatedMetadataElementInstance.Count > 0)
{
MetadataElementInstanceDataMapper dataMapper = new MetadataElementInstanceDataMapper(Database);
foreach(MetadataElementInstance item in asset.relatedMetadataElementInstance)
dataMapper.save(item);
}
if(asset.relatedRegionAvailability != null
&& asset.relatedRegionAvailability.Count > 0)
{
RegionAvailabilityDataMapper dataMapper = new RegionAvailabilityDataMapper(Database);
foreach(RegionAvailability item in asset.relatedRegionAvailability)
dataMapper.save(item);
}
raiseAffected(asset,DataMapperOperation.update);
return registerRecord(asset);
}
}
public partial class AssetFormat: DomainObject
{
protected int _iD;
protected String _nameResourceCode;
protected int _createBy;
protected DateTime _createDate;
protected int _modifyBy;
protected DateTime _modifyDate;
// parent tables
protected AssetStore _relatedAssetStore
= new AssetStore()
;
// parent tables
protected AssetTechnicalFormat _relatedAssetTechnicalFormat
= new AssetTechnicalFormat()
;
// parent tables
protected AssetType _relatedAssetType
= new AssetType()
;
public AssetFormat(){}
public AssetFormat(
int
iD,int
assetTypeID,String
nameResourceCode,int
assetStoreID,int
assetTechnicalFormatID,int
createBy,DateTime
createDate,int
modifyBy,DateTime
modifyDate
)
{
this.ID = iD;
this.AssetTypeID = assetTypeID;
this.NameResourceCode = nameResourceCode;
this.AssetStoreID = assetStoreID;
this.AssetTechnicalFormatID = assetTechnicalFormatID;
this.CreateBy = createBy;
this.CreateDate = createDate;
this.ModifyBy = modifyBy;
this.ModifyDate = modifyDate;
}
public override String getUri()
{
String uri = "AMF_dev.AssetFormat."
+ ID.ToString()
;
return uri;
}
public int ID
{
get { return _iD;}
set
{
_iD = value;
}
}
public int AssetTypeID
{
get
{
if(_relatedAssetType != null)
return _relatedAssetType.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedAssetType == null)
_relatedAssetType = new AssetType();
_relatedAssetType.ID = value;
}
}
public String NameResourceCode
{
get { return _nameResourceCode;}
set
{
_nameResourceCode = value;
}
}
public int AssetStoreID
{
get
{
if(_relatedAssetStore != null)
return _relatedAssetStore.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedAssetStore == null)
_relatedAssetStore = new AssetStore();
_relatedAssetStore.ID = value;
}
}
public int AssetTechnicalFormatID
{
get
{
if(_relatedAssetTechnicalFormat != null)
return _relatedAssetTechnicalFormat.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedAssetTechnicalFormat == null)
_relatedAssetTechnicalFormat = new AssetTechnicalFormat();
_relatedAssetTechnicalFormat.ID = value;
}
}
public int CreateBy
{
get { return _createBy;}
set
{
_createBy = value;
}
}
public DateTime CreateDate
{
get { return _createDate;}
set
{
_createDate = value;
}
}
public int ModifyBy
{
get { return _modifyBy;}
set
{
_modifyBy = value;
}
}
public DateTime ModifyDate
{
get { return _modifyDate;}
set
{
_modifyDate = value;
}
}
public AssetStore RelatedAssetStore
{
get { return _relatedAssetStore;}
set { _relatedAssetStore = value; }
}
public AssetTechnicalFormat RelatedAssetTechnicalFormat
{
get { return _relatedAssetTechnicalFormat;}
set { _relatedAssetTechnicalFormat = value; }
}
public AssetType RelatedAssetType
{
get { return _relatedAssetType;}
set { _relatedAssetType = value; }
}
public override DomainObject extractSingleObject()
{
AssetFormat assetFormat = new AssetFormat();
assetFormat.ID = this.ID;
assetFormat.AssetTypeID = this.AssetTypeID;
assetFormat.NameResourceCode = this.NameResourceCode;
assetFormat.AssetStoreID = this.AssetStoreID;
assetFormat.AssetTechnicalFormatID = this.AssetTechnicalFormatID;
assetFormat.CreateBy = this.CreateBy;
assetFormat.CreateDate = this.CreateDate;
assetFormat.ModifyBy = this.ModifyBy;
assetFormat.ModifyDate = this.ModifyDate;
assetFormat.ActiveRecordId = this.ActiveRecordId;
return assetFormat;
}
// one to many relation
private List<AssetFormatAttribute> _relatedAssetFormatAttribute;
public List<AssetFormatAttribute> relatedAssetFormatAttribute
{
get { return _relatedAssetFormatAttribute;}
set { _relatedAssetFormatAttribute = value; }
}
}
public partial class AssetFormatDataMapper:TDataMapper<AssetFormat,SqlConnection,AMF_devDb, Weborb.Data.Management.MSSql.CommandBuilder, SqlTransaction, SqlCommand>
{
public AssetFormatDataMapper(){}
public AssetFormatDataMapper(AMF_devDb database):
base(database){}
public override String TableName
{
get
{
return "[Asset].[AssetFormat]";
}
}
public override Hashtable getRelation(string tableName)
{
throw new Exception("Not yet implemented");
}
private const String SqlCreate = @"Insert Into [Asset].[AssetFormat] (
AssetTypeID,NameResourceCode,AssetStoreID,AssetTechnicalFormatID,CreateBy,CreateDate,ModifyBy,ModifyDate) Values (
@AssetTypeID,
@NameResourceCode,
@AssetStoreID,
@AssetTechnicalFormatID,
@CreateBy,
@CreateDate,
@ModifyBy,
@ModifyDate);
select scope_identity();
";
[TransactionRequired]
[Synchronized]
public override AssetFormat create( AssetFormat assetFormat )
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
{
sqlCommand.Parameters.AddWithValue("@AssetTypeID", assetFormat.AssetTypeID);
sqlCommand.Parameters.AddWithValue("@NameResourceCode", assetFormat.NameResourceCode);
sqlCommand.Parameters.AddWithValue("@AssetStoreID", assetFormat.AssetStoreID);
sqlCommand.Parameters.AddWithValue("@AssetTechnicalFormatID", assetFormat.AssetTechnicalFormatID);
sqlCommand.Parameters.AddWithValue("@CreateBy", assetFormat.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", assetFormat.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", assetFormat.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", assetFormat.ModifyDate);
assetFormat.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
}
}
if(assetFormat.relatedAssetFormatAttribute != null
&& assetFormat.relatedAssetFormatAttribute.Count > 0)
{
AssetFormatAttributeDataMapper dataMapper = new AssetFormatAttributeDataMapper(Database);
foreach(AssetFormatAttribute item in assetFormat.relatedAssetFormatAttribute)
dataMapper.create(item);
}
raiseAffected(assetFormat,DataMapperOperation.create);
return registerRecord(assetFormat);
}
private const String SqlSelectByPk = @"Select
ID,AssetTypeID,NameResourceCode,AssetStoreID,AssetTechnicalFormatID,CreateBy,CreateDate,ModifyBy,ModifyDate
From [Asset].[AssetFormat]
Where
ID = @ID
";
public AssetFormat findByPrimaryKey(
int iD
)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", iD);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
if(dataReader.Read())
return doLoad(dataReader);
}
}
}
throw new DataNotFoundException("AssetFormat not found, search by primary key");
}
public bool exists(AssetFormat assetFormat)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", assetFormat.ID);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
return dataReader.Read();
}
}
}
}
private const string CheckInSql = @"
[AssetFormat].[ID] = @CheckInID";
protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
{
AssetFormat _AssetFormat = (AssetFormat)domainObject;
SqlCommand sqlCommand = Database.CreateCommand(ModifyQueryForCheckIn(sqlQuery,CheckInSql));
sqlCommand.Parameters.AddWithValue("@CheckInID", _AssetFormat.ID);
return sqlCommand;
}
protected override AssetFormat doLoad(IDataReader dataReader)
{
AssetFormat assetFormat = new AssetFormat();
assetFormat.ID = (int) dataReader.GetValue(0);
assetFormat.AssetTypeID = (int) dataReader.GetValue(1);
assetFormat.NameResourceCode = (String) dataReader.GetValue(2);
assetFormat.AssetStoreID = (int) dataReader.GetValue(3);
assetFormat.AssetTechnicalFormatID = (int) dataReader.GetValue(4);
assetFormat.CreateBy = (int) dataReader.GetValue(5);
assetFormat.CreateDate = (DateTime) dataReader.GetValue(6);
assetFormat.ModifyBy = (int) dataReader.GetValue(7);
assetFormat.ModifyDate = (DateTime) dataReader.GetValue(8);
return registerRecord(assetFormat);
}
protected override AssetFormat doLoad(Hashtable hashtable)
{
AssetFormat assetFormat = new AssetFormat();
if(hashtable.ContainsKey("ID"))
assetFormat.ID = ( int)hashtable["ID"];
if(hashtable.ContainsKey("AssetTypeID"))
assetFormat.AssetTypeID = ( int)hashtable["AssetTypeID"];
if(hashtable.ContainsKey("NameResourceCode"))
assetFormat.NameResourceCode = ( String)hashtable["NameResourceCode"];
if(hashtable.ContainsKey("AssetStoreID"))
assetFormat.AssetStoreID = ( int)hashtable["AssetStoreID"];
if(hashtable.ContainsKey("AssetTechnicalFormatID"))
assetFormat.AssetTechnicalFormatID = ( int)hashtable["AssetTechnicalFormatID"];
if(hashtable.ContainsKey("CreateBy"))
assetFormat.CreateBy = ( int)hashtable["CreateBy"];
if(hashtable.ContainsKey("CreateDate"))
assetFormat.CreateDate = ( DateTime)hashtable["CreateDate"];
if(hashtable.ContainsKey("ModifyBy"))
assetFormat.ModifyBy = ( int)hashtable["ModifyBy"];
if(hashtable.ContainsKey("ModifyDate"))
assetFormat.ModifyDate = ( DateTime)hashtable["ModifyDate"];
return assetFormat;
}
protected override List<AssetFormat> fill(SqlCommand sqlCommand, int offset, int limit)
{
List<AssetFormat> resultList = new List<AssetFormat>();
using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
{
DataTable dataTable = new DataTable();
sqlDataAdapter.Fill(offset,limit,dataTable);
foreach(DataRow dataRow in dataTable.Rows)
{
AssetFormat item = new AssetFormat();
item.ID = ( int)dataRow["ID"] ;
item.AssetTypeID = ( int)dataRow["AssetTypeID"] ;
item.NameResourceCode = ( String)dataRow["NameResourceCode"] ;
item.AssetStoreID = ( int)dataRow["AssetStoreID"] ;
item.AssetTechnicalFormatID = ( int)dataRow["AssetTechnicalFormatID"] ;
item.CreateBy = ( int)dataRow["CreateBy"] ;
item.CreateDate = ( DateTime)dataRow["CreateDate"] ;
item.ModifyBy = ( int)dataRow["ModifyBy"] ;
item.ModifyDate = ( DateTime)dataRow["ModifyDate"] ;
registerRecord(item);
resultList.Add(item);
}
}
return resultList;
}
#region Delete
private const String SqlDelete = @"Delete From [Asset].[AssetFormat]
Where
ID = @ID";
[Synchronized]
public AssetFormat remove(AssetFormat assetFormat)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
{
sqlCommand.Parameters.AddWithValue("@ID", assetFormat.ID);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(assetFormat,DataMapperOperation.delete);
return registerRecord(assetFormat);
}
#endregion
[Synchronized]
[TransactionRequired]
public AssetFormat save( AssetFormat assetFormat )
{
if(exists(assetFormat))
return update(assetFormat);
return create(assetFormat);
}
const String SqlUpdate = @"Update [Asset].[AssetFormat] Set
AssetTypeID = @AssetTypeID,NameResourceCode = @NameResourceCode,AssetStoreID = @AssetStoreID,AssetTechnicalFormatID = @AssetTechnicalFormatID,CreateBy = @CreateBy,CreateDate = @CreateDate,ModifyBy = @ModifyBy,ModifyDate = @ModifyDate
Where
ID = @ID";
[TransactionRequired]
[Synchronized]
public AssetFormat update(AssetFormat assetFormat)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
{
sqlCommand.Parameters.AddWithValue("@ID", assetFormat.ID);
sqlCommand.Parameters.AddWithValue("@AssetTypeID", assetFormat.AssetTypeID);
sqlCommand.Parameters.AddWithValue("@NameResourceCode", assetFormat.NameResourceCode);
sqlCommand.Parameters.AddWithValue("@AssetStoreID", assetFormat.AssetStoreID);
sqlCommand.Parameters.AddWithValue("@AssetTechnicalFormatID", assetFormat.AssetTechnicalFormatID);
sqlCommand.Parameters.AddWithValue("@CreateBy", assetFormat.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", assetFormat.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", assetFormat.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", assetFormat.ModifyDate);
sqlCommand.ExecuteNonQuery();
}
}
if(assetFormat.relatedAssetFormatAttribute != null
&& assetFormat.relatedAssetFormatAttribute.Count > 0)
{
AssetFormatAttributeDataMapper dataMapper = new AssetFormatAttributeDataMapper(Database);
foreach(AssetFormatAttribute item in assetFormat.relatedAssetFormatAttribute)
dataMapper.save(item);
}
raiseAffected(assetFormat,DataMapperOperation.update);
return registerRecord(assetFormat);
}
}
public partial class AssetFormatAttribute: DomainObject
{
protected int _iD;
protected String _name;
protected String _value;
protected int _createBy;
protected DateTime _createDate;
protected int _modifyBy;
protected DateTime _modifyDate;
// parent tables
protected AssetFormat _relatedAssetFormat
= new AssetFormat()
;
public AssetFormatAttribute(){}
public AssetFormatAttribute(
int
iD,String
name,String
value,int
assetFormatID,int
createBy,DateTime
createDate,int
modifyBy,DateTime
modifyDate
)
{
this.ID = iD;
this.Name = name;
this.Value = value;
this.AssetFormatID = assetFormatID;
this.CreateBy = createBy;
this.CreateDate = createDate;
this.ModifyBy = modifyBy;
this.ModifyDate = modifyDate;
}
public override String getUri()
{
String uri = "AMF_dev.AssetFormatAttribute."
+ ID.ToString()
;
return uri;
}
public int ID
{
get { return _iD;}
set
{
_iD = value;
}
}
public String Name
{
get { return _name;}
set
{
_name = value;
}
}
public String Value
{
get { return _value;}
set
{
_value = value;
}
}
public int AssetFormatID
{
get
{
if(_relatedAssetFormat != null)
return _relatedAssetFormat.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedAssetFormat == null)
_relatedAssetFormat = new AssetFormat();
_relatedAssetFormat.ID = value;
}
}
public int CreateBy
{
get { return _createBy;}
set
{
_createBy = value;
}
}
public DateTime CreateDate
{
get { return _createDate;}
set
{
_createDate = value;
}
}
public int ModifyBy
{
get { return _modifyBy;}
set
{
_modifyBy = value;
}
}
public DateTime ModifyDate
{
get { return _modifyDate;}
set
{
_modifyDate = value;
}
}
public AssetFormat RelatedAssetFormat
{
get { return _relatedAssetFormat;}
set { _relatedAssetFormat = value; }
}
public override DomainObject extractSingleObject()
{
AssetFormatAttribute assetFormatAttribute = new AssetFormatAttribute();
assetFormatAttribute.ID = this.ID;
assetFormatAttribute.Name = this.Name;
assetFormatAttribute.Value = this.Value;
assetFormatAttribute.AssetFormatID = this.AssetFormatID;
assetFormatAttribute.CreateBy = this.CreateBy;
assetFormatAttribute.CreateDate = this.CreateDate;
assetFormatAttribute.ModifyBy = this.ModifyBy;
assetFormatAttribute.ModifyDate = this.ModifyDate;
assetFormatAttribute.ActiveRecordId = this.ActiveRecordId;
return assetFormatAttribute;
}
}
public partial class AssetFormatAttributeDataMapper:TDataMapper<AssetFormatAttribute,SqlConnection,AMF_devDb, Weborb.Data.Management.MSSql.CommandBuilder, SqlTransaction, SqlCommand>
{
public AssetFormatAttributeDataMapper(){}
public AssetFormatAttributeDataMapper(AMF_devDb database):
base(database){}
public override String TableName
{
get
{
return "[Asset].[AssetFormatAttribute]";
}
}
public override Hashtable getRelation(string tableName)
{
throw new Exception("Not yet implemented");
}
private const String SqlCreate = @"Insert Into [Asset].[AssetFormatAttribute] (
Name,Value,AssetFormatID,CreateBy,CreateDate,ModifyBy,ModifyDate) Values (
@Name,
@Value,
@AssetFormatID,
@CreateBy,
@CreateDate,
@ModifyBy,
@ModifyDate);
select scope_identity();
";
[Synchronized]
public override AssetFormatAttribute create( AssetFormatAttribute assetFormatAttribute )
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
{
sqlCommand.Parameters.AddWithValue("@Name", assetFormatAttribute.Name);
sqlCommand.Parameters.AddWithValue("@Value", assetFormatAttribute.Value);
sqlCommand.Parameters.AddWithValue("@AssetFormatID", assetFormatAttribute.AssetFormatID);
sqlCommand.Parameters.AddWithValue("@CreateBy", assetFormatAttribute.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", assetFormatAttribute.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", assetFormatAttribute.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", assetFormatAttribute.ModifyDate);
assetFormatAttribute.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
}
}
raiseAffected(assetFormatAttribute,DataMapperOperation.create);
return registerRecord(assetFormatAttribute);
}
private const String SqlSelectByPk = @"Select
ID,Name,Value,AssetFormatID,CreateBy,CreateDate,ModifyBy,ModifyDate
From [Asset].[AssetFormatAttribute]
Where
ID = @ID
";
public AssetFormatAttribute findByPrimaryKey(
int iD
)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", iD);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
if(dataReader.Read())
return doLoad(dataReader);
}
}
}
throw new DataNotFoundException("AssetFormatAttribute not found, search by primary key");
}
public bool exists(AssetFormatAttribute assetFormatAttribute)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", assetFormatAttribute.ID);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
return dataReader.Read();
}
}
}
}
private const string CheckInSql = @"
[AssetFormatAttribute].[ID] = @CheckInID";
protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
{
AssetFormatAttribute _AssetFormatAttribute = (AssetFormatAttribute)domainObject;
SqlCommand sqlCommand = Database.CreateCommand(ModifyQueryForCheckIn(sqlQuery,CheckInSql));
sqlCommand.Parameters.AddWithValue("@CheckInID", _AssetFormatAttribute.ID);
return sqlCommand;
}
protected override AssetFormatAttribute doLoad(IDataReader dataReader)
{
AssetFormatAttribute assetFormatAttribute = new AssetFormatAttribute();
assetFormatAttribute.ID = (int) dataReader.GetValue(0);
assetFormatAttribute.Name = (String) dataReader.GetValue(1);
assetFormatAttribute.Value = (String) dataReader.GetValue(2);
assetFormatAttribute.AssetFormatID = (int) dataReader.GetValue(3);
assetFormatAttribute.CreateBy = (int) dataReader.GetValue(4);
assetFormatAttribute.CreateDate = (DateTime) dataReader.GetValue(5);
assetFormatAttribute.ModifyBy = (int) dataReader.GetValue(6);
assetFormatAttribute.ModifyDate = (DateTime) dataReader.GetValue(7);
return registerRecord(assetFormatAttribute);
}
protected override AssetFormatAttribute doLoad(Hashtable hashtable)
{
AssetFormatAttribute assetFormatAttribute = new AssetFormatAttribute();
if(hashtable.ContainsKey("ID"))
assetFormatAttribute.ID = ( int)hashtable["ID"];
if(hashtable.ContainsKey("Name"))
assetFormatAttribute.Name = ( String)hashtable["Name"];
if(hashtable.ContainsKey("Value"))
assetFormatAttribute.Value = ( String)hashtable["Value"];
if(hashtable.ContainsKey("AssetFormatID"))
assetFormatAttribute.AssetFormatID = ( int)hashtable["AssetFormatID"];
if(hashtable.ContainsKey("CreateBy"))
assetFormatAttribute.CreateBy = ( int)hashtable["CreateBy"];
if(hashtable.ContainsKey("CreateDate"))
assetFormatAttribute.CreateDate = ( DateTime)hashtable["CreateDate"];
if(hashtable.ContainsKey("ModifyBy"))
assetFormatAttribute.ModifyBy = ( int)hashtable["ModifyBy"];
if(hashtable.ContainsKey("ModifyDate"))
assetFormatAttribute.ModifyDate = ( DateTime)hashtable["ModifyDate"];
return assetFormatAttribute;
}
protected override List<AssetFormatAttribute> fill(SqlCommand sqlCommand, int offset, int limit)
{
List<AssetFormatAttribute> resultList = new List<AssetFormatAttribute>();
using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
{
DataTable dataTable = new DataTable();
sqlDataAdapter.Fill(offset,limit,dataTable);
foreach(DataRow dataRow in dataTable.Rows)
{
AssetFormatAttribute item = new AssetFormatAttribute();
item.ID = ( int)dataRow["ID"] ;
item.Name = ( String)dataRow["Name"] ;
item.Value = ( String)dataRow["Value"] ;
item.AssetFormatID = ( int)dataRow["AssetFormatID"] ;
item.CreateBy = ( int)dataRow["CreateBy"] ;
item.CreateDate = ( DateTime)dataRow["CreateDate"] ;
item.ModifyBy = ( int)dataRow["ModifyBy"] ;
item.ModifyDate = ( DateTime)dataRow["ModifyDate"] ;
registerRecord(item);
resultList.Add(item);
}
}
return resultList;
}
#region Delete
private const String SqlDelete = @"Delete From [Asset].[AssetFormatAttribute]
Where
ID = @ID";
[Synchronized]
public AssetFormatAttribute remove(AssetFormatAttribute assetFormatAttribute)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
{
sqlCommand.Parameters.AddWithValue("@ID", assetFormatAttribute.ID);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(assetFormatAttribute,DataMapperOperation.delete);
return registerRecord(assetFormatAttribute);
}
#endregion
[Synchronized]
[TransactionRequired]
public AssetFormatAttribute save( AssetFormatAttribute assetFormatAttribute )
{
if(exists(assetFormatAttribute))
return update(assetFormatAttribute);
return create(assetFormatAttribute);
}
const String SqlUpdate = @"Update [Asset].[AssetFormatAttribute] Set
Name = @Name,Value = @Value,AssetFormatID = @AssetFormatID,CreateBy = @CreateBy,CreateDate = @CreateDate,ModifyBy = @ModifyBy,ModifyDate = @ModifyDate
Where
ID = @ID";
[Synchronized]
public AssetFormatAttribute update(AssetFormatAttribute assetFormatAttribute)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
{
sqlCommand.Parameters.AddWithValue("@ID", assetFormatAttribute.ID);
sqlCommand.Parameters.AddWithValue("@Name", assetFormatAttribute.Name);
sqlCommand.Parameters.AddWithValue("@Value", assetFormatAttribute.Value);
sqlCommand.Parameters.AddWithValue("@AssetFormatID", assetFormatAttribute.AssetFormatID);
sqlCommand.Parameters.AddWithValue("@CreateBy", assetFormatAttribute.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", assetFormatAttribute.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", assetFormatAttribute.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", assetFormatAttribute.ModifyDate);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(assetFormatAttribute,DataMapperOperation.update);
return registerRecord(assetFormatAttribute);
}
}
public partial class AssetStore: DomainObject
{
protected int _iD;
protected String _nameResourceCode;
protected String _location;
protected int _storeTypeID;
protected String _username;
protected String _password;
protected int _createBy;
protected DateTime _createDate;
protected int _modifyBy;
protected DateTime _modifyDate;
public AssetStore(){}
public AssetStore(
int
iD,String
nameResourceCode,String
location,int
storeTypeID,String
username,String
password,int
createBy,DateTime
createDate,int
modifyBy,DateTime
modifyDate
)
{
this.ID = iD;
this.NameResourceCode = nameResourceCode;
this.Location = location;
this.StoreTypeID = storeTypeID;
this.Username = username;
this.Password = password;
this.CreateBy = createBy;
this.CreateDate = createDate;
this.ModifyBy = modifyBy;
this.ModifyDate = modifyDate;
}
public override String getUri()
{
String uri = "AMF_dev.AssetStore."
+ ID.ToString()
;
return uri;
}
public int ID
{
get { return _iD;}
set
{
_iD = value;
}
}
public String NameResourceCode
{
get { return _nameResourceCode;}
set
{
_nameResourceCode = value;
}
}
public String Location
{
get { return _location;}
set
{
_location = value;
}
}
public int StoreTypeID
{
get { return _storeTypeID;}
set
{
_storeTypeID = value;
}
}
public String Username
{
get { return _username;}
set
{
_username = value;
}
}
public String Password
{
get { return _password;}
set
{
_password = value;
}
}
public int CreateBy
{
get { return _createBy;}
set
{
_createBy = value;
}
}
public DateTime CreateDate
{
get { return _createDate;}
set
{
_createDate = value;
}
}
public int ModifyBy
{
get { return _modifyBy;}
set
{
_modifyBy = value;
}
}
public DateTime ModifyDate
{
get { return _modifyDate;}
set
{
_modifyDate = value;
}
}
public override DomainObject extractSingleObject()
{
AssetStore assetStore = new AssetStore();
assetStore.ID = this.ID;
assetStore.NameResourceCode = this.NameResourceCode;
assetStore.Location = this.Location;
assetStore.StoreTypeID = this.StoreTypeID;
assetStore.Username = this.Username;
assetStore.Password = this.Password;
assetStore.CreateBy = this.CreateBy;
assetStore.CreateDate = this.CreateDate;
assetStore.ModifyBy = this.ModifyBy;
assetStore.ModifyDate = this.ModifyDate;
assetStore.ActiveRecordId = this.ActiveRecordId;
return assetStore;
}
// one to many relation
private List<Asset> _relatedAsset;
public List<Asset> relatedAsset
{
get { return _relatedAsset;}
set { _relatedAsset = value; }
}
// one to many relation
private List<AssetFormat> _relatedAssetFormat;
public List<AssetFormat> relatedAssetFormat
{
get { return _relatedAssetFormat;}
set { _relatedAssetFormat = value; }
}
}
public partial class AssetStoreDataMapper:TDataMapper<AssetStore,SqlConnection,AMF_devDb, Weborb.Data.Management.MSSql.CommandBuilder, SqlTransaction, SqlCommand>
{
public AssetStoreDataMapper(){}
public AssetStoreDataMapper(AMF_devDb database):
base(database){}
public override String TableName
{
get
{
return "[Asset].[AssetStore]";
}
}
public override Hashtable getRelation(string tableName)
{
throw new Exception("Not yet implemented");
}
private const String SqlCreate = @"Insert Into [Asset].[AssetStore] (
NameResourceCode,Location,StoreTypeID,Username,Password,CreateBy,CreateDate,ModifyBy,ModifyDate) Values (
@NameResourceCode,
@Location,
@StoreTypeID,
@Username,
@Password,
@CreateBy,
@CreateDate,
@ModifyBy,
@ModifyDate);
select scope_identity();
";
[TransactionRequired]
[Synchronized]
public override AssetStore create( AssetStore assetStore )
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
{
sqlCommand.Parameters.AddWithValue("@NameResourceCode", assetStore.NameResourceCode);
sqlCommand.Parameters.AddWithValue("@Location", assetStore.Location);
sqlCommand.Parameters.AddWithValue("@StoreTypeID", assetStore.StoreTypeID);
if(assetStore != null)
sqlCommand.Parameters.AddWithValue("@Username", assetStore.Username);
else
sqlCommand.Parameters.AddWithValue("@Username", DBNull.Value);
if(assetStore != null)
sqlCommand.Parameters.AddWithValue("@Password", assetStore.Password);
else
sqlCommand.Parameters.AddWithValue("@Password", DBNull.Value);
sqlCommand.Parameters.AddWithValue("@CreateBy", assetStore.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", assetStore.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", assetStore.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", assetStore.ModifyDate);
assetStore.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
}
}
if(assetStore.relatedAsset != null
&& assetStore.relatedAsset.Count > 0)
{
AssetDataMapper dataMapper = new AssetDataMapper(Database);
foreach(Asset item in assetStore.relatedAsset)
dataMapper.create(item);
}
if(assetStore.relatedAssetFormat != null
&& assetStore.relatedAssetFormat.Count > 0)
{
AssetFormatDataMapper dataMapper = new AssetFormatDataMapper(Database);
foreach(AssetFormat item in assetStore.relatedAssetFormat)
dataMapper.create(item);
}
raiseAffected(assetStore,DataMapperOperation.create);
return registerRecord(assetStore);
}
private const String SqlSelectByPk = @"Select
ID,NameResourceCode,Location,StoreTypeID,Username,Password,CreateBy,CreateDate,ModifyBy,ModifyDate
From [Asset].[AssetStore]
Where
ID = @ID
";
public AssetStore findByPrimaryKey(
int iD
)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", iD);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
if(dataReader.Read())
return doLoad(dataReader);
}
}
}
throw new DataNotFoundException("AssetStore not found, search by primary key");
}
public bool exists(AssetStore assetStore)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", assetStore.ID);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
return dataReader.Read();
}
}
}
}
private const string CheckInSql = @"
[AssetStore].[ID] = @CheckInID";
protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
{
AssetStore _AssetStore = (AssetStore)domainObject;
SqlCommand sqlCommand = Database.CreateCommand(ModifyQueryForCheckIn(sqlQuery,CheckInSql));
sqlCommand.Parameters.AddWithValue("@CheckInID", _AssetStore.ID);
return sqlCommand;
}
protected override AssetStore doLoad(IDataReader dataReader)
{
AssetStore assetStore = new AssetStore();
assetStore.ID = (int) dataReader.GetValue(0);
assetStore.NameResourceCode = (String) dataReader.GetValue(1);
assetStore.Location = (String) dataReader.GetValue(2);
assetStore.StoreTypeID = (int) dataReader.GetValue(3);
if(!dataReader.IsDBNull(4))
assetStore.Username = (String) dataReader.GetValue(4);
if(!dataReader.IsDBNull(5))
assetStore.Password = (String) dataReader.GetValue(5);
assetStore.CreateBy = (int) dataReader.GetValue(6);
assetStore.CreateDate = (DateTime) dataReader.GetValue(7);
assetStore.ModifyBy = (int) dataReader.GetValue(8);
assetStore.ModifyDate = (DateTime) dataReader.GetValue(9);
return registerRecord(assetStore);
}
protected override AssetStore doLoad(Hashtable hashtable)
{
AssetStore assetStore = new AssetStore();
if(hashtable.ContainsKey("ID"))
assetStore.ID = ( int)hashtable["ID"];
if(hashtable.ContainsKey("NameResourceCode"))
assetStore.NameResourceCode = ( String)hashtable["NameResourceCode"];
if(hashtable.ContainsKey("Location"))
assetStore.Location = ( String)hashtable["Location"];
if(hashtable.ContainsKey("StoreTypeID"))
assetStore.StoreTypeID = ( int)hashtable["StoreTypeID"];
if(hashtable.ContainsKey("Username"))
assetStore.Username = ( String)hashtable["Username"];
if(hashtable.ContainsKey("Password"))
assetStore.Password = ( String)hashtable["Password"];
if(hashtable.ContainsKey("CreateBy"))
assetStore.CreateBy = ( int)hashtable["CreateBy"];
if(hashtable.ContainsKey("CreateDate"))
assetStore.CreateDate = ( DateTime)hashtable["CreateDate"];
if(hashtable.ContainsKey("ModifyBy"))
assetStore.ModifyBy = ( int)hashtable["ModifyBy"];
if(hashtable.ContainsKey("ModifyDate"))
assetStore.ModifyDate = ( DateTime)hashtable["ModifyDate"];
return assetStore;
}
protected override List<AssetStore> fill(SqlCommand sqlCommand, int offset, int limit)
{
List<AssetStore> resultList = new List<AssetStore>();
using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
{
DataTable dataTable = new DataTable();
sqlDataAdapter.Fill(offset,limit,dataTable);
foreach(DataRow dataRow in dataTable.Rows)
{
AssetStore item = new AssetStore();
item.ID = ( int)dataRow["ID"] ;
item.NameResourceCode = ( String)dataRow["NameResourceCode"] ;
item.Location = ( String)dataRow["Location"] ;
item.StoreTypeID = ( int)dataRow["StoreTypeID"] ;
if(!dataRow.IsNull("Username"))
item.Username = ( String)dataRow["Username"] ;
if(!dataRow.IsNull("Password"))
item.Password = ( String)dataRow["Password"] ;
item.CreateBy = ( int)dataRow["CreateBy"] ;
item.CreateDate = ( DateTime)dataRow["CreateDate"] ;
item.ModifyBy = ( int)dataRow["ModifyBy"] ;
item.ModifyDate = ( DateTime)dataRow["ModifyDate"] ;
registerRecord(item);
resultList.Add(item);
}
}
return resultList;
}
#region Delete
private const String SqlDelete = @"Delete From [Asset].[AssetStore]
Where
ID = @ID";
[Synchronized]
public AssetStore remove(AssetStore assetStore)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
{
sqlCommand.Parameters.AddWithValue("@ID", assetStore.ID);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(assetStore,DataMapperOperation.delete);
return registerRecord(assetStore);
}
#endregion
[Synchronized]
[TransactionRequired]
public AssetStore save( AssetStore assetStore )
{
if(exists(assetStore))
return update(assetStore);
return create(assetStore);
}
const String SqlUpdate = @"Update [Asset].[AssetStore] Set
NameResourceCode = @NameResourceCode,Location = @Location,StoreTypeID = @StoreTypeID,Username = @Username,Password = @Password,CreateBy = @CreateBy,CreateDate = @CreateDate,ModifyBy = @ModifyBy,ModifyDate = @ModifyDate
Where
ID = @ID";
[TransactionRequired]
[Synchronized]
public AssetStore update(AssetStore assetStore)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
{
sqlCommand.Parameters.AddWithValue("@ID", assetStore.ID);
sqlCommand.Parameters.AddWithValue("@NameResourceCode", assetStore.NameResourceCode);
sqlCommand.Parameters.AddWithValue("@Location", assetStore.Location);
sqlCommand.Parameters.AddWithValue("@StoreTypeID", assetStore.StoreTypeID);
if(assetStore.Username != null)
sqlCommand.Parameters.AddWithValue("@Username", assetStore.Username);
else
sqlCommand.Parameters.AddWithValue("@Username", DBNull.Value);
if(assetStore.Password != null)
sqlCommand.Parameters.AddWithValue("@Password", assetStore.Password);
else
sqlCommand.Parameters.AddWithValue("@Password", DBNull.Value);
sqlCommand.Parameters.AddWithValue("@CreateBy", assetStore.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", assetStore.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", assetStore.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", assetStore.ModifyDate);
sqlCommand.ExecuteNonQuery();
}
}
if(assetStore.relatedAsset != null
&& assetStore.relatedAsset.Count > 0)
{
AssetDataMapper dataMapper = new AssetDataMapper(Database);
foreach(Asset item in assetStore.relatedAsset)
dataMapper.save(item);
}
if(assetStore.relatedAssetFormat != null
&& assetStore.relatedAssetFormat.Count > 0)
{
AssetFormatDataMapper dataMapper = new AssetFormatDataMapper(Database);
foreach(AssetFormat item in assetStore.relatedAssetFormat)
dataMapper.save(item);
}
raiseAffected(assetStore,DataMapperOperation.update);
return registerRecord(assetStore);
}
}
public partial class AssetTechnicalFormat: DomainObject
{
protected int _iD;
protected String _nameResourceCode;
protected int _createBy;
protected DateTime _createDate;
protected int _modifyBy;
protected DateTime _modifyDate;
// parent tables
protected Converter _relatedConverter;
public AssetTechnicalFormat(){}
public AssetTechnicalFormat(
int
iD,String
nameResourceCode,int
converterID,int
createBy,DateTime
createDate,int
modifyBy,DateTime
modifyDate
)
{
this.ID = iD;
this.NameResourceCode = nameResourceCode;
this.ConverterID = converterID;
this.CreateBy = createBy;
this.CreateDate = createDate;
this.ModifyBy = modifyBy;
this.ModifyDate = modifyDate;
}
public override String getUri()
{
String uri = "AMF_dev.AssetTechnicalFormat."
+ ID.ToString()
;
return uri;
}
public int ID
{
get { return _iD;}
set
{
_iD = value;
}
}
public String NameResourceCode
{
get { return _nameResourceCode;}
set
{
_nameResourceCode = value;
}
}
public int? ConverterID
{
get
{
if(_relatedConverter != null)
return _relatedConverter.ID;
return null;
}
set
{
if(!value.HasValue)
_relatedConverter = null;
else
{
if(_relatedConverter == null)
_relatedConverter = new Converter();
_relatedConverter.ID = value.Value;
}
}
}
public int CreateBy
{
get { return _createBy;}
set
{
_createBy = value;
}
}
public DateTime CreateDate
{
get { return _createDate;}
set
{
_createDate = value;
}
}
public int ModifyBy
{
get { return _modifyBy;}
set
{
_modifyBy = value;
}
}
public DateTime ModifyDate
{
get { return _modifyDate;}
set
{
_modifyDate = value;
}
}
public Converter RelatedConverter
{
get { return _relatedConverter;}
set { _relatedConverter = value; }
}
public override DomainObject extractSingleObject()
{
AssetTechnicalFormat assetTechnicalFormat = new AssetTechnicalFormat();
assetTechnicalFormat.ID = this.ID;
assetTechnicalFormat.NameResourceCode = this.NameResourceCode;
assetTechnicalFormat.ConverterID = this.ConverterID;
assetTechnicalFormat.CreateBy = this.CreateBy;
assetTechnicalFormat.CreateDate = this.CreateDate;
assetTechnicalFormat.ModifyBy = this.ModifyBy;
assetTechnicalFormat.ModifyDate = this.ModifyDate;
assetTechnicalFormat.ActiveRecordId = this.ActiveRecordId;
return assetTechnicalFormat;
}
// one to many relation
private List<Asset> _relatedAsset;
public List<Asset> relatedAsset
{
get { return _relatedAsset;}
set { _relatedAsset = value; }
}
// one to many relation
private List<AssetFormat> _relatedAssetFormat;
public List<AssetFormat> relatedAssetFormat
{
get { return _relatedAssetFormat;}
set { _relatedAssetFormat = value; }
}
// one to many relation
private List<AssetTypeAssetTechnicalFormat> _relatedAssetTypeAssetTechnicalFormat;
public List<AssetTypeAssetTechnicalFormat> relatedAssetTypeAssetTechnicalFormat
{
get { return _relatedAssetTypeAssetTechnicalFormat;}
set { _relatedAssetTypeAssetTechnicalFormat = value; }
}
}
public partial class AssetTechnicalFormatDataMapper:TDataMapper<AssetTechnicalFormat,SqlConnection,AMF_devDb, Weborb.Data.Management.MSSql.CommandBuilder, SqlTransaction, SqlCommand>
{
public AssetTechnicalFormatDataMapper(){}
public AssetTechnicalFormatDataMapper(AMF_devDb database):
base(database){}
public override String TableName
{
get
{
return "[Asset].[AssetTechnicalFormat]";
}
}
public override Hashtable getRelation(string tableName)
{
throw new Exception("Not yet implemented");
}
private const String SqlCreate = @"Insert Into [Asset].[AssetTechnicalFormat] (
NameResourceCode,ConverterID,CreateBy,CreateDate,ModifyBy,ModifyDate) Values (
@NameResourceCode,
@ConverterID,
@CreateBy,
@CreateDate,
@ModifyBy,
@ModifyDate);
select scope_identity();
";
[TransactionRequired]
[Synchronized]
public override AssetTechnicalFormat create( AssetTechnicalFormat assetTechnicalFormat )
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
{
sqlCommand.Parameters.AddWithValue("@NameResourceCode", assetTechnicalFormat.NameResourceCode);
if(assetTechnicalFormat.ConverterID.HasValue)
sqlCommand.Parameters.AddWithValue("@ConverterID", assetTechnicalFormat.ConverterID);
else
sqlCommand.Parameters.AddWithValue("@ConverterID", DBNull.Value);
sqlCommand.Parameters.AddWithValue("@CreateBy", assetTechnicalFormat.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", assetTechnicalFormat.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", assetTechnicalFormat.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", assetTechnicalFormat.ModifyDate);
assetTechnicalFormat.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
}
}
if(assetTechnicalFormat.relatedAsset != null
&& assetTechnicalFormat.relatedAsset.Count > 0)
{
AssetDataMapper dataMapper = new AssetDataMapper(Database);
foreach(Asset item in assetTechnicalFormat.relatedAsset)
dataMapper.create(item);
}
if(assetTechnicalFormat.relatedAssetFormat != null
&& assetTechnicalFormat.relatedAssetFormat.Count > 0)
{
AssetFormatDataMapper dataMapper = new AssetFormatDataMapper(Database);
foreach(AssetFormat item in assetTechnicalFormat.relatedAssetFormat)
dataMapper.create(item);
}
if(assetTechnicalFormat.relatedAssetTypeAssetTechnicalFormat != null
&& assetTechnicalFormat.relatedAssetTypeAssetTechnicalFormat.Count > 0)
{
AssetTypeAssetTechnicalFormatDataMapper dataMapper = new AssetTypeAssetTechnicalFormatDataMapper(Database);
foreach(AssetTypeAssetTechnicalFormat item in assetTechnicalFormat.relatedAssetTypeAssetTechnicalFormat)
dataMapper.create(item);
}
raiseAffected(assetTechnicalFormat,DataMapperOperation.create);
return registerRecord(assetTechnicalFormat);
}
private const String SqlSelectByPk = @"Select
ID,NameResourceCode,ConverterID,CreateBy,CreateDate,ModifyBy,ModifyDate
From [Asset].[AssetTechnicalFormat]
Where
ID = @ID
";
public AssetTechnicalFormat findByPrimaryKey(
int iD
)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", iD);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
if(dataReader.Read())
return doLoad(dataReader);
}
}
}
throw new DataNotFoundException("AssetTechnicalFormat not found, search by primary key");
}
public bool exists(AssetTechnicalFormat assetTechnicalFormat)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", assetTechnicalFormat.ID);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
return dataReader.Read();
}
}
}
}
private const string CheckInSql = @"
[AssetTechnicalFormat].[ID] = @CheckInID";
protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
{
AssetTechnicalFormat _AssetTechnicalFormat = (AssetTechnicalFormat)domainObject;
SqlCommand sqlCommand = Database.CreateCommand(ModifyQueryForCheckIn(sqlQuery,CheckInSql));
sqlCommand.Parameters.AddWithValue("@CheckInID", _AssetTechnicalFormat.ID);
return sqlCommand;
}
protected override AssetTechnicalFormat doLoad(IDataReader dataReader)
{
AssetTechnicalFormat assetTechnicalFormat = new AssetTechnicalFormat();
assetTechnicalFormat.ID = (int) dataReader.GetValue(0);
assetTechnicalFormat.NameResourceCode = (String) dataReader.GetValue(1);
if(!dataReader.IsDBNull(2))
assetTechnicalFormat.ConverterID = (int) dataReader.GetValue(2);
assetTechnicalFormat.CreateBy = (int) dataReader.GetValue(3);
assetTechnicalFormat.CreateDate = (DateTime) dataReader.GetValue(4);
assetTechnicalFormat.ModifyBy = (int) dataReader.GetValue(5);
assetTechnicalFormat.ModifyDate = (DateTime) dataReader.GetValue(6);
return registerRecord(assetTechnicalFormat);
}
protected override AssetTechnicalFormat doLoad(Hashtable hashtable)
{
AssetTechnicalFormat assetTechnicalFormat = new AssetTechnicalFormat();
if(hashtable.ContainsKey("ID"))
assetTechnicalFormat.ID = ( int)hashtable["ID"];
if(hashtable.ContainsKey("NameResourceCode"))
assetTechnicalFormat.NameResourceCode = ( String)hashtable["NameResourceCode"];
if(hashtable.ContainsKey("ConverterID"))
assetTechnicalFormat.ConverterID = ( int)hashtable["ConverterID"];
if(hashtable.ContainsKey("CreateBy"))
assetTechnicalFormat.CreateBy = ( int)hashtable["CreateBy"];
if(hashtable.ContainsKey("CreateDate"))
assetTechnicalFormat.CreateDate = ( DateTime)hashtable["CreateDate"];
if(hashtable.ContainsKey("ModifyBy"))
assetTechnicalFormat.ModifyBy = ( int)hashtable["ModifyBy"];
if(hashtable.ContainsKey("ModifyDate"))
assetTechnicalFormat.ModifyDate = ( DateTime)hashtable["ModifyDate"];
return assetTechnicalFormat;
}
protected override List<AssetTechnicalFormat> fill(SqlCommand sqlCommand, int offset, int limit)
{
List<AssetTechnicalFormat> resultList = new List<AssetTechnicalFormat>();
using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
{
DataTable dataTable = new DataTable();
sqlDataAdapter.Fill(offset,limit,dataTable);
foreach(DataRow dataRow in dataTable.Rows)
{
AssetTechnicalFormat item = new AssetTechnicalFormat();
item.ID = ( int)dataRow["ID"] ;
item.NameResourceCode = ( String)dataRow["NameResourceCode"] ;
if(!dataRow.IsNull("ConverterID"))
item.ConverterID = ( int)dataRow["ConverterID"] ;
item.CreateBy = ( int)dataRow["CreateBy"] ;
item.CreateDate = ( DateTime)dataRow["CreateDate"] ;
item.ModifyBy = ( int)dataRow["ModifyBy"] ;
item.ModifyDate = ( DateTime)dataRow["ModifyDate"] ;
registerRecord(item);
resultList.Add(item);
}
}
return resultList;
}
#region Delete
private const String SqlDelete = @"Delete From [Asset].[AssetTechnicalFormat]
Where
ID = @ID";
[Synchronized]
public AssetTechnicalFormat remove(AssetTechnicalFormat assetTechnicalFormat)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
{
sqlCommand.Parameters.AddWithValue("@ID", assetTechnicalFormat.ID);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(assetTechnicalFormat,DataMapperOperation.delete);
return registerRecord(assetTechnicalFormat);
}
#endregion
[Synchronized]
[TransactionRequired]
public AssetTechnicalFormat save( AssetTechnicalFormat assetTechnicalFormat )
{
if(exists(assetTechnicalFormat))
return update(assetTechnicalFormat);
return create(assetTechnicalFormat);
}
const String SqlUpdate = @"Update [Asset].[AssetTechnicalFormat] Set
NameResourceCode = @NameResourceCode,ConverterID = @ConverterID,CreateBy = @CreateBy,CreateDate = @CreateDate,ModifyBy = @ModifyBy,ModifyDate = @ModifyDate
Where
ID = @ID";
[TransactionRequired]
[Synchronized]
public AssetTechnicalFormat update(AssetTechnicalFormat assetTechnicalFormat)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
{
sqlCommand.Parameters.AddWithValue("@ID", assetTechnicalFormat.ID);
sqlCommand.Parameters.AddWithValue("@NameResourceCode", assetTechnicalFormat.NameResourceCode);
if(assetTechnicalFormat.ConverterID.HasValue)
sqlCommand.Parameters.AddWithValue("@ConverterID", assetTechnicalFormat.ConverterID);
else
sqlCommand.Parameters.AddWithValue("@ConverterID", DBNull.Value);
sqlCommand.Parameters.AddWithValue("@CreateBy", assetTechnicalFormat.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", assetTechnicalFormat.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", assetTechnicalFormat.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", assetTechnicalFormat.ModifyDate);
sqlCommand.ExecuteNonQuery();
}
}
if(assetTechnicalFormat.relatedAsset != null
&& assetTechnicalFormat.relatedAsset.Count > 0)
{
AssetDataMapper dataMapper = new AssetDataMapper(Database);
foreach(Asset item in assetTechnicalFormat.relatedAsset)
dataMapper.save(item);
}
if(assetTechnicalFormat.relatedAssetFormat != null
&& assetTechnicalFormat.relatedAssetFormat.Count > 0)
{
AssetFormatDataMapper dataMapper = new AssetFormatDataMapper(Database);
foreach(AssetFormat item in assetTechnicalFormat.relatedAssetFormat)
dataMapper.save(item);
}
if(assetTechnicalFormat.relatedAssetTypeAssetTechnicalFormat != null
&& assetTechnicalFormat.relatedAssetTypeAssetTechnicalFormat.Count > 0)
{
AssetTypeAssetTechnicalFormatDataMapper dataMapper = new AssetTypeAssetTechnicalFormatDataMapper(Database);
foreach(AssetTypeAssetTechnicalFormat item in assetTechnicalFormat.relatedAssetTypeAssetTechnicalFormat)
dataMapper.save(item);
}
raiseAffected(assetTechnicalFormat,DataMapperOperation.update);
return registerRecord(assetTechnicalFormat);
}
}
public partial class AssetType: DomainObject
{
protected int _iD;
protected String _name;
protected String _nameResourceCode;
protected int _createBy;
protected DateTime _createDate;
protected int _modifyBy;
protected DateTime _modifyDate;
public AssetType(){}
public AssetType(
int
iD,String
name,String
nameResourceCode,int
createBy,DateTime
createDate,int
modifyBy,DateTime
modifyDate
)
{
this.ID = iD;
this.Name = name;
this.NameResourceCode = nameResourceCode;
this.CreateBy = createBy;
this.CreateDate = createDate;
this.ModifyBy = modifyBy;
this.ModifyDate = modifyDate;
}
public override String getUri()
{
String uri = "AMF_dev.AssetType."
+ ID.ToString()
;
return uri;
}
public int ID
{
get { return _iD;}
set
{
_iD = value;
}
}
public String Name
{
get { return _name;}
set
{
_name = value;
}
}
public String NameResourceCode
{
get { return _nameResourceCode;}
set
{
_nameResourceCode = value;
}
}
public int CreateBy
{
get { return _createBy;}
set
{
_createBy = value;
}
}
public DateTime CreateDate
{
get { return _createDate;}
set
{
_createDate = value;
}
}
public int ModifyBy
{
get { return _modifyBy;}
set
{
_modifyBy = value;
}
}
public DateTime ModifyDate
{
get { return _modifyDate;}
set
{
_modifyDate = value;
}
}
public override DomainObject extractSingleObject()
{
AssetType assetType = new AssetType();
assetType.ID = this.ID;
assetType.Name = this.Name;
assetType.NameResourceCode = this.NameResourceCode;
assetType.CreateBy = this.CreateBy;
assetType.CreateDate = this.CreateDate;
assetType.ModifyBy = this.ModifyBy;
assetType.ModifyDate = this.ModifyDate;
assetType.ActiveRecordId = this.ActiveRecordId;
return assetType;
}
// one to many relation
private List<Asset> _relatedAsset;
public List<Asset> relatedAsset
{
get { return _relatedAsset;}
set { _relatedAsset = value; }
}
// one to many relation
private List<AssetFormat> _relatedAssetFormat;
public List<AssetFormat> relatedAssetFormat
{
get { return _relatedAssetFormat;}
set { _relatedAssetFormat = value; }
}
// one to many relation
private List<AssetTypeAssetTechnicalFormat> _relatedAssetTypeAssetTechnicalFormat;
public List<AssetTypeAssetTechnicalFormat> relatedAssetTypeAssetTechnicalFormat
{
get { return _relatedAssetTypeAssetTechnicalFormat;}
set { _relatedAssetTypeAssetTechnicalFormat = value; }
}
// one to many relation
private List<AssetTypeMetadataElementDefinition> _relatedAssetTypeMetadataElementDefinition;
public List<AssetTypeMetadataElementDefinition> relatedAssetTypeMetadataElementDefinition
{
get { return _relatedAssetTypeMetadataElementDefinition;}
set { _relatedAssetTypeMetadataElementDefinition = value; }
}
}
public partial class AssetTypeDataMapper:TDataMapper<AssetType,SqlConnection,AMF_devDb, Weborb.Data.Management.MSSql.CommandBuilder, SqlTransaction, SqlCommand>
{
public AssetTypeDataMapper(){}
public AssetTypeDataMapper(AMF_devDb database):
base(database){}
public override String TableName
{
get
{
return "[Asset].[AssetType]";
}
}
public override Hashtable getRelation(string tableName)
{
throw new Exception("Not yet implemented");
}
private const String SqlCreate = @"Insert Into [Asset].[AssetType] (
Name,NameResourceCode,CreateBy,CreateDate,ModifyBy,ModifyDate) Values (
@Name,
@NameResourceCode,
@CreateBy,
@CreateDate,
@ModifyBy,
@ModifyDate);
select scope_identity();
";
[TransactionRequired]
[Synchronized]
public override AssetType create( AssetType assetType )
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
{
sqlCommand.Parameters.AddWithValue("@Name", assetType.Name);
sqlCommand.Parameters.AddWithValue("@NameResourceCode", assetType.NameResourceCode);
sqlCommand.Parameters.AddWithValue("@CreateBy", assetType.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", assetType.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", assetType.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", assetType.ModifyDate);
assetType.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
}
}
if(assetType.relatedAsset != null
&& assetType.relatedAsset.Count > 0)
{
AssetDataMapper dataMapper = new AssetDataMapper(Database);
foreach(Asset item in assetType.relatedAsset)
dataMapper.create(item);
}
if(assetType.relatedAssetFormat != null
&& assetType.relatedAssetFormat.Count > 0)
{
AssetFormatDataMapper dataMapper = new AssetFormatDataMapper(Database);
foreach(AssetFormat item in assetType.relatedAssetFormat)
dataMapper.create(item);
}
if(assetType.relatedAssetTypeAssetTechnicalFormat != null
&& assetType.relatedAssetTypeAssetTechnicalFormat.Count > 0)
{
AssetTypeAssetTechnicalFormatDataMapper dataMapper = new AssetTypeAssetTechnicalFormatDataMapper(Database);
foreach(AssetTypeAssetTechnicalFormat item in assetType.relatedAssetTypeAssetTechnicalFormat)
dataMapper.create(item);
}
if(assetType.relatedAssetTypeMetadataElementDefinition != null
&& assetType.relatedAssetTypeMetadataElementDefinition.Count > 0)
{
AssetTypeMetadataElementDefinitionDataMapper dataMapper = new AssetTypeMetadataElementDefinitionDataMapper(Database);
foreach(AssetTypeMetadataElementDefinition item in assetType.relatedAssetTypeMetadataElementDefinition)
dataMapper.create(item);
}
raiseAffected(assetType,DataMapperOperation.create);
return registerRecord(assetType);
}
private const String SqlSelectByPk = @"Select
ID,Name,NameResourceCode,CreateBy,CreateDate,ModifyBy,ModifyDate
From [Asset].[AssetType]
Where
ID = @ID
";
public AssetType findByPrimaryKey(
int iD
)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", iD);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
if(dataReader.Read())
return doLoad(dataReader);
}
}
}
throw new DataNotFoundException("AssetType not found, search by primary key");
}
public bool exists(AssetType assetType)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", assetType.ID);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
return dataReader.Read();
}
}
}
}
private const string CheckInSql = @"
[AssetType].[ID] = @CheckInID";
protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
{
AssetType _AssetType = (AssetType)domainObject;
SqlCommand sqlCommand = Database.CreateCommand(ModifyQueryForCheckIn(sqlQuery,CheckInSql));
sqlCommand.Parameters.AddWithValue("@CheckInID", _AssetType.ID);
return sqlCommand;
}
protected override AssetType doLoad(IDataReader dataReader)
{
AssetType assetType = new AssetType();
assetType.ID = (int) dataReader.GetValue(0);
assetType.Name = (String) dataReader.GetValue(1);
assetType.NameResourceCode = (String) dataReader.GetValue(2);
assetType.CreateBy = (int) dataReader.GetValue(3);
assetType.CreateDate = (DateTime) dataReader.GetValue(4);
assetType.ModifyBy = (int) dataReader.GetValue(5);
assetType.ModifyDate = (DateTime) dataReader.GetValue(6);
return registerRecord(assetType);
}
protected override AssetType doLoad(Hashtable hashtable)
{
AssetType assetType = new AssetType();
if(hashtable.ContainsKey("ID"))
assetType.ID = ( int)hashtable["ID"];
if(hashtable.ContainsKey("Name"))
assetType.Name = ( String)hashtable["Name"];
if(hashtable.ContainsKey("NameResourceCode"))
assetType.NameResourceCode = ( String)hashtable["NameResourceCode"];
if(hashtable.ContainsKey("CreateBy"))
assetType.CreateBy = ( int)hashtable["CreateBy"];
if(hashtable.ContainsKey("CreateDate"))
assetType.CreateDate = ( DateTime)hashtable["CreateDate"];
if(hashtable.ContainsKey("ModifyBy"))
assetType.ModifyBy = ( int)hashtable["ModifyBy"];
if(hashtable.ContainsKey("ModifyDate"))
assetType.ModifyDate = ( DateTime)hashtable["ModifyDate"];
return assetType;
}
protected override List<AssetType> fill(SqlCommand sqlCommand, int offset, int limit)
{
List<AssetType> resultList = new List<AssetType>();
using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
{
DataTable dataTable = new DataTable();
sqlDataAdapter.Fill(offset,limit,dataTable);
foreach(DataRow dataRow in dataTable.Rows)
{
AssetType item = new AssetType();
item.ID = ( int)dataRow["ID"] ;
item.Name = ( String)dataRow["Name"] ;
item.NameResourceCode = ( String)dataRow["NameResourceCode"] ;
item.CreateBy = ( int)dataRow["CreateBy"] ;
item.CreateDate = ( DateTime)dataRow["CreateDate"] ;
item.ModifyBy = ( int)dataRow["ModifyBy"] ;
item.ModifyDate = ( DateTime)dataRow["ModifyDate"] ;
registerRecord(item);
resultList.Add(item);
}
}
return resultList;
}
#region Delete
private const String SqlDelete = @"Delete From [Asset].[AssetType]
Where
ID = @ID";
[Synchronized]
public AssetType remove(AssetType assetType)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
{
sqlCommand.Parameters.AddWithValue("@ID", assetType.ID);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(assetType,DataMapperOperation.delete);
return registerRecord(assetType);
}
#endregion
[Synchronized]
[TransactionRequired]
public AssetType save( AssetType assetType )
{
if(exists(assetType))
return update(assetType);
return create(assetType);
}
const String SqlUpdate = @"Update [Asset].[AssetType] Set
Name = @Name,NameResourceCode = @NameResourceCode,CreateBy = @CreateBy,CreateDate = @CreateDate,ModifyBy = @ModifyBy,ModifyDate = @ModifyDate
Where
ID = @ID";
[TransactionRequired]
[Synchronized]
public AssetType update(AssetType assetType)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
{
sqlCommand.Parameters.AddWithValue("@ID", assetType.ID);
sqlCommand.Parameters.AddWithValue("@Name", assetType.Name);
sqlCommand.Parameters.AddWithValue("@NameResourceCode", assetType.NameResourceCode);
sqlCommand.Parameters.AddWithValue("@CreateBy", assetType.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", assetType.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", assetType.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", assetType.ModifyDate);
sqlCommand.ExecuteNonQuery();
}
}
if(assetType.relatedAsset != null
&& assetType.relatedAsset.Count > 0)
{
AssetDataMapper dataMapper = new AssetDataMapper(Database);
foreach(Asset item in assetType.relatedAsset)
dataMapper.save(item);
}
if(assetType.relatedAssetFormat != null
&& assetType.relatedAssetFormat.Count > 0)
{
AssetFormatDataMapper dataMapper = new AssetFormatDataMapper(Database);
foreach(AssetFormat item in assetType.relatedAssetFormat)
dataMapper.save(item);
}
if(assetType.relatedAssetTypeAssetTechnicalFormat != null
&& assetType.relatedAssetTypeAssetTechnicalFormat.Count > 0)
{
AssetTypeAssetTechnicalFormatDataMapper dataMapper = new AssetTypeAssetTechnicalFormatDataMapper(Database);
foreach(AssetTypeAssetTechnicalFormat item in assetType.relatedAssetTypeAssetTechnicalFormat)
dataMapper.save(item);
}
if(assetType.relatedAssetTypeMetadataElementDefinition != null
&& assetType.relatedAssetTypeMetadataElementDefinition.Count > 0)
{
AssetTypeMetadataElementDefinitionDataMapper dataMapper = new AssetTypeMetadataElementDefinitionDataMapper(Database);
foreach(AssetTypeMetadataElementDefinition item in assetType.relatedAssetTypeMetadataElementDefinition)
dataMapper.save(item);
}
raiseAffected(assetType,DataMapperOperation.update);
return registerRecord(assetType);
}
}
public partial class AssetTypeAssetTechnicalFormat: DomainObject
{
protected int _iD;
protected int _createBy;
protected DateTime _createDate;
protected int _modifyBy;
protected DateTime _modifyDate;
// parent tables
protected AssetTechnicalFormat _relatedAssetTechnicalFormat
= new AssetTechnicalFormat()
;
// parent tables
protected AssetType _relatedAssetType
= new AssetType()
;
public AssetTypeAssetTechnicalFormat(){}
public AssetTypeAssetTechnicalFormat(
int
iD,int
assetTypeID,int
assetTechnicalFormatID,int
createBy,DateTime
createDate,int
modifyBy,DateTime
modifyDate
)
{
this.ID = iD;
this.AssetTypeID = assetTypeID;
this.AssetTechnicalFormatID = assetTechnicalFormatID;
this.CreateBy = createBy;
this.CreateDate = createDate;
this.ModifyBy = modifyBy;
this.ModifyDate = modifyDate;
}
public override String getUri()
{
String uri = "AMF_dev.AssetTypeAssetTechnicalFormat."
+ ID.ToString()
;
return uri;
}
public int ID
{
get { return _iD;}
set
{
_iD = value;
}
}
public int AssetTypeID
{
get
{
if(_relatedAssetType != null)
return _relatedAssetType.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedAssetType == null)
_relatedAssetType = new AssetType();
_relatedAssetType.ID = value;
}
}
public int AssetTechnicalFormatID
{
get
{
if(_relatedAssetTechnicalFormat != null)
return _relatedAssetTechnicalFormat.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedAssetTechnicalFormat == null)
_relatedAssetTechnicalFormat = new AssetTechnicalFormat();
_relatedAssetTechnicalFormat.ID = value;
}
}
public int CreateBy
{
get { return _createBy;}
set
{
_createBy = value;
}
}
public DateTime CreateDate
{
get { return _createDate;}
set
{
_createDate = value;
}
}
public int ModifyBy
{
get { return _modifyBy;}
set
{
_modifyBy = value;
}
}
public DateTime ModifyDate
{
get { return _modifyDate;}
set
{
_modifyDate = value;
}
}
public AssetTechnicalFormat RelatedAssetTechnicalFormat
{
get { return _relatedAssetTechnicalFormat;}
set { _relatedAssetTechnicalFormat = value; }
}
public AssetType RelatedAssetType
{
get { return _relatedAssetType;}
set { _relatedAssetType = value; }
}
public override DomainObject extractSingleObject()
{
AssetTypeAssetTechnicalFormat assetTypeAssetTechnicalFormat = new AssetTypeAssetTechnicalFormat();
assetTypeAssetTechnicalFormat.ID = this.ID;
assetTypeAssetTechnicalFormat.AssetTypeID = this.AssetTypeID;
assetTypeAssetTechnicalFormat.AssetTechnicalFormatID = this.AssetTechnicalFormatID;
assetTypeAssetTechnicalFormat.CreateBy = this.CreateBy;
assetTypeAssetTechnicalFormat.CreateDate = this.CreateDate;
assetTypeAssetTechnicalFormat.ModifyBy = this.ModifyBy;
assetTypeAssetTechnicalFormat.ModifyDate = this.ModifyDate;
assetTypeAssetTechnicalFormat.ActiveRecordId = this.ActiveRecordId;
return assetTypeAssetTechnicalFormat;
}
}
public partial class AssetTypeAssetTechnicalFormatDataMapper:TDataMapper<AssetTypeAssetTechnicalFormat,SqlConnection,AMF_devDb, Weborb.Data.Management.MSSql.CommandBuilder, SqlTransaction, SqlCommand>
{
public AssetTypeAssetTechnicalFormatDataMapper(){}
public AssetTypeAssetTechnicalFormatDataMapper(AMF_devDb database):
base(database){}
public override String TableName
{
get
{
return "[Asset].[AssetTypeAssetTechnicalFormat]";
}
}
public override Hashtable getRelation(string tableName)
{
throw new Exception("Not yet implemented");
}
private const String SqlCreate = @"Insert Into [Asset].[AssetTypeAssetTechnicalFormat] (
AssetTypeID,AssetTechnicalFormatID,CreateBy,CreateDate,ModifyBy,ModifyDate) Values (
@AssetTypeID,
@AssetTechnicalFormatID,
@CreateBy,
@CreateDate,
@ModifyBy,
@ModifyDate);
select scope_identity();
";
[Synchronized]
public override AssetTypeAssetTechnicalFormat create( AssetTypeAssetTechnicalFormat assetTypeAssetTechnicalFormat )
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
{
sqlCommand.Parameters.AddWithValue("@AssetTypeID", assetTypeAssetTechnicalFormat.AssetTypeID);
sqlCommand.Parameters.AddWithValue("@AssetTechnicalFormatID", assetTypeAssetTechnicalFormat.AssetTechnicalFormatID);
sqlCommand.Parameters.AddWithValue("@CreateBy", assetTypeAssetTechnicalFormat.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", assetTypeAssetTechnicalFormat.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", assetTypeAssetTechnicalFormat.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", assetTypeAssetTechnicalFormat.ModifyDate);
assetTypeAssetTechnicalFormat.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
}
}
raiseAffected(assetTypeAssetTechnicalFormat,DataMapperOperation.create);
return registerRecord(assetTypeAssetTechnicalFormat);
}
private const String SqlSelectByPk = @"Select
ID,AssetTypeID,AssetTechnicalFormatID,CreateBy,CreateDate,ModifyBy,ModifyDate
From [Asset].[AssetTypeAssetTechnicalFormat]
Where
ID = @ID
";
public AssetTypeAssetTechnicalFormat findByPrimaryKey(
int iD
)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", iD);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
if(dataReader.Read())
return doLoad(dataReader);
}
}
}
throw new DataNotFoundException("AssetTypeAssetTechnicalFormat not found, search by primary key");
}
public bool exists(AssetTypeAssetTechnicalFormat assetTypeAssetTechnicalFormat)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", assetTypeAssetTechnicalFormat.ID);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
return dataReader.Read();
}
}
}
}
private const string CheckInSql = @"
[AssetTypeAssetTechnicalFormat].[ID] = @CheckInID";
protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
{
AssetTypeAssetTechnicalFormat _AssetTypeAssetTechnicalFormat = (AssetTypeAssetTechnicalFormat)domainObject;
SqlCommand sqlCommand = Database.CreateCommand(ModifyQueryForCheckIn(sqlQuery,CheckInSql));
sqlCommand.Parameters.AddWithValue("@CheckInID", _AssetTypeAssetTechnicalFormat.ID);
return sqlCommand;
}
protected override AssetTypeAssetTechnicalFormat doLoad(IDataReader dataReader)
{
AssetTypeAssetTechnicalFormat assetTypeAssetTechnicalFormat = new AssetTypeAssetTechnicalFormat();
assetTypeAssetTechnicalFormat.ID = (int) dataReader.GetValue(0);
assetTypeAssetTechnicalFormat.AssetTypeID = (int) dataReader.GetValue(1);
assetTypeAssetTechnicalFormat.AssetTechnicalFormatID = (int) dataReader.GetValue(2);
assetTypeAssetTechnicalFormat.CreateBy = (int) dataReader.GetValue(3);
assetTypeAssetTechnicalFormat.CreateDate = (DateTime) dataReader.GetValue(4);
assetTypeAssetTechnicalFormat.ModifyBy = (int) dataReader.GetValue(5);
assetTypeAssetTechnicalFormat.ModifyDate = (DateTime) dataReader.GetValue(6);
return registerRecord(assetTypeAssetTechnicalFormat);
}
protected override AssetTypeAssetTechnicalFormat doLoad(Hashtable hashtable)
{
AssetTypeAssetTechnicalFormat assetTypeAssetTechnicalFormat = new AssetTypeAssetTechnicalFormat();
if(hashtable.ContainsKey("ID"))
assetTypeAssetTechnicalFormat.ID = ( int)hashtable["ID"];
if(hashtable.ContainsKey("AssetTypeID"))
assetTypeAssetTechnicalFormat.AssetTypeID = ( int)hashtable["AssetTypeID"];
if(hashtable.ContainsKey("AssetTechnicalFormatID"))
assetTypeAssetTechnicalFormat.AssetTechnicalFormatID = ( int)hashtable["AssetTechnicalFormatID"];
if(hashtable.ContainsKey("CreateBy"))
assetTypeAssetTechnicalFormat.CreateBy = ( int)hashtable["CreateBy"];
if(hashtable.ContainsKey("CreateDate"))
assetTypeAssetTechnicalFormat.CreateDate = ( DateTime)hashtable["CreateDate"];
if(hashtable.ContainsKey("ModifyBy"))
assetTypeAssetTechnicalFormat.ModifyBy = ( int)hashtable["ModifyBy"];
if(hashtable.ContainsKey("ModifyDate"))
assetTypeAssetTechnicalFormat.ModifyDate = ( DateTime)hashtable["ModifyDate"];
return assetTypeAssetTechnicalFormat;
}
protected override List<AssetTypeAssetTechnicalFormat> fill(SqlCommand sqlCommand, int offset, int limit)
{
List<AssetTypeAssetTechnicalFormat> resultList = new List<AssetTypeAssetTechnicalFormat>();
using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
{
DataTable dataTable = new DataTable();
sqlDataAdapter.Fill(offset,limit,dataTable);
foreach(DataRow dataRow in dataTable.Rows)
{
AssetTypeAssetTechnicalFormat item = new AssetTypeAssetTechnicalFormat();
item.ID = ( int)dataRow["ID"] ;
item.AssetTypeID = ( int)dataRow["AssetTypeID"] ;
item.AssetTechnicalFormatID = ( int)dataRow["AssetTechnicalFormatID"] ;
item.CreateBy = ( int)dataRow["CreateBy"] ;
item.CreateDate = ( DateTime)dataRow["CreateDate"] ;
item.ModifyBy = ( int)dataRow["ModifyBy"] ;
item.ModifyDate = ( DateTime)dataRow["ModifyDate"] ;
registerRecord(item);
resultList.Add(item);
}
}
return resultList;
}
#region Delete
private const String SqlDelete = @"Delete From [Asset].[AssetTypeAssetTechnicalFormat]
Where
ID = @ID";
[Synchronized]
public AssetTypeAssetTechnicalFormat remove(AssetTypeAssetTechnicalFormat assetTypeAssetTechnicalFormat)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
{
sqlCommand.Parameters.AddWithValue("@ID", assetTypeAssetTechnicalFormat.ID);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(assetTypeAssetTechnicalFormat,DataMapperOperation.delete);
return registerRecord(assetTypeAssetTechnicalFormat);
}
#endregion
[Synchronized]
[TransactionRequired]
public AssetTypeAssetTechnicalFormat save( AssetTypeAssetTechnicalFormat assetTypeAssetTechnicalFormat )
{
if(exists(assetTypeAssetTechnicalFormat))
return update(assetTypeAssetTechnicalFormat);
return create(assetTypeAssetTechnicalFormat);
}
const String SqlUpdate = @"Update [Asset].[AssetTypeAssetTechnicalFormat] Set
AssetTypeID = @AssetTypeID,AssetTechnicalFormatID = @AssetTechnicalFormatID,CreateBy = @CreateBy,CreateDate = @CreateDate,ModifyBy = @ModifyBy,ModifyDate = @ModifyDate
Where
ID = @ID";
[Synchronized]
public AssetTypeAssetTechnicalFormat update(AssetTypeAssetTechnicalFormat assetTypeAssetTechnicalFormat)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
{
sqlCommand.Parameters.AddWithValue("@ID", assetTypeAssetTechnicalFormat.ID);
sqlCommand.Parameters.AddWithValue("@AssetTypeID", assetTypeAssetTechnicalFormat.AssetTypeID);
sqlCommand.Parameters.AddWithValue("@AssetTechnicalFormatID", assetTypeAssetTechnicalFormat.AssetTechnicalFormatID);
sqlCommand.Parameters.AddWithValue("@CreateBy", assetTypeAssetTechnicalFormat.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", assetTypeAssetTechnicalFormat.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", assetTypeAssetTechnicalFormat.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", assetTypeAssetTechnicalFormat.ModifyDate);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(assetTypeAssetTechnicalFormat,DataMapperOperation.update);
return registerRecord(assetTypeAssetTechnicalFormat);
}
}
public partial class AssetTypeMetadataElementDefinition: DomainObject
{
protected int _createBy;
protected DateTime _createDate;
protected int _modifyBy;
protected DateTime _modifyDate;
// parent tables
protected AssetType _relatedAssetType
= new AssetType()
;
// parent tables
protected MetadataElementDefinition _relatedMetadataElementDefinition
= new MetadataElementDefinition()
;
public AssetTypeMetadataElementDefinition(){}
public AssetTypeMetadataElementDefinition(
int
assetTypeID,int
metadataElementID,int
createBy,DateTime
createDate,int
modifyBy,DateTime
modifyDate
)
{
this.AssetTypeID = assetTypeID;
this.MetadataElementID = metadataElementID;
this.CreateBy = createBy;
this.CreateDate = createDate;
this.ModifyBy = modifyBy;
this.ModifyDate = modifyDate;
}
public override String getUri()
{
String uri = "AMF_dev.AssetTypeMetadataElementDefinition."
+ AssetTypeID.ToString()
+ MetadataElementID.ToString()
;
return uri;
}
public int AssetTypeID
{
get
{
if(_relatedAssetType != null)
return _relatedAssetType.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedAssetType == null)
_relatedAssetType = new AssetType();
_relatedAssetType.ID = value;
}
}
public int MetadataElementID
{
get
{
if(_relatedMetadataElementDefinition != null)
return _relatedMetadataElementDefinition.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedMetadataElementDefinition == null)
_relatedMetadataElementDefinition = new MetadataElementDefinition();
_relatedMetadataElementDefinition.ID = value;
}
}
public int CreateBy
{
get { return _createBy;}
set
{
_createBy = value;
}
}
public DateTime CreateDate
{
get { return _createDate;}
set
{
_createDate = value;
}
}
public int ModifyBy
{
get { return _modifyBy;}
set
{
_modifyBy = value;
}
}
public DateTime ModifyDate
{
get { return _modifyDate;}
set
{
_modifyDate = value;
}
}
public AssetType RelatedAssetType
{
get { return _relatedAssetType;}
set { _relatedAssetType = value; }
}
public MetadataElementDefinition RelatedMetadataElementDefinition
{
get { return _relatedMetadataElementDefinition;}
set { _relatedMetadataElementDefinition = value; }
}
public override DomainObject extractSingleObject()
{
AssetTypeMetadataElementDefinition assetTypeMetadataElementDefinition = new AssetTypeMetadataElementDefinition();
assetTypeMetadataElementDefinition.AssetTypeID = this.AssetTypeID;
assetTypeMetadataElementDefinition.MetadataElementID = this.MetadataElementID;
assetTypeMetadataElementDefinition.CreateBy = this.CreateBy;
assetTypeMetadataElementDefinition.CreateDate = this.CreateDate;
assetTypeMetadataElementDefinition.ModifyBy = this.ModifyBy;
assetTypeMetadataElementDefinition.ModifyDate = this.ModifyDate;
assetTypeMetadataElementDefinition.ActiveRecordId = this.ActiveRecordId;
return assetTypeMetadataElementDefinition;
}
}
public partial class AssetTypeMetadataElementDefinitionDataMapper:TDataMapper<AssetTypeMetadataElementDefinition,SqlConnection,AMF_devDb, Weborb.Data.Management.MSSql.CommandBuilder, SqlTransaction, SqlCommand>
{
public AssetTypeMetadataElementDefinitionDataMapper(){}
public AssetTypeMetadataElementDefinitionDataMapper(AMF_devDb database):
base(database){}
public override String TableName
{
get
{
return "[Asset].[AssetTypeMetadataElementDefinition]";
}
}
public override Hashtable getRelation(string tableName)
{
throw new Exception("Not yet implemented");
}
private const String SqlCreate = @"Insert Into [Asset].[AssetTypeMetadataElementDefinition] (
AssetTypeID,MetadataElementID,CreateBy,CreateDate,ModifyBy,ModifyDate) Values (
@AssetTypeID,
@MetadataElementID,
@CreateBy,
@CreateDate,
@ModifyBy,
@ModifyDate);
";
[Synchronized]
public override AssetTypeMetadataElementDefinition create( AssetTypeMetadataElementDefinition assetTypeMetadataElementDefinition )
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
{
sqlCommand.Parameters.AddWithValue("@AssetTypeID", assetTypeMetadataElementDefinition.AssetTypeID);
sqlCommand.Parameters.AddWithValue("@MetadataElementID", assetTypeMetadataElementDefinition.MetadataElementID);
sqlCommand.Parameters.AddWithValue("@CreateBy", assetTypeMetadataElementDefinition.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", assetTypeMetadataElementDefinition.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", assetTypeMetadataElementDefinition.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", assetTypeMetadataElementDefinition.ModifyDate);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(assetTypeMetadataElementDefinition,DataMapperOperation.create);
return registerRecord(assetTypeMetadataElementDefinition);
}
private const String SqlSelectByPk = @"Select
AssetTypeID,MetadataElementID,CreateBy,CreateDate,ModifyBy,ModifyDate
From [Asset].[AssetTypeMetadataElementDefinition]
Where
AssetTypeID = @AssetTypeID and MetadataElementID = @MetadataElementID
";
public AssetTypeMetadataElementDefinition findByPrimaryKey(
int assetTypeID,int metadataElementID
)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@AssetTypeID", assetTypeID);
sqlCommand.Parameters.AddWithValue("@MetadataElementID", metadataElementID);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
if(dataReader.Read())
return doLoad(dataReader);
}
}
}
throw new DataNotFoundException("AssetTypeMetadataElementDefinition not found, search by primary key");
}
public bool exists(AssetTypeMetadataElementDefinition assetTypeMetadataElementDefinition)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@AssetTypeID", assetTypeMetadataElementDefinition.AssetTypeID);
sqlCommand.Parameters.AddWithValue("@MetadataElementID", assetTypeMetadataElementDefinition.MetadataElementID);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
return dataReader.Read();
}
}
}
}
private const string CheckInSql = @"
[AssetTypeMetadataElementDefinition].[AssetTypeID] = @CheckInAssetTypeID and
[AssetTypeMetadataElementDefinition].[MetadataElementID] = @CheckInMetadataElementID";
protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
{
AssetTypeMetadataElementDefinition _AssetTypeMetadataElementDefinition = (AssetTypeMetadataElementDefinition)domainObject;
SqlCommand sqlCommand = Database.CreateCommand(ModifyQueryForCheckIn(sqlQuery,CheckInSql));
sqlCommand.Parameters.AddWithValue("@CheckInAssetTypeID", _AssetTypeMetadataElementDefinition.AssetTypeID);
sqlCommand.Parameters.AddWithValue("@CheckInMetadataElementID", _AssetTypeMetadataElementDefinition.MetadataElementID);
return sqlCommand;
}
protected override AssetTypeMetadataElementDefinition doLoad(IDataReader dataReader)
{
AssetTypeMetadataElementDefinition assetTypeMetadataElementDefinition = new AssetTypeMetadataElementDefinition();
assetTypeMetadataElementDefinition.AssetTypeID = (int) dataReader.GetValue(0);
assetTypeMetadataElementDefinition.MetadataElementID = (int) dataReader.GetValue(1);
assetTypeMetadataElementDefinition.CreateBy = (int) dataReader.GetValue(2);
assetTypeMetadataElementDefinition.CreateDate = (DateTime) dataReader.GetValue(3);
assetTypeMetadataElementDefinition.ModifyBy = (int) dataReader.GetValue(4);
assetTypeMetadataElementDefinition.ModifyDate = (DateTime) dataReader.GetValue(5);
return registerRecord(assetTypeMetadataElementDefinition);
}
protected override AssetTypeMetadataElementDefinition doLoad(Hashtable hashtable)
{
AssetTypeMetadataElementDefinition assetTypeMetadataElementDefinition = new AssetTypeMetadataElementDefinition();
if(hashtable.ContainsKey("AssetTypeID"))
assetTypeMetadataElementDefinition.AssetTypeID = ( int)hashtable["AssetTypeID"];
if(hashtable.ContainsKey("MetadataElementID"))
assetTypeMetadataElementDefinition.MetadataElementID = ( int)hashtable["MetadataElementID"];
if(hashtable.ContainsKey("CreateBy"))
assetTypeMetadataElementDefinition.CreateBy = ( int)hashtable["CreateBy"];
if(hashtable.ContainsKey("CreateDate"))
assetTypeMetadataElementDefinition.CreateDate = ( DateTime)hashtable["CreateDate"];
if(hashtable.ContainsKey("ModifyBy"))
assetTypeMetadataElementDefinition.ModifyBy = ( int)hashtable["ModifyBy"];
if(hashtable.ContainsKey("ModifyDate"))
assetTypeMetadataElementDefinition.ModifyDate = ( DateTime)hashtable["ModifyDate"];
return assetTypeMetadataElementDefinition;
}
protected override List<AssetTypeMetadataElementDefinition> fill(SqlCommand sqlCommand, int offset, int limit)
{
List<AssetTypeMetadataElementDefinition> resultList = new List<AssetTypeMetadataElementDefinition>();
using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
{
DataTable dataTable = new DataTable();
sqlDataAdapter.Fill(offset,limit,dataTable);
foreach(DataRow dataRow in dataTable.Rows)
{
AssetTypeMetadataElementDefinition item = new AssetTypeMetadataElementDefinition();
item.AssetTypeID = ( int)dataRow["AssetTypeID"] ;
item.MetadataElementID = ( int)dataRow["MetadataElementID"] ;
item.CreateBy = ( int)dataRow["CreateBy"] ;
item.CreateDate = ( DateTime)dataRow["CreateDate"] ;
item.ModifyBy = ( int)dataRow["ModifyBy"] ;
item.ModifyDate = ( DateTime)dataRow["ModifyDate"] ;
registerRecord(item);
resultList.Add(item);
}
}
return resultList;
}
#region Delete
private const String SqlDelete = @"Delete From [Asset].[AssetTypeMetadataElementDefinition]
Where
AssetTypeID = @AssetTypeID and MetadataElementID = @MetadataElementID";
[Synchronized]
public AssetTypeMetadataElementDefinition remove(AssetTypeMetadataElementDefinition assetTypeMetadataElementDefinition)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
{
sqlCommand.Parameters.AddWithValue("@AssetTypeID", assetTypeMetadataElementDefinition.AssetTypeID);
sqlCommand.Parameters.AddWithValue("@MetadataElementID", assetTypeMetadataElementDefinition.MetadataElementID);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(assetTypeMetadataElementDefinition,DataMapperOperation.delete);
return registerRecord(assetTypeMetadataElementDefinition);
}
#endregion
[Synchronized]
[TransactionRequired]
public AssetTypeMetadataElementDefinition save( AssetTypeMetadataElementDefinition assetTypeMetadataElementDefinition )
{
if(exists(assetTypeMetadataElementDefinition))
return update(assetTypeMetadataElementDefinition);
return create(assetTypeMetadataElementDefinition);
}
const String SqlUpdate = @"Update [Asset].[AssetTypeMetadataElementDefinition] Set
CreateBy = @CreateBy,CreateDate = @CreateDate,ModifyBy = @ModifyBy,ModifyDate = @ModifyDate
Where
AssetTypeID = @AssetTypeID and MetadataElementID = @MetadataElementID";
[Synchronized]
public AssetTypeMetadataElementDefinition update(AssetTypeMetadataElementDefinition assetTypeMetadataElementDefinition)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
{
sqlCommand.Parameters.AddWithValue("@AssetTypeID", assetTypeMetadataElementDefinition.AssetTypeID);
sqlCommand.Parameters.AddWithValue("@MetadataElementID", assetTypeMetadataElementDefinition.MetadataElementID);
sqlCommand.Parameters.AddWithValue("@CreateBy", assetTypeMetadataElementDefinition.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", assetTypeMetadataElementDefinition.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", assetTypeMetadataElementDefinition.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", assetTypeMetadataElementDefinition.ModifyDate);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(assetTypeMetadataElementDefinition,DataMapperOperation.update);
return registerRecord(assetTypeMetadataElementDefinition);
}
}
public partial class Converter: DomainObject
{
protected int _iD;
protected String _nameResourceCode;
protected String _className;
protected int _createBy;
protected DateTime _createDate;
protected int _modifyBy;
protected DateTime _modifyDate;
public Converter(){}
public Converter(
int
iD,String
nameResourceCode,String
className,int
createBy,DateTime
createDate,int
modifyBy,DateTime
modifyDate
)
{
this.ID = iD;
this.NameResourceCode = nameResourceCode;
this.ClassName = className;
this.CreateBy = createBy;
this.CreateDate = createDate;
this.ModifyBy = modifyBy;
this.ModifyDate = modifyDate;
}
public override String getUri()
{
String uri = "AMF_dev.Converter."
+ ID.ToString()
;
return uri;
}
public int ID
{
get { return _iD;}
set
{
_iD = value;
}
}
public String NameResourceCode
{
get { return _nameResourceCode;}
set
{
_nameResourceCode = value;
}
}
public String ClassName
{
get { return _className;}
set
{
_className = value;
}
}
public int CreateBy
{
get { return _createBy;}
set
{
_createBy = value;
}
}
public DateTime CreateDate
{
get { return _createDate;}
set
{
_createDate = value;
}
}
public int ModifyBy
{
get { return _modifyBy;}
set
{
_modifyBy = value;
}
}
public DateTime ModifyDate
{
get { return _modifyDate;}
set
{
_modifyDate = value;
}
}
public override DomainObject extractSingleObject()
{
Converter converter = new Converter();
converter.ID = this.ID;
converter.NameResourceCode = this.NameResourceCode;
converter.ClassName = this.ClassName;
converter.CreateBy = this.CreateBy;
converter.CreateDate = this.CreateDate;
converter.ModifyBy = this.ModifyBy;
converter.ModifyDate = this.ModifyDate;
converter.ActiveRecordId = this.ActiveRecordId;
return converter;
}
// one to many relation
private List<AssetTechnicalFormat> _relatedAssetTechnicalFormat;
public List<AssetTechnicalFormat> relatedAssetTechnicalFormat
{
get { return _relatedAssetTechnicalFormat;}
set { _relatedAssetTechnicalFormat = value; }
}
// one to many relation
private List<ConverterAttribute> _relatedConverterAttribute;
public List<ConverterAttribute> relatedConverterAttribute
{
get { return _relatedConverterAttribute;}
set { _relatedConverterAttribute = value; }
}
}
public partial class ConverterDataMapper:TDataMapper<Converter,SqlConnection,AMF_devDb, Weborb.Data.Management.MSSql.CommandBuilder, SqlTransaction, SqlCommand>
{
public ConverterDataMapper(){}
public ConverterDataMapper(AMF_devDb database):
base(database){}
public override String TableName
{
get
{
return "[Asset].[Converter]";
}
}
public override Hashtable getRelation(string tableName)
{
throw new Exception("Not yet implemented");
}
private const String SqlCreate = @"Insert Into [Asset].[Converter] (
NameResourceCode,ClassName,CreateBy,CreateDate,ModifyBy,ModifyDate) Values (
@NameResourceCode,
@ClassName,
@CreateBy,
@CreateDate,
@ModifyBy,
@ModifyDate);
select scope_identity();
";
[TransactionRequired]
[Synchronized]
public override Converter create( Converter converter )
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
{
sqlCommand.Parameters.AddWithValue("@NameResourceCode", converter.NameResourceCode);
if(converter != null)
sqlCommand.Parameters.AddWithValue("@ClassName", converter.ClassName);
else
sqlCommand.Parameters.AddWithValue("@ClassName", DBNull.Value);
sqlCommand.Parameters.AddWithValue("@CreateBy", converter.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", converter.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", converter.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", converter.ModifyDate);
converter.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
}
}
if(converter.relatedAssetTechnicalFormat != null
&& converter.relatedAssetTechnicalFormat.Count > 0)
{
AssetTechnicalFormatDataMapper dataMapper = new AssetTechnicalFormatDataMapper(Database);
foreach(AssetTechnicalFormat item in converter.relatedAssetTechnicalFormat)
dataMapper.create(item);
}
if(converter.relatedConverterAttribute != null
&& converter.relatedConverterAttribute.Count > 0)
{
ConverterAttributeDataMapper dataMapper = new ConverterAttributeDataMapper(Database);
foreach(ConverterAttribute item in converter.relatedConverterAttribute)
dataMapper.create(item);
}
raiseAffected(converter,DataMapperOperation.create);
return registerRecord(converter);
}
private const String SqlSelectByPk = @"Select
ID,NameResourceCode,ClassName,CreateBy,CreateDate,ModifyBy,ModifyDate
From [Asset].[Converter]
Where
ID = @ID
";
public Converter findByPrimaryKey(
int iD
)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", iD);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
if(dataReader.Read())
return doLoad(dataReader);
}
}
}
throw new DataNotFoundException("Converter not found, search by primary key");
}
public bool exists(Converter converter)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", converter.ID);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
return dataReader.Read();
}
}
}
}
private const string CheckInSql = @"
[Converter].[ID] = @CheckInID";
protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
{
Converter _Converter = (Converter)domainObject;
SqlCommand sqlCommand = Database.CreateCommand(ModifyQueryForCheckIn(sqlQuery,CheckInSql));
sqlCommand.Parameters.AddWithValue("@CheckInID", _Converter.ID);
return sqlCommand;
}
protected override Converter doLoad(IDataReader dataReader)
{
Converter converter = new Converter();
converter.ID = (int) dataReader.GetValue(0);
converter.NameResourceCode = (String) dataReader.GetValue(1);
if(!dataReader.IsDBNull(2))
converter.ClassName = (String) dataReader.GetValue(2);
converter.CreateBy = (int) dataReader.GetValue(3);
converter.CreateDate = (DateTime) dataReader.GetValue(4);
converter.ModifyBy = (int) dataReader.GetValue(5);
converter.ModifyDate = (DateTime) dataReader.GetValue(6);
return registerRecord(converter);
}
protected override Converter doLoad(Hashtable hashtable)
{
Converter converter = new Converter();
if(hashtable.ContainsKey("ID"))
converter.ID = ( int)hashtable["ID"];
if(hashtable.ContainsKey("NameResourceCode"))
converter.NameResourceCode = ( String)hashtable["NameResourceCode"];
if(hashtable.ContainsKey("ClassName"))
converter.ClassName = ( String)hashtable["ClassName"];
if(hashtable.ContainsKey("CreateBy"))
converter.CreateBy = ( int)hashtable["CreateBy"];
if(hashtable.ContainsKey("CreateDate"))
converter.CreateDate = ( DateTime)hashtable["CreateDate"];
if(hashtable.ContainsKey("ModifyBy"))
converter.ModifyBy = ( int)hashtable["ModifyBy"];
if(hashtable.ContainsKey("ModifyDate"))
converter.ModifyDate = ( DateTime)hashtable["ModifyDate"];
return converter;
}
protected override List<Converter> fill(SqlCommand sqlCommand, int offset, int limit)
{
List<Converter> resultList = new List<Converter>();
using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
{
DataTable dataTable = new DataTable();
sqlDataAdapter.Fill(offset,limit,dataTable);
foreach(DataRow dataRow in dataTable.Rows)
{
Converter item = new Converter();
item.ID = ( int)dataRow["ID"] ;
item.NameResourceCode = ( String)dataRow["NameResourceCode"] ;
if(!dataRow.IsNull("ClassName"))
item.ClassName = ( String)dataRow["ClassName"] ;
item.CreateBy = ( int)dataRow["CreateBy"] ;
item.CreateDate = ( DateTime)dataRow["CreateDate"] ;
item.ModifyBy = ( int)dataRow["ModifyBy"] ;
item.ModifyDate = ( DateTime)dataRow["ModifyDate"] ;
registerRecord(item);
resultList.Add(item);
}
}
return resultList;
}
#region Delete
private const String SqlDelete = @"Delete From [Asset].[Converter]
Where
ID = @ID";
[Synchronized]
public Converter remove(Converter converter)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
{
sqlCommand.Parameters.AddWithValue("@ID", converter.ID);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(converter,DataMapperOperation.delete);
return registerRecord(converter);
}
#endregion
[Synchronized]
[TransactionRequired]
public Converter save( Converter converter )
{
if(exists(converter))
return update(converter);
return create(converter);
}
const String SqlUpdate = @"Update [Asset].[Converter] Set
NameResourceCode = @NameResourceCode,ClassName = @ClassName,CreateBy = @CreateBy,CreateDate = @CreateDate,ModifyBy = @ModifyBy,ModifyDate = @ModifyDate
Where
ID = @ID";
[TransactionRequired]
[Synchronized]
public Converter update(Converter converter)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
{
sqlCommand.Parameters.AddWithValue("@ID", converter.ID);
sqlCommand.Parameters.AddWithValue("@NameResourceCode", converter.NameResourceCode);
if(converter.ClassName != null)
sqlCommand.Parameters.AddWithValue("@ClassName", converter.ClassName);
else
sqlCommand.Parameters.AddWithValue("@ClassName", DBNull.Value);
sqlCommand.Parameters.AddWithValue("@CreateBy", converter.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", converter.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", converter.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", converter.ModifyDate);
sqlCommand.ExecuteNonQuery();
}
}
if(converter.relatedAssetTechnicalFormat != null
&& converter.relatedAssetTechnicalFormat.Count > 0)
{
AssetTechnicalFormatDataMapper dataMapper = new AssetTechnicalFormatDataMapper(Database);
foreach(AssetTechnicalFormat item in converter.relatedAssetTechnicalFormat)
dataMapper.save(item);
}
if(converter.relatedConverterAttribute != null
&& converter.relatedConverterAttribute.Count > 0)
{
ConverterAttributeDataMapper dataMapper = new ConverterAttributeDataMapper(Database);
foreach(ConverterAttribute item in converter.relatedConverterAttribute)
dataMapper.save(item);
}
raiseAffected(converter,DataMapperOperation.update);
return registerRecord(converter);
}
}
public partial class ConverterAttribute: DomainObject
{
protected int _iD;
protected String _name;
protected int _typeID;
protected int _createBy;
protected DateTime _createDate;
protected int _modifyBy;
protected DateTime _modifyDate;
// parent tables
protected Converter _relatedConverter
= new Converter()
;
public ConverterAttribute(){}
public ConverterAttribute(
int
iD,int
converterID,String
name,int
typeID,int
createBy,DateTime
createDate,int
modifyBy,DateTime
modifyDate
)
{
this.ID = iD;
this.ConverterID = converterID;
this.Name = name;
this.TypeID = typeID;
this.CreateBy = createBy;
this.CreateDate = createDate;
this.ModifyBy = modifyBy;
this.ModifyDate = modifyDate;
}
public override String getUri()
{
String uri = "AMF_dev.ConverterAttribute."
+ ID.ToString()
;
return uri;
}
public int ID
{
get { return _iD;}
set
{
_iD = value;
}
}
public int ConverterID
{
get
{
if(_relatedConverter != null)
return _relatedConverter.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedConverter == null)
_relatedConverter = new Converter();
_relatedConverter.ID = value;
}
}
public String Name
{
get { return _name;}
set
{
_name = value;
}
}
public int TypeID
{
get { return _typeID;}
set
{
_typeID = value;
}
}
public int CreateBy
{
get { return _createBy;}
set
{
_createBy = value;
}
}
public DateTime CreateDate
{
get { return _createDate;}
set
{
_createDate = value;
}
}
public int ModifyBy
{
get { return _modifyBy;}
set
{
_modifyBy = value;
}
}
public DateTime ModifyDate
{
get { return _modifyDate;}
set
{
_modifyDate = value;
}
}
public Converter RelatedConverter
{
get { return _relatedConverter;}
set { _relatedConverter = value; }
}
public override DomainObject extractSingleObject()
{
ConverterAttribute converterAttribute = new ConverterAttribute();
converterAttribute.ID = this.ID;
converterAttribute.ConverterID = this.ConverterID;
converterAttribute.Name = this.Name;
converterAttribute.TypeID = this.TypeID;
converterAttribute.CreateBy = this.CreateBy;
converterAttribute.CreateDate = this.CreateDate;
converterAttribute.ModifyBy = this.ModifyBy;
converterAttribute.ModifyDate = this.ModifyDate;
converterAttribute.ActiveRecordId = this.ActiveRecordId;
return converterAttribute;
}
}
public partial class ConverterAttributeDataMapper:TDataMapper<ConverterAttribute,SqlConnection,AMF_devDb, Weborb.Data.Management.MSSql.CommandBuilder, SqlTransaction, SqlCommand>
{
public ConverterAttributeDataMapper(){}
public ConverterAttributeDataMapper(AMF_devDb database):
base(database){}
public override String TableName
{
get
{
return "[Asset].[ConverterAttribute]";
}
}
public override Hashtable getRelation(string tableName)
{
throw new Exception("Not yet implemented");
}
private const String SqlCreate = @"Insert Into [Asset].[ConverterAttribute] (
ConverterID,Name,TypeID,CreateBy,CreateDate,ModifyBy,ModifyDate) Values (
@ConverterID,
@Name,
@TypeID,
@CreateBy,
@CreateDate,
@ModifyBy,
@ModifyDate);
select scope_identity();
";
[Synchronized]
public override ConverterAttribute create( ConverterAttribute converterAttribute )
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
{
sqlCommand.Parameters.AddWithValue("@ConverterID", converterAttribute.ConverterID);
sqlCommand.Parameters.AddWithValue("@Name", converterAttribute.Name);
sqlCommand.Parameters.AddWithValue("@TypeID", converterAttribute.TypeID);
sqlCommand.Parameters.AddWithValue("@CreateBy", converterAttribute.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", converterAttribute.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", converterAttribute.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", converterAttribute.ModifyDate);
converterAttribute.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
}
}
raiseAffected(converterAttribute,DataMapperOperation.create);
return registerRecord(converterAttribute);
}
private const String SqlSelectByPk = @"Select
ID,ConverterID,Name,TypeID,CreateBy,CreateDate,ModifyBy,ModifyDate
From [Asset].[ConverterAttribute]
Where
ID = @ID
";
public ConverterAttribute findByPrimaryKey(
int iD
)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", iD);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
if(dataReader.Read())
return doLoad(dataReader);
}
}
}
throw new DataNotFoundException("ConverterAttribute not found, search by primary key");
}
public bool exists(ConverterAttribute converterAttribute)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", converterAttribute.ID);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
return dataReader.Read();
}
}
}
}
private const string CheckInSql = @"
[ConverterAttribute].[ID] = @CheckInID";
protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
{
ConverterAttribute _ConverterAttribute = (ConverterAttribute)domainObject;
SqlCommand sqlCommand = Database.CreateCommand(ModifyQueryForCheckIn(sqlQuery,CheckInSql));
sqlCommand.Parameters.AddWithValue("@CheckInID", _ConverterAttribute.ID);
return sqlCommand;
}
protected override ConverterAttribute doLoad(IDataReader dataReader)
{
ConverterAttribute converterAttribute = new ConverterAttribute();
converterAttribute.ID = (int) dataReader.GetValue(0);
converterAttribute.ConverterID = (int) dataReader.GetValue(1);
converterAttribute.Name = (String) dataReader.GetValue(2);
converterAttribute.TypeID = (int) dataReader.GetValue(3);
converterAttribute.CreateBy = (int) dataReader.GetValue(4);
converterAttribute.CreateDate = (DateTime) dataReader.GetValue(5);
converterAttribute.ModifyBy = (int) dataReader.GetValue(6);
converterAttribute.ModifyDate = (DateTime) dataReader.GetValue(7);
return registerRecord(converterAttribute);
}
protected override ConverterAttribute doLoad(Hashtable hashtable)
{
ConverterAttribute converterAttribute = new ConverterAttribute();
if(hashtable.ContainsKey("ID"))
converterAttribute.ID = ( int)hashtable["ID"];
if(hashtable.ContainsKey("ConverterID"))
converterAttribute.ConverterID = ( int)hashtable["ConverterID"];
if(hashtable.ContainsKey("Name"))
converterAttribute.Name = ( String)hashtable["Name"];
if(hashtable.ContainsKey("TypeID"))
converterAttribute.TypeID = ( int)hashtable["TypeID"];
if(hashtable.ContainsKey("CreateBy"))
converterAttribute.CreateBy = ( int)hashtable["CreateBy"];
if(hashtable.ContainsKey("CreateDate"))
converterAttribute.CreateDate = ( DateTime)hashtable["CreateDate"];
if(hashtable.ContainsKey("ModifyBy"))
converterAttribute.ModifyBy = ( int)hashtable["ModifyBy"];
if(hashtable.ContainsKey("ModifyDate"))
converterAttribute.ModifyDate = ( DateTime)hashtable["ModifyDate"];
return converterAttribute;
}
protected override List<ConverterAttribute> fill(SqlCommand sqlCommand, int offset, int limit)
{
List<ConverterAttribute> resultList = new List<ConverterAttribute>();
using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
{
DataTable dataTable = new DataTable();
sqlDataAdapter.Fill(offset,limit,dataTable);
foreach(DataRow dataRow in dataTable.Rows)
{
ConverterAttribute item = new ConverterAttribute();
item.ID = ( int)dataRow["ID"] ;
item.ConverterID = ( int)dataRow["ConverterID"] ;
item.Name = ( String)dataRow["Name"] ;
item.TypeID = ( int)dataRow["TypeID"] ;
item.CreateBy = ( int)dataRow["CreateBy"] ;
item.CreateDate = ( DateTime)dataRow["CreateDate"] ;
item.ModifyBy = ( int)dataRow["ModifyBy"] ;
item.ModifyDate = ( DateTime)dataRow["ModifyDate"] ;
registerRecord(item);
resultList.Add(item);
}
}
return resultList;
}
#region Delete
private const String SqlDelete = @"Delete From [Asset].[ConverterAttribute]
Where
ID = @ID";
[Synchronized]
public ConverterAttribute remove(ConverterAttribute converterAttribute)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
{
sqlCommand.Parameters.AddWithValue("@ID", converterAttribute.ID);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(converterAttribute,DataMapperOperation.delete);
return registerRecord(converterAttribute);
}
#endregion
[Synchronized]
[TransactionRequired]
public ConverterAttribute save( ConverterAttribute converterAttribute )
{
if(exists(converterAttribute))
return update(converterAttribute);
return create(converterAttribute);
}
const String SqlUpdate = @"Update [Asset].[ConverterAttribute] Set
ConverterID = @ConverterID,Name = @Name,TypeID = @TypeID,CreateBy = @CreateBy,CreateDate = @CreateDate,ModifyBy = @ModifyBy,ModifyDate = @ModifyDate
Where
ID = @ID";
[Synchronized]
public ConverterAttribute update(ConverterAttribute converterAttribute)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
{
sqlCommand.Parameters.AddWithValue("@ID", converterAttribute.ID);
sqlCommand.Parameters.AddWithValue("@ConverterID", converterAttribute.ConverterID);
sqlCommand.Parameters.AddWithValue("@Name", converterAttribute.Name);
sqlCommand.Parameters.AddWithValue("@TypeID", converterAttribute.TypeID);
sqlCommand.Parameters.AddWithValue("@CreateBy", converterAttribute.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", converterAttribute.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", converterAttribute.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", converterAttribute.ModifyDate);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(converterAttribute,DataMapperOperation.update);
return registerRecord(converterAttribute);
}
}
public partial class MetadataElementDefinition: DomainObject
{
protected int _iD;
protected String _nameResourceCode;
protected int _typeID;
protected bool _isMultiSelect;
protected int _createBy;
protected DateTime _createDate;
protected int _modifyBy;
protected DateTime _modifyDate;
// parent tables
protected MetadataElementDefinitionGroup _relatedMetadataElementDefinitionGroup
= new MetadataElementDefinitionGroup()
;
public MetadataElementDefinition(){}
public MetadataElementDefinition(
int
iD,String
nameResourceCode,int
typeID,bool
isMultiSelect,int
metadataElementDefinitionGroupID,int
createBy,DateTime
createDate,int
modifyBy,DateTime
modifyDate
)
{
this.ID = iD;
this.NameResourceCode = nameResourceCode;
this.TypeID = typeID;
this.IsMultiSelect = isMultiSelect;
this.MetadataElementDefinitionGroupID = metadataElementDefinitionGroupID;
this.CreateBy = createBy;
this.CreateDate = createDate;
this.ModifyBy = modifyBy;
this.ModifyDate = modifyDate;
}
public override String getUri()
{
String uri = "AMF_dev.MetadataElementDefinition."
+ ID.ToString()
;
return uri;
}
public int ID
{
get { return _iD;}
set
{
_iD = value;
}
}
public String NameResourceCode
{
get { return _nameResourceCode;}
set
{
_nameResourceCode = value;
}
}
public int TypeID
{
get { return _typeID;}
set
{
_typeID = value;
}
}
public bool IsMultiSelect
{
get { return _isMultiSelect;}
set
{
_isMultiSelect = value;
}
}
public int MetadataElementDefinitionGroupID
{
get
{
if(_relatedMetadataElementDefinitionGroup != null)
return _relatedMetadataElementDefinitionGroup.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedMetadataElementDefinitionGroup == null)
_relatedMetadataElementDefinitionGroup = new MetadataElementDefinitionGroup();
_relatedMetadataElementDefinitionGroup.ID = value;
}
}
public int CreateBy
{
get { return _createBy;}
set
{
_createBy = value;
}
}
public DateTime CreateDate
{
get { return _createDate;}
set
{
_createDate = value;
}
}
public int ModifyBy
{
get { return _modifyBy;}
set
{
_modifyBy = value;
}
}
public DateTime ModifyDate
{
get { return _modifyDate;}
set
{
_modifyDate = value;
}
}
public MetadataElementDefinitionGroup RelatedMetadataElementDefinitionGroup
{
get { return _relatedMetadataElementDefinitionGroup;}
set { _relatedMetadataElementDefinitionGroup = value; }
}
public override DomainObject extractSingleObject()
{
MetadataElementDefinition metadataElementDefinition = new MetadataElementDefinition();
metadataElementDefinition.ID = this.ID;
metadataElementDefinition.NameResourceCode = this.NameResourceCode;
metadataElementDefinition.TypeID = this.TypeID;
metadataElementDefinition.IsMultiSelect = this.IsMultiSelect;
metadataElementDefinition.MetadataElementDefinitionGroupID = this.MetadataElementDefinitionGroupID;
metadataElementDefinition.CreateBy = this.CreateBy;
metadataElementDefinition.CreateDate = this.CreateDate;
metadataElementDefinition.ModifyBy = this.ModifyBy;
metadataElementDefinition.ModifyDate = this.ModifyDate;
metadataElementDefinition.ActiveRecordId = this.ActiveRecordId;
return metadataElementDefinition;
}
// one to many relation
private List<AssetTypeMetadataElementDefinition> _relatedAssetTypeMetadataElementDefinition;
public List<AssetTypeMetadataElementDefinition> relatedAssetTypeMetadataElementDefinition
{
get { return _relatedAssetTypeMetadataElementDefinition;}
set { _relatedAssetTypeMetadataElementDefinition = value; }
}
// one to many relation
private List<MetadataElementDefinitionMetadataElementOption> _relatedMetadataElementDefinitionMetadataElementOption;
public List<MetadataElementDefinitionMetadataElementOption> relatedMetadataElementDefinitionMetadataElementOption
{
get { return _relatedMetadataElementDefinitionMetadataElementOption;}
set { _relatedMetadataElementDefinitionMetadataElementOption = value; }
}
// one to many relation
private List<MetadataElementInstance> _relatedMetadataElementInstance;
public List<MetadataElementInstance> relatedMetadataElementInstance
{
get { return _relatedMetadataElementInstance;}
set { _relatedMetadataElementInstance = value; }
}
// one to many relation
private List<MetadataElementOption> _relatedMetadataElementOption;
public List<MetadataElementOption> relatedMetadataElementOption
{
get { return _relatedMetadataElementOption;}
set { _relatedMetadataElementOption = value; }
}
}
public partial class MetadataElementDefinitionDataMapper:TDataMapper<MetadataElementDefinition,SqlConnection,AMF_devDb, Weborb.Data.Management.MSSql.CommandBuilder, SqlTransaction, SqlCommand>
{
public MetadataElementDefinitionDataMapper(){}
public MetadataElementDefinitionDataMapper(AMF_devDb database):
base(database){}
public override String TableName
{
get
{
return "[Asset].[MetadataElementDefinition]";
}
}
public override Hashtable getRelation(string tableName)
{
throw new Exception("Not yet implemented");
}
private const String SqlCreate = @"Insert Into [Asset].[MetadataElementDefinition] (
NameResourceCode,TypeID,IsMultiSelect,MetadataElementDefinitionGroupID,CreateBy,CreateDate,ModifyBy,ModifyDate) Values (
@NameResourceCode,
@TypeID,
@IsMultiSelect,
@MetadataElementDefinitionGroupID,
@CreateBy,
@CreateDate,
@ModifyBy,
@ModifyDate);
select scope_identity();
";
[TransactionRequired]
[Synchronized]
public override MetadataElementDefinition create( MetadataElementDefinition metadataElementDefinition )
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
{
sqlCommand.Parameters.AddWithValue("@NameResourceCode", metadataElementDefinition.NameResourceCode);
sqlCommand.Parameters.AddWithValue("@TypeID", metadataElementDefinition.TypeID);
sqlCommand.Parameters.AddWithValue("@IsMultiSelect", metadataElementDefinition.IsMultiSelect);
sqlCommand.Parameters.AddWithValue("@MetadataElementDefinitionGroupID", metadataElementDefinition.MetadataElementDefinitionGroupID);
sqlCommand.Parameters.AddWithValue("@CreateBy", metadataElementDefinition.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", metadataElementDefinition.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", metadataElementDefinition.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", metadataElementDefinition.ModifyDate);
metadataElementDefinition.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
}
}
if(metadataElementDefinition.relatedAssetTypeMetadataElementDefinition != null
&& metadataElementDefinition.relatedAssetTypeMetadataElementDefinition.Count > 0)
{
AssetTypeMetadataElementDefinitionDataMapper dataMapper = new AssetTypeMetadataElementDefinitionDataMapper(Database);
foreach(AssetTypeMetadataElementDefinition item in metadataElementDefinition.relatedAssetTypeMetadataElementDefinition)
dataMapper.create(item);
}
if(metadataElementDefinition.relatedMetadataElementDefinitionMetadataElementOption != null
&& metadataElementDefinition.relatedMetadataElementDefinitionMetadataElementOption.Count > 0)
{
MetadataElementDefinitionMetadataElementOptionDataMapper dataMapper = new MetadataElementDefinitionMetadataElementOptionDataMapper(Database);
foreach(MetadataElementDefinitionMetadataElementOption item in metadataElementDefinition.relatedMetadataElementDefinitionMetadataElementOption)
dataMapper.create(item);
}
if(metadataElementDefinition.relatedMetadataElementInstance != null
&& metadataElementDefinition.relatedMetadataElementInstance.Count > 0)
{
MetadataElementInstanceDataMapper dataMapper = new MetadataElementInstanceDataMapper(Database);
foreach(MetadataElementInstance item in metadataElementDefinition.relatedMetadataElementInstance)
dataMapper.create(item);
}
if(metadataElementDefinition.relatedMetadataElementOption != null
&& metadataElementDefinition.relatedMetadataElementOption.Count > 0)
{
MetadataElementOptionDataMapper dataMapper = new MetadataElementOptionDataMapper(Database);
foreach(MetadataElementOption item in metadataElementDefinition.relatedMetadataElementOption)
dataMapper.create(item);
}
raiseAffected(metadataElementDefinition,DataMapperOperation.create);
return registerRecord(metadataElementDefinition);
}
private const String SqlSelectByPk = @"Select
ID,NameResourceCode,TypeID,IsMultiSelect,MetadataElementDefinitionGroupID,CreateBy,CreateDate,ModifyBy,ModifyDate
From [Asset].[MetadataElementDefinition]
Where
ID = @ID
";
public MetadataElementDefinition findByPrimaryKey(
int iD
)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", iD);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
if(dataReader.Read())
return doLoad(dataReader);
}
}
}
throw new DataNotFoundException("MetadataElementDefinition not found, search by primary key");
}
public bool exists(MetadataElementDefinition metadataElementDefinition)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", metadataElementDefinition.ID);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
return dataReader.Read();
}
}
}
}
private const string CheckInSql = @"
[MetadataElementDefinition].[ID] = @CheckInID";
protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
{
MetadataElementDefinition _MetadataElementDefinition = (MetadataElementDefinition)domainObject;
SqlCommand sqlCommand = Database.CreateCommand(ModifyQueryForCheckIn(sqlQuery,CheckInSql));
sqlCommand.Parameters.AddWithValue("@CheckInID", _MetadataElementDefinition.ID);
return sqlCommand;
}
protected override MetadataElementDefinition doLoad(IDataReader dataReader)
{
MetadataElementDefinition metadataElementDefinition = new MetadataElementDefinition();
metadataElementDefinition.ID = (int) dataReader.GetValue(0);
metadataElementDefinition.NameResourceCode = (String) dataReader.GetValue(1);
metadataElementDefinition.TypeID = (int) dataReader.GetValue(2);
metadataElementDefinition.IsMultiSelect = (bool) dataReader.GetValue(3);
metadataElementDefinition.MetadataElementDefinitionGroupID = (int) dataReader.GetValue(4);
metadataElementDefinition.CreateBy = (int) dataReader.GetValue(5);
metadataElementDefinition.CreateDate = (DateTime) dataReader.GetValue(6);
metadataElementDefinition.ModifyBy = (int) dataReader.GetValue(7);
metadataElementDefinition.ModifyDate = (DateTime) dataReader.GetValue(8);
return registerRecord(metadataElementDefinition);
}
protected override MetadataElementDefinition doLoad(Hashtable hashtable)
{
MetadataElementDefinition metadataElementDefinition = new MetadataElementDefinition();
if(hashtable.ContainsKey("ID"))
metadataElementDefinition.ID = ( int)hashtable["ID"];
if(hashtable.ContainsKey("NameResourceCode"))
metadataElementDefinition.NameResourceCode = ( String)hashtable["NameResourceCode"];
if(hashtable.ContainsKey("TypeID"))
metadataElementDefinition.TypeID = ( int)hashtable["TypeID"];
if(hashtable.ContainsKey("IsMultiSelect"))
metadataElementDefinition.IsMultiSelect = ( bool)hashtable["IsMultiSelect"];
if(hashtable.ContainsKey("MetadataElementDefinitionGroupID"))
metadataElementDefinition.MetadataElementDefinitionGroupID = ( int)hashtable["MetadataElementDefinitionGroupID"];
if(hashtable.ContainsKey("CreateBy"))
metadataElementDefinition.CreateBy = ( int)hashtable["CreateBy"];
if(hashtable.ContainsKey("CreateDate"))
metadataElementDefinition.CreateDate = ( DateTime)hashtable["CreateDate"];
if(hashtable.ContainsKey("ModifyBy"))
metadataElementDefinition.ModifyBy = ( int)hashtable["ModifyBy"];
if(hashtable.ContainsKey("ModifyDate"))
metadataElementDefinition.ModifyDate = ( DateTime)hashtable["ModifyDate"];
return metadataElementDefinition;
}
protected override List<MetadataElementDefinition> fill(SqlCommand sqlCommand, int offset, int limit)
{
List<MetadataElementDefinition> resultList = new List<MetadataElementDefinition>();
using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
{
DataTable dataTable = new DataTable();
sqlDataAdapter.Fill(offset,limit,dataTable);
foreach(DataRow dataRow in dataTable.Rows)
{
MetadataElementDefinition item = new MetadataElementDefinition();
item.ID = ( int)dataRow["ID"] ;
item.NameResourceCode = ( String)dataRow["NameResourceCode"] ;
item.TypeID = ( int)dataRow["TypeID"] ;
item.IsMultiSelect = ( bool)dataRow["IsMultiSelect"] ;
item.MetadataElementDefinitionGroupID = ( int)dataRow["MetadataElementDefinitionGroupID"] ;
item.CreateBy = ( int)dataRow["CreateBy"] ;
item.CreateDate = ( DateTime)dataRow["CreateDate"] ;
item.ModifyBy = ( int)dataRow["ModifyBy"] ;
item.ModifyDate = ( DateTime)dataRow["ModifyDate"] ;
registerRecord(item);
resultList.Add(item);
}
}
return resultList;
}
#region Delete
private const String SqlDelete = @"Delete From [Asset].[MetadataElementDefinition]
Where
ID = @ID";
[Synchronized]
public MetadataElementDefinition remove(MetadataElementDefinition metadataElementDefinition)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
{
sqlCommand.Parameters.AddWithValue("@ID", metadataElementDefinition.ID);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(metadataElementDefinition,DataMapperOperation.delete);
return registerRecord(metadataElementDefinition);
}
#endregion
[Synchronized]
[TransactionRequired]
public MetadataElementDefinition save( MetadataElementDefinition metadataElementDefinition )
{
if(exists(metadataElementDefinition))
return update(metadataElementDefinition);
return create(metadataElementDefinition);
}
const String SqlUpdate = @"Update [Asset].[MetadataElementDefinition] Set
NameResourceCode = @NameResourceCode,TypeID = @TypeID,IsMultiSelect = @IsMultiSelect,MetadataElementDefinitionGroupID = @MetadataElementDefinitionGroupID,CreateBy = @CreateBy,CreateDate = @CreateDate,ModifyBy = @ModifyBy,ModifyDate = @ModifyDate
Where
ID = @ID";
[TransactionRequired]
[Synchronized]
public MetadataElementDefinition update(MetadataElementDefinition metadataElementDefinition)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
{
sqlCommand.Parameters.AddWithValue("@ID", metadataElementDefinition.ID);
sqlCommand.Parameters.AddWithValue("@NameResourceCode", metadataElementDefinition.NameResourceCode);
sqlCommand.Parameters.AddWithValue("@TypeID", metadataElementDefinition.TypeID);
sqlCommand.Parameters.AddWithValue("@IsMultiSelect", metadataElementDefinition.IsMultiSelect);
sqlCommand.Parameters.AddWithValue("@MetadataElementDefinitionGroupID", metadataElementDefinition.MetadataElementDefinitionGroupID);
sqlCommand.Parameters.AddWithValue("@CreateBy", metadataElementDefinition.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", metadataElementDefinition.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", metadataElementDefinition.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", metadataElementDefinition.ModifyDate);
sqlCommand.ExecuteNonQuery();
}
}
if(metadataElementDefinition.relatedAssetTypeMetadataElementDefinition != null
&& metadataElementDefinition.relatedAssetTypeMetadataElementDefinition.Count > 0)
{
AssetTypeMetadataElementDefinitionDataMapper dataMapper = new AssetTypeMetadataElementDefinitionDataMapper(Database);
foreach(AssetTypeMetadataElementDefinition item in metadataElementDefinition.relatedAssetTypeMetadataElementDefinition)
dataMapper.save(item);
}
if(metadataElementDefinition.relatedMetadataElementDefinitionMetadataElementOption != null
&& metadataElementDefinition.relatedMetadataElementDefinitionMetadataElementOption.Count > 0)
{
MetadataElementDefinitionMetadataElementOptionDataMapper dataMapper = new MetadataElementDefinitionMetadataElementOptionDataMapper(Database);
foreach(MetadataElementDefinitionMetadataElementOption item in metadataElementDefinition.relatedMetadataElementDefinitionMetadataElementOption)
dataMapper.save(item);
}
if(metadataElementDefinition.relatedMetadataElementInstance != null
&& metadataElementDefinition.relatedMetadataElementInstance.Count > 0)
{
MetadataElementInstanceDataMapper dataMapper = new MetadataElementInstanceDataMapper(Database);
foreach(MetadataElementInstance item in metadataElementDefinition.relatedMetadataElementInstance)
dataMapper.save(item);
}
if(metadataElementDefinition.relatedMetadataElementOption != null
&& metadataElementDefinition.relatedMetadataElementOption.Count > 0)
{
MetadataElementOptionDataMapper dataMapper = new MetadataElementOptionDataMapper(Database);
foreach(MetadataElementOption item in metadataElementDefinition.relatedMetadataElementOption)
dataMapper.save(item);
}
raiseAffected(metadataElementDefinition,DataMapperOperation.update);
return registerRecord(metadataElementDefinition);
}
}
public partial class MetadataElementDefinitionGroup: DomainObject
{
protected int _iD;
protected String _nameResourceCode;
protected int _createBy;
protected DateTime _createDate;
protected int _modifyBy;
protected DateTime _modifyDate;
public MetadataElementDefinitionGroup(){}
public MetadataElementDefinitionGroup(
int
iD,String
nameResourceCode,int
createBy,DateTime
createDate,int
modifyBy,DateTime
modifyDate
)
{
this.ID = iD;
this.NameResourceCode = nameResourceCode;
this.CreateBy = createBy;
this.CreateDate = createDate;
this.ModifyBy = modifyBy;
this.ModifyDate = modifyDate;
}
public override String getUri()
{
String uri = "AMF_dev.MetadataElementDefinitionGroup."
+ ID.ToString()
;
return uri;
}
public int ID
{
get { return _iD;}
set
{
_iD = value;
}
}
public String NameResourceCode
{
get { return _nameResourceCode;}
set
{
_nameResourceCode = value;
}
}
public int CreateBy
{
get { return _createBy;}
set
{
_createBy = value;
}
}
public DateTime CreateDate
{
get { return _createDate;}
set
{
_createDate = value;
}
}
public int ModifyBy
{
get { return _modifyBy;}
set
{
_modifyBy = value;
}
}
public DateTime ModifyDate
{
get { return _modifyDate;}
set
{
_modifyDate = value;
}
}
public override DomainObject extractSingleObject()
{
MetadataElementDefinitionGroup metadataElementDefinitionGroup = new MetadataElementDefinitionGroup();
metadataElementDefinitionGroup.ID = this.ID;
metadataElementDefinitionGroup.NameResourceCode = this.NameResourceCode;
metadataElementDefinitionGroup.CreateBy = this.CreateBy;
metadataElementDefinitionGroup.CreateDate = this.CreateDate;
metadataElementDefinitionGroup.ModifyBy = this.ModifyBy;
metadataElementDefinitionGroup.ModifyDate = this.ModifyDate;
metadataElementDefinitionGroup.ActiveRecordId = this.ActiveRecordId;
return metadataElementDefinitionGroup;
}
// one to many relation
private List<MetadataElementDefinition> _relatedMetadataElementDefinition;
public List<MetadataElementDefinition> relatedMetadataElementDefinition
{
get { return _relatedMetadataElementDefinition;}
set { _relatedMetadataElementDefinition = value; }
}
}
public partial class MetadataElementDefinitionGroupDataMapper:TDataMapper<MetadataElementDefinitionGroup,SqlConnection,AMF_devDb, Weborb.Data.Management.MSSql.CommandBuilder, SqlTransaction, SqlCommand>
{
public MetadataElementDefinitionGroupDataMapper(){}
public MetadataElementDefinitionGroupDataMapper(AMF_devDb database):
base(database){}
public override String TableName
{
get
{
return "[Asset].[MetadataElementDefinitionGroup]";
}
}
public override Hashtable getRelation(string tableName)
{
throw new Exception("Not yet implemented");
}
private const String SqlCreate = @"Insert Into [Asset].[MetadataElementDefinitionGroup] (
NameResourceCode,CreateBy,CreateDate,ModifyBy,ModifyDate) Values (
@NameResourceCode,
@CreateBy,
@CreateDate,
@ModifyBy,
@ModifyDate);
select scope_identity();
";
[TransactionRequired]
[Synchronized]
public override MetadataElementDefinitionGroup create( MetadataElementDefinitionGroup metadataElementDefinitionGroup )
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
{
sqlCommand.Parameters.AddWithValue("@NameResourceCode", metadataElementDefinitionGroup.NameResourceCode);
sqlCommand.Parameters.AddWithValue("@CreateBy", metadataElementDefinitionGroup.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", metadataElementDefinitionGroup.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", metadataElementDefinitionGroup.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", metadataElementDefinitionGroup.ModifyDate);
metadataElementDefinitionGroup.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
}
}
if(metadataElementDefinitionGroup.relatedMetadataElementDefinition != null
&& metadataElementDefinitionGroup.relatedMetadataElementDefinition.Count > 0)
{
MetadataElementDefinitionDataMapper dataMapper = new MetadataElementDefinitionDataMapper(Database);
foreach(MetadataElementDefinition item in metadataElementDefinitionGroup.relatedMetadataElementDefinition)
dataMapper.create(item);
}
raiseAffected(metadataElementDefinitionGroup,DataMapperOperation.create);
return registerRecord(metadataElementDefinitionGroup);
}
private const String SqlSelectByPk = @"Select
ID,NameResourceCode,CreateBy,CreateDate,ModifyBy,ModifyDate
From [Asset].[MetadataElementDefinitionGroup]
Where
ID = @ID
";
public MetadataElementDefinitionGroup findByPrimaryKey(
int iD
)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", iD);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
if(dataReader.Read())
return doLoad(dataReader);
}
}
}
throw new DataNotFoundException("MetadataElementDefinitionGroup not found, search by primary key");
}
public bool exists(MetadataElementDefinitionGroup metadataElementDefinitionGroup)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", metadataElementDefinitionGroup.ID);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
return dataReader.Read();
}
}
}
}
private const string CheckInSql = @"
[MetadataElementDefinitionGroup].[ID] = @CheckInID";
protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
{
MetadataElementDefinitionGroup _MetadataElementDefinitionGroup = (MetadataElementDefinitionGroup)domainObject;
SqlCommand sqlCommand = Database.CreateCommand(ModifyQueryForCheckIn(sqlQuery,CheckInSql));
sqlCommand.Parameters.AddWithValue("@CheckInID", _MetadataElementDefinitionGroup.ID);
return sqlCommand;
}
protected override MetadataElementDefinitionGroup doLoad(IDataReader dataReader)
{
MetadataElementDefinitionGroup metadataElementDefinitionGroup = new MetadataElementDefinitionGroup();
metadataElementDefinitionGroup.ID = (int) dataReader.GetValue(0);
metadataElementDefinitionGroup.NameResourceCode = (String) dataReader.GetValue(1);
metadataElementDefinitionGroup.CreateBy = (int) dataReader.GetValue(2);
metadataElementDefinitionGroup.CreateDate = (DateTime) dataReader.GetValue(3);
metadataElementDefinitionGroup.ModifyBy = (int) dataReader.GetValue(4);
metadataElementDefinitionGroup.ModifyDate = (DateTime) dataReader.GetValue(5);
return registerRecord(metadataElementDefinitionGroup);
}
protected override MetadataElementDefinitionGroup doLoad(Hashtable hashtable)
{
MetadataElementDefinitionGroup metadataElementDefinitionGroup = new MetadataElementDefinitionGroup();
if(hashtable.ContainsKey("ID"))
metadataElementDefinitionGroup.ID = ( int)hashtable["ID"];
if(hashtable.ContainsKey("NameResourceCode"))
metadataElementDefinitionGroup.NameResourceCode = ( String)hashtable["NameResourceCode"];
if(hashtable.ContainsKey("CreateBy"))
metadataElementDefinitionGroup.CreateBy = ( int)hashtable["CreateBy"];
if(hashtable.ContainsKey("CreateDate"))
metadataElementDefinitionGroup.CreateDate = ( DateTime)hashtable["CreateDate"];
if(hashtable.ContainsKey("ModifyBy"))
metadataElementDefinitionGroup.ModifyBy = ( int)hashtable["ModifyBy"];
if(hashtable.ContainsKey("ModifyDate"))
metadataElementDefinitionGroup.ModifyDate = ( DateTime)hashtable["ModifyDate"];
return metadataElementDefinitionGroup;
}
protected override List<MetadataElementDefinitionGroup> fill(SqlCommand sqlCommand, int offset, int limit)
{
List<MetadataElementDefinitionGroup> resultList = new List<MetadataElementDefinitionGroup>();
using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
{
DataTable dataTable = new DataTable();
sqlDataAdapter.Fill(offset,limit,dataTable);
foreach(DataRow dataRow in dataTable.Rows)
{
MetadataElementDefinitionGroup item = new MetadataElementDefinitionGroup();
item.ID = ( int)dataRow["ID"] ;
item.NameResourceCode = ( String)dataRow["NameResourceCode"] ;
item.CreateBy = ( int)dataRow["CreateBy"] ;
item.CreateDate = ( DateTime)dataRow["CreateDate"] ;
item.ModifyBy = ( int)dataRow["ModifyBy"] ;
item.ModifyDate = ( DateTime)dataRow["ModifyDate"] ;
registerRecord(item);
resultList.Add(item);
}
}
return resultList;
}
#region Delete
private const String SqlDelete = @"Delete From [Asset].[MetadataElementDefinitionGroup]
Where
ID = @ID";
[Synchronized]
public MetadataElementDefinitionGroup remove(MetadataElementDefinitionGroup metadataElementDefinitionGroup)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
{
sqlCommand.Parameters.AddWithValue("@ID", metadataElementDefinitionGroup.ID);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(metadataElementDefinitionGroup,DataMapperOperation.delete);
return registerRecord(metadataElementDefinitionGroup);
}
#endregion
[Synchronized]
[TransactionRequired]
public MetadataElementDefinitionGroup save( MetadataElementDefinitionGroup metadataElementDefinitionGroup )
{
if(exists(metadataElementDefinitionGroup))
return update(metadataElementDefinitionGroup);
return create(metadataElementDefinitionGroup);
}
const String SqlUpdate = @"Update [Asset].[MetadataElementDefinitionGroup] Set
NameResourceCode = @NameResourceCode,CreateBy = @CreateBy,CreateDate = @CreateDate,ModifyBy = @ModifyBy,ModifyDate = @ModifyDate
Where
ID = @ID";
[TransactionRequired]
[Synchronized]
public MetadataElementDefinitionGroup update(MetadataElementDefinitionGroup metadataElementDefinitionGroup)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
{
sqlCommand.Parameters.AddWithValue("@ID", metadataElementDefinitionGroup.ID);
sqlCommand.Parameters.AddWithValue("@NameResourceCode", metadataElementDefinitionGroup.NameResourceCode);
sqlCommand.Parameters.AddWithValue("@CreateBy", metadataElementDefinitionGroup.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", metadataElementDefinitionGroup.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", metadataElementDefinitionGroup.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", metadataElementDefinitionGroup.ModifyDate);
sqlCommand.ExecuteNonQuery();
}
}
if(metadataElementDefinitionGroup.relatedMetadataElementDefinition != null
&& metadataElementDefinitionGroup.relatedMetadataElementDefinition.Count > 0)
{
MetadataElementDefinitionDataMapper dataMapper = new MetadataElementDefinitionDataMapper(Database);
foreach(MetadataElementDefinition item in metadataElementDefinitionGroup.relatedMetadataElementDefinition)
dataMapper.save(item);
}
raiseAffected(metadataElementDefinitionGroup,DataMapperOperation.update);
return registerRecord(metadataElementDefinitionGroup);
}
}
public partial class MetadataElementDefinitionMetadataElementOption: DomainObject
{
protected int _iD;
protected int _createBy;
protected DateTime _createDate;
protected int _modifyBy;
protected DateTime _modifyDate;
// parent tables
protected MetadataElementDefinition _relatedMetadataElementDefinition
= new MetadataElementDefinition()
;
// parent tables
protected MetadataElementOption _relatedMetadataElementOption
= new MetadataElementOption()
;
public MetadataElementDefinitionMetadataElementOption(){}
public MetadataElementDefinitionMetadataElementOption(
int
iD,int
metadataElementDefinitionID,int
metadataElementOptionID,int
createBy,DateTime
createDate,int
modifyBy,DateTime
modifyDate
)
{
this.ID = iD;
this.MetadataElementDefinitionID = metadataElementDefinitionID;
this.MetadataElementOptionID = metadataElementOptionID;
this.CreateBy = createBy;
this.CreateDate = createDate;
this.ModifyBy = modifyBy;
this.ModifyDate = modifyDate;
}
public override String getUri()
{
String uri = "AMF_dev.MetadataElementDefinitionMetadataElementOption."
+ ID.ToString()
;
return uri;
}
public int ID
{
get { return _iD;}
set
{
_iD = value;
}
}
public int MetadataElementDefinitionID
{
get
{
if(_relatedMetadataElementDefinition != null)
return _relatedMetadataElementDefinition.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedMetadataElementDefinition == null)
_relatedMetadataElementDefinition = new MetadataElementDefinition();
_relatedMetadataElementDefinition.ID = value;
}
}
public int MetadataElementOptionID
{
get
{
if(_relatedMetadataElementOption != null)
return _relatedMetadataElementOption.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedMetadataElementOption == null)
_relatedMetadataElementOption = new MetadataElementOption();
_relatedMetadataElementOption.ID = value;
}
}
public int CreateBy
{
get { return _createBy;}
set
{
_createBy = value;
}
}
public DateTime CreateDate
{
get { return _createDate;}
set
{
_createDate = value;
}
}
public int ModifyBy
{
get { return _modifyBy;}
set
{
_modifyBy = value;
}
}
public DateTime ModifyDate
{
get { return _modifyDate;}
set
{
_modifyDate = value;
}
}
public MetadataElementDefinition RelatedMetadataElementDefinition
{
get { return _relatedMetadataElementDefinition;}
set { _relatedMetadataElementDefinition = value; }
}
public MetadataElementOption RelatedMetadataElementOption
{
get { return _relatedMetadataElementOption;}
set { _relatedMetadataElementOption = value; }
}
public override DomainObject extractSingleObject()
{
MetadataElementDefinitionMetadataElementOption metadataElementDefinitionMetadataElementOption = new MetadataElementDefinitionMetadataElementOption();
metadataElementDefinitionMetadataElementOption.ID = this.ID;
metadataElementDefinitionMetadataElementOption.MetadataElementDefinitionID = this.MetadataElementDefinitionID;
metadataElementDefinitionMetadataElementOption.MetadataElementOptionID = this.MetadataElementOptionID;
metadataElementDefinitionMetadataElementOption.CreateBy = this.CreateBy;
metadataElementDefinitionMetadataElementOption.CreateDate = this.CreateDate;
metadataElementDefinitionMetadataElementOption.ModifyBy = this.ModifyBy;
metadataElementDefinitionMetadataElementOption.ModifyDate = this.ModifyDate;
metadataElementDefinitionMetadataElementOption.ActiveRecordId = this.ActiveRecordId;
return metadataElementDefinitionMetadataElementOption;
}
}
public partial class MetadataElementDefinitionMetadataElementOptionDataMapper:TDataMapper<MetadataElementDefinitionMetadataElementOption,SqlConnection,AMF_devDb, Weborb.Data.Management.MSSql.CommandBuilder, SqlTransaction, SqlCommand>
{
public MetadataElementDefinitionMetadataElementOptionDataMapper(){}
public MetadataElementDefinitionMetadataElementOptionDataMapper(AMF_devDb database):
base(database){}
public override String TableName
{
get
{
return "[Asset].[MetadataElementDefinitionMetadataElementOption]";
}
}
public override Hashtable getRelation(string tableName)
{
throw new Exception("Not yet implemented");
}
private const String SqlCreate = @"Insert Into [Asset].[MetadataElementDefinitionMetadataElementOption] (
MetadataElementDefinitionID,MetadataElementOptionID,CreateBy,CreateDate,ModifyBy,ModifyDate) Values (
@MetadataElementDefinitionID,
@MetadataElementOptionID,
@CreateBy,
@CreateDate,
@ModifyBy,
@ModifyDate);
select scope_identity();
";
[Synchronized]
public override MetadataElementDefinitionMetadataElementOption create( MetadataElementDefinitionMetadataElementOption metadataElementDefinitionMetadataElementOption )
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
{
sqlCommand.Parameters.AddWithValue("@MetadataElementDefinitionID", metadataElementDefinitionMetadataElementOption.MetadataElementDefinitionID);
sqlCommand.Parameters.AddWithValue("@MetadataElementOptionID", metadataElementDefinitionMetadataElementOption.MetadataElementOptionID);
sqlCommand.Parameters.AddWithValue("@CreateBy", metadataElementDefinitionMetadataElementOption.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", metadataElementDefinitionMetadataElementOption.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", metadataElementDefinitionMetadataElementOption.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", metadataElementDefinitionMetadataElementOption.ModifyDate);
metadataElementDefinitionMetadataElementOption.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
}
}
raiseAffected(metadataElementDefinitionMetadataElementOption,DataMapperOperation.create);
return registerRecord(metadataElementDefinitionMetadataElementOption);
}
private const String SqlSelectByPk = @"Select
ID,MetadataElementDefinitionID,MetadataElementOptionID,CreateBy,CreateDate,ModifyBy,ModifyDate
From [Asset].[MetadataElementDefinitionMetadataElementOption]
Where
ID = @ID
";
public MetadataElementDefinitionMetadataElementOption findByPrimaryKey(
int iD
)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", iD);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
if(dataReader.Read())
return doLoad(dataReader);
}
}
}
throw new DataNotFoundException("MetadataElementDefinitionMetadataElementOption not found, search by primary key");
}
public bool exists(MetadataElementDefinitionMetadataElementOption metadataElementDefinitionMetadataElementOption)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", metadataElementDefinitionMetadataElementOption.ID);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
return dataReader.Read();
}
}
}
}
private const string CheckInSql = @"
[MetadataElementDefinitionMetadataElementOption].[ID] = @CheckInID";
protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
{
MetadataElementDefinitionMetadataElementOption _MetadataElementDefinitionMetadataElementOption = (MetadataElementDefinitionMetadataElementOption)domainObject;
SqlCommand sqlCommand = Database.CreateCommand(ModifyQueryForCheckIn(sqlQuery,CheckInSql));
sqlCommand.Parameters.AddWithValue("@CheckInID", _MetadataElementDefinitionMetadataElementOption.ID);
return sqlCommand;
}
protected override MetadataElementDefinitionMetadataElementOption doLoad(IDataReader dataReader)
{
MetadataElementDefinitionMetadataElementOption metadataElementDefinitionMetadataElementOption = new MetadataElementDefinitionMetadataElementOption();
metadataElementDefinitionMetadataElementOption.ID = (int) dataReader.GetValue(0);
metadataElementDefinitionMetadataElementOption.MetadataElementDefinitionID = (int) dataReader.GetValue(1);
metadataElementDefinitionMetadataElementOption.MetadataElementOptionID = (int) dataReader.GetValue(2);
metadataElementDefinitionMetadataElementOption.CreateBy = (int) dataReader.GetValue(3);
metadataElementDefinitionMetadataElementOption.CreateDate = (DateTime) dataReader.GetValue(4);
metadataElementDefinitionMetadataElementOption.ModifyBy = (int) dataReader.GetValue(5);
metadataElementDefinitionMetadataElementOption.ModifyDate = (DateTime) dataReader.GetValue(6);
return registerRecord(metadataElementDefinitionMetadataElementOption);
}
protected override MetadataElementDefinitionMetadataElementOption doLoad(Hashtable hashtable)
{
MetadataElementDefinitionMetadataElementOption metadataElementDefinitionMetadataElementOption = new MetadataElementDefinitionMetadataElementOption();
if(hashtable.ContainsKey("ID"))
metadataElementDefinitionMetadataElementOption.ID = ( int)hashtable["ID"];
if(hashtable.ContainsKey("MetadataElementDefinitionID"))
metadataElementDefinitionMetadataElementOption.MetadataElementDefinitionID = ( int)hashtable["MetadataElementDefinitionID"];
if(hashtable.ContainsKey("MetadataElementOptionID"))
metadataElementDefinitionMetadataElementOption.MetadataElementOptionID = ( int)hashtable["MetadataElementOptionID"];
if(hashtable.ContainsKey("CreateBy"))
metadataElementDefinitionMetadataElementOption.CreateBy = ( int)hashtable["CreateBy"];
if(hashtable.ContainsKey("CreateDate"))
metadataElementDefinitionMetadataElementOption.CreateDate = ( DateTime)hashtable["CreateDate"];
if(hashtable.ContainsKey("ModifyBy"))
metadataElementDefinitionMetadataElementOption.ModifyBy = ( int)hashtable["ModifyBy"];
if(hashtable.ContainsKey("ModifyDate"))
metadataElementDefinitionMetadataElementOption.ModifyDate = ( DateTime)hashtable["ModifyDate"];
return metadataElementDefinitionMetadataElementOption;
}
protected override List<MetadataElementDefinitionMetadataElementOption> fill(SqlCommand sqlCommand, int offset, int limit)
{
List<MetadataElementDefinitionMetadataElementOption> resultList = new List<MetadataElementDefinitionMetadataElementOption>();
using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
{
DataTable dataTable = new DataTable();
sqlDataAdapter.Fill(offset,limit,dataTable);
foreach(DataRow dataRow in dataTable.Rows)
{
MetadataElementDefinitionMetadataElementOption item = new MetadataElementDefinitionMetadataElementOption();
item.ID = ( int)dataRow["ID"] ;
item.MetadataElementDefinitionID = ( int)dataRow["MetadataElementDefinitionID"] ;
item.MetadataElementOptionID = ( int)dataRow["MetadataElementOptionID"] ;
item.CreateBy = ( int)dataRow["CreateBy"] ;
item.CreateDate = ( DateTime)dataRow["CreateDate"] ;
item.ModifyBy = ( int)dataRow["ModifyBy"] ;
item.ModifyDate = ( DateTime)dataRow["ModifyDate"] ;
registerRecord(item);
resultList.Add(item);
}
}
return resultList;
}
#region Delete
private const String SqlDelete = @"Delete From [Asset].[MetadataElementDefinitionMetadataElementOption]
Where
ID = @ID";
[Synchronized]
public MetadataElementDefinitionMetadataElementOption remove(MetadataElementDefinitionMetadataElementOption metadataElementDefinitionMetadataElementOption)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
{
sqlCommand.Parameters.AddWithValue("@ID", metadataElementDefinitionMetadataElementOption.ID);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(metadataElementDefinitionMetadataElementOption,DataMapperOperation.delete);
return registerRecord(metadataElementDefinitionMetadataElementOption);
}
#endregion
[Synchronized]
[TransactionRequired]
public MetadataElementDefinitionMetadataElementOption save( MetadataElementDefinitionMetadataElementOption metadataElementDefinitionMetadataElementOption )
{
if(exists(metadataElementDefinitionMetadataElementOption))
return update(metadataElementDefinitionMetadataElementOption);
return create(metadataElementDefinitionMetadataElementOption);
}
const String SqlUpdate = @"Update [Asset].[MetadataElementDefinitionMetadataElementOption] Set
MetadataElementDefinitionID = @MetadataElementDefinitionID,MetadataElementOptionID = @MetadataElementOptionID,CreateBy = @CreateBy,CreateDate = @CreateDate,ModifyBy = @ModifyBy,ModifyDate = @ModifyDate
Where
ID = @ID";
[Synchronized]
public MetadataElementDefinitionMetadataElementOption update(MetadataElementDefinitionMetadataElementOption metadataElementDefinitionMetadataElementOption)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
{
sqlCommand.Parameters.AddWithValue("@ID", metadataElementDefinitionMetadataElementOption.ID);
sqlCommand.Parameters.AddWithValue("@MetadataElementDefinitionID", metadataElementDefinitionMetadataElementOption.MetadataElementDefinitionID);
sqlCommand.Parameters.AddWithValue("@MetadataElementOptionID", metadataElementDefinitionMetadataElementOption.MetadataElementOptionID);
sqlCommand.Parameters.AddWithValue("@CreateBy", metadataElementDefinitionMetadataElementOption.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", metadataElementDefinitionMetadataElementOption.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", metadataElementDefinitionMetadataElementOption.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", metadataElementDefinitionMetadataElementOption.ModifyDate);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(metadataElementDefinitionMetadataElementOption,DataMapperOperation.update);
return registerRecord(metadataElementDefinitionMetadataElementOption);
}
}
public partial class MetadataElementInstance: DomainObject
{
protected int _iD;
protected int? _createBy;
protected DateTime? _createDate;
protected int? _modifyBy;
protected DateTime? _modifyDate;
// parent tables
protected Asset _relatedAsset
= new Asset()
;
// parent tables
protected MetadataElementDefinition _relatedMetadataElementDefinition
= new MetadataElementDefinition()
;
public MetadataElementInstance(){}
public MetadataElementInstance(
int
iD,int
assetID,int
metadataElementDefinitionID,int
createBy,DateTime
createDate,int
modifyBy,DateTime
modifyDate
)
{
this.ID = iD;
this.AssetID = assetID;
this.MetadataElementDefinitionID = metadataElementDefinitionID;
this.CreateBy = createBy;
this.CreateDate = createDate;
this.ModifyBy = modifyBy;
this.ModifyDate = modifyDate;
}
public override String getUri()
{
String uri = "AMF_dev.MetadataElementInstance."
+ ID.ToString()
;
return uri;
}
public int ID
{
get { return _iD;}
set
{
_iD = value;
}
}
public int AssetID
{
get
{
if(_relatedAsset != null)
return _relatedAsset.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedAsset == null)
_relatedAsset = new Asset();
_relatedAsset.ID = value;
}
}
public int MetadataElementDefinitionID
{
get
{
if(_relatedMetadataElementDefinition != null)
return _relatedMetadataElementDefinition.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedMetadataElementDefinition == null)
_relatedMetadataElementDefinition = new MetadataElementDefinition();
_relatedMetadataElementDefinition.ID = value;
}
}
public int? CreateBy
{
get { return _createBy;}
set
{
_createBy = value;
}
}
public DateTime? CreateDate
{
get { return _createDate;}
set
{
_createDate = value;
}
}
public int? ModifyBy
{
get { return _modifyBy;}
set
{
_modifyBy = value;
}
}
public DateTime? ModifyDate
{
get { return _modifyDate;}
set
{
_modifyDate = value;
}
}
public Asset RelatedAsset
{
get { return _relatedAsset;}
set { _relatedAsset = value; }
}
public MetadataElementDefinition RelatedMetadataElementDefinition
{
get { return _relatedMetadataElementDefinition;}
set { _relatedMetadataElementDefinition = value; }
}
public override DomainObject extractSingleObject()
{
MetadataElementInstance metadataElementInstance = new MetadataElementInstance();
metadataElementInstance.ID = this.ID;
metadataElementInstance.AssetID = this.AssetID;
metadataElementInstance.MetadataElementDefinitionID = this.MetadataElementDefinitionID;
metadataElementInstance.CreateBy = this.CreateBy;
metadataElementInstance.CreateDate = this.CreateDate;
metadataElementInstance.ModifyBy = this.ModifyBy;
metadataElementInstance.ModifyDate = this.ModifyDate;
metadataElementInstance.ActiveRecordId = this.ActiveRecordId;
return metadataElementInstance;
}
// one to many relation
private List<MetadataElementInstanceValue> _relatedMetadataElementInstanceValue;
public List<MetadataElementInstanceValue> relatedMetadataElementInstanceValue
{
get { return _relatedMetadataElementInstanceValue;}
set { _relatedMetadataElementInstanceValue = value; }
}
}
public partial class MetadataElementInstanceDataMapper:TDataMapper<MetadataElementInstance,SqlConnection,AMF_devDb, Weborb.Data.Management.MSSql.CommandBuilder, SqlTransaction, SqlCommand>
{
public MetadataElementInstanceDataMapper(){}
public MetadataElementInstanceDataMapper(AMF_devDb database):
base(database){}
public override String TableName
{
get
{
return "[Asset].[MetadataElementInstance]";
}
}
public override Hashtable getRelation(string tableName)
{
throw new Exception("Not yet implemented");
}
private const String SqlCreate = @"Insert Into [Asset].[MetadataElementInstance] (
AssetID,MetadataElementDefinitionID,CreateBy,CreateDate,ModifyBy,ModifyDate) Values (
@AssetID,
@MetadataElementDefinitionID,
@CreateBy,
@CreateDate,
@ModifyBy,
@ModifyDate);
select scope_identity();
";
[TransactionRequired]
[Synchronized]
public override MetadataElementInstance create( MetadataElementInstance metadataElementInstance )
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
{
sqlCommand.Parameters.AddWithValue("@AssetID", metadataElementInstance.AssetID);
sqlCommand.Parameters.AddWithValue("@MetadataElementDefinitionID", metadataElementInstance.MetadataElementDefinitionID);
if(metadataElementInstance.CreateBy.HasValue)
sqlCommand.Parameters.AddWithValue("@CreateBy", metadataElementInstance.CreateBy);
else
sqlCommand.Parameters.AddWithValue("@CreateBy", DBNull.Value);
if(metadataElementInstance.CreateDate.HasValue)
sqlCommand.Parameters.AddWithValue("@CreateDate", metadataElementInstance.CreateDate);
else
sqlCommand.Parameters.AddWithValue("@CreateDate", DBNull.Value);
if(metadataElementInstance.ModifyBy.HasValue)
sqlCommand.Parameters.AddWithValue("@ModifyBy", metadataElementInstance.ModifyBy);
else
sqlCommand.Parameters.AddWithValue("@ModifyBy", DBNull.Value);
if(metadataElementInstance.ModifyDate.HasValue)
sqlCommand.Parameters.AddWithValue("@ModifyDate", metadataElementInstance.ModifyDate);
else
sqlCommand.Parameters.AddWithValue("@ModifyDate", DBNull.Value);
metadataElementInstance.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
}
}
if(metadataElementInstance.relatedMetadataElementInstanceValue != null
&& metadataElementInstance.relatedMetadataElementInstanceValue.Count > 0)
{
MetadataElementInstanceValueDataMapper dataMapper = new MetadataElementInstanceValueDataMapper(Database);
foreach(MetadataElementInstanceValue item in metadataElementInstance.relatedMetadataElementInstanceValue)
dataMapper.create(item);
}
raiseAffected(metadataElementInstance,DataMapperOperation.create);
return registerRecord(metadataElementInstance);
}
private const String SqlSelectByPk = @"Select
ID,AssetID,MetadataElementDefinitionID,CreateBy,CreateDate,ModifyBy,ModifyDate
From [Asset].[MetadataElementInstance]
Where
ID = @ID
";
public MetadataElementInstance findByPrimaryKey(
int iD
)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", iD);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
if(dataReader.Read())
return doLoad(dataReader);
}
}
}
throw new DataNotFoundException("MetadataElementInstance not found, search by primary key");
}
public bool exists(MetadataElementInstance metadataElementInstance)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", metadataElementInstance.ID);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
return dataReader.Read();
}
}
}
}
private const string CheckInSql = @"
[MetadataElementInstance].[ID] = @CheckInID";
protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
{
MetadataElementInstance _MetadataElementInstance = (MetadataElementInstance)domainObject;
SqlCommand sqlCommand = Database.CreateCommand(ModifyQueryForCheckIn(sqlQuery,CheckInSql));
sqlCommand.Parameters.AddWithValue("@CheckInID", _MetadataElementInstance.ID);
return sqlCommand;
}
protected override MetadataElementInstance doLoad(IDataReader dataReader)
{
MetadataElementInstance metadataElementInstance = new MetadataElementInstance();
metadataElementInstance.ID = (int) dataReader.GetValue(0);
metadataElementInstance.AssetID = (int) dataReader.GetValue(1);
metadataElementInstance.MetadataElementDefinitionID = (int) dataReader.GetValue(2);
if(!dataReader.IsDBNull(3))
metadataElementInstance.CreateBy = (int) dataReader.GetValue(3);
if(!dataReader.IsDBNull(4))
metadataElementInstance.CreateDate = (DateTime) dataReader.GetValue(4);
if(!dataReader.IsDBNull(5))
metadataElementInstance.ModifyBy = (int) dataReader.GetValue(5);
if(!dataReader.IsDBNull(6))
metadataElementInstance.ModifyDate = (DateTime) dataReader.GetValue(6);
return registerRecord(metadataElementInstance);
}
protected override MetadataElementInstance doLoad(Hashtable hashtable)
{
MetadataElementInstance metadataElementInstance = new MetadataElementInstance();
if(hashtable.ContainsKey("ID"))
metadataElementInstance.ID = ( int)hashtable["ID"];
if(hashtable.ContainsKey("AssetID"))
metadataElementInstance.AssetID = ( int)hashtable["AssetID"];
if(hashtable.ContainsKey("MetadataElementDefinitionID"))
metadataElementInstance.MetadataElementDefinitionID = ( int)hashtable["MetadataElementDefinitionID"];
if(hashtable.ContainsKey("CreateBy"))
metadataElementInstance.CreateBy = ( int)hashtable["CreateBy"];
if(hashtable.ContainsKey("CreateDate"))
metadataElementInstance.CreateDate = ( DateTime)hashtable["CreateDate"];
if(hashtable.ContainsKey("ModifyBy"))
metadataElementInstance.ModifyBy = ( int)hashtable["ModifyBy"];
if(hashtable.ContainsKey("ModifyDate"))
metadataElementInstance.ModifyDate = ( DateTime)hashtable["ModifyDate"];
return metadataElementInstance;
}
protected override List<MetadataElementInstance> fill(SqlCommand sqlCommand, int offset, int limit)
{
List<MetadataElementInstance> resultList = new List<MetadataElementInstance>();
using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
{
DataTable dataTable = new DataTable();
sqlDataAdapter.Fill(offset,limit,dataTable);
foreach(DataRow dataRow in dataTable.Rows)
{
MetadataElementInstance item = new MetadataElementInstance();
item.ID = ( int)dataRow["ID"] ;
item.AssetID = ( int)dataRow["AssetID"] ;
item.MetadataElementDefinitionID = ( int)dataRow["MetadataElementDefinitionID"] ;
if(!dataRow.IsNull("CreateBy"))
item.CreateBy = ( int)dataRow["CreateBy"] ;
if(!dataRow.IsNull("CreateDate"))
item.CreateDate = ( DateTime)dataRow["CreateDate"] ;
if(!dataRow.IsNull("ModifyBy"))
item.ModifyBy = ( int)dataRow["ModifyBy"] ;
if(!dataRow.IsNull("ModifyDate"))
item.ModifyDate = ( DateTime)dataRow["ModifyDate"] ;
registerRecord(item);
resultList.Add(item);
}
}
return resultList;
}
#region Delete
private const String SqlDelete = @"Delete From [Asset].[MetadataElementInstance]
Where
ID = @ID";
[Synchronized]
public MetadataElementInstance remove(MetadataElementInstance metadataElementInstance)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
{
sqlCommand.Parameters.AddWithValue("@ID", metadataElementInstance.ID);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(metadataElementInstance,DataMapperOperation.delete);
return registerRecord(metadataElementInstance);
}
#endregion
[Synchronized]
[TransactionRequired]
public MetadataElementInstance save( MetadataElementInstance metadataElementInstance )
{
if(exists(metadataElementInstance))
return update(metadataElementInstance);
return create(metadataElementInstance);
}
const String SqlUpdate = @"Update [Asset].[MetadataElementInstance] Set
AssetID = @AssetID,MetadataElementDefinitionID = @MetadataElementDefinitionID,CreateBy = @CreateBy,CreateDate = @CreateDate,ModifyBy = @ModifyBy,ModifyDate = @ModifyDate
Where
ID = @ID";
[TransactionRequired]
[Synchronized]
public MetadataElementInstance update(MetadataElementInstance metadataElementInstance)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
{
sqlCommand.Parameters.AddWithValue("@ID", metadataElementInstance.ID);
sqlCommand.Parameters.AddWithValue("@AssetID", metadataElementInstance.AssetID);
sqlCommand.Parameters.AddWithValue("@MetadataElementDefinitionID", metadataElementInstance.MetadataElementDefinitionID);
if(metadataElementInstance.CreateBy.HasValue)
sqlCommand.Parameters.AddWithValue("@CreateBy", metadataElementInstance.CreateBy);
else
sqlCommand.Parameters.AddWithValue("@CreateBy", DBNull.Value);
if(metadataElementInstance.CreateDate.HasValue)
sqlCommand.Parameters.AddWithValue("@CreateDate", metadataElementInstance.CreateDate);
else
sqlCommand.Parameters.AddWithValue("@CreateDate", DBNull.Value);
if(metadataElementInstance.ModifyBy.HasValue)
sqlCommand.Parameters.AddWithValue("@ModifyBy", metadataElementInstance.ModifyBy);
else
sqlCommand.Parameters.AddWithValue("@ModifyBy", DBNull.Value);
if(metadataElementInstance.ModifyDate.HasValue)
sqlCommand.Parameters.AddWithValue("@ModifyDate", metadataElementInstance.ModifyDate);
else
sqlCommand.Parameters.AddWithValue("@ModifyDate", DBNull.Value);
sqlCommand.ExecuteNonQuery();
}
}
if(metadataElementInstance.relatedMetadataElementInstanceValue != null
&& metadataElementInstance.relatedMetadataElementInstanceValue.Count > 0)
{
MetadataElementInstanceValueDataMapper dataMapper = new MetadataElementInstanceValueDataMapper(Database);
foreach(MetadataElementInstanceValue item in metadataElementInstance.relatedMetadataElementInstanceValue)
dataMapper.save(item);
}
raiseAffected(metadataElementInstance,DataMapperOperation.update);
return registerRecord(metadataElementInstance);
}
}
public partial class MetadataElementInstanceValue: DomainObject
{
protected int _iD;
protected String _valueText;
protected double? _valueNumber;
protected DateTime? _valueDate;
protected bool? _valueBoolean;
protected int? _createBy;
protected DateTime? _createDate;
protected int? _modifyBy;
protected DateTime? _modifyDate;
// parent tables
protected MetadataElementInstance _relatedMetadataElementInstance
= new MetadataElementInstance()
;
// parent tables
protected MetadataElementOption _relatedMetadataElementOption;
public MetadataElementInstanceValue(){}
public MetadataElementInstanceValue(
int
iD,int
metadataElementInstanceID,String
valueText,double
valueNumber,DateTime
valueDate,bool
valueBoolean,int
valueOption,int
createBy,DateTime
createDate,int
modifyBy,DateTime
modifyDate
)
{
this.ID = iD;
this.MetadataElementInstanceID = metadataElementInstanceID;
this.ValueText = valueText;
this.ValueNumber = valueNumber;
this.ValueDate = valueDate;
this.ValueBoolean = valueBoolean;
this.ValueOption = valueOption;
this.CreateBy = createBy;
this.CreateDate = createDate;
this.ModifyBy = modifyBy;
this.ModifyDate = modifyDate;
}
public override String getUri()
{
String uri = "AMF_dev.MetadataElementInstanceValue."
+ ID.ToString()
;
return uri;
}
public int ID
{
get { return _iD;}
set
{
_iD = value;
}
}
public int MetadataElementInstanceID
{
get
{
if(_relatedMetadataElementInstance != null)
return _relatedMetadataElementInstance.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedMetadataElementInstance == null)
_relatedMetadataElementInstance = new MetadataElementInstance();
_relatedMetadataElementInstance.ID = value;
}
}
public String ValueText
{
get { return _valueText;}
set
{
_valueText = value;
}
}
public double? ValueNumber
{
get { return _valueNumber;}
set
{
_valueNumber = value;
}
}
public DateTime? ValueDate
{
get { return _valueDate;}
set
{
_valueDate = value;
}
}
public bool? ValueBoolean
{
get { return _valueBoolean;}
set
{
_valueBoolean = value;
}
}
public int? ValueOption
{
get
{
if(_relatedMetadataElementOption != null)
return _relatedMetadataElementOption.ID;
return null;
}
set
{
if(!value.HasValue)
_relatedMetadataElementOption = null;
else
{
if(_relatedMetadataElementOption == null)
_relatedMetadataElementOption = new MetadataElementOption();
_relatedMetadataElementOption.ID = value.Value;
}
}
}
public int? CreateBy
{
get { return _createBy;}
set
{
_createBy = value;
}
}
public DateTime? CreateDate
{
get { return _createDate;}
set
{
_createDate = value;
}
}
public int? ModifyBy
{
get { return _modifyBy;}
set
{
_modifyBy = value;
}
}
public DateTime? ModifyDate
{
get { return _modifyDate;}
set
{
_modifyDate = value;
}
}
public MetadataElementInstance RelatedMetadataElementInstance
{
get { return _relatedMetadataElementInstance;}
set { _relatedMetadataElementInstance = value; }
}
public MetadataElementOption RelatedMetadataElementOption
{
get { return _relatedMetadataElementOption;}
set { _relatedMetadataElementOption = value; }
}
public override DomainObject extractSingleObject()
{
MetadataElementInstanceValue metadataElementInstanceValue = new MetadataElementInstanceValue();
metadataElementInstanceValue.ID = this.ID;
metadataElementInstanceValue.MetadataElementInstanceID = this.MetadataElementInstanceID;
metadataElementInstanceValue.ValueText = this.ValueText;
metadataElementInstanceValue.ValueNumber = this.ValueNumber;
metadataElementInstanceValue.ValueDate = this.ValueDate;
metadataElementInstanceValue.ValueBoolean = this.ValueBoolean;
metadataElementInstanceValue.ValueOption = this.ValueOption;
metadataElementInstanceValue.CreateBy = this.CreateBy;
metadataElementInstanceValue.CreateDate = this.CreateDate;
metadataElementInstanceValue.ModifyBy = this.ModifyBy;
metadataElementInstanceValue.ModifyDate = this.ModifyDate;
metadataElementInstanceValue.ActiveRecordId = this.ActiveRecordId;
return metadataElementInstanceValue;
}
}
public partial class MetadataElementInstanceValueDataMapper:TDataMapper<MetadataElementInstanceValue,SqlConnection,AMF_devDb, Weborb.Data.Management.MSSql.CommandBuilder, SqlTransaction, SqlCommand>
{
public MetadataElementInstanceValueDataMapper(){}
public MetadataElementInstanceValueDataMapper(AMF_devDb database):
base(database){}
public override String TableName
{
get
{
return "[Asset].[MetadataElementInstanceValue]";
}
}
public override Hashtable getRelation(string tableName)
{
throw new Exception("Not yet implemented");
}
private const String SqlCreate = @"Insert Into [Asset].[MetadataElementInstanceValue] (
MetadataElementInstanceID,ValueText,ValueNumber,ValueDate,ValueBoolean,ValueOption,CreateBy,CreateDate,ModifyBy,ModifyDate) Values (
@MetadataElementInstanceID,
@ValueText,
@ValueNumber,
@ValueDate,
@ValueBoolean,
@ValueOption,
@CreateBy,
@CreateDate,
@ModifyBy,
@ModifyDate);
select scope_identity();
";
[Synchronized]
public override MetadataElementInstanceValue create( MetadataElementInstanceValue metadataElementInstanceValue )
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
{
sqlCommand.Parameters.AddWithValue("@MetadataElementInstanceID", metadataElementInstanceValue.MetadataElementInstanceID);
if(metadataElementInstanceValue != null)
sqlCommand.Parameters.AddWithValue("@ValueText", metadataElementInstanceValue.ValueText);
else
sqlCommand.Parameters.AddWithValue("@ValueText", DBNull.Value);
if(metadataElementInstanceValue.ValueNumber.HasValue)
sqlCommand.Parameters.AddWithValue("@ValueNumber", metadataElementInstanceValue.ValueNumber);
else
sqlCommand.Parameters.AddWithValue("@ValueNumber", DBNull.Value);
if(metadataElementInstanceValue.ValueDate.HasValue)
sqlCommand.Parameters.AddWithValue("@ValueDate", metadataElementInstanceValue.ValueDate);
else
sqlCommand.Parameters.AddWithValue("@ValueDate", DBNull.Value);
if(metadataElementInstanceValue.ValueBoolean.HasValue)
sqlCommand.Parameters.AddWithValue("@ValueBoolean", metadataElementInstanceValue.ValueBoolean);
else
sqlCommand.Parameters.AddWithValue("@ValueBoolean", DBNull.Value);
if(metadataElementInstanceValue.ValueOption.HasValue)
sqlCommand.Parameters.AddWithValue("@ValueOption", metadataElementInstanceValue.ValueOption);
else
sqlCommand.Parameters.AddWithValue("@ValueOption", DBNull.Value);
if(metadataElementInstanceValue.CreateBy.HasValue)
sqlCommand.Parameters.AddWithValue("@CreateBy", metadataElementInstanceValue.CreateBy);
else
sqlCommand.Parameters.AddWithValue("@CreateBy", DBNull.Value);
if(metadataElementInstanceValue.CreateDate.HasValue)
sqlCommand.Parameters.AddWithValue("@CreateDate", metadataElementInstanceValue.CreateDate);
else
sqlCommand.Parameters.AddWithValue("@CreateDate", DBNull.Value);
if(metadataElementInstanceValue.ModifyBy.HasValue)
sqlCommand.Parameters.AddWithValue("@ModifyBy", metadataElementInstanceValue.ModifyBy);
else
sqlCommand.Parameters.AddWithValue("@ModifyBy", DBNull.Value);
if(metadataElementInstanceValue.ModifyDate.HasValue)
sqlCommand.Parameters.AddWithValue("@ModifyDate", metadataElementInstanceValue.ModifyDate);
else
sqlCommand.Parameters.AddWithValue("@ModifyDate", DBNull.Value);
metadataElementInstanceValue.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
}
}
raiseAffected(metadataElementInstanceValue,DataMapperOperation.create);
return registerRecord(metadataElementInstanceValue);
}
private const String SqlSelectByPk = @"Select
ID,MetadataElementInstanceID,ValueText,ValueNumber,ValueDate,ValueBoolean,ValueOption,CreateBy,CreateDate,ModifyBy,ModifyDate
From [Asset].[MetadataElementInstanceValue]
Where
ID = @ID
";
public MetadataElementInstanceValue findByPrimaryKey(
int iD
)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", iD);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
if(dataReader.Read())
return doLoad(dataReader);
}
}
}
throw new DataNotFoundException("MetadataElementInstanceValue not found, search by primary key");
}
public bool exists(MetadataElementInstanceValue metadataElementInstanceValue)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", metadataElementInstanceValue.ID);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
return dataReader.Read();
}
}
}
}
private const string CheckInSql = @"
[MetadataElementInstanceValue].[ID] = @CheckInID";
protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
{
MetadataElementInstanceValue _MetadataElementInstanceValue = (MetadataElementInstanceValue)domainObject;
SqlCommand sqlCommand = Database.CreateCommand(ModifyQueryForCheckIn(sqlQuery,CheckInSql));
sqlCommand.Parameters.AddWithValue("@CheckInID", _MetadataElementInstanceValue.ID);
return sqlCommand;
}
protected override MetadataElementInstanceValue doLoad(IDataReader dataReader)
{
MetadataElementInstanceValue metadataElementInstanceValue = new MetadataElementInstanceValue();
metadataElementInstanceValue.ID = (int) dataReader.GetValue(0);
metadataElementInstanceValue.MetadataElementInstanceID = (int) dataReader.GetValue(1);
if(!dataReader.IsDBNull(2))
metadataElementInstanceValue.ValueText = (String) dataReader.GetValue(2);
if(!dataReader.IsDBNull(3))
metadataElementInstanceValue.ValueNumber = (double) dataReader.GetValue(3);
if(!dataReader.IsDBNull(4))
metadataElementInstanceValue.ValueDate = (DateTime) dataReader.GetValue(4);
if(!dataReader.IsDBNull(5))
metadataElementInstanceValue.ValueBoolean = (bool) dataReader.GetValue(5);
if(!dataReader.IsDBNull(6))
metadataElementInstanceValue.ValueOption = (int) dataReader.GetValue(6);
if(!dataReader.IsDBNull(7))
metadataElementInstanceValue.CreateBy = (int) dataReader.GetValue(7);
if(!dataReader.IsDBNull(8))
metadataElementInstanceValue.CreateDate = (DateTime) dataReader.GetValue(8);
if(!dataReader.IsDBNull(9))
metadataElementInstanceValue.ModifyBy = (int) dataReader.GetValue(9);
if(!dataReader.IsDBNull(10))
metadataElementInstanceValue.ModifyDate = (DateTime) dataReader.GetValue(10);
return registerRecord(metadataElementInstanceValue);
}
protected override MetadataElementInstanceValue doLoad(Hashtable hashtable)
{
MetadataElementInstanceValue metadataElementInstanceValue = new MetadataElementInstanceValue();
if(hashtable.ContainsKey("ID"))
metadataElementInstanceValue.ID = ( int)hashtable["ID"];
if(hashtable.ContainsKey("MetadataElementInstanceID"))
metadataElementInstanceValue.MetadataElementInstanceID = ( int)hashtable["MetadataElementInstanceID"];
if(hashtable.ContainsKey("ValueText"))
metadataElementInstanceValue.ValueText = ( String)hashtable["ValueText"];
if(hashtable.ContainsKey("ValueNumber"))
metadataElementInstanceValue.ValueNumber = ( double)hashtable["ValueNumber"];
if(hashtable.ContainsKey("ValueDate"))
metadataElementInstanceValue.ValueDate = ( DateTime)hashtable["ValueDate"];
if(hashtable.ContainsKey("ValueBoolean"))
metadataElementInstanceValue.ValueBoolean = ( bool)hashtable["ValueBoolean"];
if(hashtable.ContainsKey("ValueOption"))
metadataElementInstanceValue.ValueOption = ( int)hashtable["ValueOption"];
if(hashtable.ContainsKey("CreateBy"))
metadataElementInstanceValue.CreateBy = ( int)hashtable["CreateBy"];
if(hashtable.ContainsKey("CreateDate"))
metadataElementInstanceValue.CreateDate = ( DateTime)hashtable["CreateDate"];
if(hashtable.ContainsKey("ModifyBy"))
metadataElementInstanceValue.ModifyBy = ( int)hashtable["ModifyBy"];
if(hashtable.ContainsKey("ModifyDate"))
metadataElementInstanceValue.ModifyDate = ( DateTime)hashtable["ModifyDate"];
return metadataElementInstanceValue;
}
protected override List<MetadataElementInstanceValue> fill(SqlCommand sqlCommand, int offset, int limit)
{
List<MetadataElementInstanceValue> resultList = new List<MetadataElementInstanceValue>();
using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
{
DataTable dataTable = new DataTable();
sqlDataAdapter.Fill(offset,limit,dataTable);
foreach(DataRow dataRow in dataTable.Rows)
{
MetadataElementInstanceValue item = new MetadataElementInstanceValue();
item.ID = ( int)dataRow["ID"] ;
item.MetadataElementInstanceID = ( int)dataRow["MetadataElementInstanceID"] ;
if(!dataRow.IsNull("ValueText"))
item.ValueText = ( String)dataRow["ValueText"] ;
if(!dataRow.IsNull("ValueNumber"))
item.ValueNumber = ( double)dataRow["ValueNumber"] ;
if(!dataRow.IsNull("ValueDate"))
item.ValueDate = ( DateTime)dataRow["ValueDate"] ;
if(!dataRow.IsNull("ValueBoolean"))
item.ValueBoolean = ( bool)dataRow["ValueBoolean"] ;
if(!dataRow.IsNull("ValueOption"))
item.ValueOption = ( int)dataRow["ValueOption"] ;
if(!dataRow.IsNull("CreateBy"))
item.CreateBy = ( int)dataRow["CreateBy"] ;
if(!dataRow.IsNull("CreateDate"))
item.CreateDate = ( DateTime)dataRow["CreateDate"] ;
if(!dataRow.IsNull("ModifyBy"))
item.ModifyBy = ( int)dataRow["ModifyBy"] ;
if(!dataRow.IsNull("ModifyDate"))
item.ModifyDate = ( DateTime)dataRow["ModifyDate"] ;
registerRecord(item);
resultList.Add(item);
}
}
return resultList;
}
#region Delete
private const String SqlDelete = @"Delete From [Asset].[MetadataElementInstanceValue]
Where
ID = @ID";
[Synchronized]
public MetadataElementInstanceValue remove(MetadataElementInstanceValue metadataElementInstanceValue)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
{
sqlCommand.Parameters.AddWithValue("@ID", metadataElementInstanceValue.ID);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(metadataElementInstanceValue,DataMapperOperation.delete);
return registerRecord(metadataElementInstanceValue);
}
#endregion
[Synchronized]
[TransactionRequired]
public MetadataElementInstanceValue save( MetadataElementInstanceValue metadataElementInstanceValue )
{
if(exists(metadataElementInstanceValue))
return update(metadataElementInstanceValue);
return create(metadataElementInstanceValue);
}
const String SqlUpdate = @"Update [Asset].[MetadataElementInstanceValue] Set
MetadataElementInstanceID = @MetadataElementInstanceID,ValueText = @ValueText,ValueNumber = @ValueNumber,ValueDate = @ValueDate,ValueBoolean = @ValueBoolean,ValueOption = @ValueOption,CreateBy = @CreateBy,CreateDate = @CreateDate,ModifyBy = @ModifyBy,ModifyDate = @ModifyDate
Where
ID = @ID";
[Synchronized]
public MetadataElementInstanceValue update(MetadataElementInstanceValue metadataElementInstanceValue)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
{
sqlCommand.Parameters.AddWithValue("@ID", metadataElementInstanceValue.ID);
sqlCommand.Parameters.AddWithValue("@MetadataElementInstanceID", metadataElementInstanceValue.MetadataElementInstanceID);
if(metadataElementInstanceValue.ValueText != null)
sqlCommand.Parameters.AddWithValue("@ValueText", metadataElementInstanceValue.ValueText);
else
sqlCommand.Parameters.AddWithValue("@ValueText", DBNull.Value);
if(metadataElementInstanceValue.ValueNumber.HasValue)
sqlCommand.Parameters.AddWithValue("@ValueNumber", metadataElementInstanceValue.ValueNumber);
else
sqlCommand.Parameters.AddWithValue("@ValueNumber", DBNull.Value);
if(metadataElementInstanceValue.ValueDate.HasValue)
sqlCommand.Parameters.AddWithValue("@ValueDate", metadataElementInstanceValue.ValueDate);
else
sqlCommand.Parameters.AddWithValue("@ValueDate", DBNull.Value);
if(metadataElementInstanceValue.ValueBoolean.HasValue)
sqlCommand.Parameters.AddWithValue("@ValueBoolean", metadataElementInstanceValue.ValueBoolean);
else
sqlCommand.Parameters.AddWithValue("@ValueBoolean", DBNull.Value);
if(metadataElementInstanceValue.ValueOption.HasValue)
sqlCommand.Parameters.AddWithValue("@ValueOption", metadataElementInstanceValue.ValueOption);
else
sqlCommand.Parameters.AddWithValue("@ValueOption", DBNull.Value);
if(metadataElementInstanceValue.CreateBy.HasValue)
sqlCommand.Parameters.AddWithValue("@CreateBy", metadataElementInstanceValue.CreateBy);
else
sqlCommand.Parameters.AddWithValue("@CreateBy", DBNull.Value);
if(metadataElementInstanceValue.CreateDate.HasValue)
sqlCommand.Parameters.AddWithValue("@CreateDate", metadataElementInstanceValue.CreateDate);
else
sqlCommand.Parameters.AddWithValue("@CreateDate", DBNull.Value);
if(metadataElementInstanceValue.ModifyBy.HasValue)
sqlCommand.Parameters.AddWithValue("@ModifyBy", metadataElementInstanceValue.ModifyBy);
else
sqlCommand.Parameters.AddWithValue("@ModifyBy", DBNull.Value);
if(metadataElementInstanceValue.ModifyDate.HasValue)
sqlCommand.Parameters.AddWithValue("@ModifyDate", metadataElementInstanceValue.ModifyDate);
else
sqlCommand.Parameters.AddWithValue("@ModifyDate", DBNull.Value);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(metadataElementInstanceValue,DataMapperOperation.update);
return registerRecord(metadataElementInstanceValue);
}
}
public partial class MetadataElementOption: DomainObject
{
protected int _iD;
protected String _nameResourceCode;
protected int _createBy;
protected DateTime _createDate;
protected int _modifyBy;
protected DateTime _modifyDate;
// parent tables
protected MetadataElementDefinition _relatedMetadataElementDefinition
= new MetadataElementDefinition()
;
public MetadataElementOption(){}
public MetadataElementOption(
int
iD,int
metadataElementDefinitionID,String
nameResourceCode,int
createBy,DateTime
createDate,int
modifyBy,DateTime
modifyDate
)
{
this.ID = iD;
this.MetadataElementDefinitionID = metadataElementDefinitionID;
this.NameResourceCode = nameResourceCode;
this.CreateBy = createBy;
this.CreateDate = createDate;
this.ModifyBy = modifyBy;
this.ModifyDate = modifyDate;
}
public override String getUri()
{
String uri = "AMF_dev.MetadataElementOption."
+ ID.ToString()
;
return uri;
}
public int ID
{
get { return _iD;}
set
{
_iD = value;
}
}
public int MetadataElementDefinitionID
{
get
{
if(_relatedMetadataElementDefinition != null)
return _relatedMetadataElementDefinition.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedMetadataElementDefinition == null)
_relatedMetadataElementDefinition = new MetadataElementDefinition();
_relatedMetadataElementDefinition.ID = value;
}
}
public String NameResourceCode
{
get { return _nameResourceCode;}
set
{
_nameResourceCode = value;
}
}
public int CreateBy
{
get { return _createBy;}
set
{
_createBy = value;
}
}
public DateTime CreateDate
{
get { return _createDate;}
set
{
_createDate = value;
}
}
public int ModifyBy
{
get { return _modifyBy;}
set
{
_modifyBy = value;
}
}
public DateTime ModifyDate
{
get { return _modifyDate;}
set
{
_modifyDate = value;
}
}
public MetadataElementDefinition RelatedMetadataElementDefinition
{
get { return _relatedMetadataElementDefinition;}
set { _relatedMetadataElementDefinition = value; }
}
public override DomainObject extractSingleObject()
{
MetadataElementOption metadataElementOption = new MetadataElementOption();
metadataElementOption.ID = this.ID;
metadataElementOption.MetadataElementDefinitionID = this.MetadataElementDefinitionID;
metadataElementOption.NameResourceCode = this.NameResourceCode;
metadataElementOption.CreateBy = this.CreateBy;
metadataElementOption.CreateDate = this.CreateDate;
metadataElementOption.ModifyBy = this.ModifyBy;
metadataElementOption.ModifyDate = this.ModifyDate;
metadataElementOption.ActiveRecordId = this.ActiveRecordId;
return metadataElementOption;
}
// one to many relation
private List<MetadataElementDefinitionMetadataElementOption> _relatedMetadataElementDefinitionMetadataElementOption;
public List<MetadataElementDefinitionMetadataElementOption> relatedMetadataElementDefinitionMetadataElementOption
{
get { return _relatedMetadataElementDefinitionMetadataElementOption;}
set { _relatedMetadataElementDefinitionMetadataElementOption = value; }
}
// one to many relation
private List<MetadataElementInstanceValue> _relatedMetadataElementInstanceValue;
public List<MetadataElementInstanceValue> relatedMetadataElementInstanceValue
{
get { return _relatedMetadataElementInstanceValue;}
set { _relatedMetadataElementInstanceValue = value; }
}
}
public partial class MetadataElementOptionDataMapper:TDataMapper<MetadataElementOption,SqlConnection,AMF_devDb, Weborb.Data.Management.MSSql.CommandBuilder, SqlTransaction, SqlCommand>
{
public MetadataElementOptionDataMapper(){}
public MetadataElementOptionDataMapper(AMF_devDb database):
base(database){}
public override String TableName
{
get
{
return "[Asset].[MetadataElementOption]";
}
}
public override Hashtable getRelation(string tableName)
{
throw new Exception("Not yet implemented");
}
private const String SqlCreate = @"Insert Into [Asset].[MetadataElementOption] (
MetadataElementDefinitionID,NameResourceCode,CreateBy,CreateDate,ModifyBy,ModifyDate) Values (
@MetadataElementDefinitionID,
@NameResourceCode,
@CreateBy,
@CreateDate,
@ModifyBy,
@ModifyDate);
select scope_identity();
";
[TransactionRequired]
[Synchronized]
public override MetadataElementOption create( MetadataElementOption metadataElementOption )
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
{
sqlCommand.Parameters.AddWithValue("@MetadataElementDefinitionID", metadataElementOption.MetadataElementDefinitionID);
sqlCommand.Parameters.AddWithValue("@NameResourceCode", metadataElementOption.NameResourceCode);
sqlCommand.Parameters.AddWithValue("@CreateBy", metadataElementOption.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", metadataElementOption.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", metadataElementOption.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", metadataElementOption.ModifyDate);
metadataElementOption.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
}
}
if(metadataElementOption.relatedMetadataElementDefinitionMetadataElementOption != null
&& metadataElementOption.relatedMetadataElementDefinitionMetadataElementOption.Count > 0)
{
MetadataElementDefinitionMetadataElementOptionDataMapper dataMapper = new MetadataElementDefinitionMetadataElementOptionDataMapper(Database);
foreach(MetadataElementDefinitionMetadataElementOption item in metadataElementOption.relatedMetadataElementDefinitionMetadataElementOption)
dataMapper.create(item);
}
if(metadataElementOption.relatedMetadataElementInstanceValue != null
&& metadataElementOption.relatedMetadataElementInstanceValue.Count > 0)
{
MetadataElementInstanceValueDataMapper dataMapper = new MetadataElementInstanceValueDataMapper(Database);
foreach(MetadataElementInstanceValue item in metadataElementOption.relatedMetadataElementInstanceValue)
dataMapper.create(item);
}
raiseAffected(metadataElementOption,DataMapperOperation.create);
return registerRecord(metadataElementOption);
}
private const String SqlSelectByPk = @"Select
ID,MetadataElementDefinitionID,NameResourceCode,CreateBy,CreateDate,ModifyBy,ModifyDate
From [Asset].[MetadataElementOption]
Where
ID = @ID
";
public MetadataElementOption findByPrimaryKey(
int iD
)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", iD);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
if(dataReader.Read())
return doLoad(dataReader);
}
}
}
throw new DataNotFoundException("MetadataElementOption not found, search by primary key");
}
public bool exists(MetadataElementOption metadataElementOption)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", metadataElementOption.ID);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
return dataReader.Read();
}
}
}
}
private const string CheckInSql = @"
[MetadataElementOption].[ID] = @CheckInID";
protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
{
MetadataElementOption _MetadataElementOption = (MetadataElementOption)domainObject;
SqlCommand sqlCommand = Database.CreateCommand(ModifyQueryForCheckIn(sqlQuery,CheckInSql));
sqlCommand.Parameters.AddWithValue("@CheckInID", _MetadataElementOption.ID);
return sqlCommand;
}
protected override MetadataElementOption doLoad(IDataReader dataReader)
{
MetadataElementOption metadataElementOption = new MetadataElementOption();
metadataElementOption.ID = (int) dataReader.GetValue(0);
metadataElementOption.MetadataElementDefinitionID = (int) dataReader.GetValue(1);
metadataElementOption.NameResourceCode = (String) dataReader.GetValue(2);
metadataElementOption.CreateBy = (int) dataReader.GetValue(3);
metadataElementOption.CreateDate = (DateTime) dataReader.GetValue(4);
metadataElementOption.ModifyBy = (int) dataReader.GetValue(5);
metadataElementOption.ModifyDate = (DateTime) dataReader.GetValue(6);
return registerRecord(metadataElementOption);
}
protected override MetadataElementOption doLoad(Hashtable hashtable)
{
MetadataElementOption metadataElementOption = new MetadataElementOption();
if(hashtable.ContainsKey("ID"))
metadataElementOption.ID = ( int)hashtable["ID"];
if(hashtable.ContainsKey("MetadataElementDefinitionID"))
metadataElementOption.MetadataElementDefinitionID = ( int)hashtable["MetadataElementDefinitionID"];
if(hashtable.ContainsKey("NameResourceCode"))
metadataElementOption.NameResourceCode = ( String)hashtable["NameResourceCode"];
if(hashtable.ContainsKey("CreateBy"))
metadataElementOption.CreateBy = ( int)hashtable["CreateBy"];
if(hashtable.ContainsKey("CreateDate"))
metadataElementOption.CreateDate = ( DateTime)hashtable["CreateDate"];
if(hashtable.ContainsKey("ModifyBy"))
metadataElementOption.ModifyBy = ( int)hashtable["ModifyBy"];
if(hashtable.ContainsKey("ModifyDate"))
metadataElementOption.ModifyDate = ( DateTime)hashtable["ModifyDate"];
return metadataElementOption;
}
protected override List<MetadataElementOption> fill(SqlCommand sqlCommand, int offset, int limit)
{
List<MetadataElementOption> resultList = new List<MetadataElementOption>();
using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
{
DataTable dataTable = new DataTable();
sqlDataAdapter.Fill(offset,limit,dataTable);
foreach(DataRow dataRow in dataTable.Rows)
{
MetadataElementOption item = new MetadataElementOption();
item.ID = ( int)dataRow["ID"] ;
item.MetadataElementDefinitionID = ( int)dataRow["MetadataElementDefinitionID"] ;
item.NameResourceCode = ( String)dataRow["NameResourceCode"] ;
item.CreateBy = ( int)dataRow["CreateBy"] ;
item.CreateDate = ( DateTime)dataRow["CreateDate"] ;
item.ModifyBy = ( int)dataRow["ModifyBy"] ;
item.ModifyDate = ( DateTime)dataRow["ModifyDate"] ;
registerRecord(item);
resultList.Add(item);
}
}
return resultList;
}
#region Delete
private const String SqlDelete = @"Delete From [Asset].[MetadataElementOption]
Where
ID = @ID";
[Synchronized]
public MetadataElementOption remove(MetadataElementOption metadataElementOption)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
{
sqlCommand.Parameters.AddWithValue("@ID", metadataElementOption.ID);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(metadataElementOption,DataMapperOperation.delete);
return registerRecord(metadataElementOption);
}
#endregion
[Synchronized]
[TransactionRequired]
public MetadataElementOption save( MetadataElementOption metadataElementOption )
{
if(exists(metadataElementOption))
return update(metadataElementOption);
return create(metadataElementOption);
}
const String SqlUpdate = @"Update [Asset].[MetadataElementOption] Set
MetadataElementDefinitionID = @MetadataElementDefinitionID,NameResourceCode = @NameResourceCode,CreateBy = @CreateBy,CreateDate = @CreateDate,ModifyBy = @ModifyBy,ModifyDate = @ModifyDate
Where
ID = @ID";
[TransactionRequired]
[Synchronized]
public MetadataElementOption update(MetadataElementOption metadataElementOption)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
{
sqlCommand.Parameters.AddWithValue("@ID", metadataElementOption.ID);
sqlCommand.Parameters.AddWithValue("@MetadataElementDefinitionID", metadataElementOption.MetadataElementDefinitionID);
sqlCommand.Parameters.AddWithValue("@NameResourceCode", metadataElementOption.NameResourceCode);
sqlCommand.Parameters.AddWithValue("@CreateBy", metadataElementOption.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", metadataElementOption.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", metadataElementOption.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", metadataElementOption.ModifyDate);
sqlCommand.ExecuteNonQuery();
}
}
if(metadataElementOption.relatedMetadataElementDefinitionMetadataElementOption != null
&& metadataElementOption.relatedMetadataElementDefinitionMetadataElementOption.Count > 0)
{
MetadataElementDefinitionMetadataElementOptionDataMapper dataMapper = new MetadataElementDefinitionMetadataElementOptionDataMapper(Database);
foreach(MetadataElementDefinitionMetadataElementOption item in metadataElementOption.relatedMetadataElementDefinitionMetadataElementOption)
dataMapper.save(item);
}
if(metadataElementOption.relatedMetadataElementInstanceValue != null
&& metadataElementOption.relatedMetadataElementInstanceValue.Count > 0)
{
MetadataElementInstanceValueDataMapper dataMapper = new MetadataElementInstanceValueDataMapper(Database);
foreach(MetadataElementInstanceValue item in metadataElementOption.relatedMetadataElementInstanceValue)
dataMapper.save(item);
}
raiseAffected(metadataElementOption,DataMapperOperation.update);
return registerRecord(metadataElementOption);
}
}
public partial class Region: DomainObject
{
protected int _iD;
protected String _nameResourceCode;
protected int _createBy;
protected DateTime _createDate;
protected int _modifyBy;
protected DateTime _modifyDate;
public Region(){}
public Region(
int
iD,String
nameResourceCode,int
createBy,DateTime
createDate,int
modifyBy,DateTime
modifyDate
)
{
this.ID = iD;
this.NameResourceCode = nameResourceCode;
this.CreateBy = createBy;
this.CreateDate = createDate;
this.ModifyBy = modifyBy;
this.ModifyDate = modifyDate;
}
public override String getUri()
{
String uri = "AMF_dev.Region."
+ ID.ToString()
;
return uri;
}
public int ID
{
get { return _iD;}
set
{
_iD = value;
}
}
public String NameResourceCode
{
get { return _nameResourceCode;}
set
{
_nameResourceCode = value;
}
}
public int CreateBy
{
get { return _createBy;}
set
{
_createBy = value;
}
}
public DateTime CreateDate
{
get { return _createDate;}
set
{
_createDate = value;
}
}
public int ModifyBy
{
get { return _modifyBy;}
set
{
_modifyBy = value;
}
}
public DateTime ModifyDate
{
get { return _modifyDate;}
set
{
_modifyDate = value;
}
}
public override DomainObject extractSingleObject()
{
Region region = new Region();
region.ID = this.ID;
region.NameResourceCode = this.NameResourceCode;
region.CreateBy = this.CreateBy;
region.CreateDate = this.CreateDate;
region.ModifyBy = this.ModifyBy;
region.ModifyDate = this.ModifyDate;
region.ActiveRecordId = this.ActiveRecordId;
return region;
}
// one to many relation
private List<RegionAvailability> _relatedRegionAvailability;
public List<RegionAvailability> relatedRegionAvailability
{
get { return _relatedRegionAvailability;}
set { _relatedRegionAvailability = value; }
}
}
public partial class RegionDataMapper:TDataMapper<Region,SqlConnection,AMF_devDb, Weborb.Data.Management.MSSql.CommandBuilder, SqlTransaction, SqlCommand>
{
public RegionDataMapper(){}
public RegionDataMapper(AMF_devDb database):
base(database){}
public override String TableName
{
get
{
return "[Global].[Region]";
}
}
public override Hashtable getRelation(string tableName)
{
throw new Exception("Not yet implemented");
}
private const String SqlCreate = @"Insert Into [Global].[Region] (
NameResourceCode,CreateBy,CreateDate,ModifyBy,ModifyDate) Values (
@NameResourceCode,
@CreateBy,
@CreateDate,
@ModifyBy,
@ModifyDate);
select scope_identity();
";
[TransactionRequired]
[Synchronized]
public override Region create( Region region )
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
{
sqlCommand.Parameters.AddWithValue("@NameResourceCode", region.NameResourceCode);
sqlCommand.Parameters.AddWithValue("@CreateBy", region.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", region.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", region.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", region.ModifyDate);
region.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
}
}
if(region.relatedRegionAvailability != null
&& region.relatedRegionAvailability.Count > 0)
{
RegionAvailabilityDataMapper dataMapper = new RegionAvailabilityDataMapper(Database);
foreach(RegionAvailability item in region.relatedRegionAvailability)
dataMapper.create(item);
}
raiseAffected(region,DataMapperOperation.create);
return registerRecord(region);
}
private const String SqlSelectByPk = @"Select
ID,NameResourceCode,CreateBy,CreateDate,ModifyBy,ModifyDate
From [Global].[Region]
Where
ID = @ID
";
public Region findByPrimaryKey(
int iD
)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", iD);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
if(dataReader.Read())
return doLoad(dataReader);
}
}
}
throw new DataNotFoundException("Region not found, search by primary key");
}
public bool exists(Region region)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", region.ID);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
return dataReader.Read();
}
}
}
}
private const string CheckInSql = @"
[Region].[ID] = @CheckInID";
protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
{
Region _Region = (Region)domainObject;
SqlCommand sqlCommand = Database.CreateCommand(ModifyQueryForCheckIn(sqlQuery,CheckInSql));
sqlCommand.Parameters.AddWithValue("@CheckInID", _Region.ID);
return sqlCommand;
}
protected override Region doLoad(IDataReader dataReader)
{
Region region = new Region();
region.ID = (int) dataReader.GetValue(0);
region.NameResourceCode = (String) dataReader.GetValue(1);
region.CreateBy = (int) dataReader.GetValue(2);
region.CreateDate = (DateTime) dataReader.GetValue(3);
region.ModifyBy = (int) dataReader.GetValue(4);
region.ModifyDate = (DateTime) dataReader.GetValue(5);
return registerRecord(region);
}
protected override Region doLoad(Hashtable hashtable)
{
Region region = new Region();
if(hashtable.ContainsKey("ID"))
region.ID = ( int)hashtable["ID"];
if(hashtable.ContainsKey("NameResourceCode"))
region.NameResourceCode = ( String)hashtable["NameResourceCode"];
if(hashtable.ContainsKey("CreateBy"))
region.CreateBy = ( int)hashtable["CreateBy"];
if(hashtable.ContainsKey("CreateDate"))
region.CreateDate = ( DateTime)hashtable["CreateDate"];
if(hashtable.ContainsKey("ModifyBy"))
region.ModifyBy = ( int)hashtable["ModifyBy"];
if(hashtable.ContainsKey("ModifyDate"))
region.ModifyDate = ( DateTime)hashtable["ModifyDate"];
return region;
}
protected override List<Region> fill(SqlCommand sqlCommand, int offset, int limit)
{
List<Region> resultList = new List<Region>();
using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
{
DataTable dataTable = new DataTable();
sqlDataAdapter.Fill(offset,limit,dataTable);
foreach(DataRow dataRow in dataTable.Rows)
{
Region item = new Region();
item.ID = ( int)dataRow["ID"] ;
item.NameResourceCode = ( String)dataRow["NameResourceCode"] ;
item.CreateBy = ( int)dataRow["CreateBy"] ;
item.CreateDate = ( DateTime)dataRow["CreateDate"] ;
item.ModifyBy = ( int)dataRow["ModifyBy"] ;
item.ModifyDate = ( DateTime)dataRow["ModifyDate"] ;
registerRecord(item);
resultList.Add(item);
}
}
return resultList;
}
#region Delete
private const String SqlDelete = @"Delete From [Global].[Region]
Where
ID = @ID";
[Synchronized]
public Region remove(Region region)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
{
sqlCommand.Parameters.AddWithValue("@ID", region.ID);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(region,DataMapperOperation.delete);
return registerRecord(region);
}
#endregion
[Synchronized]
[TransactionRequired]
public Region save( Region region )
{
if(exists(region))
return update(region);
return create(region);
}
const String SqlUpdate = @"Update [Global].[Region] Set
NameResourceCode = @NameResourceCode,CreateBy = @CreateBy,CreateDate = @CreateDate,ModifyBy = @ModifyBy,ModifyDate = @ModifyDate
Where
ID = @ID";
[TransactionRequired]
[Synchronized]
public Region update(Region region)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
{
sqlCommand.Parameters.AddWithValue("@ID", region.ID);
sqlCommand.Parameters.AddWithValue("@NameResourceCode", region.NameResourceCode);
sqlCommand.Parameters.AddWithValue("@CreateBy", region.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", region.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", region.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", region.ModifyDate);
sqlCommand.ExecuteNonQuery();
}
}
if(region.relatedRegionAvailability != null
&& region.relatedRegionAvailability.Count > 0)
{
RegionAvailabilityDataMapper dataMapper = new RegionAvailabilityDataMapper(Database);
foreach(RegionAvailability item in region.relatedRegionAvailability)
dataMapper.save(item);
}
raiseAffected(region,DataMapperOperation.update);
return registerRecord(region);
}
}
public partial class RegionAvailability: DomainObject
{
protected int _iD;
protected int _createBy;
protected DateTime _createDate;
protected int _modifyBy;
protected DateTime _modifyDate;
// parent tables
protected Asset _relatedAsset
= new Asset()
;
// parent tables
protected Region _relatedRegion
= new Region()
;
public RegionAvailability(){}
public RegionAvailability(
int
iD,int
regionID,int
assetID,int
createBy,DateTime
createDate,int
modifyBy,DateTime
modifyDate
)
{
this.ID = iD;
this.RegionID = regionID;
this.AssetID = assetID;
this.CreateBy = createBy;
this.CreateDate = createDate;
this.ModifyBy = modifyBy;
this.ModifyDate = modifyDate;
}
public override String getUri()
{
String uri = "AMF_dev.RegionAvailability."
+ ID.ToString()
;
return uri;
}
public int ID
{
get { return _iD;}
set
{
_iD = value;
}
}
public int RegionID
{
get
{
if(_relatedRegion != null)
return _relatedRegion.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedRegion == null)
_relatedRegion = new Region();
_relatedRegion.ID = value;
}
}
public int AssetID
{
get
{
if(_relatedAsset != null)
return _relatedAsset.ID;
throw new NullReferenceException("Parent instance not initialized ");
}
set
{
if(_relatedAsset == null)
_relatedAsset = new Asset();
_relatedAsset.ID = value;
}
}
public int CreateBy
{
get { return _createBy;}
set
{
_createBy = value;
}
}
public DateTime CreateDate
{
get { return _createDate;}
set
{
_createDate = value;
}
}
public int ModifyBy
{
get { return _modifyBy;}
set
{
_modifyBy = value;
}
}
public DateTime ModifyDate
{
get { return _modifyDate;}
set
{
_modifyDate = value;
}
}
public Asset RelatedAsset
{
get { return _relatedAsset;}
set { _relatedAsset = value; }
}
public Region RelatedRegion
{
get { return _relatedRegion;}
set { _relatedRegion = value; }
}
public override DomainObject extractSingleObject()
{
RegionAvailability regionAvailability = new RegionAvailability();
regionAvailability.ID = this.ID;
regionAvailability.RegionID = this.RegionID;
regionAvailability.AssetID = this.AssetID;
regionAvailability.CreateBy = this.CreateBy;
regionAvailability.CreateDate = this.CreateDate;
regionAvailability.ModifyBy = this.ModifyBy;
regionAvailability.ModifyDate = this.ModifyDate;
regionAvailability.ActiveRecordId = this.ActiveRecordId;
return regionAvailability;
}
}
public partial class RegionAvailabilityDataMapper:TDataMapper<RegionAvailability,SqlConnection,AMF_devDb, Weborb.Data.Management.MSSql.CommandBuilder, SqlTransaction, SqlCommand>
{
public RegionAvailabilityDataMapper(){}
public RegionAvailabilityDataMapper(AMF_devDb database):
base(database){}
public override String TableName
{
get
{
return "[Asset].[RegionAvailability]";
}
}
public override Hashtable getRelation(string tableName)
{
throw new Exception("Not yet implemented");
}
private const String SqlCreate = @"Insert Into [Asset].[RegionAvailability] (
RegionID,AssetID,CreateBy,CreateDate,ModifyBy,ModifyDate) Values (
@RegionID,
@AssetID,
@CreateBy,
@CreateDate,
@ModifyBy,
@ModifyDate);
select scope_identity();
";
[Synchronized]
public override RegionAvailability create( RegionAvailability regionAvailability )
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
{
sqlCommand.Parameters.AddWithValue("@RegionID", regionAvailability.RegionID);
sqlCommand.Parameters.AddWithValue("@AssetID", regionAvailability.AssetID);
sqlCommand.Parameters.AddWithValue("@CreateBy", regionAvailability.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", regionAvailability.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", regionAvailability.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", regionAvailability.ModifyDate);
regionAvailability.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
}
}
raiseAffected(regionAvailability,DataMapperOperation.create);
return registerRecord(regionAvailability);
}
private const String SqlSelectByPk = @"Select
ID,RegionID,AssetID,CreateBy,CreateDate,ModifyBy,ModifyDate
From [Asset].[RegionAvailability]
Where
ID = @ID
";
public RegionAvailability findByPrimaryKey(
int iD
)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", iD);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
if(dataReader.Read())
return doLoad(dataReader);
}
}
}
throw new DataNotFoundException("RegionAvailability not found, search by primary key");
}
public bool exists(RegionAvailability regionAvailability)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
{
sqlCommand.Parameters.AddWithValue("@ID", regionAvailability.ID);
using(IDataReader dataReader = sqlCommand.ExecuteReader())
{
return dataReader.Read();
}
}
}
}
private const string CheckInSql = @"
[RegionAvailability].[ID] = @CheckInID";
protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
{
RegionAvailability _RegionAvailability = (RegionAvailability)domainObject;
SqlCommand sqlCommand = Database.CreateCommand(ModifyQueryForCheckIn(sqlQuery,CheckInSql));
sqlCommand.Parameters.AddWithValue("@CheckInID", _RegionAvailability.ID);
return sqlCommand;
}
protected override RegionAvailability doLoad(IDataReader dataReader)
{
RegionAvailability regionAvailability = new RegionAvailability();
regionAvailability.ID = (int) dataReader.GetValue(0);
regionAvailability.RegionID = (int) dataReader.GetValue(1);
regionAvailability.AssetID = (int) dataReader.GetValue(2);
regionAvailability.CreateBy = (int) dataReader.GetValue(3);
regionAvailability.CreateDate = (DateTime) dataReader.GetValue(4);
regionAvailability.ModifyBy = (int) dataReader.GetValue(5);
regionAvailability.ModifyDate = (DateTime) dataReader.GetValue(6);
return registerRecord(regionAvailability);
}
protected override RegionAvailability doLoad(Hashtable hashtable)
{
RegionAvailability regionAvailability = new RegionAvailability();
if(hashtable.ContainsKey("ID"))
regionAvailability.ID = ( int)hashtable["ID"];
if(hashtable.ContainsKey("RegionID"))
regionAvailability.RegionID = ( int)hashtable["RegionID"];
if(hashtable.ContainsKey("AssetID"))
regionAvailability.AssetID = ( int)hashtable["AssetID"];
if(hashtable.ContainsKey("CreateBy"))
regionAvailability.CreateBy = ( int)hashtable["CreateBy"];
if(hashtable.ContainsKey("CreateDate"))
regionAvailability.CreateDate = ( DateTime)hashtable["CreateDate"];
if(hashtable.ContainsKey("ModifyBy"))
regionAvailability.ModifyBy = ( int)hashtable["ModifyBy"];
if(hashtable.ContainsKey("ModifyDate"))
regionAvailability.ModifyDate = ( DateTime)hashtable["ModifyDate"];
return regionAvailability;
}
protected override List<RegionAvailability> fill(SqlCommand sqlCommand, int offset, int limit)
{
List<RegionAvailability> resultList = new List<RegionAvailability>();
using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
{
DataTable dataTable = new DataTable();
sqlDataAdapter.Fill(offset,limit,dataTable);
foreach(DataRow dataRow in dataTable.Rows)
{
RegionAvailability item = new RegionAvailability();
item.ID = ( int)dataRow["ID"] ;
item.RegionID = ( int)dataRow["RegionID"] ;
item.AssetID = ( int)dataRow["AssetID"] ;
item.CreateBy = ( int)dataRow["CreateBy"] ;
item.CreateDate = ( DateTime)dataRow["CreateDate"] ;
item.ModifyBy = ( int)dataRow["ModifyBy"] ;
item.ModifyDate = ( DateTime)dataRow["ModifyDate"] ;
registerRecord(item);
resultList.Add(item);
}
}
return resultList;
}
#region Delete
private const String SqlDelete = @"Delete From [Asset].[RegionAvailability]
Where
ID = @ID";
[Synchronized]
public RegionAvailability remove(RegionAvailability regionAvailability)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
{
sqlCommand.Parameters.AddWithValue("@ID", regionAvailability.ID);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(regionAvailability,DataMapperOperation.delete);
return registerRecord(regionAvailability);
}
#endregion
[Synchronized]
[TransactionRequired]
public RegionAvailability save( RegionAvailability regionAvailability )
{
if(exists(regionAvailability))
return update(regionAvailability);
return create(regionAvailability);
}
const String SqlUpdate = @"Update [Asset].[RegionAvailability] Set
RegionID = @RegionID,AssetID = @AssetID,CreateBy = @CreateBy,CreateDate = @CreateDate,ModifyBy = @ModifyBy,ModifyDate = @ModifyDate
Where
ID = @ID";
[Synchronized]
public RegionAvailability update(RegionAvailability regionAvailability)
{
using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
{
using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
{
sqlCommand.Parameters.AddWithValue("@ID", regionAvailability.ID);
sqlCommand.Parameters.AddWithValue("@RegionID", regionAvailability.RegionID);
sqlCommand.Parameters.AddWithValue("@AssetID", regionAvailability.AssetID);
sqlCommand.Parameters.AddWithValue("@CreateBy", regionAvailability.CreateBy);
sqlCommand.Parameters.AddWithValue("@CreateDate", regionAvailability.CreateDate);
sqlCommand.Parameters.AddWithValue("@ModifyBy", regionAvailability.ModifyBy);
sqlCommand.Parameters.AddWithValue("@ModifyDate", regionAvailability.ModifyDate);
sqlCommand.ExecuteNonQuery();
}
}
raiseAffected(regionAvailability,DataMapperOperation.update);
return registerRecord(regionAvailability);
}
}
}