aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/FSE/Tango.FSE.BL/Services/MachineConfigurationService.cs
blob: 6dec3a40db9c1b1735341d81e84deed867344532 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.BL;
using Tango.BL.Entities;
using System.Data.Entity;
using Tango.BL.Builders;
using Tango.BL.DTO;
using Tango.BL.Enumerations;
using Tango.Core;

namespace Tango.FSE.BL.Services
{
    public class MachineConfigurationService : FSEServiceBase
    {
        public class MachineEditingComposition : ExtendedObject, IDisposable
        {
            internal MachineDTO PreviousMachineState { get; set; }

            public Machine Machine { get; set; }
            public List<Organization> Organizations { get; set; }
            public List<HardwareVersion> HardwareVersions { get; set; }
            public String TotalDyeTime { get; set; }
            public String TotalDyeMeters { get; set; }
            internal ObservablesContext Context { get; set; }

            public MachineEditingComposition()
            {
                Organizations = new List<Organization>();
                HardwareVersions = new List<HardwareVersion>();
            }

            public void ResetCounters()
            {
                TotalDyeMeters = "0 meters";
                RaisePropertyChanged(nameof(TotalDyeMeters));
                TotalDyeTime = "00:00:00";
                RaisePropertyChanged(nameof(TotalDyeTime));
            }

            public void Dispose()
            {
                Context?.Dispose();
                Context = null;
            }
        }

        public Task<MachineEditingComposition> GetMachineEditingComposition(String machineGuid)
        {
            return Task.Factory.StartNew<MachineEditingComposition>(() =>
            {
                ObservablesContext db = ObservablesContext.CreateDefault();

                MachineEditingComposition composition = new MachineEditingComposition();

                //Organizations
                bool allowAll = CurrentUser.HasPermission(Tango.BL.Enumerations.Permissions.FSE_ManageAllOrganizationsUsersAndRoles);
                composition.Organizations = db.Organizations.Where(x => allowAll || x.Guid == CurrentUser.OrganizationGuid).Include(x => x.Sites).ToList();

                //Machine
                composition.Machine = new MachineBuilder(db).Set(machineGuid).WithConfiguration().Build();

                //Hardware Versions
                composition.HardwareVersions = db.HardwareVersions.OrderByDescending(x => x.Version).ToList();

                //Counters
                var jobRuns = db.JobRuns.Where(x => x.MachineGuid == machineGuid).Select(x => new { x.StartDate, x.EndDate, x.EndPosition }).ToList();
                composition.TotalDyeTime = TimeSpan.FromHours(jobRuns.Select(x => x.EndDate - x.StartDate).Sum(x => x.TotalHours)).ToStringUnlimitedHours();
                int meters = (int)jobRuns.Select(x => x.EndPosition).Sum();
                composition.TotalDyeMeters = $"{meters.ToString("N0")} meters";

                //Store current machine state for action log.
                composition.PreviousMachineState = MachineDTO.FromObservable(composition.Machine);

                composition.Context = db;

                return composition;
            });
        }

        public Task<MachineEditingComposition> SaveMachineEditingComposition(MachineEditingComposition composition)
        {
            return Task.Factory.StartNew<MachineEditingComposition>(() =>
            {
                Authentication.ThrowIfNoPermission(Permissions.FSE_RunConfigurationModule);
                ConnectivityProvider.ThrowIfNoInternet();

                composition.Machine.SetupFpga = composition.Machine.SetupFirmware; //Unify setup FPGA with setup firmware.

                try
                {
                    var machineAfterUpdateDTO = MachineDTO.FromObservable(composition.Machine);
                    ActionLogManager.InsertLog(ActionLogType.MachineSaved, CurrentUser, composition.Machine.SerialNumber, composition.PreviousMachineState, machineAfterUpdateDTO, "Machine saved via FSE.");
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error inserting machine save action log.");
                }

                composition.Context.SaveChanges();
                composition.Context.Dispose();
                return GetMachineEditingComposition(composition.Machine.Guid).Result;
            });
        }

        public Task<int> ResetCounters(String machineGuid)
        {
            return Task.Factory.StartNew<int>(() =>
            {
                Authentication.ThrowIfNoPermission(Permissions.FSE_ResetMachineCounters);

                using (ObservablesContext db = ObservablesContext.CreateDefault())
                {
                    var sn = db.Machines.SingleOrDefault(x => x.Guid == machineGuid).SerialNumber;
                    ActionLogManager.InsertLog(ActionLogType.MachineCountersReset, CurrentUser.Guid, sn, machineGuid, "Machine counters reset via FSE.");
                    return db.JobRuns.Where(x => x.MachineGuid == machineGuid).DeleteFromQuery();
                }
            });
        }
    }
}