initial source commit

2013-02-01 12:35:28 +11:00
parent 543a005d31
commit 0a93429800
1103 changed files with 285609 additions and 0 deletions
@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web;
+using System.ComponentModel.DataAnnotations;
+using System.Web.Mvc;
+
+namespace Disco.Web.Models.Device
+{
+    public class AddOfflineModel
+    {
+        public Disco.Models.Repository.Device Device { get; set; }
+        public List<Disco.Models.Repository.DeviceProfile> DeviceProfiles { get; set; }
+        public List<SelectListItem> DeviceBatches { get; set; }
+        public int DefaultDeviceProfileId { get; set; }
+    }
+}
@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web;
+using System.Web.Mvc;
+using Disco.BI;
+using Disco.BI.Extensions;
+using Disco.Web.Extensions;
+
+namespace Disco.Web.Models.Device
+{
+    public class ShowModel
+    {
+        public Disco.Models.Repository.Device Device { get; set; }
+
+
+        public List<Disco.Models.Repository.DeviceProfile> DeviceProfiles { get; set; }
+        public List<SelectListItem> DeviceBatches { get; set; }
+        public Disco.Models.BI.Job.JobTableModel Jobs { get; set; }
+        public List<Disco.Models.Repository.DeviceCertificate> Certificates { get; set; }
+
+        public string OrganisationUnit { get; set; }
+
+        public List<Disco.Models.Repository.DocumentTemplate> DocumentTemplates { get; set; }
+
+        public List<SelectListItem> DocumentTemplatesSelectListItems
+        {
+            get
+            {
+                var list = new List<SelectListItem>();
+                list.Add(new SelectListItem() { Selected = true, Value = string.Empty, Text = "Select a Document to Generate" });
+                list.AddRange(this.DocumentTemplates.ToSelectListItems());
+                return list;
+            }
+        }
+    }
+}
@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web;
+using System.Net;
+using System.IO;
+
+namespace Disco.Web.Models.InitialConfig
+{
+    public class CompleteModel
+    {
+        public Tuple<IPHostEntry, Exception> DiscoDnsTestResult { get; set; }
+        public Exception RegistryDatabaseResult { get; set; }
+        public Exception DiscoIctComAuWebResult { get; set; }
+
+        public bool LaunchAllowed
+        {
+            get
+            {
+                return (RegistryDatabaseResult == null);
+            }
+        }
+
+        public void PerformTests()
+        {
+
+            #region DNS for 'Disco'
+            try
+            {
+                // Try and Resolve 'disco'
+                DiscoDnsTestResult = new Tuple<IPHostEntry, Exception>(Dns.GetHostEntry("disco"), null);
+            }
+            catch (Exception ex)
+            {
+                DiscoDnsTestResult = new Tuple<IPHostEntry, Exception>(null, ex);
+            }
+            #endregion
+
+            #region Write Database to Registry
+            try
+            {
+                // Make Connection String Persistent
+                Disco.Data.Repository.DiscoDatabaseConnectionFactory.SetDiscoDataContextConnectionString(
+                    Disco.Data.Repository.DiscoDatabaseConnectionFactory.DiscoDataContextConnectionString, true);
+                RegistryDatabaseResult = null;
+            }
+            catch (Exception ex)
+            {
+                RegistryDatabaseResult = ex;
+            }
+            #endregion
+
+            #region Communicate with http://discoict.com.au/
+            try
+            {
+                Dns.GetHostEntry("discoict.com.au");
+                try
+                {
+                    HttpWebRequest wReq = (HttpWebRequest)HttpWebRequest.Create("http://discoict.com.au/");
+                    wReq.Method = WebRequestMethods.Http.Get;
+                    wReq.UserAgent = string.Format("Disco/{0} (Initial Config; Org: {1})", DiscoApplication.Version, DiscoApplication.OrganisationName);
+                    using (HttpWebResponse wRes = (HttpWebResponse)wReq.GetResponse())
+                    {
+                        if (wRes.StatusCode == HttpStatusCode.OK)
+                        {
+                            DiscoIctComAuWebResult = null;
+                        }
+                        else
+                        {
+                            DiscoIctComAuWebResult = new Exception(string.Format("Server returned response: [{0}] {1}", wRes.StatusCode, wRes.StatusDescription));
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    DiscoIctComAuWebResult = new WebException("DNS Resolved the host 'discoict.com.au' but could not establish a connection.", ex);
+                }
+            }
+            catch (Exception ex)
+            {
+                DiscoIctComAuWebResult = new Exception("Could not resolve the name 'discoict.com.au'", ex);
+                throw;
+            }
+            #endregion
+
+        }
+    }
+}
@@ -0,0 +1,111 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Data.SqlClient;
+using System.Linq;
+using System.Web;
+using System.Web.Mvc;
+
+namespace Disco.Web.Models.InitialConfig
+{
+    public class DatabaseModel
+    {
+        public DatabaseModel()
+        {
+            // Set Defaults
+            this.Server = "(local)";
+            this.DatabaseName = "Disco";
+            this.AuthMethod = "SSPI";
+        }
+
+        public static DatabaseModel FromConnectionString(string ConnectionString)
+        {
+            var result = new DatabaseModel();
+
+            try
+            {
+                var csb = new SqlConnectionStringBuilder(ConnectionString);
+
+                if (!string.IsNullOrEmpty(csb.DataSource))
+                    result.Server = csb.DataSource;
+                if (!string.IsNullOrEmpty(csb.InitialCatalog))
+                    result.DatabaseName = csb.InitialCatalog;
+                if (csb.IntegratedSecurity)
+                {
+                    result.AuthMethod = "SSPI";
+                }
+                else
+                {
+                    result.AuthMethod = "SQL";
+                    result.Auth_SQL_Username = csb.UserID;
+                    result.Auth_SQL_Password = csb.Password;
+                }
+            }
+            catch (Exception)
+            {
+                // Ignore Parsing errors
+            }
+
+            return result;
+        }
+
+        public SqlConnectionStringBuilder ToConnectionString()
+        {
+            var csb = new SqlConnectionStringBuilder()
+            {
+                DataSource = this.Server,
+                InitialCatalog = this.DatabaseName,
+                IntegratedSecurity = (this.AuthMethod.Equals("SSPI", StringComparison.InvariantCultureIgnoreCase)),
+                UserID = (this.AuthMethod.Equals("SQL", StringComparison.InvariantCultureIgnoreCase)) ? this.Auth_SQL_Username : string.Empty,
+                Password = (this.AuthMethod.Equals("SQL", StringComparison.InvariantCultureIgnoreCase)) ? this.Auth_SQL_Password : string.Empty,
+                ApplicationName = "Disco WebApp",
+                MultipleActiveResultSets = true,
+                Pooling = true
+            };
+
+            return csb;
+        }
+
+        [Required(ErrorMessage = "The Server name is required")]
+        public string Server { get; set; }
+        [Required(ErrorMessage = "The Database name is required")]
+        public string DatabaseName { get; set; }
+        [Required(ErrorMessage = "The Authentication Method is required")]
+        public string AuthMethod { get; set; }
+
+        [CustomValidation(typeof(DatabaseModel), "SqlAuthRequired", ErrorMessage = "When using SQL Authentication a Username is required")]
+        public string Auth_SQL_Username { get; set; }
+        [DataType(DataType.Password), CustomValidation(typeof(DatabaseModel), "SqlAuthRequired", ErrorMessage="When using SQL Authentication a Password is required")]
+        public string Auth_SQL_Password { get; set; }
+
+        public List<SelectListItem> AuthMethods
+        {
+            get
+            {
+                return new List<SelectListItem>(){
+                    new SelectListItem(){
+                         Value="SSPI", Text="Integrated Authentication", Selected=true
+                    },
+                    new SelectListItem(){
+                         Value="SQL", Text="SQL Authentication", Selected=false
+                    }
+                };
+            }
+        }
+
+        public static ValidationResult SqlAuthRequired(object value, ValidationContext validationContext)
+        {
+            var instance = validationContext.ObjectInstance as DatabaseModel;
+
+            if (instance != null && instance.AuthMethod != null && instance.AuthMethod.Equals("SQL", StringComparison.InvariantCultureIgnoreCase))
+            {
+                var stringValue = value as string;
+                if (string.IsNullOrWhiteSpace(stringValue))
+                    return null; // Invalid
+            }
+
+            return ValidationResult.Success;
+        }
+
+    }
+}
@@ -0,0 +1,181 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Security;
+using System.Security.Permissions;
+using System.Security.Principal;
+using System.Web;
+
+namespace Disco.Web.Models.InitialConfig
+{
+    public class FileStoreModel
+    {
+        public FileStoreModel()
+        {
+            DirectoryModel = FileStoreModel.FileStoreDirectoryModel.DirectoryRoots();
+        }
+
+        [Required(), CustomValidation(typeof(FileStoreModel), "DirectoryPermissionRequired")]
+        public string FileStoreLocation { get; set; }
+
+        public FileStoreDirectoryModel DirectoryModel { get; set; }
+
+        public void ExpandDirectoryModel()
+        {
+            if (!string.IsNullOrWhiteSpace(FileStoreLocation))
+            {
+                var branches = this.FileStoreLocation.ToUpper().Split(Path.DirectorySeparatorChar);
+                var branchesCase = this.FileStoreLocation.Split(Path.DirectorySeparatorChar);
+                FileStoreDirectoryModel branchModel;
+                FileStoreDirectoryModel branchParent = this.DirectoryModel;
+                for (int i = 0; i < branches.Length; i++)
+                {
+                    var branch = branches[i];
+                    if (branchParent.SubDirectories.TryGetValue(branch, out branchModel))
+                    {
+                        branchModel.ExpandSubDirectories();
+                    }
+                    else
+                    {
+                        // New
+                        branchModel = FileStoreDirectoryModel.FromNew(branchesCase[i], Path.Combine(branchParent.Path, branchesCase[i]));
+                        branchParent.SubDirectories.Add(branchModel.Name.ToUpper(), branchModel);
+                    }
+
+                    branchParent = branchModel;
+                }
+            }
+        }
+
+        public static ValidationResult DirectoryPermissionRequired(object value, ValidationContext validationContext)
+        {
+            var instance = validationContext.ObjectInstance as FileStoreModel;
+
+            if (instance != null && !string.IsNullOrEmpty(instance.FileStoreLocation))
+            {
+                var stringValue = value as string;
+
+                DirectoryInfo info = new DirectoryInfo(stringValue);
+
+                if (!info.Exists)
+                {
+                    // Try and Create
+                    try
+                    {
+                        info.Create();
+                    }
+                    catch (Exception ex)
+                    {
+                        return new ValidationResult(string.Format("Unable to Create Directory '{0}'; [{1}] {2}", info.FullName, ex.GetType().Name, ex.Message));
+                    }
+                }
+            }
+
+            return ValidationResult.Success;
+        }
+
+
+        public class FileStoreDirectoryModel
+        {
+            public string Name { get; set; }
+            public string Path { get; set; }
+            public bool IsNew { get; set; }
+            public bool Selectable { get; set; }
+            public Dictionary<string, FileStoreDirectoryModel> SubDirectories { get; set; }
+
+            internal static FileStoreDirectoryModel FromInfo(DirectoryInfo info)
+            {
+                return new FileStoreDirectoryModel()
+                {
+                    Name = info.Name,
+                    Path = info.FullName,
+                    IsNew = false,
+                    Selectable = (info.Root.Name != info.Name)
+                };
+            }
+            internal static FileStoreDirectoryModel FromNew(string Name, string FullPath)
+            {
+                return new FileStoreDirectoryModel()
+                {
+                    Name = Name,
+                    Path = FullPath,
+                    IsNew = true,
+                    Selectable = true,
+                    SubDirectories = new Dictionary<string, FileStoreDirectoryModel>()
+                };
+            }
+            internal static FileStoreDirectoryModel FromInfo(DriveInfo info)
+            {
+                return new FileStoreDirectoryModel()
+                {
+                    Name = info.Name.Substring(0, 2),
+                    Path = info.RootDirectory.Name,
+                    IsNew = false,
+                    Selectable = false
+                };
+            }
+            internal static FileStoreDirectoryModel FromPath(string DirectoryPath, bool ExpandSubDirectories)
+            {
+                DirectoryInfo info = new DirectoryInfo(DirectoryPath);
+
+                if (info.Exists)
+                {
+                    var fsd = FromInfo(info);
+
+                    if (ExpandSubDirectories)
+                        fsd.ExpandSubDirectories();
+
+                    return fsd;
+                }
+                else
+                    return null;
+            }
+
+            internal static FileStoreDirectoryModel DirectoryRoots()
+            {
+                var root = new FileStoreDirectoryModel()
+                {
+                    Name = "ROOT",
+                    Path = null,
+                    IsNew = false,
+                    Selectable = false,
+                    SubDirectories = new Dictionary<string, FileStoreDirectoryModel>()
+                };
+
+                foreach (var driveInfo in DriveInfo.GetDrives())
+                {
+                    if (driveInfo.DriveType == DriveType.Fixed)
+                        root.SubDirectories.Add(driveInfo.Name.Substring(0, 2).ToUpper(), FileStoreDirectoryModel.FromInfo(driveInfo));
+                }
+
+                return root;
+            }
+
+            internal void ExpandSubDirectories()
+            {
+                if (this.SubDirectories == null)
+                {
+                    this.SubDirectories = new Dictionary<string, FileStoreDirectoryModel>();
+                    if (!this.IsNew)
+                    {
+                        var dirInfo = new DirectoryInfo(Path);
+                        if (dirInfo.Exists)
+                        {
+                            foreach (var subDir in dirInfo.EnumerateDirectories())
+                            {
+                                this.SubDirectories.Add(subDir.Name.ToUpper(), FileStoreDirectoryModel.FromInfo(subDir));
+                            }
+                        }
+                        else
+                        {
+                            this.IsNew = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Web;
+using System.Net;
+using System.Xml.Linq;
+using System.IO;
+using System.Globalization;
+
+namespace Disco.Web.Models.InitialConfig
+{
+    public class WelcomeModel
+    {
+        [Required(ErrorMessage="The Organisation Name is required.")]
+        public string OrganisationName { get; set; }
+
+
+        private static string _OrganisationNameCache;
+        public bool AutodetectOrganisation()
+        {
+            if (_OrganisationNameCache != null)
+            {
+                this.OrganisationName = _OrganisationNameCache;
+                return true;
+            }
+
+            // DnsQuery for broadband.doe.wan
+            IPHostEntry doeWanDnsEntry;
+            try
+            {
+                doeWanDnsEntry = Dns.GetHostEntry("broadband.doe.wan");
+            }
+            catch (Exception)
+            { return false; } // Fail on error
+
+            // Try using IPSearch feature
+            XDocument doeWanIPSearchResult = TryDownloadDoeIPSearch(true);
+            if (doeWanIPSearchResult == null)
+                doeWanIPSearchResult = TryDownloadDoeIPSearch(false);
+
+            if (doeWanIPSearchResult == null)
+                return false;
+
+            try
+            {
+                var siteName = doeWanIPSearchResult.Element("resultset").Element("site").Element("name").Value.ToLower();
+                this.OrganisationName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(siteName);
+                _OrganisationNameCache = this.OrganisationName;
+                return true;
+            }
+            catch (Exception)
+            { return false; } // Fail on error
+        }
+        private XDocument TryDownloadDoeIPSearch(bool useProxy)
+        {
+            try
+            {
+                HttpWebRequest wReq = (HttpWebRequest)HttpWebRequest.Create("http://broadband.doe.wan/ipsearch/showresult.php");
+                if (!useProxy)
+                    wReq.Proxy = new WebProxy(); // Empty Proxy Config
+                wReq.Method = WebRequestMethods.Http.Post;
+                wReq.ContentType = "application/x-www-form-urlencoded";
+                wReq.UserAgent = string.Format("Disco/{0}", DiscoApplication.Version);
+                using (var wrStream = wReq.GetRequestStream())
+                {
+                    using (var wrStreamWriter = new StreamWriter(wrStream))
+                    {
+                        wrStreamWriter.Write("mode=whoami");
+                    }
+                }
+                using (HttpWebResponse wRes = (HttpWebResponse)wReq.GetResponse())
+                {
+                    if (wRes.StatusCode == HttpStatusCode.OK)
+                    {
+                        using (var wResStream = wRes.GetResponseStream())
+                        {
+                            return XDocument.Load(wResStream);
+                        }
+                    }
+                    else
+                        return null;
+                }
+            }
+            catch (Exception)
+            { return null; } // Fail on error
+        }
+
+    }
+}
@@ -0,0 +1,184 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Web;
+using Disco.Data.Repository;
+
+namespace Disco.Web.Models.Job
+{
+    [CustomValidation(typeof(CreateModel), "ValidateCreateModel")]
+    public class CreateModel
+    {
+        public string DeviceSerialNumber { get; set; }
+        public string UserId { get; set; }
+
+        [Required]
+        public string Type { get; set; }
+        [Required]
+        public List<string> SubTypes { get; set; }
+
+        [DataType(System.ComponentModel.DataAnnotations.DataType.MultilineText)]
+        public string Comments { get; set; }
+
+        //public string AssignedUserId { get; set; }
+        //public DateTime? AssignedUserTargetCompletionDate { get; set; }
+
+        [Required(ErrorMessage = "Please specify whether the device is held or not")]
+        public bool? DeviceHeld { get; set; }
+
+        public string QuickLogDestinationUrl { get; set; }
+
+        [Display(Description = "Automatically close this job")]
+        public bool? QuickLog { get; set; }
+        public int? QuickLogTaskTimeMinutes { get; set; }
+        public int? QuickLogTaskTimeMinutesOther { get; set; }
+
+        #region Helpers & Model Logic
+        // View Required Data
+        public Disco.Models.Repository.Device Device { get; set; }
+        public Disco.Models.Repository.User User { get; set; }
+        public List<Disco.Models.Repository.JobType> JobTypes { get; set; }
+        public List<Disco.Models.Repository.JobSubType> JobSubTypes { get; set; }
+        public void UpdateModel(DiscoDataContext dbContext)
+        {
+            if (this.JobTypes == null)
+                JobTypes = dbContext.JobTypes.ToList();
+            if (this.JobSubTypes == null)
+                JobSubTypes = dbContext.JobSubTypes.ToList();
+
+            if (!string.IsNullOrEmpty(DeviceSerialNumber))
+            {
+                this.Device = dbContext.Devices.Include("DeviceModel").Where(d => d.SerialNumber == DeviceSerialNumber).FirstOrDefault();
+                if (this.Device == null)
+                {
+                    throw new ArgumentException("Invalid Device Serial Number Specified", "DeviceSerialNumber");
+                }
+                if (string.IsNullOrEmpty(this.UserId) && !string.IsNullOrEmpty(this.Device.AssignedUserId))
+                {
+                    this.UserId = this.Device.AssignedUserId;
+                }
+                if (string.IsNullOrEmpty(this.Type))
+                    this.Type = this.JobTypes.First(jt => jt.Id == Disco.Models.Repository.JobType.JobTypeIds.HWar).Id;
+
+                if (string.IsNullOrEmpty(this.UserId))
+                {
+                    // No User - Remove User Types
+                    foreach (var jobType in JobTypes.ToArray())
+                    {
+                        switch (jobType.Id)
+                        {
+                            case Disco.Models.Repository.JobType.JobTypeIds.UMgmt:
+                                JobTypes.Remove(jobType);
+                                JobSubTypes.RemoveAll(jst => jst.JobType == jobType);
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                // No Device - Remove Hardware Types
+                foreach (var jobType in JobTypes.ToArray())
+                {
+                    switch (jobType.Id)
+                    {
+                        case Disco.Models.Repository.JobType.JobTypeIds.HMisc:
+                        case Disco.Models.Repository.JobType.JobTypeIds.HNWar:
+                        case Disco.Models.Repository.JobType.JobTypeIds.HWar:
+                        case Disco.Models.Repository.JobType.JobTypeIds.SImg:
+                            JobTypes.Remove(jobType);
+                            JobSubTypes.RemoveAll(jst => jst.JobType == jobType);
+                            break;
+                        default:
+                            break;
+                    }
+                }
+
+                // Set Default Job Type for Users
+                if (string.IsNullOrEmpty(this.Type))
+                    this.Type = this.JobTypes.First(jt => jt.Id == Disco.Models.Repository.JobType.JobTypeIds.SApp).Id;
+            }
+            if (!string.IsNullOrEmpty(UserId))
+            {
+                this.User = dbContext.Users.Find(UserId);
+                if (this.User == null)
+                {
+                    throw new ArgumentException("Invalid User Id Specified", "UserId");
+                }
+                if (string.IsNullOrEmpty(this.Type))
+                    this.Type = Disco.Models.Repository.JobType.JobTypeIds.SApp;
+            }
+            if (this.User == null && this.Device == null)
+            {
+                throw new InvalidOperationException("A Job must reference a Device and/or a User");
+            }
+        }
+
+        // Job Type Helpers
+        public Disco.Models.Repository.JobType GetJobType
+        {
+            get
+            {
+                if (!string.IsNullOrEmpty(this.Type))
+                {
+                    return this.JobTypes.FirstOrDefault(m => m.Id == this.Type);
+                }
+                return null;
+            }
+        }
+        public List<Disco.Models.Repository.JobSubType> GetJobSubTypes
+        {
+            get
+            {
+                if (SubTypes != null)
+                {
+                    var subTypes = this.SubTypes;
+                    return this.JobSubTypes.Where(m => subTypes.Contains(String.Format("{0}_{1}", m.JobTypeId, m.Id))).ToList();
+                }
+                return null;
+            }
+        }
+
+        public static ValidationResult ValidateCreateModel(CreateModel model)
+        {
+            // Device && User both can't be null
+            if (string.IsNullOrEmpty(model.DeviceSerialNumber) && string.IsNullOrEmpty(model.UserId))
+                return new ValidationResult("A Job must reference a Device and/or a User");
+
+            if (!string.IsNullOrEmpty(model.Type) && model.SubTypes != null)
+            {
+                var typeId = string.Format("{0}_", model.Type);
+                model.SubTypes = model.SubTypes.Where(m => m.StartsWith(typeId)).ToList();
+                if (model.SubTypes.Count == 0)
+                {
+                    model.SubTypes = null;
+                    return new ValidationResult("At least one Sub Type is required", new string[] { "SubTypes" });
+                }
+            }
+
+            // Enforce Behaviour
+            if (model.DeviceHeld.HasValue && model.DeviceHeld.Value)
+            {
+                model.QuickLog = false;
+            }
+            else
+            {
+                if (model.QuickLog.HasValue && model.QuickLog.Value)
+                {
+                    if (!model.QuickLogTaskTimeMinutes.HasValue || model.QuickLogTaskTimeMinutes.Value <= 0)
+                        if (model.QuickLogTaskTimeMinutesOther.HasValue && model.QuickLogTaskTimeMinutesOther.Value > 0)
+                            model.QuickLogTaskTimeMinutes = model.QuickLogTaskTimeMinutesOther.Value;
+                        else
+                            model.QuickLogTaskTimeMinutes = 10; // Default to 10 Minutes
+                }
+            }
+
+            return ValidationResult.Success;
+        }
+        #endregion
+
+    }
+}
@@ -0,0 +1,154 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web;
+using Disco.Models;
+using System.ComponentModel.DataAnnotations;
+using Disco.Data.Repository;
+
+namespace Disco.Web.Models.Job
+{
+    [CustomValidation(typeof(CreateModelValidation), "ValidateCreateModel")]
+    public class CreateModelOld
+    {
+        private Disco.Models.Repository.Device _Device;
+        private Disco.Models.Repository.User _User;
+
+        public Disco.Models.Repository.Device Device
+        {
+            get
+            {
+                return _Device;
+            }
+            set
+            {
+                _Device = value;
+                DeviceSerialNumber = value.SerialNumber;
+            }
+        }
+        public Disco.Models.Repository.User User
+        {
+            get
+            {
+                return _User;
+            }
+            set
+            {
+                _User = value;
+                UserId = value.Id;
+            }
+        }
+
+        public string DeviceSerialNumber { get; set; }
+        public string UserId { get; set; }
+
+        [Required]
+        public string Type { get; set; }
+        [Required]
+        public List<string> SubTypes { get; set; }
+
+        public List<Disco.Models.Repository.JobType> JobTypes { get; set; }
+        public List<Disco.Models.Repository.JobSubType> JobSubTypes { get; set; }
+
+        public Disco.Models.Repository.JobType GetJobType
+        {
+            get
+            {
+                if (!string.IsNullOrEmpty(this.Type))
+                {
+                    return this.JobTypes.FirstOrDefault(m => m.Id == this.Type);
+                }
+                return null;
+            }
+        }
+        public List<Disco.Models.Repository.JobSubType> GetJobSubTypes
+        {
+            get
+            {
+                if (SubTypes != null)
+                {
+                    var subTypes = this.SubTypes;
+                    return this.JobSubTypes.Where(m => subTypes.Contains(String.Format("{0}_{1}", m.JobTypeId, m.Id))).ToList();
+                }
+                return null;
+            }
+        }
+
+        public void UpdateModel(DiscoDataContext dbContext)
+        {
+            if (this.JobTypes == null)
+                JobTypes = dbContext.JobTypes.ToList();
+            if (this.JobSubTypes == null)
+                JobSubTypes = dbContext.JobSubTypes.ToList();
+
+            if (!string.IsNullOrEmpty(DeviceSerialNumber))
+            {
+                this.Device = dbContext.Devices.Include("DeviceModel").Where(d => d.SerialNumber == DeviceSerialNumber).FirstOrDefault();
+                if (this.Device == null)
+                {
+                    throw new ArgumentException("Invalid Device Serial Number Specified", "DeviceSerialNumber");
+                }
+                if (string.IsNullOrEmpty(this.UserId) && !string.IsNullOrEmpty(this.Device.AssignedUserId))
+                {
+                    this.UserId = this.Device.AssignedUserId;
+                }
+                if (string.IsNullOrEmpty(this.Type))
+                    this.Type = this.JobTypes.First(jt => jt.Id == "HWar").Id;
+            }
+            else
+            {
+                // No Device - Remove Hardware Types
+                foreach (var jobType in JobTypes.ToArray())
+                {
+                    if (jobType.Id != Disco.Models.Repository.JobType.JobTypeIds.SApp)
+                    {
+                        JobTypes.Remove(jobType);
+                        JobSubTypes.RemoveAll(jst => jst.JobType == jobType);
+                    }
+                }
+            }
+            if (!string.IsNullOrEmpty(UserId))
+            {
+                this.User = dbContext.Users.Find(UserId);
+                if (this.User == null)
+                {
+                    throw new ArgumentException("Invalid User Id Specified", "UserId");
+                }
+                if (string.IsNullOrEmpty(this.Type))
+                    this.Type = Disco.Models.Repository.JobType.JobTypeIds.SApp;
+            }
+            if (this.User == null && this.Device == null)
+            {
+                throw new InvalidOperationException("A Job must reference a Device and/or a User");
+            }
+        }
+
+    }
+
+    public class CreateModelValidation
+    {
+
+        public static ValidationResult ValidateCreateModel(CreateModelOld model)
+        {
+
+            // Device && User both can't be null
+            if (string.IsNullOrEmpty(model.DeviceSerialNumber) && string.IsNullOrEmpty(model.UserId))
+                return new ValidationResult("A Job must reference a Device and/or a User");
+
+            if (!string.IsNullOrEmpty(model.Type) && model.SubTypes != null)
+            {
+                var typeId = string.Format("{0}_", model.Type);
+                model.SubTypes = model.SubTypes.Where(m => m.StartsWith(typeId)).ToList();
+                if (model.SubTypes.Count == 0)
+                {
+                    model.SubTypes = null;
+                    return new ValidationResult("At least one Sub Type is required", new string[] { "SubTypes" });
+                }
+            }
+
+            return ValidationResult.Success;
+        }
+
+    }
+
+}
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web;
+using System.Web.Mvc;
+
+namespace Disco.Web.Models.Job
+{
+    public class CreateRedirectModel
+    {
+        public string RedirectLink { get; set; }
+    }
+}
@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web;
+
+namespace Disco.Web.Models.Job
+{
+    public class IndexModel
+    {
+        public Disco.Models.BI.Job.JobTableModel OpenJobs { get; set; }
+        public Disco.Models.BI.Job.JobTableModel LongRunningJobs { get; set; }
+        //public Disco.Models.BI.Job.JobTableModel WaitingForUserActionJobs { get; set; }
+        //public Disco.Models.BI.Job.JobTableModel ReadyForReturnJobs { get; set; }
+        //public Disco.Models.BI.Job.JobTableModel RecentlyClosedJobs { get; set; }
+    }
+}
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web;
+
+namespace Disco.Web.Models.Job
+{
+    public class ListModel
+    {
+        public string Title { get; set; }
+        public Disco.Models.BI.Job.JobTableModel JobTable { get; set; }
+
+        public string PageTitle
+        {
+            get
+            {
+                return string.Format("{0} ({1})", Title, JobTable.Items.Count);
+            }
+        }
+    }
+}
@@ -0,0 +1,99 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web;
+using Disco.Data.Repository;
+using System.ComponentModel.DataAnnotations;
+using Disco.BI;
+using System.Web.Script.Serialization;
+using Disco.Services.Plugins;
+using Disco.Services.Plugins.Features.WarrantyProvider;
+
+namespace Disco.Web.Models.Job
+{
+    public class LogWarrantyModel
+    {
+        public Disco.Models.Repository.Job Job { get; set; }
+        public List<PluginFeatureManifest> WarrantyProviders { get; set; }
+        public PluginFeatureManifest WarrantyProvider { get; set; }
+        public List<Disco.Models.BI.Config.OrganisationAddress> OrganisationAddresses { get; set; }
+        public Disco.Models.BI.Config.OrganisationAddress OrganisationAddress { get; set; }
+
+        public Disco.Models.Repository.User TechUser { get; set; }
+
+        [Required]
+        public int JobId { get; set; }
+        [Required(ErrorMessage = "Please specify a Repair Address")]
+        public Nullable<int> OrganisationAddressId { get; set; }
+        [Required(ErrorMessage = "Please specify a Warranty Provider")]
+        public string WarrantyProviderId { get; set; }
+        [Required(ErrorMessage = "A fault description is required"), DataType(System.ComponentModel.DataAnnotations.DataType.MultilineText)]
+        public string FaultDescription { get; set; }
+        [Required]
+        public string WarrantyAction { get; set; }
+
+        public Type WarrantyProviderSubmitJobViewType { get; set; }
+        public object WarrantyProviderSubmitJobModel { get; set; }
+        public string WarrantyProviderPropertiesJson { get; set; }
+        public Dictionary<string, string> WarrantyProviderProperties()
+        {
+            Dictionary<string, string> p = default(Dictionary<string, string>);
+            if (string.IsNullOrEmpty(this.WarrantyProviderPropertiesJson))
+            {
+                JavaScriptSerializer s = new JavaScriptSerializer();
+                try
+                {
+                    p = s.Deserialize<Dictionary<string, string>>(this.WarrantyProviderPropertiesJson);
+                }
+                catch (Exception)
+                {
+                    // Ignore Errors
+                }
+            }
+            return p;
+        }
+
+        public Dictionary<string, string> DiscloseProperties { get; set; }
+
+        public Exception Error { get; set; }
+
+        public void UpdateModel(DiscoDataContext dbContext, bool IsPostBack)
+        {
+            dbContext.Configuration.LazyLoadingEnabled = true;
+            if (Job == null)
+            {
+                Job = (from j in dbContext.Jobs.Include("Device.DeviceModel").Include("JobMetaWarranty").Include("JobSubTypes")
+                       where (j.Id == JobId)
+                       select j).FirstOrDefault();
+                if (Job == null)
+                {
+                    throw new ArgumentException("Invalid Job Number Specified", "JobId");
+                }
+            }
+
+            this.TechUser = DiscoApplication.CurrentUser;
+
+            WarrantyProviders = Plugins.GetPluginFeatures(typeof(WarrantyProviderFeature));
+
+            if (!IsPostBack && string.IsNullOrEmpty(WarrantyProviderId))
+            {
+                WarrantyProviderId = Job.Device.DeviceModel.DefaultWarrantyProvider;
+            }
+
+            if (!string.IsNullOrEmpty(WarrantyProviderId))
+                WarrantyProvider = Plugins.GetPluginFeature(WarrantyProviderId, typeof(WarrantyProviderFeature));
+
+            this.OrganisationAddresses = dbContext.DiscoConfiguration.OrganisationAddresses.Addresses;
+
+            if (!IsPostBack && !this.OrganisationAddressId.HasValue)
+            {
+                OrganisationAddressId = Job.Device.DeviceProfile.DefaultOrganisationAddress;
+            }
+            if (this.OrganisationAddressId.HasValue)
+                this.OrganisationAddress = this.OrganisationAddresses.FirstOrDefault(oa => oa.Id == this.OrganisationAddressId.Value);
+
+            if (!string.IsNullOrEmpty(FaultDescription))
+                FaultDescription = FaultDescription.Trim();
+        }
+    }
+}
@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web;
+using System.Web.Mvc;
+using Disco.BI.Extensions;
+using Disco.Web.Extensions;
+
+namespace Disco.Web.Models.Job
+{
+    public class ShowModel
+    {
+        public Disco.Models.Repository.Job Job { get; set; }
+
+        public List<Disco.Models.Repository.DocumentTemplate> DocumentTemplates { get; set; }
+        public List<Disco.Models.Repository.JobSubType> UpdatableJobSubTypes { get; set; }
+
+        public List<SelectListItem> DocumentTemplatesSelectListItems
+        {
+            get
+            {
+                var list = new List<SelectListItem>();
+                list.Add(new SelectListItem() { Selected = true, Value = string.Empty, Text = "Generate Document" });
+                list.AddRange(this.DocumentTemplates.ToSelectListItems());
+                return list;
+            }
+        }
+    }
+}
@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web;
+
+namespace Disco.Web.Models.Job
+{
+    public class WarrantyProviderJobDetailsModel
+    {
+        public Type ViewType { get; set; }
+        public object ViewModel { get; set; }
+
+        public Exception JobDetailsException { get; set; }
+        public bool JobDetailsSupported { get; set; }
+        public string JobDetailsNotSupportedMessage { get; set; }
+    }
+}
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web;
+
+namespace Disco.Web.Models.Search
+{
+    public class QueryModel
+    {
+        public string FriendlyTerm { get; set; }
+        public string Term { get; set; }
+        public bool Success { get; set; }
+        public string ErrorMessage { get; set; }
+        public List<Disco.Models.BI.Search.DeviceSearchResultItem> Devices { get; set; }
+        public Disco.Models.BI.Job.JobTableModel Jobs { get; set; }
+        public List<Disco.Models.BI.Search.UserSearchResultItem> Users { get; set; }
+    }
+}
@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web;
+using System.Web.Mvc;
+using Disco.BI;
+using Disco.BI.Extensions;
+using Disco.Models.Interop.ActiveDirectory;
+using Disco.Web.Extensions;
+
+namespace Disco.Web.Models.User
+{
+    public class ShowModel
+    {
+        public Disco.Models.Repository.User User { get; set; }
+        public Disco.Models.BI.Job.JobTableModel Jobs { get; set; }
+        public List<Disco.Models.Repository.DocumentTemplate> DocumentTemplates { get; set; }
+
+        public List<SelectListItem> DocumentTemplatesSelectListItems
+        {
+            get
+            {
+                var list = new List<SelectListItem>();
+                list.Add(new SelectListItem() { Selected = true, Value = string.Empty, Text = "Select a Document to Generate" });
+                list.AddRange(this.DocumentTemplates.ToSelectListItems());
+                return list;
+            }
+        }
+
+        public string PrimaryDeviceSerialNumber
+        {
+            get
+            {
+                var assignedDevice = User.DeviceUserAssignments.Where(d => !d.UnassignedDate.HasValue).FirstOrDefault();
+                if (assignedDevice == null)
+                {
+                    return null;
+                }
+                else
+                {
+                    return assignedDevice.DeviceSerialNumber;
+                }
+            }
+        }
+    }
+}