Пример #1
0
 public static Common.Models.Timing.TimeCategory Create(
     Transaction t,
     Common.Models.Timing.TimeCategory model,
     Common.Models.Account.Users creator)
 {
     return(Create(model, creator, t.Connection, false));
 }
Пример #2
0
 public static Common.Models.Timing.TimeCategory Disable(
     Transaction t,
     Common.Models.Timing.TimeCategory model,
     Common.Models.Account.Users disabler)
 {
     return(Disable(model, disabler, t.Connection, false));
 }
Пример #3
0
 public static Common.Models.Timing.TimeCategory Edit(
     Transaction t,
     Common.Models.Timing.TimeCategory model,
     Common.Models.Account.Users modifier)
 {
     return(Edit(model, modifier, t.Connection, false));
 }
Пример #4
0
        public static Common.Models.Timing.TimeCategory Disable(
            Common.Models.Timing.TimeCategory model,
            Common.Models.Account.Users disabler,
            IDbConnection conn   = null,
            bool closeConnection = true)
        {
            model.DisabledBy = disabler;
            model.Disabled   = DateTime.UtcNow;

            DataHelper.Disable <Common.Models.Timing.TimeCategory,
                                DBOs.Timing.TimeCategory>("time_category", disabler.PId.Value, model.Id, conn, closeConnection);

            return(model);
        }
Пример #5
0
        public ActionResult Details(Guid id)
        {
            Common.Models.Timing.Time         model;
            ViewModels.Timing.TimeViewModel   viewModel;
            Common.Models.Contacts.Contact    contact;
            Common.Models.Tasks.Task          task;
            Common.Models.Matters.Matter      matter;
            Common.Models.Timing.TimeCategory timeCategory;

            using (IDbConnection conn = Data.Database.Instance.GetConnection())
            {
                model = Data.Timing.Time.Get(id, conn, false);

                viewModel = Mapper.Map <ViewModels.Timing.TimeViewModel>(model);

                contact = Data.Contacts.Contact.Get(viewModel.Worker.Id.Value, conn, false);

                viewModel.Worker = Mapper.Map <ViewModels.Contacts.ContactViewModel>(contact);

                task = Data.Timing.Time.GetRelatedTask(model.Id.Value, conn, false);

                if (model.TimeCategory == null || !model.TimeCategory.Id.HasValue)
                {
                    timeCategory = new Common.Models.Timing.TimeCategory()
                    {
                        Id = 0, Title = "Standard"
                    }
                }
                ;
                else
                {
                    timeCategory = Data.Timing.TimeCategory.Get(model.TimeCategory.Id.Value, conn, false);
                }
                viewModel.TimeCategory = Mapper.Map <ViewModels.Timing.TimeCategoryViewModel>(timeCategory);

                PopulateCoreDetails(viewModel, conn);

                ViewBag.IsFastTime = Data.Timing.Time.IsFastTime(id);

                matter = Data.Tasks.Task.GetRelatedMatter(task.Id.Value, conn, false);
            }

            ViewBag.Task   = task;
            ViewBag.Matter = matter;
            return(View(viewModel));
        }
Пример #6
0
        public static Common.Models.Timing.TimeCategory Edit(
            Common.Models.Timing.TimeCategory model,
            Common.Models.Account.Users modifier,
            IDbConnection conn   = null,
            bool closeConnection = true)
        {
            model.ModifiedBy = modifier;
            model.Modified   = DateTime.UtcNow;
            DBOs.Timing.TimeCategory dbo = Mapper.Map <DBOs.Timing.TimeCategory>(model);

            conn = DataHelper.OpenIfNeeded(conn);

            conn.Execute("UPDATE \"time_category\" SET " +
                         "\"title\"=@Title, \"utc_modified\"=@UtcModified, \"modified_by_user_pid\"=@ModifiedByUserPId " +
                         "WHERE \"id\"=@Id", dbo);

            DataHelper.Close(conn, closeConnection);

            return(model);
        }
        public ActionResult Details(Guid id)
        {
            Common.Models.Timing.Time model;
            ViewModels.Timing.TimeViewModel viewModel;
            Common.Models.Contacts.Contact contact;
            Common.Models.Tasks.Task task;
            Common.Models.Matters.Matter matter;
            Common.Models.Timing.TimeCategory timeCategory;

            using (IDbConnection conn = Data.Database.Instance.GetConnection())
            {
                model = Data.Timing.Time.Get(id, conn, false);

                viewModel = Mapper.Map<ViewModels.Timing.TimeViewModel>(model);

                contact = Data.Contacts.Contact.Get(viewModel.Worker.Id.Value, conn, false);

                viewModel.Worker = Mapper.Map<ViewModels.Contacts.ContactViewModel>(contact);

                task = Data.Timing.Time.GetRelatedTask(model.Id.Value, conn, false);

                if (model.TimeCategory == null || !model.TimeCategory.Id.HasValue)
                    timeCategory = new Common.Models.Timing.TimeCategory() { Id = 0, Title = "Standard" };
                else
                    timeCategory = Data.Timing.TimeCategory.Get(model.TimeCategory.Id.Value, conn, false);
                viewModel.TimeCategory = Mapper.Map<ViewModels.Timing.TimeCategoryViewModel>(timeCategory);

                PopulateCoreDetails(viewModel, conn);

                ViewBag.IsFastTime = Data.Timing.Time.IsFastTime(id);

                matter = Data.Tasks.Task.GetRelatedMatter(task.Id.Value, conn, false);
            }

            ViewBag.Task = task;
            ViewBag.Matter = matter;
            return View(viewModel);
        }
Пример #8
0
        public static Common.Models.Timing.TimeCategory Create(
            Common.Models.Timing.TimeCategory model,
            Common.Models.Account.Users creator,
            IDbConnection conn   = null,
            bool closeConnection = true)
        {
            model.CreatedBy = model.ModifiedBy = creator;
            model.Created   = model.Modified = DateTime.UtcNow;
            DBOs.Timing.TimeCategory dbo = Mapper.Map <DBOs.Timing.TimeCategory>(model);

            conn = DataHelper.OpenIfNeeded(conn);

            if (conn.Execute("INSERT INTO \"time_category\" (\"title\", \"utc_created\", \"utc_modified\", \"created_by_user_pid\", \"modified_by_user_pid\") " +
                             "VALUES (@Title, @UtcCreated, @UtcModified, @CreatedByUserPId, @ModifiedByUserPId)",
                             dbo) > 0)
            {
                model.Id = conn.Query <DBOs.Timing.TimeCategory>("SELECT currval(pg_get_serial_sequence('time_category', 'id')) AS \"id\"").Single().Id;
            }

            DataHelper.Close(conn, closeConnection);

            return(model);
        }
Пример #9
0
        public ActionResult Edit(Guid id)
        {
            Common.Models.Timing.Time                   model;
            ViewModels.Timing.TimeViewModel             viewModel;
            Common.Models.Contacts.Contact              contact;
            Common.Models.Tasks.Task                    task;
            Common.Models.Matters.Matter                matter;
            List <ViewModels.Contacts.ContactViewModel> employeeContactList;

            Common.Models.Timing.TimeCategory        timeCategory;
            List <Common.Models.Timing.TimeCategory> timeCategoryList;

            employeeContactList = new List <ViewModels.Contacts.ContactViewModel>();

            using (IDbConnection conn = Data.Database.Instance.GetConnection())
            {
                model = Data.Timing.Time.Get(id, conn, false);

                viewModel = Mapper.Map <ViewModels.Timing.TimeViewModel>(model);

                contact = Data.Contacts.Contact.Get(viewModel.Worker.Id.Value, conn, false);

                viewModel.Worker = Mapper.Map <ViewModels.Contacts.ContactViewModel>(contact);

                task = Data.Timing.Time.GetRelatedTask(model.Id.Value, conn, false);

                if (model.TimeCategory == null || !model.TimeCategory.Id.HasValue)
                {
                    timeCategory = new Common.Models.Timing.TimeCategory()
                    {
                        Id = 0, Title = "Standard"
                    }
                }
                ;
                else
                {
                    timeCategory = Data.Timing.TimeCategory.Get(model.TimeCategory.Id.Value, conn, false);
                }
                viewModel.TimeCategory = Mapper.Map <ViewModels.Timing.TimeCategoryViewModel>(timeCategory);

                Data.Contacts.Contact.ListEmployeesOnly(conn, false).ForEach(x =>
                {
                    employeeContactList.Add(Mapper.Map <ViewModels.Contacts.ContactViewModel>(x));
                });

                if (!employeeContactList.Exists(x => x.Id == model.Worker.Id))
                {
                    employeeContactList.Add(Mapper.Map <ViewModels.Contacts.ContactViewModel>(Data.Contacts.Contact.Get(model.Worker.Id.Value, conn, false)));
                }

                ViewBag.TaskId = task.Id.Value;

                matter = Data.Tasks.Task.GetRelatedMatter(task.Id.Value, conn, false);

                timeCategoryList = Data.Timing.TimeCategory.List(conn, false);
                timeCategoryList.Insert(0, new Common.Models.Timing.TimeCategory()
                {
                    Id    = 0,
                    Title = "Standard"
                });
            }

            ViewBag.Task   = task;
            ViewBag.Matter = matter;
            ViewBag.EmployeeContactList = employeeContactList;
            ViewBag.TimeCategoryList    = timeCategoryList;

            return(View(viewModel));
        }
Пример #10
0
        public ViewModels.Billing.GroupInvoiceViewModel BuildGroupInvoiceViewModel(int id, IDbConnection conn, bool closeConnection, DateTime?startDate = null, DateTime?stopDate = null, string rateFrom = null)
        {
            Common.Models.Billing.BillingRate        billingRate = null;
            Common.Models.Billing.BillingGroup       billingGroup;
            ViewModels.Billing.GroupInvoiceViewModel viewModel       = new ViewModels.Billing.GroupInvoiceViewModel();
            Common.Models.Billing.Invoice            previousInvoice = null;
            List <Common.Models.Matters.Matter>      mattersList;

            if (!string.IsNullOrEmpty(Request["StartDate"]))
            {
                startDate = DateTime.Parse(Request["StartDate"]);
            }
            if (!string.IsNullOrEmpty(Request["StopDate"]))
            {
                stopDate = DateTime.Parse(Request["StopDate"]);
            }

            billingGroup    = Data.Billing.BillingGroup.Get(id, conn, false);
            previousInvoice = Data.Billing.Invoice.GetMostRecentInvoiceForContact(billingGroup.BillTo.Id.Value, conn, false);

            billingGroup.NextRun = new DateTime(DateTime.Now.Year, DateTime.Now.AddMonths(1).Month, 1);

            viewModel.Id           = Guid.NewGuid();
            viewModel.BillTo       = Mapper.Map <ViewModels.Contacts.ContactViewModel>(Data.Contacts.Contact.Get(billingGroup.BillTo.Id.Value, conn, false));
            viewModel.Date         = DateTime.Now;
            viewModel.Due          = DateTime.Now.AddDays(30);
            viewModel.BillingGroup = Mapper.Map <ViewModels.Billing.BillingGroupViewModel>(billingGroup);

            if (previousInvoice == null)
            {
                viewModel.BillTo_NameLine1 = viewModel.BillTo.DisplayName;
                if (string.IsNullOrEmpty(viewModel.BillTo.Address1AddressPostOfficeBox))
                {
                    viewModel.BillTo_AddressLine1 = viewModel.BillTo.Address1AddressStreet;
                }
                else
                {
                    viewModel.BillTo_AddressLine1 = "P.O. Box " + viewModel.BillTo.Address1AddressPostOfficeBox;
                }
                viewModel.BillTo_City  = viewModel.BillTo.Address1AddressCity;
                viewModel.BillTo_State = viewModel.BillTo.Address1AddressStateOrProvince;
                viewModel.BillTo_Zip   = viewModel.BillTo.Address1AddressPostalCode;
            }
            else
            {
                viewModel.BillTo_NameLine1    = previousInvoice.BillTo_NameLine1;
                viewModel.BillTo_NameLine2    = previousInvoice.BillTo_NameLine2;
                viewModel.BillTo_AddressLine1 = previousInvoice.BillTo_AddressLine1;
                viewModel.BillTo_AddressLine2 = previousInvoice.BillTo_AddressLine2;
                viewModel.BillTo_City         = previousInvoice.BillTo_City;
                viewModel.BillTo_State        = previousInvoice.BillTo_State;
                viewModel.BillTo_Zip          = previousInvoice.BillTo_Zip;
            }

            // Get list of matters for the group
            mattersList = Data.Billing.BillingGroup.ListMattersForGroup(billingGroup.Id.Value, conn, false);

            for (int i = 0; i < mattersList.Count; i++)
            {
                ViewModels.Billing.GroupInvoiceItemViewModel giivm = new ViewModels.Billing.GroupInvoiceItemViewModel();
                Common.Models.Matters.Matter matter = mattersList[i];

                giivm.Matter = Mapper.Map <ViewModels.Matters.MatterViewModel>(matter);

                Data.Timing.Time.ListUnbilledAndBillableTimeForMatter(matter.Id.Value, startDate, stopDate, conn, false).ForEach(x =>
                {
                    ViewModels.Billing.InvoiceTimeViewModel vm = new ViewModels.Billing.InvoiceTimeViewModel()
                    {
                        //Invoice = viewModel,
                        Time    = Mapper.Map <ViewModels.Timing.TimeViewModel>(x),
                        Details = x.Details
                    };
                    if (x.Stop.HasValue)
                    {
                        vm.Duration = x.Stop.Value - x.Start;
                    }
                    else
                    {
                        vm.Duration = new TimeSpan(0);
                    }

                    if (string.IsNullOrEmpty(Request["RateFrom"]))
                    { // Not specified in URL
                        if (matter.OverrideMatterRateWithEmployeeRate)
                        {
                            Common.Models.Contacts.Contact contact = Data.Contacts.Contact.Get(x.Worker.Id.Value, conn, false);
                            if (contact.BillingRate != null && contact.BillingRate.Id.HasValue)
                            {
                                billingRate = Data.Billing.BillingRate.Get(contact.BillingRate.Id.Value, conn, false);
                            }
                        }
                    }
                    else
                    { // Overridden by current user in URL
                        if (Request["RateFrom"] == "Employee")
                        {
                            Common.Models.Contacts.Contact contact = Data.Contacts.Contact.Get(x.Worker.Id.Value, conn, false);
                            if (contact.BillingRate != null && contact.BillingRate.Id.HasValue)
                            {
                                billingRate = Data.Billing.BillingRate.Get(contact.BillingRate.Id.Value, conn, false);
                            }
                        }
                    }

                    if (billingRate != null)
                    {
                        vm.PricePerHour = billingRate.PricePerUnit;
                    }

                    ViewModels.Billing.InvoiceTimeGroupViewModel timeGroup;
                    if (x.TimeCategory == null || !x.TimeCategory.Id.HasValue)
                    {
                        timeGroup = giivm.TimeGroups.SingleOrDefault(y => y.Id == 0);
                    }
                    else
                    {
                        timeGroup = giivm.TimeGroups.SingleOrDefault(y => y.Id == x.TimeCategory.Id);
                    }
                    if (timeGroup == null || timeGroup.Id == -1)
                    {
                        Common.Models.Timing.TimeCategory tc = Data.Timing.TimeCategory.Get(x.TimeCategory.Id.Value, conn, false);
                        timeGroup = new ViewModels.Billing.InvoiceTimeGroupViewModel()
                        {
                            Id        = tc.Id.Value,
                            GroupName = tc.Title,
                            Times     = new List <ViewModels.Billing.InvoiceTimeViewModel>()
                        };
                        timeGroup.Times.Add(vm);
                        giivm.TimeGroups.Add(timeGroup);
                    }
                    else
                    {
                        timeGroup.Times.Add(vm);
                    }
                });
                // On instantiation, GroupInvoiceItemViewModel.TimeGroups has the first element created as "Standard"
                // if it is not used, we need to drop it
                if (giivm.TimeGroups.Count > 1 && giivm.TimeGroups[0].Times.Count == 0)
                {
                    giivm.TimeGroups.RemoveAt(0);
                }

                Data.Billing.Expense.ListUnbilledExpensesForMatter(matter.Id.Value, startDate, stopDate, conn, false).ForEach(x =>
                {
                    giivm.Expenses.Add(new ViewModels.Billing.InvoiceExpenseViewModel()
                    {
                        //Invoice = viewModel,
                        Expense = Mapper.Map <ViewModels.Billing.ExpenseViewModel>(x),
                        Details = x.Details,
                        Amount  = x.Amount
                    });
                });

                Data.Billing.Fee.ListUnbilledFeesForMatter(matter.Id.Value, startDate, stopDate, conn, false).ForEach(x =>
                {
                    giivm.Fees.Add(new ViewModels.Billing.InvoiceFeeViewModel()
                    {
                        //Invoice = viewModel,
                        Fee     = Mapper.Map <ViewModels.Billing.FeeViewModel>(x),
                        Details = x.Details,
                        Amount  = x.Amount
                    });
                });

                if ((giivm.TimeGroups.Count(x => x.Times.Count > 0) > 0) ||
                    (giivm.Expenses.Count > 0) ||
                    (giivm.Fees.Count > 0))
                {
                    viewModel.Matters.Add(giivm);
                }
            }

            ViewData["FirmName"]    = Common.Settings.Manager.Instance.System.BillingFirmName;
            ViewData["FirmAddress"] = Common.Settings.Manager.Instance.System.BillingFirmAddress;
            ViewData["FirmCity"]    = Common.Settings.Manager.Instance.System.BillingFirmCity;
            ViewData["FirmState"]   = Common.Settings.Manager.Instance.System.BillingFirmState;
            ViewData["FirmZip"]     = Common.Settings.Manager.Instance.System.BillingFirmZip;
            ViewData["FirmPhone"]   = Common.Settings.Manager.Instance.System.BillingFirmPhone;
            ViewData["FirmWeb"]     = Common.Settings.Manager.Instance.System.BillingFirmWeb;

            return(viewModel);
        }
Пример #11
0
        public ViewModels.Billing.InvoiceViewModel BuildSingleMatterViewModel(Guid id, IDbConnection conn, bool closeConnection, DateTime?startDate = null, DateTime?stopDate = null, string rateFrom = null)
        {
            Common.Models.Billing.BillingRate   billingRate     = null;
            ViewModels.Billing.InvoiceViewModel viewModel       = new ViewModels.Billing.InvoiceViewModel();
            Common.Models.Billing.Invoice       previousInvoice = null;
            Common.Models.Matters.Matter        matter;

            matter = Data.Matters.Matter.Get(id, conn, false);

            previousInvoice = Data.Billing.Invoice.GetMostRecentInvoiceForContact(matter.BillTo.Id.Value, conn, false);

            // Set default billing rate
            if (matter.DefaultBillingRate != null && matter.DefaultBillingRate.Id.HasValue)
            {
                billingRate = Data.Billing.BillingRate.Get(matter.DefaultBillingRate.Id.Value, conn, false);
            }

            viewModel.Id     = Guid.NewGuid();
            viewModel.BillTo = Mapper.Map <ViewModels.Contacts.ContactViewModel>(Data.Contacts.Contact.Get(matter.BillTo.Id.Value, conn, false));
            viewModel.Date   = DateTime.Now;
            viewModel.Due    = DateTime.Now.AddDays(30);
            viewModel.Matter = Mapper.Map <ViewModels.Matters.MatterViewModel>(matter);

            if (previousInvoice == null)
            {
                viewModel.BillTo_NameLine1 = viewModel.BillTo.DisplayName;
                if (string.IsNullOrEmpty(viewModel.BillTo.Address1AddressPostOfficeBox))
                {
                    viewModel.BillTo_AddressLine1 = viewModel.BillTo.Address1AddressStreet;
                }
                else
                {
                    viewModel.BillTo_AddressLine1 = "P.O. Box " + viewModel.BillTo.Address1AddressPostOfficeBox;
                }
                viewModel.BillTo_City  = viewModel.BillTo.Address1AddressCity;
                viewModel.BillTo_State = viewModel.BillTo.Address1AddressStateOrProvince;
                viewModel.BillTo_Zip   = viewModel.BillTo.Address1AddressPostalCode;
            }
            else
            {
                viewModel.BillTo_NameLine1    = previousInvoice.BillTo_NameLine1;
                viewModel.BillTo_NameLine2    = previousInvoice.BillTo_NameLine2;
                viewModel.BillTo_AddressLine1 = previousInvoice.BillTo_AddressLine1;
                viewModel.BillTo_AddressLine2 = previousInvoice.BillTo_AddressLine2;
                viewModel.BillTo_City         = previousInvoice.BillTo_City;
                viewModel.BillTo_State        = previousInvoice.BillTo_State;
                viewModel.BillTo_Zip          = previousInvoice.BillTo_Zip;
            }

            Data.Timing.Time.ListUnbilledAndBillableTimeForMatter(matter.Id.Value, startDate, stopDate, conn, false).ForEach(x =>
            {
                ViewModels.Billing.InvoiceTimeViewModel vm = new ViewModels.Billing.InvoiceTimeViewModel()
                {
                    Invoice = viewModel,
                    Time    = Mapper.Map <ViewModels.Timing.TimeViewModel>(x),
                    Details = x.Details
                };
                if (x.Stop.HasValue)
                {
                    vm.Duration = x.Stop.Value - x.Start;
                }
                else
                {
                    vm.Duration = new TimeSpan(0);
                }

                if (string.IsNullOrEmpty(rateFrom))
                { // Not specified in URL
                    if (matter.OverrideMatterRateWithEmployeeRate)
                    {
                        Common.Models.Contacts.Contact contact = Data.Contacts.Contact.Get(x.Worker.Id.Value, conn, false);
                        if (contact.BillingRate != null && contact.BillingRate.Id.HasValue)
                        {
                            billingRate = Data.Billing.BillingRate.Get(contact.BillingRate.Id.Value, conn, false);
                        }
                    }
                }
                else
                { // Overridden by current user in URL
                    if (rateFrom == "employee")
                    {
                        Common.Models.Contacts.Contact contact = Data.Contacts.Contact.Get(x.Worker.Id.Value, conn, false);
                        if (contact.BillingRate != null && contact.BillingRate.Id.HasValue)
                        {
                            billingRate = Data.Billing.BillingRate.Get(contact.BillingRate.Id.Value, conn, false);
                        }
                    }
                }

                if (billingRate != null)
                {
                    vm.PricePerHour = billingRate.PricePerUnit;
                }
                ViewModels.Billing.InvoiceTimeGroupViewModel timeGroup;
                if (x.TimeCategory == null || !x.TimeCategory.Id.HasValue)
                {
                    timeGroup = viewModel.TimeGroups.SingleOrDefault(y => y.Id == 0);
                }
                else
                {
                    timeGroup = viewModel.TimeGroups.SingleOrDefault(y => y.Id == x.TimeCategory.Id);
                }
                if (timeGroup == null || timeGroup.Id == -1)
                {
                    Common.Models.Timing.TimeCategory tc = Data.Timing.TimeCategory.Get(x.TimeCategory.Id.Value, conn, false);
                    timeGroup = new ViewModels.Billing.InvoiceTimeGroupViewModel()
                    {
                        Id        = tc.Id.Value,
                        GroupName = tc.Title,
                        Times     = new List <ViewModels.Billing.InvoiceTimeViewModel>()
                    };
                    timeGroup.Times.Add(vm);
                    viewModel.TimeGroups.Add(timeGroup);
                }
                else
                {
                    timeGroup.Times.Add(vm);
                }
            });

            Data.Billing.Expense.ListUnbilledExpensesForMatter(matter.Id.Value, startDate, stopDate, conn, false).ForEach(x =>
            {
                viewModel.Expenses.Add(new ViewModels.Billing.InvoiceExpenseViewModel()
                {
                    Invoice = viewModel,
                    Expense = Mapper.Map <ViewModels.Billing.ExpenseViewModel>(x),
                    Details = x.Details,
                    Amount  = x.Amount
                });
            });

            Data.Billing.Fee.ListUnbilledFeesForMatter(matter.Id.Value, startDate, stopDate, conn, false).ForEach(x =>
            {
                viewModel.Fees.Add(new ViewModels.Billing.InvoiceFeeViewModel()
                {
                    Invoice = viewModel,
                    Fee     = Mapper.Map <ViewModels.Billing.FeeViewModel>(x),
                    Details = x.Details,
                    Amount  = x.Amount
                });
            });

            viewModel.TimeGroups = viewModel.TimeGroups.OrderBy(y => y.GroupName).ToList();

            ViewData["MatterTitle"] = matter.Title;
            ViewData["CaseNumber"]  = matter.CaseNumber;
            ViewData["FirmName"]    = Common.Settings.Manager.Instance.System.BillingFirmName;
            ViewData["FirmAddress"] = Common.Settings.Manager.Instance.System.BillingFirmAddress;
            ViewData["FirmCity"]    = Common.Settings.Manager.Instance.System.BillingFirmCity;
            ViewData["FirmState"]   = Common.Settings.Manager.Instance.System.BillingFirmState;
            ViewData["FirmZip"]     = Common.Settings.Manager.Instance.System.BillingFirmZip;
            ViewData["FirmPhone"]   = Common.Settings.Manager.Instance.System.BillingFirmPhone;
            ViewData["FirmWeb"]     = Common.Settings.Manager.Instance.System.BillingFirmWeb;

            return(viewModel);
        }
        public ActionResult Edit(Guid id)
        {
            Common.Models.Timing.Time model;
            ViewModels.Timing.TimeViewModel viewModel;
            Common.Models.Contacts.Contact contact;
            Common.Models.Tasks.Task task;
            Common.Models.Matters.Matter matter;
            List<ViewModels.Contacts.ContactViewModel> employeeContactList;
            Common.Models.Timing.TimeCategory timeCategory;
            List<Common.Models.Timing.TimeCategory> timeCategoryList;

            employeeContactList = new List<ViewModels.Contacts.ContactViewModel>();

            using (IDbConnection conn = Data.Database.Instance.GetConnection())
            {
                model = Data.Timing.Time.Get(id, conn, false);

                viewModel = Mapper.Map<ViewModels.Timing.TimeViewModel>(model);

                contact = Data.Contacts.Contact.Get(viewModel.Worker.Id.Value, conn, false);

                viewModel.Worker = Mapper.Map<ViewModels.Contacts.ContactViewModel>(contact);

                task = Data.Timing.Time.GetRelatedTask(model.Id.Value, conn, false);

                if (model.TimeCategory == null || !model.TimeCategory.Id.HasValue)
                    timeCategory = new Common.Models.Timing.TimeCategory() { Id = 0, Title = "Standard" };
                else
                    timeCategory = Data.Timing.TimeCategory.Get(model.TimeCategory.Id.Value, conn, false);
                viewModel.TimeCategory = Mapper.Map<ViewModels.Timing.TimeCategoryViewModel>(timeCategory);

                Data.Contacts.Contact.ListEmployeesOnly(conn, false).ForEach(x =>
                {
                    employeeContactList.Add(Mapper.Map<ViewModels.Contacts.ContactViewModel>(x));
                });

                ViewBag.TaskId = task.Id.Value;

                matter = Data.Tasks.Task.GetRelatedMatter(task.Id.Value, conn, false);

                timeCategoryList = Data.Timing.TimeCategory.List(conn, false);
                timeCategoryList.Insert(0, new Common.Models.Timing.TimeCategory()
                {
                    Id = 0,
                    Title = "Standard"
                });
            }

            ViewBag.Task = task;
            ViewBag.Matter = matter;
            ViewBag.EmployeeContactList = employeeContactList;
            ViewBag.TimeCategoryList = timeCategoryList;

            return View(viewModel);
        }
        public ActionResult GroupDetails(Guid id)
        {
            Common.Models.Billing.BillingGroup       billingGroup;
            ViewModels.Billing.GroupInvoiceViewModel viewModel = new ViewModels.Billing.GroupInvoiceViewModel();
            List <Common.Models.Matters.Matter>      mattersList;

            Common.Models.Billing.Invoice invoice = null;

            using (IDbConnection conn = Data.Database.Instance.GetConnection())
            {
                invoice      = Data.Billing.Invoice.Get(id, conn, false);
                billingGroup = Data.Billing.BillingGroup.Get(invoice.BillingGroup.Id.Value, conn, false);

                viewModel = new ViewModels.Billing.GroupInvoiceViewModel()
                {
                    Id     = invoice.Id,
                    BillTo = new ViewModels.Contacts.ContactViewModel()
                    {
                        Id = invoice.BillTo.Id
                    },
                    Date                = invoice.Date,
                    Due                 = invoice.Due,
                    Subtotal            = invoice.Subtotal,
                    TaxAmount           = invoice.TaxAmount,
                    Total               = invoice.Total,
                    ExternalInvoiceId   = invoice.ExternalInvoiceId,
                    BillTo_NameLine1    = invoice.BillTo_NameLine1,
                    BillTo_NameLine2    = invoice.BillTo_NameLine2,
                    BillTo_AddressLine1 = invoice.BillTo_AddressLine1,
                    BillTo_AddressLine2 = invoice.BillTo_AddressLine2,
                    BillTo_City         = invoice.BillTo_City,
                    BillTo_State        = invoice.BillTo_State,
                    BillTo_Zip          = invoice.BillTo_Zip,
                    BillingGroup        = Mapper.Map <ViewModels.Billing.BillingGroupViewModel>(billingGroup)
                };

                mattersList = Data.Billing.BillingGroup.ListMattersForGroup(billingGroup.Id.Value, conn, false);

                for (int i = 0; i < mattersList.Count; i++)
                {
                    ViewModels.Billing.GroupInvoiceItemViewModel giivm = new ViewModels.Billing.GroupInvoiceItemViewModel();
                    giivm.Matter = Mapper.Map <ViewModels.Matters.MatterViewModel>(mattersList[i]);

                    Data.Billing.InvoiceExpense.ListForMatterAndInvoice(id, mattersList[i].Id.Value, conn, false).ForEach(x =>
                    {
                        ViewModels.Billing.InvoiceExpenseViewModel vm = Mapper.Map <ViewModels.Billing.InvoiceExpenseViewModel>(x);
                        vm.Expense = Mapper.Map <ViewModels.Billing.ExpenseViewModel>(
                            Data.Billing.Expense.Get(vm.Expense.Id.Value, conn, false));
                        giivm.ExpensesSum += vm.Amount;
                        giivm.Expenses.Add(vm);
                    });

                    Data.Billing.InvoiceFee.ListForMatterAndInvoice(id, mattersList[i].Id.Value, conn, false).ForEach(x =>
                    {
                        ViewModels.Billing.InvoiceFeeViewModel vm = Mapper.Map <ViewModels.Billing.InvoiceFeeViewModel>(x);
                        vm.Fee = Mapper.Map <ViewModels.Billing.FeeViewModel>(
                            Data.Billing.Fee.Get(vm.Fee.Id.Value, conn, false));
                        giivm.FeesSum += vm.Amount;
                        giivm.Fees.Add(vm);
                    });

                    Data.Billing.InvoiceTime.ListForMatterAndInvoice(id, mattersList[i].Id.Value, conn, false).ForEach(x =>
                    {
                        ViewModels.Billing.InvoiceTimeViewModel vm = Mapper.Map <ViewModels.Billing.InvoiceTimeViewModel>(x);
                        vm.Time = Mapper.Map <ViewModels.Timing.TimeViewModel>(
                            Data.Timing.Time.Get(vm.Time.Id.Value, conn, false));

                        ViewModels.Billing.InvoiceTimeGroupViewModel timeGroup;
                        if (vm.Time.TimeCategory == null || !vm.Time.TimeCategory.Id.HasValue)
                        {
                            timeGroup = giivm.TimeGroups.SingleOrDefault(y => y.Id == 0);
                        }
                        else
                        {
                            timeGroup = giivm.TimeGroups.SingleOrDefault(y => y.Id == vm.Time.TimeCategory.Id);
                        }
                        if (timeGroup == null || timeGroup.Id == -1)
                        {
                            Common.Models.Timing.TimeCategory tc = Data.Timing.TimeCategory.Get(vm.Time.TimeCategory.Id.Value, conn, false);
                            timeGroup = new ViewModels.Billing.InvoiceTimeGroupViewModel()
                            {
                                Id        = tc.Id.Value,
                                GroupName = tc.Title,
                                Times     = new List <ViewModels.Billing.InvoiceTimeViewModel>()
                            };
                            timeGroup.Times.Add(vm);
                            giivm.TimeGroups.Add(timeGroup);
                        }
                        else
                        {
                            timeGroup.Times.Add(vm);
                        }

                        giivm.TimeSum       = giivm.TimeSum.Add(vm.Duration);
                        giivm.TimeSumMoney += vm.PricePerHour * (decimal)vm.Duration.TotalHours;
                    });

                    if (((giivm.TimeGroups.Count > 0) && (giivm.TimeGroups.Count(x => x.Times.Count > 0) > 0)) ||
                        (giivm.Expenses.Count > 0) ||
                        (giivm.Fees.Count > 0))
                    {
                        viewModel.Matters.Add(giivm);
                    }
                }
            }

            ViewBag.Invoice         = Mapper.Map <ViewModels.Billing.InvoiceViewModel>(invoice);
            ViewBag.BillingGroup    = Mapper.Map <ViewModels.Billing.BillingGroupViewModel>(billingGroup);
            ViewData["FirmName"]    = Common.Settings.Manager.Instance.System.BillingFirmName;
            ViewData["FirmAddress"] = Common.Settings.Manager.Instance.System.BillingFirmAddress;
            ViewData["FirmCity"]    = Common.Settings.Manager.Instance.System.BillingFirmCity;
            ViewData["FirmState"]   = Common.Settings.Manager.Instance.System.BillingFirmState;
            ViewData["FirmZip"]     = Common.Settings.Manager.Instance.System.BillingFirmZip;
            ViewData["FirmPhone"]   = Common.Settings.Manager.Instance.System.BillingFirmPhone;
            ViewData["FirmWeb"]     = Common.Settings.Manager.Instance.System.BillingFirmWeb;

            return(View(viewModel));
        }
        public ActionResult MatterEdit(Guid id)
        {
            Common.Models.Billing.BillingRate   billingRate = null;
            Common.Models.Matters.Matter        matter      = null;
            Common.Models.Billing.Invoice       invoice     = null;
            ViewModels.Billing.InvoiceViewModel viewModel   = new ViewModels.Billing.InvoiceViewModel();

            using (IDbConnection conn = Data.Database.Instance.GetConnection())
            {
                invoice   = Data.Billing.Invoice.Get(id, conn, false);
                viewModel = Mapper.Map <ViewModels.Billing.InvoiceViewModel>(invoice);

                if (invoice.Matter != null)
                {
                    matter           = Data.Matters.Matter.Get(invoice.Matter.Id.Value, conn, false);
                    viewModel.Matter = Mapper.Map <ViewModels.Matters.MatterViewModel>(matter);
                    if (matter.DefaultBillingRate != null && matter.DefaultBillingRate.Id.HasValue)
                    {
                        billingRate = Data.Billing.BillingRate.Get(matter.DefaultBillingRate.Id.Value, conn, false);
                    }
                }

                invoice.BillTo = Data.Contacts.Contact.Get(invoice.BillTo.Id.Value, conn, false);

                Data.Billing.Invoice.ListInvoiceExpensesForInvoice(invoice.Id.Value, conn, false).ForEach(x =>
                {
                    ViewModels.Billing.InvoiceExpenseViewModel vm = Mapper.Map <ViewModels.Billing.InvoiceExpenseViewModel>(x);
                    vm.Expense = Mapper.Map <ViewModels.Billing.ExpenseViewModel>(
                        Data.Billing.Expense.Get(vm.Expense.Id.Value, conn, false));
                    viewModel.Expenses.Add(vm);
                });

                Data.Billing.Invoice.ListInvoiceFeesForInvoice(invoice.Id.Value, conn, false).ForEach(x =>
                {
                    ViewModels.Billing.InvoiceFeeViewModel vm = Mapper.Map <ViewModels.Billing.InvoiceFeeViewModel>(x);
                    vm.Fee = Mapper.Map <ViewModels.Billing.FeeViewModel>(
                        Data.Billing.Fee.Get(vm.Fee.Id.Value, conn, false));
                    viewModel.Fees.Add(vm);
                });

                Data.Billing.Invoice.ListInvoiceTimesForInvoice(invoice.Id.Value, conn, false).ForEach(x =>
                {
                    ViewModels.Billing.InvoiceTimeViewModel vm = Mapper.Map <ViewModels.Billing.InvoiceTimeViewModel>(x);
                    vm.Time = Mapper.Map <ViewModels.Timing.TimeViewModel>(
                        Data.Timing.Time.Get(vm.Time.Id.Value, conn, false));

                    ViewModels.Billing.InvoiceTimeGroupViewModel timeGroup;
                    if (vm.Time.TimeCategory == null || !vm.Time.TimeCategory.Id.HasValue)
                    {
                        timeGroup = viewModel.TimeGroups.SingleOrDefault(y => y.Id == 0);
                    }
                    else
                    {
                        timeGroup = viewModel.TimeGroups.SingleOrDefault(y => y.Id == vm.Time.TimeCategory.Id);
                    }
                    if (timeGroup == null || timeGroup.Id == -1)
                    {
                        Common.Models.Timing.TimeCategory tc = Data.Timing.TimeCategory.Get(vm.Time.TimeCategory.Id.Value, conn, false);
                        timeGroup = new ViewModels.Billing.InvoiceTimeGroupViewModel()
                        {
                            Id        = tc.Id.Value,
                            GroupName = tc.Title,
                            Times     = new List <ViewModels.Billing.InvoiceTimeViewModel>()
                        };
                        timeGroup.Times.Add(vm);
                        viewModel.TimeGroups.Add(timeGroup);
                    }
                    else
                    {
                        timeGroup.Times.Add(vm);
                    }
                });
            }

            ViewData["MatterTitle"] = matter.Title;
            ViewData["CaseNumber"]  = matter.CaseNumber;
            ViewData["FirmName"]    = Common.Settings.Manager.Instance.System.BillingFirmName;
            ViewData["FirmAddress"] = Common.Settings.Manager.Instance.System.BillingFirmAddress;
            ViewData["FirmCity"]    = Common.Settings.Manager.Instance.System.BillingFirmCity;
            ViewData["FirmState"]   = Common.Settings.Manager.Instance.System.BillingFirmState;
            ViewData["FirmZip"]     = Common.Settings.Manager.Instance.System.BillingFirmZip;
            ViewData["FirmPhone"]   = Common.Settings.Manager.Instance.System.BillingFirmPhone;
            ViewData["FirmWeb"]     = Common.Settings.Manager.Instance.System.BillingFirmWeb;

            return(View(viewModel));
        }
        public ActionResult MatterEdit(Guid id, ViewModels.Billing.InvoiceViewModel viewModel)
        {
            // Update Invoice
            // Loop Expenses
            // Loop Fees
            // Loop Times
            // Redirect to invoice viewing
            Common.Models.Account.Users  currentUser;
            Common.Models.Matters.Matter matter;
            DateTime?start = null, stop = null;
            List <Common.Models.Billing.InvoiceExpense> invoiceExpenseList;
            List <Common.Models.Billing.InvoiceFee>     invoiceFeeList;
            List <Common.Models.Billing.InvoiceTime>    invoiceTimeList;

            Common.Models.Billing.Invoice invoice = null;

            if (!string.IsNullOrEmpty(Request["StartDate"]))
            {
                start = DateTime.Parse(Request["StartDate"]);
            }
            if (!string.IsNullOrEmpty(Request["StopDate"]))
            {
                stop = DateTime.Parse(Request["StopDate"]);
            }

            using (Data.Transaction trans = Data.Transaction.Create(true))
            {
                try
                {
                    currentUser = Data.Account.Users.Get(trans, User.Identity.Name);
                    invoice     = Mapper.Map <Common.Models.Billing.Invoice>(viewModel);
                    ViewModels.Billing.InvoiceViewModel        savedInvoice;
                    ViewModels.Billing.InvoiceExpenseViewModel ievm;
                    ViewModels.Billing.InvoiceFeeViewModel     ifvm;
                    ViewModels.Billing.InvoiceTimeViewModel    itvm;

                    // Validation
                    for (int i = 0; i < viewModel.TimeGroups.Count; i++)
                    {
                        if (viewModel.TimeGroups[i].Times.Count > 0)
                        {
                            Common.Models.Timing.TimeCategory zTc;
                            Common.Models.Timing.Time         zItem = Data.Timing.Time.Get(viewModel.TimeGroups[i].Times[0].Time.Id.Value);

                            if (zItem.TimeCategory == null || !zItem.TimeCategory.Id.HasValue || zItem.TimeCategory.Id.Value < 1)
                            {
                                viewModel.TimeGroups[i].GroupName = "Standard";
                                viewModel.TimeGroups[i].Id        = 0;
                            }
                            else
                            {
                                zTc = Data.Timing.TimeCategory.Get(zItem.TimeCategory.Id.Value);
                                viewModel.TimeGroups[i].GroupName = zTc.Title;
                                viewModel.TimeGroups[i].Id        = zTc.Id.Value;
                            }
                        }
                    }

                    savedInvoice          = Mapper.Map <ViewModels.Billing.InvoiceViewModel>(Data.Billing.Invoice.Get(trans, id));
                    savedInvoice.Expenses = new List <ViewModels.Billing.InvoiceExpenseViewModel>();
                    Data.Billing.Invoice.ListInvoiceExpensesForInvoice(trans, id).ForEach(x =>
                    {
                        savedInvoice.Expenses.Add(Mapper.Map <ViewModels.Billing.InvoiceExpenseViewModel>(x));
                    });
                    savedInvoice.Fees = new List <ViewModels.Billing.InvoiceFeeViewModel>();
                    Data.Billing.Invoice.ListInvoiceFeesForInvoice(trans, id).ForEach(x =>
                    {
                        savedInvoice.Fees.Add(Mapper.Map <ViewModels.Billing.InvoiceFeeViewModel>(x));
                    });

                    Data.Billing.Invoice.ListInvoiceTimesForInvoice(trans, id).ForEach(x =>
                    {
                        ViewModels.Billing.InvoiceTimeViewModel vm = Mapper.Map <ViewModels.Billing.InvoiceTimeViewModel>(x);
                        vm.Time = Mapper.Map <ViewModels.Timing.TimeViewModel>(Data.Timing.Time.Get(trans, vm.Time.Id.Value));

                        ViewModels.Billing.InvoiceTimeGroupViewModel timeGroup;
                        if (vm.Time.TimeCategory == null || !vm.Time.TimeCategory.Id.HasValue)
                        {
                            timeGroup = savedInvoice.TimeGroups.SingleOrDefault(y => y.Id == 0);
                        }
                        else
                        {
                            timeGroup = savedInvoice.TimeGroups.SingleOrDefault(y => y.Id == vm.Time.TimeCategory.Id);
                        }
                        if (timeGroup == null || timeGroup.Id == -1)
                        {
                            Common.Models.Timing.TimeCategory tc = Data.Timing.TimeCategory.Get(trans, vm.Time.TimeCategory.Id.Value);
                            timeGroup = new ViewModels.Billing.InvoiceTimeGroupViewModel()
                            {
                                Id        = tc.Id.Value,
                                GroupName = tc.Title,
                                Times     = new List <ViewModels.Billing.InvoiceTimeViewModel>()
                            };
                            timeGroup.Times.Add(vm);
                            savedInvoice.TimeGroups.Add(timeGroup);
                        }
                        else
                        {
                            timeGroup.Times.Add(vm);
                        }
                    });

                    // Validation
                    for (int i = 0; i < viewModel.Expenses.Count; i++)
                    {
                        ievm = savedInvoice.Expenses.Single(x => x.Expense.Id.Value == viewModel.Expenses[i].Expense.Id.Value);
                        viewModel.Expenses[i].Expense = ievm.Expense;
                        if (string.IsNullOrEmpty(viewModel.Expenses[i].Details))
                        {
                            ModelState.AddModelError(string.Format("Expenses[{0}].Details", i), "Required");
                        }
                    }
                    ;
                    for (int i = 0; i < viewModel.Fees.Count; i++)
                    {
                        ifvm = savedInvoice.Fees.Single(x => x.Fee.Id.Value == viewModel.Fees[i].Fee.Id.Value);
                        viewModel.Fees[i].Fee = ifvm.Fee;
                        if (string.IsNullOrEmpty(viewModel.Fees[i].Details))
                        {
                            ModelState.AddModelError(string.Format("Fees[{0}].Details", i), "Required");
                        }
                    }
                    ;
                    for (int i = 0; i < viewModel.TimeGroups.Count; i++)
                    {
                        for (int j = 0; j < viewModel.TimeGroups[i].Times.Count; j++)
                        {
                            itvm = savedInvoice.TimeGroups[i].Times.Single(x => x.Time.Id.Value == viewModel.TimeGroups[i].Times[j].Time.Id);
                            viewModel.TimeGroups[i].Times[j].Time = itvm.Time;
                            if (string.IsNullOrEmpty(viewModel.TimeGroups[i].Times[j].Details))
                            {
                                ModelState.AddModelError(string.Format("TimeGroups[{0}].Times[{1}].Details", i, j), "Required");
                            }
                        }
                        ;
                    }

                    if (!ModelState.IsValid)
                    {
                        // Errors - do nothing, but tell user and show again for fixing
                        matter = Data.Matters.Matter.Get(trans, id);
                        ViewData["MatterTitle"] = matter.Title;
                        ViewData["CaseNumber"]  = matter.CaseNumber;
                        ViewData["FirmName"]    = Common.Settings.Manager.Instance.System.BillingFirmName;
                        ViewData["FirmAddress"] = Common.Settings.Manager.Instance.System.BillingFirmAddress;
                        ViewData["FirmCity"]    = Common.Settings.Manager.Instance.System.BillingFirmCity;
                        ViewData["FirmState"]   = Common.Settings.Manager.Instance.System.BillingFirmState;
                        ViewData["FirmZip"]     = Common.Settings.Manager.Instance.System.BillingFirmZip;
                        ViewData["FirmPhone"]   = Common.Settings.Manager.Instance.System.BillingFirmPhone;
                        ViewData["FirmWeb"]     = Common.Settings.Manager.Instance.System.BillingFirmWeb;
                        return(View(viewModel));
                    }

                    decimal subtotal = 0;
                    invoiceExpenseList = new List <Common.Models.Billing.InvoiceExpense>();
                    invoiceFeeList     = new List <Common.Models.Billing.InvoiceFee>();
                    invoiceTimeList    = new List <Common.Models.Billing.InvoiceTime>();

                    viewModel.Expenses.ForEach(vm =>
                    {
                        Common.Models.Billing.InvoiceExpense mod = new Common.Models.Billing.InvoiceExpense()
                        {
                            Id      = vm.Id,
                            Invoice = invoice,
                            Expense = new Common.Models.Billing.Expense()
                            {
                                Id = vm.Expense.Id
                            },
                            Amount  = vm.Amount,
                            Details = vm.Details
                        };
                        subtotal += mod.Amount;
                        Data.Billing.InvoiceExpense.Edit(trans, mod, currentUser);
                    });

                    viewModel.Fees.ForEach(vm =>
                    {
                        Common.Models.Billing.InvoiceFee mod = new Common.Models.Billing.InvoiceFee()
                        {
                            Id      = vm.Id,
                            Invoice = invoice,
                            Fee     = new Common.Models.Billing.Fee()
                            {
                                Id = vm.Fee.Id
                            },
                            Amount  = vm.Amount,
                            Details = vm.Details
                        };
                        subtotal += mod.Amount;
                        Data.Billing.InvoiceFee.Edit(trans, mod, currentUser);
                    });

                    viewModel.TimeGroups.ForEach(tg =>
                    {
                        tg.Times.ForEach(vm =>
                        {
                            Common.Models.Billing.InvoiceTime mod = new Common.Models.Billing.InvoiceTime()
                            {
                                Id      = vm.Id,
                                Invoice = invoice,
                                Time    = new Common.Models.Timing.Time()
                                {
                                    Id           = vm.Time.Id,
                                    TimeCategory = new Common.Models.Timing.TimeCategory()
                                    {
                                        Id    = tg.Id,
                                        Title = tg.GroupName
                                    }
                                },
                                Duration     = vm.Duration,
                                PricePerHour = vm.PricePerHour,
                                Details      = vm.Details
                            };
                            subtotal += ((decimal)mod.Duration.TotalHours * mod.PricePerHour);
                            Data.Billing.InvoiceTime.Edit(trans, mod, currentUser);
                        });
                    });

                    invoice.Subtotal = subtotal;
                    invoice.Total    = invoice.Subtotal + invoice.TaxAmount;

                    Data.Billing.Invoice.Edit(trans, invoice, currentUser);

                    trans.Commit();
                }
                catch
                {
                    trans.Rollback();
                    throw;
                }
            }

            return(RedirectToAction("Details", "Invoices", new { id = invoice.Id }));
        }
        public ActionResult Create()
        {
            long taskId;
            int  contactId;

            Common.Models.Account.Users              currentUser;
            ViewModels.Tasks.TaskTimeViewModel       viewModel;
            Common.Models.Matters.Matter             matter;
            Common.Models.Tasks.Task                 task;
            Common.Models.Contacts.Contact           contact;
            Common.Models.Timing.TimeCategory        timeCategory = null;
            List <Common.Models.Timing.TimeCategory> timeCategoryList;

            // Every TaskTime must be created from a task, so we should always know the TaskId
            taskId    = long.Parse(Request["TaskId"]);
            contactId = int.Parse(Request["ContactId"]);

            using (IDbConnection conn = Data.Database.Instance.GetConnection())
            {
                // Load task & contact
                currentUser = Data.Account.Users.Get(User.Identity.Name);
                task        = Data.Tasks.Task.Get(taskId, conn, false);

                contact = Data.Contacts.Contact.Get(contactId, conn, false);

                timeCategory = Data.Timing.TimeCategory.Get(1, conn, false);

                if (timeCategory == null || !timeCategory.Id.HasValue)
                {
                    timeCategory = Data.Timing.TimeCategory.Create(new Common.Models.Timing.TimeCategory()
                    {
                        Title = "Standard"
                    }, currentUser);
                }

                viewModel = new ViewModels.Tasks.TaskTimeViewModel()
                {
                    Task = Mapper.Map <ViewModels.Tasks.TaskViewModel>(task),
                    Time = new ViewModels.Timing.TimeViewModel()
                    {
                        Worker       = Mapper.Map <ViewModels.Contacts.ContactViewModel>(contact),
                        TimeCategory = Mapper.Map <ViewModels.Timing.TimeCategoryViewModel>(timeCategory),
                        Start        = DateTime.Now,
                        Billable     = true
                    }
                };

                matter = Data.Tasks.Task.GetRelatedMatter(task.Id.Value, conn, false);

                timeCategoryList = Data.Timing.TimeCategory.List(conn, false);
                timeCategoryList.Insert(0, new Common.Models.Timing.TimeCategory()
                {
                    Id    = 0,
                    Title = "Standard"
                });

                viewModel.Time.TimeCategory.Id = 0;
            }

            ViewBag.Task             = task;
            ViewBag.Matter           = matter;
            ViewBag.TimeCategoryList = timeCategoryList;

            return(View(viewModel));
        }