Exemple #1
0
 public SearchLog(WorkingData wd, ISearch isp)
 {
     Plugins = isp;
     Config  = wd.Config;
     Log     = wd.Log;
     Station = new List <StationData>();
 }
Exemple #2
0
        public SearchWindow(WorkingData wd, InterSet[] isp)
        {
            int ispl = isp.Length;

            sl = new SearchLog[ispl];
            bw = new BackgroundWorker[ispl];
            InitializeComponent();
            DevideLog(wd);

            pbCondition1.Maximum = wdx[0].Log.Count;
            pbCondition2.Maximum = wdx[1].Log.Count;
            pbConditionA.Maximum = wd.Log.Count;
            pbCondition1.Value   = pbCondition2.Value = pbConditionA.Value = 0;

            btStop.IsEnabled = true;
            for (int i = 0; i < ispl; i++)
            {
                sl[i] = new SearchLog(wdx[i], isp[i].Sea);
                bw[i] = new BackgroundWorker();
                sl[i].SetWorker(bw[i]);
                bw[i].DoWork             += new DoWorkEventHandler(sl[i].StartSearch);
                bw[i].ProgressChanged    += new ProgressChangedEventHandler(ProgressChanged);
                bw[i].RunWorkerCompleted += new RunWorkerCompletedEventHandler(RunWorkerCompleted);

                bw[i].WorkerReportsProgress      = true;
                bw[i].WorkerSupportsCancellation = true;
                bw[i].RunWorkerAsync();
            }
        }
Exemple #3
0
        public SearchWindow(WorkingData wd, InterSet[] isp)
        {
            int ispl = isp.Length;
            sl = new SearchLog[ispl];
            bw = new BackgroundWorker[ispl];
            InitializeComponent();
            DevideLog(wd);

            pbCondition1.Maximum = wdx[0].Log.Count;
            pbCondition2.Maximum = wdx[1].Log.Count;
            pbConditionA.Maximum = wd.Log.Count;
            pbCondition1.Value = pbCondition2.Value = pbConditionA.Value = 0;

            btStop.IsEnabled = true;
            for(int i = 0;i < ispl; i++) {
                sl[i] = new SearchLog(wdx[i], isp[i].Sea);
                bw[i] = new BackgroundWorker();
                sl[i].SetWorker(bw[i]);
                bw[i].DoWork += new DoWorkEventHandler(sl[i].StartSearch);
                bw[i].ProgressChanged += new ProgressChangedEventHandler(ProgressChanged);
                bw[i].RunWorkerCompleted += new RunWorkerCompletedEventHandler(RunWorkerCompleted);

                bw[i].WorkerReportsProgress = true;
                bw[i].WorkerSupportsCancellation = true;
                bw[i].RunWorkerAsync();
            }
        }
Exemple #4
0
 public SearchLog(WorkingData wd, ISearch isp)
 {
     Plugins = isp;
     Config = wd.Config;
     Log = wd.Log;
     Station = new List<StationData>();
 }
Exemple #5
0
        private void CreateHavestMoistureSpatialRecord(WorkingData workingData, double value)
        {
            var spatialRecord = new SpatialRecord();
            var meter1Value1  = CreateHarvestMoisture(value);

            spatialRecord.SetMeterValue(workingData, meter1Value1);
            _spatialRecords.Add(spatialRecord);
        }
        public void Setup()
        {
            _meter  = new NumericWorkingData();
            _meters = new List <WorkingData>();

            _representationMapperMock = new Mock <IRepresentationMapper>();
            _dlvHeaderMapper          = new DlvHeaderMapper(_representationMapperMock.Object);
        }
        private static void CreateNumericMeterCell(SpatialRecord spatialRecord, WorkingData workingData, int depth, DataRow dataRow)
        {
            var numericRepresentationValue = spatialRecord.GetMeterValue(workingData) as NumericRepresentationValue;
            var value = numericRepresentationValue != null
                ? numericRepresentationValue.Value.Value.ToString(CultureInfo.InvariantCulture)
                : "";

            dataRow[GetColumnName(workingData, depth)] = value;
        }
Exemple #8
0
            /// <summary>
            /// ログデータからオペレータリストを作成
            /// </summary>
            /// <param name="workData">作業データ</param>
            /// <returns>自動集計がtrueならカンマ区切りでオペレータリストを作成, そうでないなら入力されているもの</returns>
            public static string GetOpList(WorkingData workData)
            {
                if (!workData.Config.IsAutoOperatorEditEnabled)
                {
                    return(workData.Config.Operator);
                }
                var op = workData.Log.Select(x => x.Operator).Where(x => x != "").Distinct().OrderBy(x => x).ToArray();

                return(string.Join(",", op));
            }
Exemple #9
0
 private void DevideLog(WorkingData wd)
 {
     wdx = new WorkingData[sl.Length];
     int SkipCount = 0;
     for(int i = 0;i < sl.Length; i++) {
         wdx[i] = new WorkingData();
         wdx[i].Config = wd.Config;
         wdx[i].Log = new ObservableCollection<LogData>(wd.Log.Skip(SkipCount).Take(wd.Log.Count / sl.Length));
         SkipCount += wd.Log.Count / sl.Length;
     }
 }
Exemple #10
0
        private void LoadWork(string filename)
        {
            DataContractSerializer serial = new DataContractSerializer(typeof(WorkingData));
            XmlReader xr = XmlReader.Create(filename);

            Work = new WorkingData();
            Work = (WorkingData)serial.ReadObject(xr);
            ConfTab.DoLoad(Work.Config);
            UpdateData();
            xr.Close();
        }
Exemple #11
0
 public void onTick(WorkingData wd)
 {
     if (root == null)
     {
         return;
     }
     if (root.canDo(wd))
     {
         root.onTick(wd);
     }
 }
Exemple #12
0
 public void SetMostRecentMeterValue(WorkingData meter, RepresentationValue value)
 {
     if (_meterToPreviousValue.ContainsKey(meter))
     {
         _meterToPreviousValue[meter] = value;
     }
     else
     {
         _meterToPreviousValue.Add(meter, value);
     }
 }
Exemple #13
0
            public override void Process(ImageContext context)
            {
                base.Process(context);

                if (context != null && context.Eos)
                {
                    MyEmguEvent?.Invoke(this, new EmguEventArgs {
                        ImageData = WorkingData.ToArray()
                    });
                    WorkingData.Clear();
                }
            }
Exemple #14
0
        public OutputSummery(WorkingData wd, InterSet[] isp)
        {
            OutputLog ol = new OutputLog(wd, isp[0].Sum);

            if (!ol.Execute())
            {
                MessageBox.Show("サマリ作成に失敗しました。", "通知");
                return;
            }
            InitializeComponent();
            tbOutput.Text = ol.Sheet;
        }
        public List <WorkingData> Map(ISOTime time,
                                      IEnumerable <ISOSpatialRow> isoSpatialRows,
                                      DeviceElementUse deviceElementUse,
                                      DeviceElementHierarchy isoDeviceElementHierarchy,
                                      List <DeviceElementUse> pendingDeviceElementUses,
                                      Dictionary <string, List <ISOProductAllocation> > isoProductAllocations)
        {
            var workingDatas = new List <WorkingData>();

            //Set orders on the collection of DLVs
            var allDLVs = time.DataLogValues;

            for (int order = 0; order < allDLVs.Count(); order++)
            {
                var dlv = allDLVs.ElementAt(order);
                dlv.Order = order;
            }


            //Create vrProductIndex on relevant device elements if more than one product on this OperationData
            if (TimeLogMapper.GetDistinctProductIDs(TaskDataMapper, isoProductAllocations).Count > 1 &&
                isoProductAllocations.Keys.Contains(isoDeviceElementHierarchy.DeviceElement.DeviceElementId))
            {
                WorkingData workingData = CreateProductIndexWorkingData(deviceElementUse.Id.ReferenceId);
                ISODeviceElementIDsByWorkingDataID.Add(workingData.Id.ReferenceId, isoDeviceElementHierarchy.DeviceElement.DeviceElementId);
                workingDatas.Add(workingData);
            }

            //Add the Working Datas for this DeviceElement
            IEnumerable <ISODataLogValue> deviceElementDLVs = allDLVs.Where(dlv => dlv.DeviceElementIdRef == isoDeviceElementHierarchy.DeviceElement.DeviceElementId);

            foreach (ISODataLogValue dlv in deviceElementDLVs)
            {
                IEnumerable <WorkingData> newWorkingDatas = Map(dlv,
                                                                isoSpatialRows,
                                                                deviceElementUse,
                                                                dlv.Order,
                                                                pendingDeviceElementUses,
                                                                isoDeviceElementHierarchy);
                if (newWorkingDatas.Count() > 0)
                {
                    int ddi = dlv.ProcessDataDDI.AsInt32DDI();
                    if (!EnumeratedMeterFactory.IsCondensedMeter(ddi))
                    {
                        //We skip adding Condensed WorkingDatas to this DeviceElementUse since they were added separately below to their specific DeviceElementUse
                        workingDatas.AddRange(newWorkingDatas);
                    }
                }
            }

            return(workingDatas);
        }
Exemple #16
0
        private void DevideLog(WorkingData wd)
        {
            wdx = new WorkingData[sl.Length];
            int SkipCount = 0;

            for (int i = 0; i < sl.Length; i++)
            {
                wdx[i]        = new WorkingData();
                wdx[i].Config = wd.Config;
                wdx[i].Log    = new ObservableCollection <LogData>(wd.Log.Skip(SkipCount).Take(wd.Log.Count / sl.Length));
                SkipCount    += wd.Log.Count / sl.Length;
            }
        }
Exemple #17
0
 public OutputLog(WorkingData wd, ISummery isp)
 {
     Plugins = isp;
     freqNum = 15;
     areaMax = 500000;
     Multi = new List<Multiply>();
     Work = wd;
     if (Plugins != null) {
         Plugins.config = Work.Config;
         Plugins.areaMax = areaMax;
         Plugins.freqNum = freqNum;
         Plugins.listMulti = Multi;
     }
 }
Exemple #18
0
    public static WorkingData createData(BaseEntity agent)
    {
        WorkingData             wd = new WorkingData();
        WorkingDataConfigConfig dt = WorkingDataConfigConfig.Get(agent.getWorkingDataId());

        if (dt != null)
        {
            wd.dyAgent     = agent as EntityDynamicActor;
            wd.orgPos      = agent.CacheTrans.position;
            wd.seekTime    = dt.seekTime;
            wd.seekRange   = dt.seekRange;
            wd.partolRange = dt.partolRange;
        }
        return(wd);
    }
Exemple #19
0
 public OutputLog(WorkingData wd, ISummery isp)
 {
     Plugins = isp;
     freqNum = 15;
     areaMax = 500000;
     Multi   = new List <Multiply>();
     Work    = wd;
     if (Plugins != null)
     {
         Plugins.config    = Work.Config;
         Plugins.areaMax   = areaMax;
         Plugins.freqNum   = freqNum;
         Plugins.listMulti = Multi;
     }
 }
        private void UpdateCondensedWorkingDatas(List <WorkingData> condensedWorkingDatas, ISODataLogValue dlv, DeviceElementUse deviceElementUse, List <DeviceElementUse> pendingDeviceElementUses, DeviceElementHierarchy isoDeviceElementHierarchy)
        {
            ISODeviceElement isoDeviceElement = TaskDataMapper.DeviceElementHierarchies.GetISODeviceElementFromID(dlv.DeviceElementIdRef);
            IEnumerable <ISODeviceElement> isoSectionElements = isoDeviceElement.ChildDeviceElements.Where(d => d.DeviceElementType == ISOEnumerations.ISODeviceElementType.Section);

            if (isoSectionElements.Count() > 0 && isoSectionElements.Count() <= condensedWorkingDatas.Count)
            {
                //We have found the expected number of sections in the DDOP
                List <ISODeviceElement> targetSections = isoSectionElements.ToList();

                //Update the DeviceElementReference on the Condensed WorkingDatas
                for (int i = 0; i < isoSectionElements.Count(); i++)
                {
                    WorkingData workingData = condensedWorkingDatas[i];

                    DeviceElementUse condensedDeviceElementUse = new DeviceElementUse();
                    condensedDeviceElementUse.OperationDataId = deviceElementUse.OperationDataId;

                    ISODeviceElement targetSection = targetSections[i];
                    int?deviceElementID            = TaskDataMapper.InstanceIDMap.GetADAPTID(targetSection.DeviceElementId);
                    if (deviceElementID.HasValue)
                    {
                        DeviceElement deviceElement = DataModel.Catalog.DeviceElements.SingleOrDefault(d => d.Id.ReferenceId == deviceElementID.Value);
                        if (deviceElement != null)
                        {
                            //Reference the device element in its hierarchy so that we can get the depth & order
                            DeviceElementHierarchy deviceElementInHierarchy = isoDeviceElementHierarchy.FromDeviceElementID(targetSection.DeviceElementId);

                            //Get the config id
                            DeviceElementConfiguration deviceElementConfig = DeviceElementMapper.GetDeviceElementConfiguration(deviceElement, deviceElementInHierarchy, DataModel.Catalog);
                            condensedDeviceElementUse.DeviceConfigurationId = deviceElementConfig.Id.ReferenceId;

                            //Set the depth & order
                            condensedDeviceElementUse.Depth = deviceElementInHierarchy.Depth;
                            condensedDeviceElementUse.Order = deviceElementInHierarchy.Order;
                        }
                    }

                    condensedDeviceElementUse.GetWorkingDatas = () => new List <WorkingData> {
                        workingData
                    };

                    workingData.DeviceElementUseId = condensedDeviceElementUse.Id.ReferenceId;

                    pendingDeviceElementUses.Add(condensedDeviceElementUse);
                }
            }
        }
        public IEnumerable <ISODataLogValue> ExportDataLogValues(List <WorkingData> workingDatas, List <DeviceElementUse> deviceElementUses)
        {
            if (workingDatas == null)
            {
                return(null);
            }

            List <ISODataLogValue> dlvs = new List <ISODataLogValue>();

            for (int i = 0; i < workingDatas.Count(); i++)
            {
                WorkingData workingData = workingDatas[i];

                //DDI
                int?mappedDDI = RepresentationMapper.Map(workingData.Representation);
                var dlv       = new ISODataLogValue();
                if (mappedDDI != null)
                {
                    if (workingData.Representation != null && workingData.Representation.Code == "dtRecordingStatus" && workingData.DeviceElementUseId != 0)
                    {
                        dlv.ProcessDataDDI = 141.AsHexDDI(); //No support for exporting CondensedWorkState at this time
                    }
                    else
                    {
                        dlv.ProcessDataDDI = mappedDDI.Value.AsHexDDI();
                    }
                }
                else if (workingData.Representation.CodeSource == ApplicationDataModel.Representations.RepresentationCodeSourceEnum.ISO11783_DDI)
                {
                    dlv.ProcessDataDDI = workingData.Representation.Code;
                }

                //DeviceElementIdRef
                DeviceElementUse use = deviceElementUses.FirstOrDefault(d => d.Id.ReferenceId == workingData.DeviceElementUseId);
                if (use != null)
                {
                    DeviceElementConfiguration deviceElementConfiguration = DataModel.Catalog.DeviceElementConfigurations.FirstOrDefault(d => d.Id.ReferenceId == use.DeviceConfigurationId);
                    if (deviceElementConfiguration != null)
                    {
                        //This requires the Devices will have been mapped prior to the LoggedData
                        dlv.DeviceElementIdRef = TaskDataMapper.InstanceIDMap.GetISOID(deviceElementConfiguration.DeviceElementId);
                    }
                }
                dlvs.Add(dlv);
                _dataLogValueOrdersByWorkingDataID.Add(workingData.Id.ReferenceId, i);
            }
            return(dlvs);
        }
Exemple #22
0
        private static void Callback(object o)
        {
            if (_isWork)
            {
                return;
            }

            try
            {
                _isWork = true;
                WorkingData.Create(new WorkOrderSQLServer());
            }
            finally
            {
                _isWork = false;
            }
        }
Exemple #23
0
    public override ActionStatus onUpdate(WorkingData wd)
    {
        if (Time.timeSinceLevelLoad >= nextSeekTime && wd.dyAgent.Target == null)
        {
            //List<BaseEntity> players = EntityMgr.Instance.getEntityByType(EntityType.player);
            //if (players != null && players.Count > 0)
            //{
            //    for (int i = 0; i < players.Count; i++)
            //    {
            //        if (Vector3.Distance(players[i].CacheTrans.position, wd.dyAgent.CacheTrans.position) <= wd.seekRange)
            //        {
            //            wd.dyAgent.Target = players[i];
            //            return ActionStatus.finished;
            //        }
            //    }
            //}
            nextSeekTime = wd.seekTime + Time.timeSinceLevelLoad;
        }

        if (wd.dyAgent.SType == StateType.onHit)
        {
            return(ActionStatus.finished);
        }

        if (Time.timeSinceLevelLoad >= nextPartolTime)
        {
            if (Vector3.Distance(wd.dyAgent.CacheTrans.position, nextPartolPoint) > 1f)
            {
                this.dyAgent.onChangeState(StateType.run);
                wd.dyAgent.CacheTrans.LookAt(nextPartolPoint, Vector3.up);
                wd.dyAgent.moveTo((nextPartolPoint - wd.dyAgent.CacheTrans.position).normalized);
            }
            else
            {
                nextPartolPoint = getPartolPoint(wd);
                nextPartolTime  = partolTime + Time.timeSinceLevelLoad;
            }
        }
        else
        {
            this.dyAgent.onChangeState(StateType.idle);
        }
        return(ActionStatus.running);
    }
        public List <WorkingData> Map(ISOTime time,
                                      IEnumerable <ISOSpatialRow> isoSpatialRows,
                                      DeviceElementUse deviceElementUse,
                                      DeviceHierarchyElement isoDeviceElementHierarchy,
                                      List <DeviceElementUse> pendingDeviceElementUses,
                                      Dictionary <string, List <ISOProductAllocation> > isoProductAllocations)
        {
            var workingDatas = new List <WorkingData>();

            //Create vrProductIndex on relevant device elements if more than one product on this OperationData
            if (TimeLogMapper.GetDistinctProductIDs(TaskDataMapper, isoProductAllocations).Count > 1 &&
                isoProductAllocations.Keys.Contains(isoDeviceElementHierarchy.DeviceElement.DeviceElementId))
            {
                WorkingData workingData = CreateProductIndexWorkingData(deviceElementUse.Id.ReferenceId);
                ISODeviceElementIDsByWorkingDataID.Add(workingData.Id.ReferenceId, isoDeviceElementHierarchy.DeviceElement.DeviceElementId);
                workingDatas.Add(workingData);
            }

            //Add the Working Datas for this DeviceElement
            IEnumerable <ISODataLogValue> deviceElementDLVs = time.DataLogValues.Where(dlv => dlv.DeviceElementIdRef == isoDeviceElementHierarchy.DeviceElement.DeviceElementId ||      //DLV DET reference matches the primary DET for the ADAPT element
                                                                                       isoDeviceElementHierarchy.MergedElements.Any(e => e.DeviceElementId == dlv.DeviceElementIdRef)); //DLV DET reference matches one of the merged DETs on the ADAPT element


            foreach (ISODataLogValue dlv in deviceElementDLVs)
            {
                IEnumerable <WorkingData> newWorkingDatas = Map(dlv,
                                                                isoSpatialRows,
                                                                deviceElementUse,
                                                                dlv.Index,
                                                                pendingDeviceElementUses,
                                                                isoDeviceElementHierarchy);
                if (newWorkingDatas.Count() > 0)
                {
                    int ddi = dlv.ProcessDataDDI.AsInt32DDI();
                    if (!EnumeratedMeterFactory.IsCondensedMeter(ddi))
                    {
                        //We skip adding Condensed WorkingDatas to this DeviceElementUse since they were added separately below to their specific DeviceElementUse
                        workingDatas.AddRange(newWorkingDatas);
                    }
                }
            }

            return(workingDatas);
        }
Exemple #25
0
        public RepresentationValue Interpolate(WorkingData meter)
        {
            if (!_meterToPreviousValue.ContainsKey(meter))
            {
                return(null);
            }

            var previousValue = _meterToPreviousValue[meter];

            var numericRepresentationValue = previousValue as NumericRepresentationValue;

            if (numericRepresentationValue != null)
            {
                var newNumericRepresentationValue = numericRepresentationValue.Copy();

                if (numericRepresentationValue.Representation != null && _numericRepresentationTotals.Contains(numericRepresentationValue.Representation.Code))
                {
                    newNumericRepresentationValue.Value.Value = 0;
                }

                return(newNumericRepresentationValue);
            }

            var enumeratedValue = previousValue as EnumeratedValue;

            if (enumeratedValue != null)
            {
                var newEnumeratedValue = new EnumeratedValue
                {
                    Code  = enumeratedValue.Code,
                    Value = new EnumerationMember
                    {
                        Code  = enumeratedValue.Value.Code,
                        Value = enumeratedValue.Value.Value
                    },
                    Representation = enumeratedValue.Representation
                };

                return(newEnumeratedValue);
            }

            return(null);
        }
Exemple #26
0
        /// <summary>
        /// 接收UDP数据包
        /// </summary>
        /// <param name="token">取消任务标记</param>
        private void Listener(CancellationToken token)
        {
            while (true)
            {
                try {
                    byte[]   buff   = new byte[512];
                    EndPoint client = new IPEndPoint(IPAddress.Loopback, 0);
                    int      read   = server.ReceiveFrom(buff, ref client);

                    TaskFactory task = new TaskFactory();
                    WorkingData data = new WorkingData(buff.Take(read).ToArray(), client);
                    task.StartNew(new Action <object>(t => {
                        Working(data);
                    }), data);
                } catch { continue; }

                token.ThrowIfCancellationRequested();
            }
        }
        public WorkingData ConvertToBaseType(WorkingData meter)
        {
            if (meter is ISOEnumeratedMeter)
            {
                var enumMeter = (ISOEnumeratedMeter)meter;
                var newMeter  = new EnumeratedWorkingData
                {
                    AppliedLatency     = enumMeter.AppliedLatency,
                    DeviceElementUseId = enumMeter.DeviceElementUseId,
                    ReportedLatency    = enumMeter.ReportedLatency,
                    Representation     = enumMeter.Representation,
                    ValueCodes         = enumMeter.ValueCodes,
                };
                newMeter.Id.ReferenceId = meter.Id.ReferenceId;
                newMeter.Id.UniqueIds   = meter.Id.UniqueIds;

                return(newMeter);
            }
            return(meter);
        }
Exemple #28
0
        public MainWindow()
        {
            try {
                if (System.IO.File.Exists("check.ls"))
                {
                    System.IO.StreamReader sr = new System.IO.StreamReader("check.ls", System.Text.Encoding.UTF8);
                    if (sr.Peek() > 0)
                    {
                        if (Version != sr.ReadLine())
                        {
                            sr.Close();
                            WarnRule();
                        }
                        else
                        {
                            sr.Close();
                        }
                    }
                }
                else
                {
                    WarnRule();
                }
            } catch {
                this.Close();
            }
            Work     = new WorkingData();
            Work.Log = new ObservableCollection <LogData>();

            InitializeComponent();
            this.Title += "(Ver: " + Version + ")";
            SetInterset();
            List <IDefine> defPlugins = new List <IDefine>();

            foreach (var i in Intersets[0])
            {
                defPlugins.Add(i.Def);
            }
            ConfTab.Plugins   = defPlugins.ToArray();
            dgLog.ItemsSource = Work.Log;
        }
Exemple #29
0
    /// <summary>
    /// 选择节点
    /// 当节点返回success 则返回success
    /// 当节点返回failure 则执行下一个节点 返回running
    /// 否则返回running
    /// </summary>
    /// <returns></returns>
    public override BTResult onTick(WorkingData wd)
    {
        BTResult status = this.children[this.currIndex].onTick(wd);

        if (status == BTResult.success)
        {
            clear();
            return(BTResult.success);
        }
        if (status == BTResult.failure)
        {
            this.currIndex++;
            if (this.currIndex >= this.children.Count)
            {
                clear();
                return(BTResult.success);
            }
            status = BTResult.running;
        }
        return(status);
    }
    sealed public override BTResult onTick(WorkingData wd)
    {
        BTResult result = BTResult.running;

        if (actStatus == ActionStatus.ready)
        {
            onEnter(wd);
            actStatus = ActionStatus.running;
        }
        if (actStatus == ActionStatus.running)
        {
            actStatus = onUpdate(wd);
            if (actStatus == ActionStatus.finished)
            {
                onExit(wd);
                actStatus = ActionStatus.ready;
                result    = BTResult.success;
            }
        }
        return(result);
    }
        public WorkerViewModel()
        {
            _workOrderRepository      = new WorkOrderSQLServer();
            Worker1StartButton        = new DelegateCommand(Worker1StartButtonExecute);
            Worker2StartButton        = new DelegateCommand(Worker2StartButtonExecute);
            Worker3StartButton        = new DelegateCommand(Worker3StartButtonExecute);
            _timeManagementRepository = new TimeManagementSQLServer();

            observableTimer = Observable.Timer(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2))
                              .Subscribe(_ =>
            {
                LabelContent.Value  += 1;
                WorkerWorkings.Value = new ObservableCollection <WorkingEntity>(WorkingData.GetWorkings(WorkId.Value, WorkerId.Value));
            });

            NextCommand = CanNext.Select(x => x == false).ToReactiveCommand();
            NextCommand.Subscribe(_ => { _workOrderRepository.ToNext(WorkId.Value, WorkerId.Value); });

            WorkerId.Subscribe(x =>
            {
            });
        }
Exemple #32
0
        public DLV Map(WorkingData meter)
        {
            var representation = _representationMapper.Map(meter.Representation);

            var dlv = new DLV();

            if (representation == null)
            {
                dlv.A = null;
            }
            else
            {
                if (meter.Representation != null && meter.Representation.Code == "dtRecordingStatus" && meter.DeviceElementUseId != 0)
                {
                    dlv.A = "161";
                }
                else
                {
                    dlv.A = representation.ToString();
                }
            }

            return(dlv);
        }
        private static void GetAsAppliedData(OperationData opData, Catalog catalog)
        {
            WorkingData areaMeter    = null;
            WorkingData appRateMeter = null;
            IEnumerable <DeviceElementUse> headDEUs = opData.GetDeviceElementUses(1);

            foreach (DeviceElementUse deu in headDEUs)
            {
                IEnumerable <WorkingData> workingDatas = deu.GetWorkingDatas();
                foreach (WorkingData meter in workingDatas)
                {
                    switch (meter.Representation.Code)
                    {
                    case "vrDeltaArea":
                        areaMeter = meter;
                        break;

                    case "vrAppRateVolumeActual":
                        appRateMeter = meter;
                        break;
                    }
                }
            }

            double totalArea   = 0;
            double totalAmount = 0;

            string rateUnits = "";

            // Loop through all the spatial records to get total area and total amount
            IEnumerable <SpatialRecord> spatialRecords = opData.GetSpatialRecords();

            foreach (SpatialRecord spatialRecord in spatialRecords)
            {
                // Calculate the area
                NumericRepresentationValue area = spatialRecord.GetMeterValue(areaMeter) as NumericRepresentationValue;

                double acres = area.Value.Value;
                totalArea += acres;

                NumericRepresentationValue appRate = spatialRecord.GetMeterValue(appRateMeter) as NumericRepresentationValue;
                rateUnits = appRate.Value.UnitOfMeasure.Code;

                double rate   = appRate.Value.Value; // gal/ac
                double amount = rate * acres;        // gal
                totalAmount += amount;
            }

            double averageRate = totalAmount / totalArea;

            Console.WriteLine("Application Summary:");

            string result = String.Format("Area: {0:F2}\tAmount: {1:F2}\tRate: {2:F2} {3}", totalArea, totalAmount, averageRate, rateUnits);

            Console.WriteLine(result);

            if (opData.ProductIds.Count > 0)
            {
                Console.WriteLine("Product Details:");
                Product product = catalog.Products.Find(x => x.Id.ReferenceId == opData.ProductIds[0]);

                result = String.Format("Product Description: {0}", product.Description);
                Console.WriteLine(result);

                if (product.ProductComponents.Count > 0)
                {
                    Console.WriteLine("Product Components:");

                    // Calculate the total rates for each type of ProductComponent in the MixProduct
                    double volumeTotalRate = 0;
                    double massTotalRate   = 0;
                    foreach (ProductComponent component in product.ProductComponents)
                    {
                        if (component.Quantity.Value.UnitOfMeasure.Dimension == UnitOfMeasureDimensionEnum.Volume)
                        {
                            // gal
                            volumeTotalRate += component.Quantity.Value.Value;
                        }
                        else if (component.Quantity.Value.UnitOfMeasure.Dimension == UnitOfMeasureDimensionEnum.Mass)
                        {
                            // lb
                            massTotalRate += component.Quantity.Value.Value;
                        }
                    }

                    // Determine the correct total applied date for the MixProduct
                    double totalRate = volumeTotalRate;
                    if (totalRate == 0)
                    {
                        // The volumeTotalRate will be 0 for dry product mixes
                        totalRate = massTotalRate;
                    }

                    // Calculate the total units of tank mix actually applied to the field.
                    //  This is important to be able to determine the actual proportion of each ProductComponent
                    double totalUnitsOfMixProduct = totalAmount / volumeTotalRate;

                    foreach (ProductComponent component in product.ProductComponents)
                    {
                        Product componentProduct = catalog.Products.Find(x => x.Id.ReferenceId == component.IngredientId);
                        double  componentRate    = component.Quantity.Value.Value;

                        // Calculate the total amount of the product component
                        double componentAmount     = totalUnitsOfMixProduct * componentRate;
                        double componentActualRate = componentAmount / totalArea;

                        result = String.Format("Component: {0}\tAmount: {1:F2}\tRate: {2:F2} {3}/ac", componentProduct.Description, componentAmount, componentActualRate, component.Quantity.Value.UnitOfMeasure.Code);
                        Console.WriteLine(result);
                    }
                }
            }
        }
Exemple #34
0
 public OutputSummery(WorkingData wd, InterSet[] isp)
 {
     OutputLog ol = new OutputLog(wd, isp[0].Sum);
     if (!ol.Execute()) {
         MessageBox.Show("サマリ作成に失敗しました。", "通知");
         return;
     }
     InitializeComponent();
     tbOutput.Text = ol.Sheet;
 }
        private static void GetHarvestData(OperationData opData, Catalog catalog)
        {
            WorkingData distanceMeter = null;
            WorkingData moistureMeter = null;
            WorkingData wetMassMeter  = null;
            WorkingData dryYieldMeter = null;

            IEnumerable <DeviceElementUse> machineDEUs = opData.GetDeviceElementUses(0);

            foreach (DeviceElementUse deu in machineDEUs)
            {
                IEnumerable <WorkingData> workingDatas = deu.GetWorkingDatas();
                foreach (WorkingData meter in workingDatas)
                {
                    switch (meter.Representation.Code)
                    {
                    case "vrDistanceTraveled":
                        distanceMeter = meter;
                        break;

                    case "vrHarvestMoisture":
                        moistureMeter = meter;
                        break;

                    case "vrYieldWetMass":
                        wetMassMeter = meter;
                        break;

                    case "vrYieldVolume":
                        dryYieldMeter = meter;
                        break;
                    }
                }
            }

            // Active width is kept on Level 1 which indicates the header
            WorkingData widthMeter = null;
            IEnumerable <DeviceElementUse> headDEUs = opData.GetDeviceElementUses(1);

            foreach (DeviceElementUse deu in headDEUs)
            {
                IEnumerable <WorkingData> workingDatas = deu.GetWorkingDatas();
                foreach (WorkingData meter in workingDatas)
                {
                    switch (meter.Representation.Code)
                    {
                    case "vrEquipmentWidth":
                        widthMeter = meter;
                        break;
                    }
                }
            }

            double totalArea       = 0;
            double totalWetMass    = 0;
            double totalDryBushels = 0;
            double totalMoisture   = 0;

            // Loop through all the spatial records to get total area, wet mass, and moisture.
            IEnumerable <SpatialRecord> spatialRecords = opData.GetSpatialRecords();

            foreach (SpatialRecord spatialRecord in spatialRecords)
            {
                // Calculate the area
                NumericRepresentationValue distance = spatialRecord.GetMeterValue(distanceMeter) as NumericRepresentationValue;
                NumericRepresentationValue width    = spatialRecord.GetMeterValue(widthMeter) as NumericRepresentationValue;

                double distanceFt = distance.Value.Value;
                double widthFt    = width.Value.Value;

                double squareFeet = distanceFt * widthFt;
                double acres      = squareFeet / SQUARE_FEET_PER_ACRE;
                totalArea += acres;

                NumericRepresentationValue wetMass = spatialRecord.GetMeterValue(wetMassMeter) as NumericRepresentationValue;

                double wetMassLbs = wetMass.Value.Value;    // lbs
                totalWetMass += wetMassLbs;

                NumericRepresentationValue moisture = spatialRecord.GetMeterValue(moistureMeter) as NumericRepresentationValue;

                double moisturePct = moisture.Value.Value;  // %
                totalMoisture += moisturePct * wetMassLbs;  // Only used for calculating weighted average

                NumericRepresentationValue dryVol = spatialRecord.GetMeterValue(dryYieldMeter) as NumericRepresentationValue;

                double dryVolBu = dryVol.Value.Value;    // bu
                totalDryBushels += dryVolBu;
            }

            double averageMoisture = totalMoisture / totalWetMass;

            string result = String.Format("Area: {0:F2}\tWetMass: {1:F2}\tMoisture: {2:F2}\tDryBushels: {3:F2}", totalArea, totalWetMass, averageMoisture, totalDryBushels);

            Console.WriteLine(result);
        }