FCC/Extension/WayneClassicFdcClient/FControlFUSIONCF/FUSIONTank.cs

#region  --------------- Copyright Dresser Wayne Pignone -------------
/*
 * $Log: /Wrk/Support/ForecourtControl/Wrk/NfsControl/NfsTank.cs $
 *
 * 3     07-11-14 20:35 roger.månsson
 * Set ParserDomain on messages.
 *
 * 2     07-03-09 15:42 roger.månsson
 * Implemented the RPC function sending
 *
 * 1     07-02-02 17:13 roger.månsson
 * Created
 */
#endregion
using System;
using Wayne.Lib;

#if _SINP
using Wayne.ForecourtControl.Nfs;
#endif

namespace Wayne.ForecourtControl.Fusion
{
    public class FUSIONTank : ITank
    {
        #region Fields

        FUSIONManager manager;

        int id;
        ITankGroup tankGroup;
        Wayne.Lib.DeviceConnectionState connectionState = Wayne.Lib.DeviceConnectionState.Unknown;
        ITankReading latestPhysicalReading;
        ITankReadingEx latestPhysicalReadingEx;
        bool capPhysicalReading;

        #endregion

        #region Events

        public event EventHandler<ConnectionChangedEventArgs> OnConnectionStateChange;

        #endregion

        #region Construction

        public FUSIONTank(FUSIONManager manager, int id, ITankGroup tankGroup)
        {
            this.manager = manager;
            this.id = id;
            this.tankGroup = tankGroup;
        }

        #endregion

        #region Properties

        public int Id
        {
            get
            {
                if (manager.IdTankShift > 0)
                    return this.id + manager.IdTankShift;
                else
                    return this.id + manager.IdShift;
            }
        }

        public int realId
        {
            get
            {
                return this.id;
            }
        }


        public ITankGroup TankGroup
        {
            get { return tankGroup; }
        }

        public Wayne.Lib.DeviceConnectionState ConnectionState
        {
            get { return connectionState; }
        }

        public ITankReading LatestPhysicalReading
        {
            get { return latestPhysicalReading; }
        }
        public ITankReadingEx LatestPhysicalReadingEx
        {
            get { return latestPhysicalReadingEx; }
        }

        public bool CapPhysicalReading
        {
            get { return capPhysicalReading; }
        }

        #endregion

        /*static public ITank getTankByIndex(int iTankGroupId, int iTankId)
        {
            foreach (ITankGroup tankgroup in FUSIONFactory.fusionForecourtControl.TankGroups)
            {
                if (tankgroup.Id == iTankGroupId)
                {
                    foreach (ITank tank in tankgroup.Tanks)
                    {
                        if (tank.Id == iTankId)
                            return tank;
                    }
                }
            }
            return null;
        }*/

        #region Methods

        public void ReadAsync(EventHandler<Wayne.Lib.AsyncCompletedEventArgs<ITankReading>> readingCompleted, object userToken)
        {
            throw new NotImplementedException();
            //this.manager.ifsfManager.GetTankData(this.realId, this.realId, readingCompleted, userToken, this);
        }

        public void ReadAsyncEx(EventHandler<Wayne.Lib.AsyncCompletedEventArgs<ITankReadingEx>> readingCompleted, object userToken)
        {
            //AsyncOperation<UInt16> operation = manager.AsyncManager.RegisterOperation(this, readingCompleted, userToken);

            //manager.Send(new Function(Fid.RpcReqTigScan,
            //    ParserDomain.FillingServer,
            //    new PrimitiveParameter(Pid.SequenceNumber, PrimitiveType.UInt16, operation.Id),
            //    new PrimitiveParameter(Pid.TankNumber, PrimitiveType.Byte, this.id + 1)));

            this.manager.ifsfManager.GetTankData(this.realId, this.realId, readingCompleted, userToken, this);
            //if (readingCompleted != null)
            //    readingCompleted.Invoke(this, new AsyncCompletedEventArgs<ITankReadingEx>(true, null, userToken));
        }

        public void RegisterManualTankDippingAsync(decimal tankLevel, EventHandler<Wayne.Lib.AsyncCompletedEventArgs> manualTankDippingRegistered, object userToken)
        {
            throw new NotImplementedException();
            //AsyncOperation<UInt16> operation = manager.AsyncManager.RegisterOperation(this, manualTankDippingRegistered, userToken);

            //manager.Send(new Function(Fid.RpcReqTankDipping,
            //    ParserDomain.FillingServer,
            //    new PrimitiveParameter(Pid.SequenceNumber, PrimitiveType.UInt16, operation.Id),
            //    new PrimitiveParameter(Pid.DateTime, PrimitiveType.DateTime, DateTime.Now),
            //    new PrimitiveParameter(Pid.TankNumber, PrimitiveType.Byte, this.id + 1),
            //    new PrimitiveParameter(Pid.TankVolume, PrimitiveType.Decimal, tankLevel)));
        }

        #endregion

        #region Internal Writable Properties

        internal Wayne.Lib.DeviceConnectionState WritableConnectionState
        {
            get { return connectionState; }
            set
            {
                if (connectionState != value)
                {
                    connectionState = value;
                    if (OnConnectionStateChange != null)
                        OnConnectionStateChange.BeginInvoke(this, new ConnectionChangedEventArgs(connectionState), null, null);
                }
            }
        }

        internal ITankReading WritableLatestPhysicalReading
        {
            get { return latestPhysicalReading; }
            set { latestPhysicalReading = value; }
        }
        internal ITankReadingEx WritableLatestPhysicalReadingEx
        {
            get { return latestPhysicalReadingEx; }
            set { latestPhysicalReadingEx = value; }
        }

        internal bool WritableCapPhysicalReading
        {
            get { return capPhysicalReading; }
            set { capPhysicalReading = value; }
        }

        #endregion
    }
}