Initial

2012-11-30 21:35:06 -05:00
commit 3963d6363a
346 changed files with 351799 additions and 0 deletions
@@ -0,0 +1,430 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text.RegularExpressions;
+using MileageTraker.Web.Models;
+using MileageTraker.Web.Utility;
+using MileageTraker.Web.ViewModels;
+
+namespace MileageTraker.Web.DAL
+{
+	public class DataService : IDisposable
+	{
+		private readonly MileageTrakerContext _db = new MileageTrakerContext();
+
+		#region Log
+
+		public void AddLog(Log log)
+		{
+			log.Created = DateTime.Now;
+			_db.Logs.Add(log);
+			_db.SaveChanges();
+
+			UpdateCurrentOdometer(log.VehicleId);
+		}
+
+		public IQueryable<Log> GetLogs()
+		{
+			return _db.Logs;
+		}
+
+		public Log GetLog(int id)
+		{
+			return _db.Logs.Find(id);
+		}
+
+		public IEnumerable<int> GetValidLogYears()
+		{
+			return
+			from l in GetLogs()
+			group l by new {year = l.Date.Year}
+				into y
+				orderby y.Key descending 
+				select y.Key.year;
+		}
+
+		public IEnumerable<int> GetValidLogMonths(int year)
+		{
+			var start = new DateTime(year, 1, 1);
+			var end = new DateTime(year + 1, 1, 1);
+			return
+			from l in GetLogs()
+			where l.Date >= start && l.Date < end
+			group l by new { month = l.Date.Month }
+				into m
+				orderby m.Key descending 
+				select m.Key.month;
+		}
+
+		public IEnumerable<LogIndexViewModel> GetLogIndexViewModels(IQueryable<Log> logs)
+		{
+			var t =
+				from log in logs
+				 let previousLog = (from ol in _db.Logs
+				                    where ol.VehicleId == log.VehicleId &&
+									((ol.Date <= log.Date && ol.EndOdometer < log.EndOdometer) || 
+									(ol.EndOdometer == log.EndOdometer && ol.Created < log.Created))
+									orderby ol.EndOdometer descending, ol.Created descending 
+				                    select ol).FirstOrDefault()
+				 select new {log, previousLog};
+			return from l in t.ToList()
+			       select new LogIndexViewModel(l.log, l.previousLog);
+		}
+
+		public IEnumerable<VehicleMileageItem> GetMonthlyVehicleMileageItems(LogQueryViewModel query)
+		{
+			var items =
+				from l in
+					from log in FilterLogs(_db.Logs, query)
+					let previousLog = (from ol in _db.Logs
+									   where ol.VehicleId == log.VehicleId &&
+									   ((ol.Date <= log.Date && ol.EndOdometer < log.EndOdometer) ||
+									   (ol.EndOdometer == log.EndOdometer && ol.Created < log.Created))
+									   orderby ol.EndOdometer descending, ol.Created descending 
+					                   select ol).FirstOrDefault()
+					select new {log, previousLog, miles = (previousLog != null ? log.EndOdometer - previousLog.EndOdometer : 0)}
+				group l by l.log.VehicleId
+				into g
+				join v in _db.Vehicles on g.Key equals v.VehicleId
+				let miles = g.Sum(l => l.miles)
+				let gasPurchased = g.Sum(l => l.log.GasPurchased)
+				where miles > 0 || gasPurchased > 0
+				let logPairs =
+					from i in g
+					orderby i.log.Date descending , i.log.EndOdometer descending
+					select new { PreviousLog = i.previousLog, Log = i.log }
+				select
+					new
+						{
+							VehicleId = g.Key,
+							GasPurchased = gasPurchased,
+							Miles = miles,
+							v.Prog,
+							LogPairs = logPairs
+						};
+
+			return items.ToList().Select(i => new VehicleMileageItem
+							{
+								VehicleId = i.VehicleId,
+								GasPurchased = i.GasPurchased,
+								Miles = i.Miles,
+								Prog = i.Prog,
+								LogPairs = i.LogPairs.ToList()
+									.Select(lp => new Tuple<Log,Log>(lp.PreviousLog, lp.Log))
+							});
+		}
+
+
+		public IEnumerable<EmployeeMileageItem> GetMonthlyEmployeeMileageItems(LogQueryViewModel query)
+		{
+			var items =
+				from l in
+					from log in FilterLogs(_db.Logs, query)
+					let previousLog = (from ol in _db.Logs
+									   where ol.VehicleId == log.VehicleId &&
+									   ((ol.Date <= log.Date && ol.EndOdometer < log.EndOdometer) ||
+									   (ol.EndOdometer == log.EndOdometer && ol.Created < log.Created))
+									   orderby ol.EndOdometer descending, ol.Created descending
+									   select ol).FirstOrDefault()
+					select new { log, previousLog, miles = (previousLog != null ? log.EndOdometer - previousLog.EndOdometer : 0) }
+				group l by l.log.EmployeeName
+				into g
+				let miles = g.Sum(l => l.miles)
+				let gasPurchased = g.Sum(l => l.log.GasPurchased)
+				where miles > 0 || gasPurchased > 0
+				let logPairs =
+					from i in g
+					orderby i.log.Date descending, i.log.EndOdometer descending
+					select new { PreviousLog = i.previousLog, Log = i.log }
+				select
+					new
+					{
+						EmployeeName = g.Key,
+						GasPurchased = gasPurchased,
+						Miles = miles,
+						LogPairs = logPairs
+					};
+
+			return items.ToList().Select(i => new EmployeeMileageItem
+			{
+				EmployeeName = i.EmployeeName,
+				GasPurchased = i.GasPurchased,
+				Miles = i.Miles,
+				LogPairs = i.LogPairs.ToList()
+					.Select(lp => new Tuple<Log, Log>(lp.PreviousLog, lp.Log))
+			});
+		}
+
+		public static IQueryable<Log> FilterLogs(IQueryable<Log> logs, LogQueryViewModel query)
+		{
+			if (query.Year.HasValue & query.Month.HasValue)
+			{
+				var start = new DateTime(query.Year.Value, query.Month.Value, 1);
+				var end = start.AddMonths(1);
+				logs = logs.Where(l => l.Date >= start && l.Date < end);
+			}
+
+			if (query.LogType.HasValue)
+			{
+				// WTF The specified value is not an instance of type 'Edm.Int32'
+				Expression<Func<Log, bool>> predicate;
+				switch (query.LogType.Value)
+				{
+					case MileageLogType.NonCommuting:
+						 predicate = l => l.LogType.Value == 1;
+						break;
+					case MileageLogType.Commuting:
+						predicate = l => l.LogType.Value == 2;
+						break;
+					case MileageLogType.GasPurchase:
+						predicate = l => l.LogType.Value == 3;
+						break;
+					default:
+						throw new ArgumentOutOfRangeException();
+				}
+				logs = logs.Where(predicate);
+			}
+
+			return logs;
+		}
+
+		public Log GetPreviousLog(Log current)
+		{
+			var vehicleId = current.VehicleId;
+			var date = current.Date;
+			var endOdometer = current.EndOdometer;
+			return GetPreviousLog(endOdometer, vehicleId, date, current.Created);
+		}
+
+		public Log GetPreviousLog(int endOdometer, string vehicleId, DateTime date, DateTime created)
+		{
+			return GetPreviousLogQuery(endOdometer, vehicleId, date, created).FirstOrDefault();
+		}
+
+		private IOrderedQueryable<Log> GetPreviousLogQuery(int endOdometer, string vehicleId, DateTime date, DateTime created)
+		{
+			return from pl in _db.Logs
+				   where pl.VehicleId == vehicleId &&
+					((pl.Date <= date && pl.EndOdometer < endOdometer)
+					|| (pl.EndOdometer == endOdometer && pl.Created < created))
+				   orderby pl.EndOdometer descending, pl.Created descending
+				   select pl;
+		}
+
+		public Log GetNextLog(Log current)
+		{
+			var vehicleId = current.VehicleId;
+			var date = current.Date;
+			var endOdometer = current.EndOdometer;
+			return GetNextLog(endOdometer, vehicleId, date, current.Created);
+		}
+
+		public Log GetNextLog(int endOdometer, string vehicleId, DateTime date, DateTime created)
+		{
+			return (from nl in GetLogs()
+					where nl.VehicleId == vehicleId &&
+						((nl.Date >= date && nl.EndOdometer > endOdometer)
+						|| (nl.EndOdometer == endOdometer && nl.Created > created))
+					orderby nl.EndOdometer ascending, nl.Created ascending 
+					select nl).FirstOrDefault();
+		}
+
+		public void UpdateLog(Log log)
+		{
+			var currentLog = GetLog(log.LogId);
+
+			// ignore these properties while updating
+			log.Created = currentLog.Created;
+			log.Source = currentLog.Source;
+			log.UserAgent = currentLog.UserAgent;
+			log.UserHostAddress = currentLog.UserHostAddress;
+
+			_db.Entry(currentLog).CurrentValues.SetValues(log);
+
+			_db.Entry(currentLog).State = EntityState.Modified;
+			_db.SaveChanges();
+
+			UpdateCurrentOdometer(log.VehicleId);
+		}
+
+		public void DeleteLog(int id)
+		{
+			var log = _db.Logs.Find(id);
+			_db.Logs.Remove(log);
+			_db.SaveChanges();
+
+			UpdateCurrentOdometer(log.VehicleId);
+		}
+
+		public IEnumerable<Log> GetRecentLogsByEmployee(string employeeName)
+		{
+			return
+				(from l in _db.Logs
+				 where l.EmployeeName == employeeName
+				 orderby l.Created descending
+				 select l)
+					.Take(3)
+					.ToList();
+		}
+
+		#endregion
+
+		#region Vehicle
+
+		public void AddVehicle(Vehicle vehicle)
+		{
+			if (vehicle.Assigned == "Unassigned")
+				vehicle.Assigned = null;
+			_db.Vehicles.Add(vehicle);
+			_db.SaveChanges();
+		}
+
+		public IEnumerable<Vehicle> GetVehicles()
+		{
+			var vehicles = _db.Vehicles;
+			return vehicles;
+		}
+
+		public Vehicle GetVehicle(string id)
+		{
+			return _db.Vehicles.Find(id);
+		}
+
+		public void UpdateVehicle(Vehicle vehicle)
+		{
+			if (vehicle.Assigned == "Unassigned")
+				vehicle.Assigned = null;
+			_db.Entry(vehicle).State = EntityState.Modified;
+			_db.SaveChanges();
+		}
+		
+		public void UpdateCurrentOdometer(string vehicleId)
+		{
+			var mostRecentOdometerQuery =
+				from log in _db.Logs
+				where
+					log.VehicleId == vehicleId
+				orderby log.Date descending, log.EndOdometer descending
+				select log;
+			var mostRecentOdometer = mostRecentOdometerQuery.FirstOrDefault();
+			var vehicle = _db.Vehicles.Find(vehicleId);
+			if (mostRecentOdometer != null && mostRecentOdometer.EndOdometer != vehicle.CurrentOdometer)
+			{
+				vehicle.CurrentOdometer = mostRecentOdometer.EndOdometer;
+				UpdateVehicle(vehicle);
+			}
+		}
+
+		public void ValidateOdometerChronology(string vehicleId, int odometer, DateTime date)
+		{
+			var conflictingLog = GetFirstConflictingOdometerChronologyLog(vehicleId, date, odometer);
+			if (conflictingLog != null)
+			{
+				throw new ChronologicalOrderException(
+					String.Format(
+						"Odometer of {0} miles on {1:d} conflicts with other logs for vehicle {2}" +
+						", including an odometer log of {3} miles on {4:d} reported by {5}.",
+						odometer, date, vehicleId, conflictingLog.EndOdometer, conflictingLog.Date, conflictingLog.EmployeeName));
+			}
+		}
+
+		public Log GetFirstConflictingOdometerChronologyLog(string vehicleId, DateTime date, int odometer)
+		{
+			// TODO HACK for testing, delete later
+			try
+			{
+				if (_db.Logs.Count() == 0)
+					return null;
+			}
+			catch (NullReferenceException)
+			{
+				return null;
+			}
+
+			var conflictingLogsQuery =
+				from log in _db.Logs
+				let existingDate = log.Date
+				let existingOdometer = log.EndOdometer
+				where
+					log.VehicleId == vehicleId &&
+					!(existingDate == date
+					  || existingOdometer == odometer
+					  || existingDate < date && existingOdometer < odometer
+					  || existingDate > date && existingOdometer > odometer)
+				orderby existingOdometer descending 
+				select log;
+
+			return conflictingLogsQuery.FirstOrDefault();
+		}
+
+		#endregion
+
+		#region Employee Name
+
+		public string GetEmployeeNameCorrected(string term)
+		{
+			var names = GetEmployeeNames().ToList();
+			return (from potentialName in names
+			        let potentialNameClean = Regex.Replace(potentialName, @"\s*\(.*\)", "").ToLower()
+			        let name = term.ToLower()
+			        let similarity = Algorithms.Similarity(potentialNameClean, name)
+			        where similarity > .7 || potentialNameClean.StartsWith(name)
+			        orderby similarity descending
+			        select potentialName).FirstOrDefault();
+		}
+
+		public IEnumerable<string> GetEmployeeNamesAutocomplete(string term)
+		{
+			var termLower = term.ToLower();
+			return from name in GetEmployeeNames()
+				   let nameLower = name.ToLower()
+				   where nameLower.StartsWith(termLower) || Algorithms.Similarity(nameLower, termLower) > .8
+				   select name;
+		}
+
+		public IEnumerable<string> GetEmployeeNames()
+		{
+			var names = _db.Vehicles.Select(v => v.Assigned).Where(n => !String.IsNullOrEmpty(n) && n != "to be sold");
+			var logNames = 
+				(from l in _db.Logs
+				select l.EmployeeName);
+			return names.Union(logNames).Distinct();
+		}
+
+		#endregion
+
+		#region City
+
+		public string GetCitiesCorrected(string term)
+		{
+			var termLower = term.ToLower();
+			return (from city in GetCities().ToList()
+				   let cityToLower = city.Name.ToLower()
+				   let similarity = Algorithms.Similarity(cityToLower, termLower)
+					where city.Name.StartsWith(term) || Algorithms.Similarity(cityToLower, termLower) > .8
+			       select city.Name).FirstOrDefault();
+		}
+
+		public IEnumerable<string> GetCitiesAutocomplete(string term)
+		{
+			return 
+				from city in GetCities()
+				   where city.Name.StartsWith(term)
+				   select city.Name;
+		}
+
+		private IQueryable<City> GetCities()
+		{
+			return _db.Cities;
+		}
+
+		#endregion
+
+		public void Dispose()
+		{
+			_db.Dispose();
+		}
+	}
+}