public int CopyStrandsFromTemplate( RecProductionCast record )
        {
            var rec = new RecProductionFormStrandStd
                          { Factory = record.Factory, Project = record.Project, Name = record.Form };
            var svc = new ProjectManager();
            var list = svc.LoadProductionFormStrandStd( rec );
            if (list == null || list.Count == 0)
            {
                return 0;
            }
            list = (from o in list where o.IsUsed select o).ToList();

            foreach (var std in list)
            {
                var strand = new RecProductionCastStrand
                                 {
                                     Factory = record.Factory,
                                     Project = record.Project,
                                     CastId = record.CastId,
                                     StrandPos = std.StrandPos,
                                     StrandX = std.StrandX,
                                     StrandY = std.StrandY,
                                     StrandQuality = std.StrandQuality,
                                     StrandDimension = std.StrandDimension,
                                     StrandPrestressing = std.StrandPrestressing
                                 };

                this.InsertProductionCastStrand( strand, null, null );
            }

            return list.Count;
        }
Example #2
0
        public ProductionBed( RecProductionFormStd form, BedFilter filter )
            : base( form )
        {
            this.bedFilter = filter;
            IsFull = false;
            if( null != form.ProductionCast && form.ProductionCast.CastId > 0 )
            {
                // Well this is never used so far
                this.ProductionCast = form.ProductionCast;
            }
            else
            {
                // Create a cast object
                var cast = new RecProductionCast( form )
                               {
                                   Factory = filter.Factory,
                                   Project = filter.Project,
                                   StartDate = filter.StartDateFrom,
                                   EndDate = filter.EndDateFrom,
                                   Shift = filter.Shift
                               };

                if( form.FormType == V120.Planning.Common.FormType.Bed && form.StrandType == V120.Planning.Common.StrandType.Bed )
                {
                    var strand = new RecProductionFormStrandStd()
                                     { Factory = filter.Factory, Project = filter.Project, Name = form.Name };
                    cast.Strands = LoadStandardStrands( strand );
                }

                this.ProductionCast = cast;
            }
        }
Example #3
0
		public ExBed( RecProductionFormStd form, BedFilter filter )
			: base( form )
		{
			_bedFilter = filter;
			IsFull = false;
			// Create a cast object
			RecProductionCast cast = new RecProductionCast( form );
			cast.Factory = filter.Factory;
			cast.Project = filter.Project;

			cast.StartDate = filter.StartDateFrom;
			cast.EndDate = filter.EndDateFrom;

			cast.Shift = filter.Shift;
			AddCast( cast );
		}
				/// <summary>
		/// Parses one row in <see cref="System.Data.Common.DbDataReader"/> into
		/// a new instance of <see cref="StruSoft.Impact.V120.Common.Records.RecProductionCast"/>.
		/// </summary>
		/// <param name="dataReader">The data reader.</param>
		/// <returns>A new instance of <see cref="StruSoft.Impact.V120.Common.Records.RecProductionCast"/>.</returns>
		public static RecProductionCast ParseProductionCast( DbDataReader dataReader )
		{
			var record = new RecProductionCast();
			record.Factory = DataConverter.Cast<string>( dataReader[0] );
			record.Project = DataConverter.Cast<string>( dataReader[1] );
			record.CastId = DataConverter.Cast<int>( dataReader[2] );
			record.CastType = DataConverter.Cast<int>( dataReader[3] );
			record.Description = DataConverter.Cast<string>( dataReader[4] );
			record.Shift = DataConverter.Cast<int>( dataReader[5] );
			record.StartDate = DataConverter.Cast<System.DateTime?>( dataReader[6] );
			record.EndDate = DataConverter.Cast<System.DateTime?>( dataReader[7] );
			record.Form = DataConverter.Cast<string>( dataReader[8] );
			record.Tolerance = DataConverter.Cast<double>( dataReader[9] );
			record.ElementType = DataConverter.Cast<string>( dataReader[10] );
			record.Style = DataConverter.Cast<string>( dataReader[11] );
			record.Strandptn = DataConverter.Cast<string>( dataReader[12] );
			record.CastStatus = DataConverter.Cast<int>( dataReader[13] );
			record.CastDivision = DataConverter.Cast<string>( dataReader[14] );

			record.Location = DataConverter.Cast<string>( dataReader[15] );
			return record;
		}
Example #5
0
        /// <summary>
        /// Returns a list of elements that are allowed to bed positioned of the given castunit(bed)
        /// </summary>
        /// <param name="filter">curFilter</param>
        /// <param name="form">castunit</param>
        /// <param name="recProductionCast"> </param>
        /// <param name="elements">A list of elements to be positioned</param>
        /// <param name="strict">Strict flag</param>
        /// <returns></returns>
        private List<RecTMElement> LoadAllowedElements( BedFilter filter, RecProductionFormStd form, RecProductionCast recProductionCast, List<RecTMElement> elements, bool strict )
        {
            if( elements == null || elements.Count == 0 || form == null &&
                filter == null || string.IsNullOrEmpty( filter.Factory ) || string.IsNullOrEmpty( filter.Project ) )
            {
                return null;
            }

            var inVect = ( from o in elements select o.ElementId ).ToArray();

            List<RecTMElement> result;
            var query = new ImpactQuery()
            {
                Select =
				{
                    ImpElement.ElementMark,

                    ImpElement.ElementLength,
					ImpElement.ElementWidth,
					ImpElement.ElementHeight,

                    ImpElement.ElementType,
                    ImpElement.AngleLeftSide,
					ImpElement.AngleRightSide,

					ImpElement.Style,
					ImpElement.Strandptn,
					ImpElement.NbrOfStrands,

                    ImpModelGeometry.Factory,
                    ImpModelGeometry.Project,
                    ImpModelGeometry.ElementId,
				},

                From = { ImpElement.As( "ELM" ) },

                Join =
				{
					Join.Left( ImpModelGeometry.As( "GEO" ),	
						ImpModelGeometry.Factory.Equal( ImpElement.Factory ),
						ImpModelGeometry.Project.Equal( ImpElement.Project ),
						ImpModelGeometry.ElementMark.Equal( ImpElement.ElementMark ) ),
				},

                Where = {
							ImpElement.Factory.Equal( filter.Factory ), 
							ImpElement.Project.Equal( filter.Project ), 
							ImpModelGeometry.ElementId.In( inVect ), 
						},
            };

            if( form != null && ( strict && form.FormType == FormType.Bed ) )
            {
                query.Where.Add( ImpElement.ElementType.Equal( form.ElementType ) );

                var hasStrands = form.ElementType.Equals( ImpactElementType.HollowCore ) ||
                                  form.ElementType.Equals( ImpactElementType.PrestressedSlab ) ||
                                  form.ElementType.Equals( ImpactElementType.PrestressedFormSlab );

                if( hasStrands )
                {
                    if( filter.ForceStyleControl )
                    {
                        var style = (null != recProductionCast)? recProductionCast.Style : form.Style;
                        var strandptn = (null != recProductionCast)? recProductionCast.Strandptn : form.Strandptn;
                        var nbrOfStrands = (null != recProductionCast)? GetNumberOfStrands( recProductionCast ) : GetNumberOfStrands( form );

                        query.Where.Add( ImpElement.Style.Equal( style ) );
                        query.Where.Add( ImpElement.Strandptn.Equal( strandptn ) );
                        query.Where.Add( ImpElement.NbrOfStrands.LessThanOrEqual( nbrOfStrands ) );
                    }
                }
            }

            var statement = query.ToString();
            using( var database = new ImpactDatabase() )  
            {
                result = database.GetAll( statement, ElementParse );
            }

            return result;
        }
Example #6
0
        /// <summary>
        /// Parsing helper
        /// </summary>
        /// <param name="column">column</param>
        /// <returns></returns>
        private static DataHolder ParseSchedule( DbDataReader column )
        {
            RecProductionCast cast = new RecProductionCast()
            {
                CastId = DataConverter.Cast<int>( column[0] ),

                Description = DataConverter.Cast<string>( column[1] ),
                StartDate = DataConverter.Cast<DateTime>( column[2] ),
                EndDate = DataConverter.Cast<DateTime?>( column[3] ),
                Tolerance = DataConverter.Cast<double>( column[4] ),
                ElementType = DataConverter.Cast<string>( column[5] ),
                Style = DataConverter.Cast<string>( column[6] ),
                Strandptn = DataConverter.Cast<string>( column[7] ),
                CastStatus = DataConverter.Cast<int>( column[8] ),
                CastType = DataConverter.Cast<int>( column[9] ),

                Form = DataConverter.Cast<string>( column[10] ),
                Shift = DataConverter.Cast<int>( column[11] ),
                NumOfStrands = DataConverter.Cast<int>( column[12] ),
                Location = DataConverter.Cast<string>( column[13] ),
            };
            RecProductionFormStd form = new RecProductionFormStd()
            {
                Location = DataConverter.Cast<string>( column[13] ), // Location repeated here!!!
                FormType = DataConverter.Cast<int>( column[14] ),
                MaxLength = DataConverter.Cast<double?>( column[15] ) ?? 0d,
                MaxWidth = DataConverter.Cast<double?>( column[16] ) ?? 0d,
                MaxHeight = DataConverter.Cast<double?>( column[17] ) ?? 0d,
                ElementType = DataConverter.Cast<string>( column[18] ),
            };

            RecTMElement elem = null;
            int elementId = DataConverter.Cast<int?>( column[19] ) ?? 0;
            if( 0 != elementId )
            {
                elem = new RecTMElement()
                {
                    ElementId = elementId,
                    ElementMark = DataConverter.Cast<string>( column[20] ),

                    Building = DataConverter.Cast<string>( column[21] ),
                    FloorId = DataConverter.Cast<int?>( column[22] ) ?? 0,
                    Phase = DataConverter.Cast<string>( column[23] ),

                    ErectionSequenceNo = DataConverter.Cast<int?>( column[24] ) ?? 0,
                    TransportId = DataConverter.Cast<int?>( column[25] ) ?? 0,

                    BedSequenceNo = DataConverter.Cast<int>( column[26] ),
                    BedX = DataConverter.Cast<double>( column[27] ),
                    BedY = DataConverter.Cast<double>( column[28] ),
                    BedZ = DataConverter.Cast<double>( column[29] ),
                    BedRotation = DataConverter.Cast<double>( column[30] ),
                    ElementIdStatus = DataConverter.Cast<int>( column[31] ),

                    ProductionDate = column[32].Cast<DateTime?>(),
                    PlannedProductionDate = column[33].Cast<DateTime?>(),

                    ElementLength = DataConverter.Cast<double?>( column[34] ) ?? 0d,
                    ElementWidth = DataConverter.Cast<double?>( column[35] ) ?? 0d,
                    ElementHeight = DataConverter.Cast<double?>( column[36] ) ?? 0d,
                    ElementType = DataConverter.Cast<string>( column[37] ),
                    GrossArea = DataConverter.Cast<double?>( column[38] ) ?? 0d,
                    NetArea = DataConverter.Cast<double?>( column[39] ) ?? 0d,
                    Volume = DataConverter.Cast<double?>( column[40] ) ?? 0d,
                    Product = DataConverter.Cast<string>( column[41] ),
                    Project = DataConverter.Cast<string>( column[42] ),
                    AngleLeft = DataConverter.Cast<double?>( column[43] ) ?? 0d,
                    AngleRight = DataConverter.Cast<double?>( column[44] ) ?? 0d,
                    Mass = DataConverter.Cast<double?>( column[45] ) ?? 0d,

                    Style = DataConverter.Cast<string>( column[46] ),
                    Strandptn = DataConverter.Cast<string>( column[47] ),
                    NbrOfStrands = DataConverter.Cast<int>( column[48] ),
                };
            }

            return new DataHolder( cast, form, elem );
        }
Example #7
0
 public DataHolder( RecProductionCast cast, RecProductionFormStd form, RecTMElement element )
 {
     this.Cast = cast;
     this.Form = form;
     this.Element = element;
 }
Example #8
0
 /// <summary>
 /// Returns no of strands
 /// </summary>
 /// <param name="cast"></param>
 /// <returns></returns>
 private int GetNumberOfStrands( RecProductionCast cast )
 {
     if( cast == null || null == cast.Strands )
     {
         return 0;
     }
     return cast.Strands.Count;
     //var nbrOfStrands = 0;
     //if( cast == null || string.IsNullOrEmpty( cast.Factory ) || string.IsNullOrEmpty( cast.Project ) || 0 == cast.CastId)
     //{
     //    return nbrOfStrands;
     //}
     //var svc = new ProductionCastStrand();
     //var recStrand = new RecProductionCastStrand { Factory = cast.Factory, Project = cast.Project, CastId = cast.CastId };
     //var strands = svc.Load( recStrand );
     //if( null != strands )
     //{
     //    nbrOfStrands = strands.Count;
     //}
     //return nbrOfStrands;
 }
Example #9
0
            public void Parse( RecProductionFormStd form, RecProductionCast cast, RecTMElement elem )
            {
                string formKey = form.Factory + form.Project + form.Name;
                RecProductionFormStd formObj = null;
                if( dic.ContainsKey( formKey ) )
                {
                    formObj = dic[formKey];
                }
                else
                {
                    formObj = new RecProductionFormStd( form );
                    dic.Add( formKey, formObj );
                    tmList.Add( formObj );
                }

                RecProductionCast castObj = null;
                if( cast != null )
                {
                    castObj = formObj.FindCast( cast );
                    if( castObj == null )
                    {
                        castObj = new RecProductionCast( cast ) { Form = form.Name };
                        formObj.ProductionCast = castObj;
                    }
                }
                // Save the element if we do have an element
                if( null == elem || elem.ElementId <= 0 )
                {
                    return;
                }
                if( castObj == null || castObj.CastId <= 0 )
                {
                    return;
                }
                elem.CastId = castObj.CastId;
                castObj.Project = elem.Project;
                castObj.AddElement( elem );
            }
Example #10
0
            public void Parse( RecProductionFormStd form, RecProductionCast cast, RecTMElement elem )
            {
                string castKey = cast.Factory + cast.Project + cast.CastId;
                RecProductionCast castObj = null;
                if( dic.ContainsKey( castKey ) )
                {
                    castObj = dic[castKey];
                }
                else
                {
                    castObj = new RecProductionCast( cast );
                    dic.Add( castKey, castObj );
                    tmList.Add( castObj );
                }

                // Save the element if we do have an element
                if( elem != null && elem.ElementId > 0 )
                {
                    if( castObj != null && castObj.CastId > 0 )
                    {
                        elem.CastId = castObj.CastId;
                        castObj.Project = elem.Project;
                        castObj.AddElement( elem );
                    }
                }
            }
	    /// <summary>
		/// Insert the specified record into the database.
		/// </summary>
		/// <param name="record">The record to insert into the database.</param>
		/// <returns>The number of affected records.</returns>
        public int InsertProductionCastStrand(RecProductionCastStrand record, RecProductionFormStd form, BedFilter filter)
		{
            if (null == record)
            {
                return -1;
            }
            int castId = record.CastId;
            if (castId <= 0)
            {
                if (null == form || null == filter)
                {
                    return -1;
                }
                var cast = new RecProductionCast
                    {
                        Factory = record.Factory,
                        Project = record.Project,
                        CastType = form.FormType,
                        Description = "",
                        Shift = filter.Shift,
                        StartDate = filter.StartDateFrom,
                        EndDate = filter.StartDateFrom,
                        Form = form.Name,
                        Tolerance = form.Tolerance,
                        ElementType = form.ElementType,
                        Style = form.Style,
                        Strandptn = form.Strandptn,
                        CastStatus = 0,
                        CastDivision = ""
                    };

                var svc = new ProjectManager();
                var newCast = svc.InsertProductionCast(cast);
                castId = newCast.CastId;
            }

			var insert = new ImpactInsert( ImpProductionCastStrand.Instance )
			{
				Columns = 
				{
					{ ImpProductionCastStrand.Factory, record.Factory },
					{ ImpProductionCastStrand.Project, record.Factory },// Factory, Factory for productionCast & ProductionCastStrand
					{ ImpProductionCastStrand.CastId, castId },
					{ ImpProductionCastStrand.StrandPos, record.StrandPos },
					{ ImpProductionCastStrand.StrandX, record.StrandX },
					{ ImpProductionCastStrand.StrandY, record.StrandY },
					{ ImpProductionCastStrand.StrandQuality, record.StrandQuality },
					{ ImpProductionCastStrand.StrandDimension, record.StrandDimension },
					{ ImpProductionCastStrand.StrandPrestressing, record.StrandPrestressing },
				}
			};

			string statement = insert.ToString();

			int result;

			using( var database = new ImpactDatabase() )
			{
				result = database.ExecuteNonQuery( statement );
			}

			return result;
		}
		/// <summary>
		/// Returns a list of the reset element ids.
		/// </summary>
		/// <param name="record">The record to delete from the database.</param>
		/// <returns>The number of affected records.</returns>
		public CastScheduleResult DeleteProductionCast( RecProductionCast record )
		{
            ProjectManager projectManagerService = new ProjectManager();   
            BedFilter filter = new BedFilter();
            filter.Factory = record.Factory;
            List<string> projectsInvolved = projectManagerService.LoadCastProjects( filter, record.CastId );
            if( null == projectsInvolved )
            {
                return null;
            }

            ProjectManager mgr = new ProjectManager();
            RecElementIdStatusStd std = new RecElementIdStatusStd { Factory = record.Factory, Project = record.Project };
            List<RecElementIdStatusStd> settings = mgr.LoadStandardSettings( std );

			ModelPlanner svc = new ModelPlanner( );
            List<int> deletedIds = svc.LoadElementIds( record.Factory, record.Project, record.CastId );

            // (1) Reset elements
            // Update Status, Note this can be optimized!
            RecProductionCast recProductionCastStatus = new RecProductionCast( record );
            recProductionCastStatus.CastStatus = (int)CastStatus.NoStatus;
            recProductionCastStatus.ElementIdStatus = RecElementIdStatusStd.GetLocalSettingFromGlobalId( settings, recProductionCastStatus.CastStatus).StatusId;
            UpdateStatus( record, recProductionCastStatus, settings );
            // Now reset
			svc.ResetElementProduction( record.Factory, record.Project, record.CastId, 0, false );

            // (2) Delete strands
            RecProductionCastStrand recStrand = new RecProductionCastStrand();
            recStrand.Factory = record.Factory;
            recStrand.Project = record.Factory; // Factory, Factory for productionCast & ProductionCastStrand
            recStrand.CastId = record.CastId;
            recStrand.StrandPos = 0;
            ProjectManager strand = new ProjectManager();
            strand.DeleteProductionCastStrand(recStrand);
            // (3) Now delete the cast Object
            int result = 0;
            // The cast object can be deleted if no elements belong to other projects other that the current one
            if( projectsInvolved.Count == 0 || (projectsInvolved.Count == 1 && projectsInvolved[0].Equals( record.Project ) )  )
            {
                var delete = new ImpactDelete( ImpProductionCast.Instance )
                {
                    Where = 
				{
					{ ImpProductionCast.Factory.Equal( record.Factory )},
					{ ImpProductionCast.Project.Equal( record.Factory )},// Factory, Factory for productionCast & ProductionCastStrand
					{ ImpProductionCast.CastId.Equal( record.CastId )},
				}
                };

                string statement = delete.ToString();

                using( ImpactDatabase database = new ImpactDatabase() )
                {
                    result = database.ExecuteNonQuery( statement );
                }
            }

			return new CastScheduleResult(deletedIds, projectsInvolved);
		}
Example #13
0
        /// <summary>
        /// Resets status
        /// </summary>
        /// <param name="rec"></param>
        /// <param name="settings"> </param>
        /// <returns></returns>
        private int SaveElementProductionNoStatus( RecProductionCast rec, List<RecElementIdStatusStd> settings )
        {
            var readyForProduction = RecElementIdStatusStd.GetLocalSettingFromGlobalId( settings, 2 ).StatusId;
            var notReadyForProduction = RecElementIdStatusStd.GetLocalSettingFromGlobalId( settings, 1 ).StatusId;

            switch( ImpactDatabase.DataSource )
            {
                case DataSource.SqlServer:
                case DataSource.SqlServerExpress:
                {
                    string statement = string.Format( @"
                        UPDATE PLN
                        SET
                        PLN.ELEMENT_ID_STATUS =
                        ( CASE 
                            WHEN (GEO.READY_FOR_PRODUCTION  > 0 ) THEN {0}
                            ELSE {1}
                            END
                        )
                        FROM IMP_MODEL_PLANNING PLN
                        INNER JOIN IMP_MODEL_GEOMETRY GEO ON
                            PLN.FACTORY = GEO.FACTORY AND
                            PLN.PROJECT = GEO.PROJECT AND
                            PLN.ELEMENT_ID = GEO.ELEMENT_ID
                        WHERE 
                        PLN.CAST_ID =  {2} AND
                        PLN.FACTORY = '{3}' 
                        ", readyForProduction, notReadyForProduction, rec.CastId, rec.Factory ); //, rec.Project  AND PLN.PROJECT = '{4}' 

                    int result;

                    using( ImpactDatabase database = new ImpactDatabase() )
                    {
                        result = database.ExecuteNonQuery( statement );
                    }
                    return result;
                }
                case DataSource.Ingres92:
                case DataSource.Ingres100:
                {
                    int result = 0;
                    List<StatusDataHolder> list = LoadElementStatusData( rec.Factory, rec.Project, rec.CastId, 0, false );
                    if( null == list || list.Count == 0 )
                    {
                        return 0;
                    }
                    foreach( var data in list )
                    {
                        var idStatus = 0;
                        if( 1 == data.ReadyForProduction )
                        {
                            idStatus = readyForProduction;
                        }
                        else
                        {
                            idStatus = notReadyForProduction;
                        }

                        UpdateElementStatus( data.Factory, data.Project, data.ElementId, idStatus );
                    }
                    return result;
                }
            }
            return 0;
        }
		/// <summary>
		/// Insert the specified record into the database.
		/// </summary>
		/// <param name="record">The record to insert into the database.</param>
		/// <returns>The number of affected records.</returns>
		public RecProductionCast InsertProductionCast( RecProductionCast record )
		{
            // Get new sequence
			ProjectManager ng = new ProjectManager();
			string company = ProjectManager.GetCompany( record.Factory );
			int castId = ng.GetNextNumber( company, company, RecNumberGenerator.CMP_NG_CAST_ID );

			var insert = new ImpactInsert( ImpProductionCast.Instance )
			{
				Columns = 
				{
					{ ImpProductionCast.Factory, record.Factory },
					{ ImpProductionCast.Project, record.Factory }, // Factory, Factory for productionCast
					{ ImpProductionCast.CastId, castId }, //Sequence
					{ ImpProductionCast.CastType, record.CastType },
					{ ImpProductionCast.Description, record.Description },
					{ ImpProductionCast.Shift, record.Shift },
					{ ImpProductionCast.StartDate, record.StartDate },
					{ ImpProductionCast.EndDate, record.EndDate },
					{ ImpProductionCast.Form, record.Form },
					{ ImpProductionCast.Tolerance, record.Tolerance },
					{ ImpProductionCast.ElementType, record.ElementType },
					{ ImpProductionCast.Style, record.Style },
					{ ImpProductionCast.Strandptn, record.Strandptn },
					{ ImpProductionCast.CastStatus, record.CastStatus },
					{ ImpProductionCast.CastDivision, record.CastDivision },
				}
			};

			string statement = insert.ToString();

			int result;

			using( ImpactDatabase database = new ImpactDatabase() )
			{
				result = database.ExecuteNonQuery( statement );
			}

            // Copy strands from template (form)
            if (!string.IsNullOrWhiteSpace(record.Form))
            {
                record.CastId = castId;
                ProjectManager svc = new ProjectManager( );
                svc.CopyStrandsFromTemplate( record );
            }

			return record;
		}
Example #15
0
        /// <summary>
        /// Sets the cast status
        /// </summary>
        /// <param name="rec"></param>
        /// <returns></returns>
        public int SaveElementProductionStatus( RecProductionCast rec, RecProductionCast productionCastStatus, List<RecElementIdStatusStd> settings )
        {
            if( null == rec || string.IsNullOrWhiteSpace( rec.Factory ) || string.IsNullOrWhiteSpace( rec.Project ) || 0 == rec.CastId )
            {
                return 0;
            }

            bool isValidElementIdStatus = productionCastStatus.ElementIdStatus != -1;
            bool noStatus = productionCastStatus.CastStatus == (int)CastStatus.NoStatus;
            int result = 0;
            if( noStatus )
            {
                SaveElementProductionNoStatus( rec, settings );
            }

            var update = new ImpactUpdate( ImpModelPlanning.Instance )
            {
                Columns = 
				{
					//{ ImpModelPlanning.ElementIdStatus, rec.ElementIdStatus },
				},
                Where = 
				{
					{ ImpModelPlanning.Factory.Equal( rec.Factory ) },
					//{ ImpModelPlanning.Project.Equal( rec.Project ) },
					{ ImpModelPlanning.CastId.Equal( rec.CastId ) },
				},
            };

            if( noStatus )
            {
                if( productionCastStatus.ClearProductionDate )
                {
                    update.Columns.Add( ImpModelPlanning.ProductionDate, null );
                }
                if( productionCastStatus.ClearPlannedProductionDate )
                {
                    update.Columns.Add( ImpModelPlanning.PlannedProductionDate, null );
                }
            }
            else if( productionCastStatus.CastStatus == (int)CastStatus.Planned )
            {
                if( productionCastStatus.UpdateElementStatus && isValidElementIdStatus )
                {
                    update.Columns.Add( ImpModelPlanning.ElementIdStatus, productionCastStatus.ElementIdStatus );
                }
                if( productionCastStatus.UpdateProductionDate && productionCastStatus.StartDate != null )
                {
                    update.Columns.Add( ImpModelPlanning.PlannedProductionDate, productionCastStatus.StartDate );
                }
            }
            else if( productionCastStatus.CastStatus == (int)CastStatus.Produced )
            {
                if( productionCastStatus.UpdateElementStatus && isValidElementIdStatus )
                {
                    update.Columns.Add( ImpModelPlanning.ElementIdStatus, productionCastStatus.ElementIdStatus );
                }
                if( productionCastStatus.UpdateProductionDate && productionCastStatus.StartDate != null )
                {
                    update.Columns.Add( ImpModelPlanning.ProductionDate, productionCastStatus.StartDate );
                }
            }

            if( update.Columns.Count == 0 )
            {
                return 0; // Nothing to update
            }

            string sql = update.ToString();

            using( ImpactDatabase database = new ImpactDatabase() )
            {
                result += database.ExecuteNonQuery( sql );
            }
            return result;
        }
		/// <summary>
		/// Update the specified record in the database.
		/// </summary>
		/// <param name="record">The record to update.</param>
		/// <returns></returns>
		public CastResult UpdateProductionCast( RecProductionCast record )
		{
            bool hasScheduleCollision = false;
            BedFilter filter = new BedFilter();
            filter.Factory = record.Factory;
            filter.Project = record.Project;
            filter.Shift = record.Shift;
            List<RecProductionCast> casts = this.LoadProductionCast( filter, record );
            if( null != casts && casts.Count > 0 )
            {
                List<RecProductionCast> otherCasts = (from o in casts where o.CastId != record.CastId select o).ToList();
                if( null != otherCasts && otherCasts.Count > 0 )
                {
                    hasScheduleCollision = true;
                }
            }

			var update = new ImpactUpdate( ImpProductionCast.Instance )
			{
				Columns = 
				{
					{ ImpProductionCast.CastType, record.CastType },
					{ ImpProductionCast.Description, record.Description },

					{ ImpProductionCast.Form, record.Form },
					{ ImpProductionCast.Tolerance, record.Tolerance },
					{ ImpProductionCast.ElementType, record.ElementType },
					{ ImpProductionCast.Style, record.Style },
					{ ImpProductionCast.Strandptn, record.Strandptn },
					{ ImpProductionCast.CastStatus, record.CastStatus },
					{ ImpProductionCast.CastDivision, record.CastDivision },
				},
				Where = 
				{
					{ ImpProductionCast.Factory.Equal( record.Factory ) },
					{ ImpProductionCast.Project.Equal( record.Factory ) },// Factory, Factory for productionCast & ProductionCastStrand
					{ ImpProductionCast.CastId.Equal( record.CastId ) },
				},
			};

            if( !hasScheduleCollision )
            {
                update.Columns.Add( ImpProductionCast.Shift, record.Shift );
                update.Columns.Add( ImpProductionCast.StartDate, record.StartDate );
                update.Columns.Add( ImpProductionCast.EndDate, record.EndDate );
            }

			string statement = update.ToString();

			int result;

			using( ImpactDatabase database = new ImpactDatabase() )
			{
				result = database.ExecuteNonQuery( statement );
			}

			return new CastResult { HasScheduleCollision = hasScheduleCollision, EffectedRows = result };
		}
        /// <summary>
        /// Update the transport and elements with new status
        /// </summary>
        /// <param name="transports"></param>
        /// <param name="recTransportStatus"></param>
        /// <returns></returns>
        public int UpdateStatusProductionCast( List<RecProductionCast> casts, RecProductionCast recProductionCastStatus )
        {
            if( null == casts || casts.Count == 0 )
            {
                return 0;
            }

            ProjectManager mgr = new ProjectManager();
            RecElementIdStatusStd std = new RecElementIdStatusStd { Factory = recProductionCastStatus.Factory, Project = recProductionCastStatus.Project };
            List<RecElementIdStatusStd> settings = mgr.LoadStandardSettings( std );

            int ret = 0;
            foreach( RecProductionCast rec in casts )
            {
                ret += UpdateStatus( rec, recProductionCastStatus, settings );
            }

            return ret;
        }
        /// <summary>
        /// Update the cast and elements with new status
        /// </summary>
        /// <param name="transports"></param>
        /// <param name="recTransportStatus"></param>
        /// <returns></returns>
        private int UpdateStatus( RecProductionCast cast, RecProductionCast recProductionCastStatus, List<RecElementIdStatusStd> settings )
        {
            if( null == cast || null == recProductionCastStatus )
            {
                return 0;
            }

            ModelPlanner plannerService = new ModelPlanner();
            
            plannerService.SaveElementProductionStatus( cast, recProductionCastStatus, settings );

            int ret = 0;
            using( ImpactDatabase database = new ImpactDatabase() )
            {
                ImpactUpdate update = new ImpactUpdate( ImpProductionCast.Instance )
                {
                    Columns = 
					{
 						{ ImpProductionCast.CastStatus, recProductionCastStatus.CastStatus },
					},
                    Where =
					{
						ImpProductionCast.Factory.Equal( cast.Factory ),
						ImpProductionCast.Project.Equal( cast.Factory ), //Factory, Factory
						ImpProductionCast.CastId.Equal( cast.CastId ),
					}
                };
                
                string sql = update.ToString();

                ret = database.ExecuteNonQuery( sql );
            }
            return ret;
        }
		/// <summary>  
		/// Load all records of the same factory and project as the supplied record.
		/// </summary>
		/// <param name="record">A record with factory and project set.</param>
		/// <returns>A list of all mathcing records.</returns>
		public List<RecProductionCast> LoadProductionCast( BedFilter filter, RecProductionCast record )
		{
            List<RecProductionCast> castData = new List<RecProductionCast>( );
			ImpactQuery query = new ImpactQuery()
			{
				Select =
				{
					ImpProductionCast.Factory,
					ImpProductionCast.Project,
					ImpProductionCast.CastId,
					ImpProductionCast.CastType,
					ImpProductionCast.Description,
					ImpProductionCast.Shift,
					ImpProductionCast.StartDate,
					ImpProductionCast.EndDate,
					ImpProductionCast.Form,
					ImpProductionCast.Tolerance,
					ImpProductionCast.ElementType,
					ImpProductionCast.Style,
					ImpProductionCast.Strandptn,
					ImpProductionCast.CastStatus,
					ImpProductionCast.CastDivision,

					ImpProductionFormStd.Location,
				},
				From  = { ImpProductionCast.As( "T1" ) },

				Join =
				{
					Join.Left( ImpProductionFormStd.As( "FRM" ),	
						ImpProductionCast.Factory.Equal( ImpProductionFormStd.Factory ),
						ImpProductionCast.Project.Equal( ImpProductionFormStd.Project ),//Factory, Factory
						ImpProductionCast.Form.Equal( ImpProductionFormStd.Name ) ),
				},

				Where = { ImpProductionCast.Factory.Equal( record.Factory ) , 
                          ImpProductionCast.Project.Equal( record.Factory ) }, // Factory, Factory for productionCast & ProductionCastStrand
			};

			query.Where.Add( ImpProductionCast.StartDate.Equal( record.StartDate ) );
			query.Where.Add( ImpProductionCast.Form.Equal( record.Form ) );

            if( filter != null )
            {
                if( filter.Shift != 0 )
                {
                    query.Where.Add( ImpProductionCast.Shift.Equal( filter.Shift) );
                }
                if( !filter.Location.Equals( Filter.All) && !string.IsNullOrEmpty( filter.Location ) )
                {
                    query.Where.Add( ImpProductionFormStd.Location.Equal( filter.Location) );
                }
                if( !filter.Bed.Equals( Filter.All) && !string.IsNullOrEmpty( filter.Bed ) )
                {
                    query.Where.Add( ImpProductionCast.Form.Equal( filter.Bed ) );
                }
                if( filter.UseStartDateFrom )
                {
                    query.Where.Add( ImpProductionCast.StartDate.GreaterThanOrEqual( filter.StartDateFrom ) );
                }			
                if( filter.UseStartDateTo )
                {
                    query.Where.Add( ImpProductionCast.StartDate.LessThanOrEqual( filter.StartDateTo ) );
                }			
                if( filter.UseEndDateFrom )
                {
                    query.Where.Add( ImpProductionCast.EndDate.GreaterThanOrEqual( filter.EndDateFrom ) );
                }			
                if( filter.UseEndDateTo )
                {
                    query.Where.Add( ImpProductionCast.EndDate.LessThanOrEqual( filter.EndDateTo ) );
                }			
            }
			string statement = query.ToString();

			List<RecProductionCast> result;

			using( ImpactDatabase database = new ImpactDatabase() )
			{
				result = database.GetAll( statement, ParseProductionCast );
			}

            return result;
		}