public static CheckResult ValidateSave(DSModel db, DriverLicenseModel model)
        {
            CheckResult res = new CheckResult(model);

            if (model.DriverID == 0)
                res.AddError("Driver cannot be empty!", model.GetName(p => p.DriverID));
            if (model.LicenseID == 0)
                res.AddError("License type cannot be empty!", model.GetName(p => p.LicenseID));
            if (model.IssueDate == DateTime.MinValue)
                res.AddError("Issue date cannot be empty!", model.GetName(p => p.IssueDate));
            if (model.ExpirationDate == DateTime.MinValue)
                res.AddError("Expiration date cannot be empty!", model.GetName(p => p.ExpirationDate));
            if (model.MVRReviewDate.HasValue && model.MVRReviewDate.Value.Date < model.IssueDate.Date)
                res.AddError("MVR review date cannot be earlier than Issue date!", model.GetName(p => p.MVRReviewDate));
            if (model.IssueDate.Date > model.ExpirationDate.Date)
                res.AddError("Expiration date cannot be earlier than Issue date!", model.GetName(p => p.ExpirationDate));
            if (model.Permits.Count == 0)
                res.AddError("At least one permit must be selected!", model.GetName(p => p.Permits));

            //overlap check
            var check = db.DriversLicenses
                .Where(d =>
                    d.DriverLicenseID != model.DriverLicenseID &&
                    d.DriverID == model.DriverID &&
                    d.IssueDate < model.ExpirationDate &&
                    d.ExpirationDate > model.IssueDate)
                .FirstOrDefault();
            if (check != null)
                res.AddError("There is an overlapping license already!");

            return res;
        }
        private static void InsertDriverLicense(DSModel db, KeyBinder key, DriverLicenseModel model)
        {
            var poco = new DriversLicense();
            model.Map(poco);
            db.Add(poco);
            key.AddKey(poco, model, model.GetName(p => p.DriverLicenseID));
            db.FlushChanges();

            SaveDriverLicensePermits(db, key, poco, model);
            SaveDriverLicenseReminders(db, key, poco, model);
        }
        private static void UpdateDriverLicense(DSModel db, KeyBinder key, DriverLicenseModel model)
        {
            var poco = db.DriversLicenses.Where(d => d.DriverLicenseID == model.DriverLicenseID).FirstOrDefault();
            if (poco == null)
                throw new ArgumentNullException("poco");

            model.Map(poco);
            db.FlushChanges();

            SaveDriverLicensePermits(db, key, poco, model);
            SaveDriverLicenseReminders(db, key, poco, model);
        }
        public static void SaveDriverLicense(DSModel db, KeyBinder key, DriverLicenseModel model)
        {
            if (db == null)
                throw new ArgumentNullException("db");
            if (key == null)
                throw new ArgumentNullException("key");
            if (model == null)
                throw new ArgumentNullException("model");

            if (model.DriverLicenseID == 0)
                InsertDriverLicense(db, key, model);
            else
                UpdateDriverLicense(db, key, model);
        }
        public static CheckResult ValidateDelete(DSModel db, DriverLicenseModel model)
        {
            CheckResult res = new CheckResult(model);

            var checkDispatch = db.Dispatches
                .Where(d => d.DriverID == model.DriverID &&
                    d.FromDateTime.Date >= model.IssueDate &&
                    d.ToDateTime.Date <= model.ExpirationDate)
                .FirstOrDefault();
            if (checkDispatch != null)
                res.AddError("Cannot delete license, a dispatch uses the license!");

            return res;
        }
        private void HandleDelete(DriverLicenseModel mod, RowCellClickEventArgs e)
        {
            if (Mess.Question("Are you sure you wish to delete this license?", "Caution") != DialogResult.Yes)
                return;

            var manager = DriverLicenseManager.CreateEdit(mod.DriverLicenseID);
            var res = manager.Delete();
            if (res.Failed)
            {
                Mess.Error(res.Message);
            }
            else
            {
                RefreshLicenses();
            }
        }
 private void HandleRenew(DriverLicenseModel mod, RowCellClickEventArgs e)
 {
     var manager = DriverLicenseManager.CreateRenew(mod.DriverLicenseID);
     if (XF_DriverLicenseNewEdit.ShowWindow(manager) == DialogResult.Yes)
         RefreshLicenses();
 }
        private static void SaveDriverLicensePermits(DSModel db, KeyBinder key, DriversLicense poco, DriverLicenseModel model)
        {
            db.ExecuteNonQuery("DELETE FROM drivers_licenses_permits WHERE DriverLicenseID = @DriverLicenseID;",
                new MySqlParameter("DriverLicenseID", poco.DriverLicenseID));

            string sql = @"
                INSERT INTO drivers_licenses_permits (DriverLicenseID, PermitID) VALUES (@DriverLicenseID, @PermitID);
                SELECT LAST_INSERT_ID();";
            foreach (var per in model.Permits)
            {
                per.DriverLicenseID = poco.DriverLicenseID;
                per.DriverLicensePermitID = (uint)db.ExecuteScalar<ulong>(sql,
                    new MySqlParameter("DriverLicenseID", per.DriverLicenseID),
                    new MySqlParameter("PermitID", per.PermitID));
            }
        }
        public static void DeleteDriverLicense(DSModel db, KeyBinder key, DriverLicenseModel model)
        {
            if (db == null)
                throw new ArgumentNullException("db");
            if (key == null)
                throw new ArgumentNullException("key");
            if (model == null)
                throw new ArgumentNullException("model");

            db.DriversLicensesPermits
                .Where(p => p.DriverLicenseID == model.DriverLicenseID)
                .DeleteAll();
            db.DriversLicensesReminders
                .Where(l => l.DriverLicenseID == model.DriverLicenseID)
                .DeleteAll();
            db.DriversLicenses
                .Where(d => d.DriverLicenseID == model.DriverLicenseID)
                .DeleteAll();
        }
        private static void SaveDriverLicenseReminders(DSModel db, KeyBinder key, DriversLicense poco, DriverLicenseModel model)
        {
            db.ExecuteNonQuery("delete from drivers_licenses_reminders where DriverLicenseID = @DriverLicenseID;",
                new MySqlParameter("DriverLicenseID", poco.DriverLicenseID));

            string sql = @"
                INSERT INTO drivers_licenses_reminders 
                  (DriverLicenseID, ReminderID, ReminderType, ShouldRemind) 
                  VALUES 
                  (@DriverLicenseID, @ReminderID, @ReminderType, @ShouldRemind);
                SELECT LAST_INSERT_ID();";

            foreach (var rem in model.Reminders)
            {
                rem.DriverLicenseID = poco.DriverLicenseID;
                rem.DriverLicenseReminderID = (uint)db.ExecuteScalar<ulong>(sql,
                    new MySqlParameter("DriverLicenseID", rem.DriverLicenseID),
                    new MySqlParameter("ReminderID", rem.ReminderID),
                    new MySqlParameter("ReminderType", rem.ReminderType),
                    new MySqlParameter("ShouldRemind", rem.ShouldRemind));
            }
        }