aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/MachineStudio/Modules/MachineStudio.Dispensers/DispensersModule.cs
blob: 6d6c7d8e60186a54c8bf4aceaef4fc439af3ac9b (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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Media.Imaging;
using Tango.BL.Enumerations;
using Tango.MachineStudio.Dispensers.Views;
using Tango.MachineStudio.Common;
using Tango.SharedUI.Helpers;

namespace Tango.MachineStudio.ColorLab
{
    [StudioModule(10)]
    public class DispensersModule : StudioModuleBase
    {
        public override string Name
        {
            get
            {
                return "Dispensers";
            }
        }

        public override string Description
        {
            get
            {
                return "Manage twine's dispensers repository.";
            }
        }

        public override BitmapSource Image
        {
            get
            {
                return ResourceHelper.GetImageFromResources("Images/dispensers.png");
            }
        }

        public override Type MainViewType
        {
            get
            {
                return typeof(MainView);
            }
        }

        public override Permissions Permission
        {
            get
            {
                return Permissions.RunResearchModule;
            }
        }

        public override void Dispose()
        {
            
        }
    }
}
/ .highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */ .highlight .vc { color: #336699 } /* Name.Variable.Class */ .highlight .vg { color: #dd7700 } /* Name.Variable.Global */ .highlight .vi { color: #3333bb } /* Name.Variable.Instance */ .highlight .vm { color: #336699 } /* Name.Variable.Magic */ .highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.BL;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.Core;
using Tango.Core.DI;
using Tango.Integration.Operation;
using Tango.PPC.Common.Connection;
using Tango.PPC.Common.Messages;
using Tango.PPC.Common.Models;
using Tango.PPC.Common.Navigation;
using Tango.PPC.Common.Notifications;
using Tango.PPC.Common.Printing;
using Tango.PPC.Jobs.Messages;
using Tango.PPC.UI.Dialogs;

namespace Tango.PPC.UI.Printing
{
    /// <summary>
    /// Represents a printing manager capable of executing jobs, changing job statuses according to completion stage and generating sample and fine tuning jobs.
    /// </summary>
    /// <seealso cref="Tango.Core.ExtendedObject" />
    /// <seealso cref="Tango.PPC.Common.Printing.IPrintingManager" />
    public class DefaultPrintingManager : ExtendedObject, IPrintingManager
    {
        private IMachineProvider _machineProvider;
        private INotificationProvider _notificationProvider;

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultPrintingManager"/> class.
        /// </summary>
        /// <param name="machineProvider">The machine provider.</param>
        public DefaultPrintingManager(IMachineProvider machineProvider, INotificationProvider notificationProvider)
        {
            _machineProvider = machineProvider;
            _notificationProvider = notificationProvider;
        }

        /// <summary>
        /// Prints the specified job.
        /// When the job is complete the job status will change according to the completion stage.
        /// </summary>
        /// <param name="job">The job.</param>
        /// <param name="context">The context.</param>
        /// <returns></returns>
        public async Task<JobHandler> Print(Job job, ObservablesContext context)
        {
            ThrowIfJobInvalid(job);

            JobHandler handler = null;

#if STUBPRINT
            handler = await _machineProvider.MachineOperator.PrintStub(job);
#else
            try
            {
                handler = await _machineProvider.MachineOperator.Print(job);
            }
            catch (InsufficientLiquidQuantityException ex)
            {
                LogManager.Log(ex);
                await _notificationProvider.ShowDialog(new InsufficientLiquidQuantityViewVM(ex));
                throw ex;
            }
#endif

            handler.Completed += async (x, e) =>
            {
                try
                {
                    job.JobStatus = JobStatuses.Completed;

                    if (!context.IsDisposed)
                    {
                        await context.SaveChangesAsync();
                    }
                    else
                    {
                        using (var newContext = ObservablesContext.CreateDefault())
                        {
                            var newJob = newContext.Jobs.SingleOrDefault(y => y.Guid == job.Guid);
                            if (newJob != null)
                            {
                                newJob.JobStatus = JobStatuses.Completed;
                                await newContext.SaveChangesAsync();
                            }
                        }
                    }

                    RaiseJobSaved(job);
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error occurred after job printing completed.");
                }
            };
            handler.Canceled += (x, e) =>
            {
                try
                {
                    //No change in status !
                    //await context.SaveChangesAsync();
                    RaiseJobSaved(job);
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error occurred after job printing completed.");
                }
            };
            handler.Failed += async (x, e) =>
            {
                try
                {

                    job.JobStatus = JobStatuses.Disrupted;

                    if (!context.IsDisposed)
                    {
                        await context.SaveChangesAsync();
                    }
                    else
                    {
                        using (var newContext = ObservablesContext.CreateDefault())
                        {
                            var newJob = newContext.Jobs.SingleOrDefault(y => y.Guid == job.Guid);
                            if (newJob != null)
                            {
                                newJob.JobStatus = JobStatuses.Disrupted;
                                await newContext.SaveChangesAsync();
                            }
                        }
                    }

                    RaiseJobSaved(job);
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error occurred after job printing completed.");
                }
            };


            return handler;
        }

        /// <summary>
        /// Creates a sample dye job from the specified job and prints it.
        /// When the sample dye job is complete, the job sample dye status will change.
        /// </summary>
        /// <param name="job">The job.</param>
        /// <param name="context">The context.</param>
        /// <returns></returns>
        public async Task<JobHandler> PrintSample(Job job, ObservablesContext context)
        {
            ThrowIfJobInvalid(job);

            LogManager.Log("Cloning job...");
            Job sampleDyeJob = job.Clone();
            sampleDyeJob.Guid = job.Guid;
            sampleDyeJob.Designation = BL.Enumerations.JobDesignations.SampleDye;
            sampleDyeJob.Name = job.Name;

            if (job.JobType == BL.Enumerations.JobTypes.Embroidery)
            {
                sampleDyeJob.NumberOfUnits = job.SampleUnitsOrMeters;
            }
            else
            {
                sampleDyeJob.NumberOfUnits = 1;

                foreach (var segment in sampleDyeJob.OrderedSegments)
                {
                    segment.Length = job.SampleUnitsOrMeters;
                }
            }

            context.SaveChanges();
            RaiseJobSaved(job);

            LogManager.Log("Executing sample dye job...");

            var handler = await _machineProvider.MachineOperator.Print(sampleDyeJob);
            handler.Completed += async (x, e) =>
            {
                try
                {
                    job.JobEditingState = BL.Enumerations.EditingStates.SampleDye;
                    job.JobSampleDyeStatus = BL.Enumerations.SampleDyeStatuses.PendingApproval;
                    await context.SaveChangesAsync();
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error occurred after sample dye printing completed.");
                }
            };

            return handler;
        }

        /// <summary>
        /// Creates a fine tuning job from the specified job and fine tune items.
        /// When the fine tuning job is complete, the job fine tuning status will change.
        /// </summary>
        /// <param name="job">The job.</param>
        /// <param name="context">The context.</param>
        /// <param name="fineTuneItems">The fine tune items.</param>
        /// <returns></returns>
        public async Task<JobHandler> PrintFineTuning(Job job, ObservablesContext context, IEnumerable<FineTuneItem> fineTuneItems)
        {
            ThrowIfJobInvalid(job);

            LogManager.Log("Cloning job...");
            Job fineTuneJob = job.Clone();
            fineTuneJob.NumberOfUnits = 1;
            fineTuneJob.Designation = BL.Enumerations.JobDesignations.FineTuning;
            fineTuneJob.Guid = job.Guid;
            fineTuneJob.Name = job.Name;
            fineTuneJob.Segments.Clear();

            foreach (var suggestion in fineTuneItems.Where(x => x.IsSelected).SelectMany(x => x.Suggestions))
            {
                var segment = fineTuneJob.AddSolidSegment(suggestion.Color);
            }

            var handler = await _machineProvider.MachineOperator.Print(fineTuneJob);
            handler.Completed += async (x, e) =>
            {
                try
                {
                    job.JobEditingState = BL.Enumerations.EditingStates.FineTuning;
                    job.JobFineTuningStatus = BL.Enumerations.FineTuningStatuses.PendingApproval;
                    await context.SaveChangesAsync();
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error occurred after fine tunning job completed.");
                }
            };

            return handler;
        }

        /// <summary>
        /// Raises the job saved messenger message.
        /// </summary>
        /// <param name="job">The job.</param>
        private void RaiseJobSaved(Job job)
        {
            TangoMessenger.Default.Send(new JobSavedMessage() { Job = job });
        }

        private void ThrowIfJobInvalid(Job job)
        {
            if (job.Segments.SelectMany(x => x.BrushStops).Any(x => x.IsOutOfGamut))
            {
                throw new InvalidOperationException("Error starting job. Color is out of range.");
            }
            if (job.Segments.SelectMany(x => x.BrushStops).Any(x => x.BrushColorSpace == ColorSpaces.Catalog && x.ColorCatalogsItem == null && !x.IsTransparent && !x.IsWhite))
            {
                throw new InvalidOperationException("Error starting job. Please select a catalog color.");
            }
            if (job.Rml.Cct == null)
            {
                throw new InvalidOperationException($"Error starting job. No color table found for thread '{job.Rml.Name}'.");
            }
        }
    }
}