public static Common.Models.Opportunities.Opportunity Create(
     Transaction t,
     Common.Models.Opportunities.Opportunity model,
     Common.Models.Account.Users creator)
 {
     return(Create(model, creator, t.Connection, false));
 }
 public static Common.Models.Opportunities.Opportunity Close(
     Transaction t,
     Common.Models.Opportunities.Opportunity model,
     Common.Models.Account.Users modifier)
 {
     return(Close(model, modifier, t.Connection, false));
 }
        public ActionResult Edit(long id)
        {
            List <ViewModels.Leads.LeadStatusViewModel> leadStatusList = new List <ViewModels.Leads.LeadStatusViewModel>();
            List <ViewModels.Leads.LeadSourceViewModel> leadSourceList = new List <ViewModels.Leads.LeadSourceViewModel>();

            ViewModels.Leads.LeadViewModel viewModel = new ViewModels.Leads.LeadViewModel();

            using (IDbConnection conn = Data.Database.Instance.GetConnection())
            {
                Common.Models.Leads.Lead model = Mapper.Map <Common.Models.Leads.Lead>(Data.Leads.Lead.Get(id, conn, false));

                // Has this already been made an opportunity?  If so, redirect
                Common.Models.Opportunities.Opportunity op = Data.Opportunities.Opportunity.GetForLead(model.Id.Value);
                if (op != null)
                {
                    return(new RedirectResult("/Opportunities/Edit/" + op.Id.Value.ToString()));
                }

                model.Contact = Mapper.Map <Common.Models.Contacts.Contact>(Data.Contacts.Contact.Get(model.Contact.Id.Value));
                if (model.Fee != null)
                {
                    model.Fee = Mapper.Map <Common.Models.Leads.LeadFee>(Data.Leads.LeadFee.Get(model.Fee.Id.Value, conn, false));
                    if (model.Fee.To != null)
                    {
                        model.Fee.To = Mapper.Map <Common.Models.Contacts.Contact>(Data.Contacts.Contact.Get(model.Fee.To.Id.Value));
                    }
                }

                Data.Leads.LeadStatus.List(conn, false).ForEach(x =>
                {
                    leadStatusList.Add(Mapper.Map <ViewModels.Leads.LeadStatusViewModel>(x));
                });

                Data.Leads.LeadSource.List(conn, false).ForEach(x =>
                {
                    leadSourceList.Add(Mapper.Map <ViewModels.Leads.LeadSourceViewModel>(x));
                });

                viewModel         = Mapper.Map <ViewModels.Leads.LeadViewModel>(model);
                viewModel.Contact = Mapper.Map <ViewModels.Contacts.ContactViewModel>(model.Contact);
                viewModel.Fee     = Mapper.Map <ViewModels.Leads.LeadFeeViewModel>(model.Fee);
                if (model.Fee != null)
                {
                    viewModel.Fee.To = Mapper.Map <ViewModels.Contacts.ContactViewModel>(model.Fee.To);
                }
                else
                {
                    viewModel.Fee    = new ViewModels.Leads.LeadFeeViewModel();
                    viewModel.Fee.To = new ViewModels.Contacts.ContactViewModel();
                }
            }

            ViewBag.LeadStatusList = leadStatusList;
            ViewBag.LeadSourceList = leadSourceList;

            return(View(viewModel));
        }
        public static Common.Models.Opportunities.Opportunity Edit(
            Common.Models.Opportunities.Opportunity model,
            Common.Models.Account.Users modifier,
            IDbConnection conn   = null,
            bool closeConnection = true)
        {
            model.ModifiedBy = modifier;
            model.Modified   = DateTime.UtcNow;
            DBOs.Opportunities.Opportunity dbo = Mapper.Map <DBOs.Opportunities.Opportunity>(model);

            conn = DataHelper.OpenIfNeeded(conn);

            conn.Execute("UPDATE \"opportunity\" SET " +
                         "\"account_id\"=@AccountId, \"stage_id\"=@StageId, \"probability\"=@Probability, \"amount\"=@Amount, \"closed\"=@Closed, \"lead_id\"=@LeadId, \"matter_id\"=@MatterId, \"utc_modified\"=@UtcModified, \"modified_by_user_pid\"=@ModifiedByUserPId " +
                         "WHERE \"id\"=@Id", dbo);

            DataHelper.Close(conn, closeConnection);

            return(model);
        }
        public static Common.Models.Opportunities.Opportunity Close(
            Common.Models.Opportunities.Opportunity model,
            Common.Models.Account.Users modifier,
            IDbConnection conn   = null,
            bool closeConnection = true)
        {
            model.ModifiedBy = modifier;
            model.Modified   = DateTime.UtcNow;
            DBOs.Opportunities.Opportunity dbo = Mapper.Map <DBOs.Opportunities.Opportunity>(model);
            dbo.Closed = DateTime.UtcNow;

            conn = DataHelper.OpenIfNeeded(conn);

            conn.Execute("UPDATE \"opportunity\" SET " +
                         "\"closed\"=@Closed, \"utc_modified\"=@UtcModified, \"modified_by_user_pid\"=@ModifiedByUserPId " +
                         "WHERE \"id\"=@Id", dbo);

            DataHelper.Close(conn, closeConnection);

            return(model);
        }
        public static Common.Models.Opportunities.Opportunity Create(
            Common.Models.Opportunities.Opportunity model,
            Common.Models.Account.Users creator,
            IDbConnection conn   = null,
            bool closeConnection = true)
        {
            model.CreatedBy = model.ModifiedBy = creator;
            model.Created   = model.Modified = DateTime.UtcNow;
            DBOs.Opportunities.Opportunity dbo = Mapper.Map <DBOs.Opportunities.Opportunity>(model);

            conn = DataHelper.OpenIfNeeded(conn);

            if (conn.Execute("INSERT INTO \"opportunity\" (\"account_id\", \"stage_id\", \"probability\", \"amount\", \"closed\", \"lead_id\", \"matter_id\", \"utc_created\", \"utc_modified\", \"created_by_user_pid\", \"modified_by_user_pid\") " +
                             "VALUES (@AccountId, @StageId, @Probability, @Amount, @Closed, @LeadId, @MatterId, @UtcCreated, @UtcModified, @CreatedByUserPId, @ModifiedByUserPId)",
                             dbo) > 0)
            {
                model.Id = conn.Query <DBOs.Opportunities.Opportunity>("SELECT currval(pg_get_serial_sequence('opportunity', 'id')) AS \"id\"").Single().Id;
            }

            DataHelper.Close(conn, closeConnection);

            return(model);
        }
        public ActionResult Details(long id, bool preventRedirect = false)
        {
            ViewModels.Leads.LeadViewModel viewModel;
            Common.Models.Leads.Lead       model;

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

                // Has this already been made an opportunity?  If so, redirect
                Common.Models.Opportunities.Opportunity op = Data.Opportunities.Opportunity.GetForLead(model.Id.Value);
                if (op != null && !preventRedirect)
                {
                    return(new RedirectResult("/Opportunities/Details/" + op.Id.Value.ToString()));
                }

                viewModel = Mapper.Map <ViewModels.Leads.LeadViewModel>(model);

                if (op != null)
                {
                    viewModel.Opportunity = Mapper.Map <ViewModels.Opportunities.OpportunityViewModel>(op);
                }

                if (model.Status != null && model.Status.Id.HasValue)
                {
                    model.Status     = Data.Leads.LeadStatus.Get(model.Status.Id.Value, conn, false);
                    viewModel.Status = Mapper.Map <ViewModels.Leads.LeadStatusViewModel>(model.Status);
                }

                if (model.Contact != null && model.Contact.Id.HasValue)
                {
                    model.Contact     = Data.Contacts.Contact.Get(model.Contact.Id.Value, conn, false);
                    viewModel.Contact = Mapper.Map <ViewModels.Contacts.ContactViewModel>(model.Contact);
                }

                if (model.Source != null && model.Source.Id.HasValue)
                {
                    model.Source     = Data.Leads.LeadSource.Get(model.Source.Id.Value, conn, false);
                    viewModel.Source = Mapper.Map <ViewModels.Leads.LeadSourceViewModel>(model.Source);

                    if (model.Source.Contact != null && model.Source.Contact.Id.HasValue)
                    {
                        model.Source.Contact     = Data.Contacts.Contact.Get(model.Source.Contact.Id.Value, conn, false);
                        viewModel.Source.Contact = Mapper.Map <ViewModels.Contacts.ContactViewModel>(model.Source.Contact);
                    }
                    if (model.Source.Type != null && model.Source.Type.Id.HasValue)
                    {
                        model.Source.Type     = Data.Leads.LeadSourceType.Get(model.Source.Type.Id.Value, conn, false);
                        viewModel.Source.Type = Mapper.Map <ViewModels.Leads.LeadSourceTypeViewModel>(model.Source.Type);
                    }
                }

                if (model.Fee != null && model.Fee.Id.HasValue)
                {
                    model.Fee     = Data.Leads.LeadFee.Get(model.Fee.Id.Value, conn, false);
                    viewModel.Fee = Mapper.Map <ViewModels.Leads.LeadFeeViewModel>(model.Fee);

                    if (model.Fee.To != null && model.Fee.To.Id.HasValue)
                    {
                        model.Fee.To     = Data.Contacts.Contact.Get(model.Fee.To.Id.Value, conn, false);
                        viewModel.Fee.To = Mapper.Map <ViewModels.Contacts.ContactViewModel>(model.Fee.To);
                    }
                }

                viewModel.Activities         = new List <ViewModels.Activities.ActivityBaseViewModel>();
                viewModel.InactiveActivities = new List <ViewModels.Activities.ActivityBaseViewModel>();
                Data.Leads.Lead.GetActivities(id, conn, false).ForEach(x =>
                {
                    Common.Models.Activities.ActivityStatusReason statusReason = Data.Activities.ActivityStatusReason.Get(x.StatusReason.Id.Value, conn, false);
                    Common.Models.Activities.ActivityType type     = Data.Activities.ActivityType.Get(x.Type.Id.Value, conn, false);
                    ViewModels.Activities.ActivityBaseViewModel vm = Mapper.Map <ViewModels.Activities.ActivityBaseViewModel>(x);
                    vm.Type         = Mapper.Map <ViewModels.Activities.ActivityTypeViewModel>(type);
                    vm.StatusReason = Mapper.Map <ViewModels.Activities.ActivityStatusReasonViewModel>(statusReason);

                    if (x.State.HasValue && x.State.Value)
                    {
                        viewModel.Activities.Add(vm);
                    }
                    else
                    {
                        viewModel.InactiveActivities.Add(vm);
                    }
                });
            }

            return(View(viewModel));
        }