public static RecTransportVehicleStd ParseTransportVehicleStd( DbDataReader dataReader )
{
var record = new RecTransportVehicleStd();
record.Factory = DataConverter.Cast<string>( dataReader[0] );
record.Project = DataConverter.Cast<string>( dataReader[1] );
record.Name = DataConverter.Cast<string>( dataReader[2] );
record.Division = DataConverter.Cast<string>( dataReader[3] );
record.Description = DataConverter.Cast<string>( dataReader[4] );
record.VehicleType = DataConverter.Cast<int>( dataReader[5] );
record.TransportType = DataConverter.Cast<int>( dataReader[6] );
record.Length = DataConverter.Cast<double>( dataReader[7] );
record.Width = DataConverter.Cast<double>( dataReader[8] );
record.Height = DataConverter.Cast<double>( dataReader[9] );
record.Mass = DataConverter.Cast<double>( dataReader[10] );
record.MaxLength = DataConverter.Cast<double>( dataReader[11] );
record.MaxWidth = DataConverter.Cast<double>( dataReader[12] );
record.MaxHeight = DataConverter.Cast<double>( dataReader[13] );
record.MaxMass = DataConverter.Cast<double>( dataReader[14] );
record.Created_By = DataConverter.Cast<string>( dataReader[15] );
record.Created_Date = DataConverter.Cast<DateTime?>( dataReader[16] );
record.Changed_By = DataConverter.Cast<string>( dataReader[17] );
record.Changed_Date = DataConverter.Cast<DateTime?>( dataReader[18] );
return record;
}
public bool Load( RecTMElement elem, RecTransport recTransport, RecTransportVehicleStd recVeh )
{
// *** Force erection sequence since it is paramount ***
// Once a vehicle is set till full, never try to put other lighter elements even though
// the total weight still allowed
if( IsFull )
{
return false;
}
// It is not allowed to use a vehicle not capable to carry a single element!
if( elem.Mass > TransportVehicleStackStdObject.MaxMass )
{
string elemMass = elem.Mass.ToString( "#0.000" );
string stackMaxMass = TransportVehicleStackStdObject.MaxMass.ToString( "#0.000" );
string msg = string.Format( "The stack \"{0}\" max load capacity {1} < element mass {2} for element \"{3}\", Standard vehicle \"{4}\" !",
TransportVehicleStackStdObject.Description,
stackMaxMass,
elemMass,
elem.ElementId,
TransportVehicleStackStdObject.Name );
throw new FaultException<BusinessFaultContract>( new BusinessFaultContract() { Argument = msg }, "Stack load capacity < Element mass!" );
}
double tot = GetTotElementMass() + elem.Mass;
if( tot > TransportVehicleStackStdObject.MaxMass )
{
IsFull = true;
return false;
}
else
{
TMElements.Add( new TMElement( elem ) );
}
return true;
}
public void CreateFromTemplate( RecTransportVehicleStd recVehTpl )
{
TransportVehicleStdObject = new RecTransportVehicleStd( recVehTpl );
foreach( RecTransportVehicleStackStd rec in recVehTpl.Stacks )
{
TMStack tmStack = new TMStack( rec );
Stacks.Add( tmStack );
}
}
/// <summary>
/// Load of Transport Vehicle Standard items
/// </summary>
/// <param name="vehicle"></param>
/// <returns></returns>
public List<RecTransportVehicleStd> LoadTransportVehicleStd( RecTransportVehicleStd record )
{
if( record == null )
{
throw new ArgumentNullException( "TransportVehicleStd" );
}
ImpactQuery query = new ImpactQuery()
{
Select =
{
ImpTransportVehicleStd.Factory,
ImpTransportVehicleStd.Project,
ImpTransportVehicleStd.Name,
ImpTransportVehicleStd.Division,
ImpTransportVehicleStd.Description,
ImpTransportVehicleStd.VehicleType,
ImpTransportVehicleStd.TransportType,
ImpTransportVehicleStd.Length,
ImpTransportVehicleStd.Width,
ImpTransportVehicleStd.Height,
ImpTransportVehicleStd.Mass,
ImpTransportVehicleStd.MaxLength,
ImpTransportVehicleStd.MaxWidth,
ImpTransportVehicleStd.MaxHeight,
ImpTransportVehicleStd.MaxMass,
ImpTransportVehicleStd.CreatedBy,
ImpTransportVehicleStd.CreatedDate,
ImpTransportVehicleStd.ChangedBy,
ImpTransportVehicleStd.ChangedDate,
},
From = { ImpTransportVehicleStd.As( "T1" ) },
Where = { ImpTransportVehicleStd.Factory.Equal( record.Factory ),
ImpTransportVehicleStd.Project.Equal( record.Factory ),//for Std use Factory, Factory
},
OrderBy = {ImpTransportVehicleStd.Name}
};
string statement = query.ToString();
List<RecTransportVehicleStd> result;
using( ImpactDatabase database = new ImpactDatabase() )
{
result = database.GetAll( statement, ParseTransportVehicleStd );
}
return result;
}
/// <summary>
/// Saves the transport into the database
/// </summary>
private void SaveTransportVehicleStack( RecTransport transport, RecTransportVehicleStd recVeh, int seq )
{
// Prepare data
TransportVehicleStackStdObject.Factory = transport.Factory;
TransportVehicleStackStdObject.Project = transport.Project;
TransportVehicleStackStdObject.TransportId = transport.TransportId;
TransportVehicleStackStdObject.VehicleId = recVeh.VehicleId;
// Save Stack object
ProjectManager svc = new ProjectManager();
// Use the new stack id
TransportVehicleStackStdObject.StackId = svc.InsertTransportVehicleStack( TransportVehicleStackStdObject );
}
void SimpleSave( RecTransport transport, RecTransportVehicleStd recVeh )
{
if( TMElements == null || TMElements.Count == 0 )
{
return;
}
// Update the elements with transport info;
int loadSeq = TMElements.Count;
foreach( TMElement tmElement in TMElements )
{
tmElement.StackSequenceNo = loadSeq;
tmElement.StackId = TransportVehicleStackStdObject.StackId;
tmElement.VehicleId = recVeh.VehicleId;
tmElement.Factory = transport.Factory;
tmElement.Project = transport.Project;
tmElement.TransportId = transport.TransportId;
tmElement.Save();
loadSeq--;
}
}
/// <summary>
/// Delete Cascade Stack
/// </summary>
/// <param name="transport"></param>
/// <param name="veh"></param>
/// <param name="stack"></param>
/// <returns></returns>
public int DeleteCascadeStackTransport( RecTransport transport, RecTransportVehicleStd veh, RecTransportStack stack )
{
ProjectManager mgr = new ProjectManager();
RecElementIdStatusStd std = new RecElementIdStatusStd { Factory = transport.Factory, Project = transport.Project };
List<RecElementIdStatusStd> settings = mgr.LoadStandardSettings( std );
// Update Status, Note this can be optimized!
RecTransport recTransportStatus = new RecTransport( transport );
recTransportStatus.TransportStatus = (int)TransportStatus.NoStatus;
recTransportStatus.ElementIdStatus = RecElementIdStatusStd.GetLocalSettingFromGlobalId( settings, recTransportStatus.TransportStatus).StatusId;
UpdateStatus( transport, recTransportStatus, settings );
// No reset
ModelPlanner svc = new ModelPlanner();
svc.ResetTransport( transport.Factory, transport.Project, 0, transport.TransportId, veh.VehicleId, stack.StackId );
ProjectManager StackSvc = new ProjectManager();
return StackSvc.DeleteTransportStack( stack );
}
public int DeleteCascadeVehicleTransport( RecTransport transport, RecTransportVehicleStd veh )
{
RecTransportStack rec = new RecTransportStack();
rec.Factory = transport.Factory;
rec.Project = transport.Project;
rec.TransportId = transport.TransportId;
rec.VehicleId = veh.VehicleId;
// Delete cascade stacks
ProjectManager svc = new ProjectManager();
List<RecTransportStack> stacks = svc.LoadTransportStack( rec );
foreach( RecTransportStack stack in stacks )
{
this.DeleteCascadeStackTransport( transport, veh, stack );
}
// Now delete the vehicle
ProjectManager vehSvc = new ProjectManager();
List<RecTransportVehicleStd> vehicles = new List<RecTransportVehicleStd>();
vehicles.Add( veh );
return vehSvc.RemoveTransportVehicles( transport, vehicles );
}
/// <summary>
/// Parsing method
/// </summary>
/// <param name="transport"></param>
/// <param name="vehicle"></param>
/// <param name="rack"></param>
/// <param name="elem"></param>
public void Parse( RecTransport transport, RecTransportVehicleStd vehicle, RecTransportVehicleStackStd stack, RecTMElement elem )
{
string transpKey = transport.Factory + transport.Project + transport.TransportId;
RecTMVehicle vehObj = null;
RecTMStack stackObj = null;
RecTMTransport transpObj = null;
if( dic.ContainsKey( transpKey ) )
{
transpObj = dic[transpKey];
}
else
{
transpObj = new RecTMTransport();
dic.Add( transpKey, transpObj );
tmList.Add( transpObj );
}
transpObj.TransportObject = transport;
bool isVehicleMode = vehicle.VehicleId != 0;
if( isVehicleMode || transpObj.Vehicles.Count > 0 )
{
vehObj = transpObj.FindVehicle( vehicle );
if( vehObj == null )
{
vehObj = new RecTMVehicle();
transpObj.AddVehicle( vehObj );
}
vehObj.TransportVehicleStdObject = vehicle;
if( stack.StackId != 0 )
{
stackObj = vehObj.FindStack( stack );
if( stackObj == null )
{
stackObj = new RecTMStack();
vehObj.AddStack( stackObj );
}
stackObj.TransportVehicleStackStdObject = stack;
// To be revised!!!!!!!!!!! rackObj.TransportVehicleStackStdObject = stack;
}
}
// Save the element if we do have an element
if( elem.ElementId > 0 )
{
if( stackObj != null )
{
stackObj.TMElements.Add( elem );
}
else if( vehObj != null )
{
vehObj.TMElements.Add( elem );
}
else
{
transpObj.TMElements.Add( elem );
}
}
}
private RecTransportVehicleStd LoadVehicleStdDetails( RecTransportVehicleStd record )
{
if( record == null )
{
throw new ArgumentNullException( "VehicleStd" );
}
ImpactQuery query = new ImpactQuery()
{
Select =
{
ImpTransportVehicleStd.Name,
ImpTransportVehicleStd.Description,
ImpTransportVehicleStd.MaxLength,
ImpTransportVehicleStd.MaxWidth,
ImpTransportVehicleStd.MaxHeight,
ImpTransportVehicleStd.MaxMass,
ImpTransportVehicleStd.VehicleType,
ImpTransportVehicleStd.TransportType,
},
From = { ImpTransportVehicleStd.As( "T1" ) },
Where = { ImpTransportVehicleStd.Factory.Equal( record.Factory ),
ImpTransportVehicleStd.Project.Equal( record.Factory ),
ImpTransportVehicleStd.Name.Equal( record.Name)}
};
string statement = query.ToString();
RecTransportVehicleStd result;
using( ImpactDatabase database = new ImpactDatabase() )
{
result = database.GetFirst<RecTransportVehicleStd>( statement, column =>
{
return new RecTransportVehicleStd()
{
Factory = record.Factory,
Project = record.Project,
Name = DataConverter.Cast<string>( column[0] ),
Description = DataConverter.Cast<string>( column[1] ),
MaxLength = DataConverter.Cast<double>( column[2] ),
MaxWidth = DataConverter.Cast<double>( column[3] ),
MaxHeight = DataConverter.Cast<double>( column[4] ),
MaxMass = DataConverter.Cast<double>( column[5] ),
VehicleType = DataConverter.Cast<int>( column[6] ),
TransportType = DataConverter.Cast<int>( column[7] ),
};
} );
}
if( result != null )
{
result.Factory = record.Factory;
result.Project = record.Project;
result.TransportType = record.TransportType; // Hmm which one should be used?
result.VehicleId = record.VehicleId;
result.TransportId = record.TransportId;
}
return result;
}
/// <summary>
/// Insert of Transport Vehicle Standard items
/// </summary>
/// <param name="rec"></param>
/// <param name="vehicle"></param>
/// <param name="seq"></param>
/// <returns></returns>
public RecTransportVehicleStd InsertTransportVehicle( RecTransport rec, RecTransportVehicleStd vehicle, int seq )
{
if( rec == null || rec.Factory == null || rec.Project == null )
{
throw new ArgumentNullException( "Transport" );
}
string project = "";
if( rec.IsTemplate == 1 )
{
// Templates are saved on factory level (factory, factory), 2012-04-23
project = rec.Factory;
}
else
{
project = rec.Project;
}
RecTransportVehicleStd res = new RecTransportVehicleStd( vehicle );
using( ImpactDatabase database = new ImpactDatabase() )
{
// 1. Instantiate a new command with a query and connection
ProjectManager ng = new ProjectManager();
int vehicleId = ng.GetNextNumber( rec.Factory, rec.Project, RecNumberGenerator.NG_VEHICLE_ID );
string sql = "Insert into IMP_TRANSPORT_VEHICLE(FACTORY,PROJECT,TRANSPORT_ID,VEHICLE_ID,VEHICLE,VEHICLE_SEQUENCE_NO,TRANSPORT_TYPE)values("
+ Conv.Sql( rec.Factory ) + ","
+ Conv.Sql( project ) + "," //Templates are saved on factory level (factory, factory), 2012-04-23
+ Conv.Sql( rec.TransportId ) + ","
+ Conv.Sql( vehicleId ) + ","
+ Conv.Sql( vehicle.Name ) + ","
+ Conv.Sql( seq ) + ","
+ Conv.Sql( vehicle.TransportType )
+ ")";
database.ExecuteNonQuery( sql );
res.VehicleId = vehicleId;
}
return res;
}
/// <summary>
/// Insert of Transport Vehicle Standard items
/// </summary>
/// <param name="vehicle"></param>
/// <returns></returns>
public int InsertTransportVehicleStd( RecTransportVehicleStd record )
{
if( record == null )
{
throw new ArgumentNullException( "TransportVehicleStd" );
}
var insert = new ImpactInsert( ImpTransportVehicleStd.Instance )
{
Columns =
{
{ ImpTransportVehicleStd.Factory, record.Factory },
{ ImpTransportVehicleStd.Project, record.Factory }, //Std use, Factory, Factory
{ ImpTransportVehicleStd.Name, record.Name },
{ ImpTransportVehicleStd.Division, record.Division },
{ ImpTransportVehicleStd.Description, record.Description },
{ ImpTransportVehicleStd.VehicleType, record.VehicleType },
{ ImpTransportVehicleStd.TransportType, record.TransportType },
{ ImpTransportVehicleStd.Length, record.Length },
{ ImpTransportVehicleStd.Width, record.Width },
{ ImpTransportVehicleStd.Height, record.Height },
{ ImpTransportVehicleStd.Mass, record.Mass },
{ ImpTransportVehicleStd.MaxLength, record.MaxLength },
{ ImpTransportVehicleStd.MaxWidth, record.MaxWidth },
{ ImpTransportVehicleStd.MaxHeight, record.MaxHeight },
{ ImpTransportVehicleStd.MaxMass, record.MaxMass },
{ ImpTransportVehicleStd.CreatedBy, record.Created_By },
{ ImpTransportVehicleStd.CreatedDate, record.Created_Date },
//{ ImpTransportVehicleStd.ChangedBy, record.Created_By },
//{ ImpTransportVehicleStd.ChangedDate, record.Created_Date },
}
};
string statement = insert.ToString();
int result;
using( ImpactDatabase database = new ImpactDatabase() )
{
result = database.ExecuteNonQuery( statement );
}
return result;
}
/// <summary>
/// Delete of Transport Vehicle Standard items
/// </summary>
/// <param name="vehicle"></param>
/// <returns></returns>
public int DeleteTransportVehicleStd( RecTransportVehicleStd record )
{
if( record == null )
{
throw new ArgumentNullException( "TransportVehicleStd" );
}
// Delete underlying std stacks
ProjectManager svc = new ProjectManager();
RecTransportVehicleStackStd stack = new RecTransportVehicleStackStd()
{
Factory = record.Factory,
Project = record.Project,
Name = record.Name,
};
svc.DeleteTransportVehicleStackStd( stack );
// Now delete the std veh
var delete = new ImpactDelete( ImpTransportVehicleStd.Instance )
{
Where =
{
{ ImpTransportVehicleStd.Factory.Equal( record.Factory )},
{ ImpTransportVehicleStd.Project.Equal( record.Factory )},//for Std use Factory, Factory
{ ImpTransportVehicleStd.Name.Equal( record.Name )},
}
};
string statement = delete.ToString();
int result;
using( ImpactDatabase database = new ImpactDatabase() )
{
result = database.ExecuteNonQuery( statement );
}
return result;
}
public void Save( RecTransport transport, RecTransportVehicleStd recVeh, int seq )
{
//Rack transport Mode, saves vehicle objects and elements on them
//TransportVehicleStackStdObject.Save(_transport);
//// Save the stack object;
SaveTransportVehicleStack( transport, recVeh, seq );
// Save elements
SimpleSave( transport, recVeh );
}
public TMVehicle( RecTransportVehicleStd recTransportVehicleStd )
{
TransportVehicleStdObject = recTransportVehicleStd;
}
