public int AddLeadDoc(LeadDocEntity leadDoc)
{
int docid = 0;
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
LeadDoc leaddocdb = new LeadDoc();
leaddocdb.DocumentName = leadDoc.DocumentName;
leaddocdb.DocumentPath = leadDoc.DocumentPath;
leaddocdb.UploadDate = leadDoc.UploadDate;
leaddocdb.UploadedBy = leadDoc.UploadedBy;
leaddocdb.UploadedFor = leadDoc.UploadedFor;
uow.LeadDocRepository.Insert(leaddocdb);
uow.Save();
docid = leaddocdb.LeadDocID;
}
catch
{
docid = 0;
}
}
return(docid);
}
public bool AddSaleRecord(SalesData dailySales)
{
bool isSalesAdded = false;
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
Sale dailySalesdb = new Sale();
dailySalesdb.EntryDate = dailySales.EntryDate;
dailySalesdb.DailySaleAmount = dailySales.DailySaleAmount;
dailySalesdb.MonthlySales = dailySales.MonthlySales;
dailySalesdb.NetSales = dailySales.NetSales;
dailySalesdb.Refunds = dailySales.Refunds;
dailySalesdb.SalesPersonID = dailySales.SalesPersonID;
dailySalesdb.QBTotalPay = dailySales.QBTotalPay;
dailySalesdb.CashBonus = dailySales.CashBonus;
dailySalesdb.MonthlyOfficeRent = dailySales.MonthlyOfficeRent;
dailySalesdb.DrawTakenInMonth = dailySales.DrawTakenInMonth;
dailySalesdb.DailyBonus = dailySales.DailyBonus;
dailySalesdb.CommisionInUSD = dailySales.CommisionInUSD;
dailySalesdb.CommisionPercentage = dailySales.CommisionPercentage;
uow.SaleRepository.Insert(dailySalesdb);
uow.Save();
isSalesAdded = true;
}
catch
{
isSalesAdded = false;
}
}
return(isSalesAdded);
}
public bool UpdateLeadDoc(LeadDocEntity leadDoc)
{
bool isDocUpdated = false;
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
LeadDoc leaddocdb = uow.LeadDocRepository.Get().Where(x => x.LeadDocID == leadDoc.LeadDocID).FirstOrDefault();
leaddocdb.DocumentName = leadDoc.DocumentName;
leaddocdb.DocumentPath = leadDoc.DocumentPath;
leaddocdb.UploadDate = leadDoc.UploadDate;
leaddocdb.UploadedBy = leadDoc.UploadedBy;
leaddocdb.UploadedFor = leadDoc.UploadedFor;
uow.LeadDocRepository.Update(leaddocdb);
uow.Save();
isDocUpdated = true;
}
catch
{
isDocUpdated = false;
}
}
return(isDocUpdated);
}
public bool DeleteMCSale(int MCID)
{
bool isDeleted = false;
try
{
using (uow = new UnitOfWork.UnitOfWork())
{
MCSale sale = uow.MCSaleRepository.Get().Where(x => x.MCID == MCID).FirstOrDefault();
uow.MCSaleRepository.Delete(sale);
uow.Save();
List <MCServiceSale> mcTemp = uow.MCServiceSaleRepository.Get().Where(x => x.MCSaleID == MCID).ToList();
foreach (MCServiceSale item in mcTemp)
{
uow.MCServiceSaleRepository.Delete(item);
uow.Save();
}
}
}
catch (Exception ex)
{
}
return(isDeleted);
}
public List <SalesData> GetAllSalesDataByMonthYear(int month, int year)
{
List <SalesData> lstSales = new List <SalesData>();
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
lstSales = uow.SaleRepository.Get().Where(x => Convert.ToDateTime(x.EntryDate).Month == month && Convert.ToDateTime(x.EntryDate).Year == year).Select(usd => new SalesData
{
SaleID = usd.SaleID,
EntryDate = usd.EntryDate,
DailySaleAmount = usd.DailySaleAmount,
MonthlySales = usd.MonthlySales,
NetSales = usd.NetSales,
SalesPersonID = usd.SalesPersonID,
Refunds = usd.Refunds,
QBTotalPay = usd.QBTotalPay,
MonthlyOfficeRent = usd.MonthlyOfficeRent,
CashBonus = usd.CashBonus,
DrawTakenInMonth = usd.DrawTakenInMonth,
DailyBonus = usd.DailyBonus,
CommisionInUSD = usd.CommisionInUSD,
CommisionPercentage = usd.CommisionPercentage
}).ToList();
}
catch
{
}
}
return(lstSales);
}
public bool AddTarget(SettingEntity setting)
{
bool isTargetAdded = false;
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
Setting settingdb = uow.SettingRepository.Get().Where(x => x.SettingID == 1).FirstOrDefault();
settingdb.MaxTarget = setting.MaxTarget;
settingdb.AdminEmails = setting.AdminEmails;
settingdb.ProcessedEmails = setting.ProcessedEmails;
settingdb.VoidedEmails = setting.VoidedEmails;
settingdb.RefundEmails = setting.RefundEmails;
settingdb.Mob_login_text1 = setting.Mob_login_text1;
settingdb.Mob_login_text2 = setting.Mob_login_text2;
uow.SettingRepository.Update(settingdb);
uow.Save();
isTargetAdded = true;
}
catch
{
isTargetAdded = false;
}
}
return(isTargetAdded);
}
public SettingEntity GetSettings()
{
SettingEntity setting = new SettingEntity();
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
setting = uow.SettingRepository.Get().Select(usd => new SettingEntity
{
SettingID = usd.SettingID,
MaxTarget = usd.MaxTarget,
AdminEmails = usd.AdminEmails,
ProcessedEmails = usd.ProcessedEmails,
RefundEmails = usd.RefundEmails,
VoidedEmails = usd.VoidedEmails,
Mob_login_text1 = usd.Mob_login_text1,
Mob_login_text2 = usd.Mob_login_text2
}).FirstOrDefault();
}
catch
{
}
}
return(setting);
}
public List <SalesData> GetSalesBySalesPersonID(int salesPersonID)
{
List <SalesData> lstSales = new List <SalesData>();
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
lstSales = uow.SaleRepository.Get().Where(x => x.SalesPersonID == salesPersonID).Select(usd => new SalesData
{
SaleID = usd.SaleID,
EntryDate = usd.EntryDate,
DailySaleAmount = usd.DailySaleAmount,
MonthlySales = usd.MonthlySales,
NetSales = usd.NetSales,
SalesPersonID = usd.SalesPersonID,
Refunds = usd.Refunds,
QBTotalPay = usd.QBTotalPay,
MonthlyOfficeRent = usd.MonthlyOfficeRent,
CashBonus = usd.CashBonus,
DrawTakenInMonth = usd.DrawTakenInMonth,
DailyBonus = usd.DailyBonus
}).ToList();
}
catch
{
}
}
return(lstSales);
}
public SalesData GetMonthYearSaleBySaleID(int month, int year, int saleID)
{
SalesData lstSales = new SalesData();
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
lstSales = uow.SaleRepository.Get().Where(x => Convert.ToDateTime(x.EntryDate).Month == month && Convert.ToDateTime(x.EntryDate).Year == year && x.SaleID == saleID).Select(usd => new SalesData
{
SaleID = usd.SaleID,
EntryDate = usd.EntryDate,
DailySaleAmount = usd.DailySaleAmount,
MonthlySales = usd.MonthlySales,
NetSales = usd.NetSales,
SalesPersonID = usd.SalesPersonID,
Refunds = usd.Refunds,
QBTotalPay = usd.QBTotalPay,
MonthlyOfficeRent = usd.MonthlyOfficeRent,
CashBonus = usd.CashBonus,
DrawTakenInMonth = usd.DrawTakenInMonth,
DailyBonus = usd.DailyBonus,
CommisionInUSD = usd.CommisionInUSD,
CommisionPercentage = usd.CommisionPercentage
}).FirstOrDefault();
}
catch
{
}
}
return(lstSales);
}
public List <DailySalesData> GetSalesRecords()
{
List <DailySalesData> lstSales = new List <DailySalesData>();
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
lstSales = uow.DailySalesRecordRepository.Get().Select(usd => new DailySalesData
{
DailySalesRecordID = usd.DailySalesRecordID,
DateTime = usd.DateTime,
DaySales = usd.DaySales,
MonthlySales = usd.MonthlySales,
NetSales = usd.NetSales,
UserID = usd.UserID,
Refunds = usd.Refunds,
Tier1 = usd.Tier1,
Tier2 = usd.Tier2,
Tier3 = usd.Tier3,
Tier4 = usd.Tier4,
QBTotalPay = usd.QBTotalPay,
MonthlyDrawsTaken = usd.MonthlyDrawsTaken,
CashBonus = usd.CashBonus,
MonthlyOfficeRent = usd.MonthlyOfficeRent,
ActualPayoutTotal = usd.ActualPayoutTotal,
Bonus = usd.Bonus
}).ToList();
}
catch
{
}
}
return(lstSales);
}
public LeadData GetLeadsByLeadID(int leadID)
{
LeadData lstLeads = new LeadData();
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
lstLeads = uow.LeadRepository.Get().Where(x => x.LeadID == leadID).Select(usd => new LeadData
{
BusinessName = usd.BusinessName,
ContactName = usd.ContactName,
Date = usd.Date,
DOTNo = usd.DOTNo,
Email = usd.Email,
LeadID = usd.LeadID,
PhoneNoForContact = usd.PhoneNoForContact,
SalesPersonID = usd.SalesPersonID,
ServiceDiscussed = usd.ServiceDiscussed,
ComplianceAgent = usd.ComplianceAgent
}).FirstOrDefault();
}
catch
{
}
}
return(lstLeads);
}
public List <LeadData> GetLeadsByUserID(int userid)
{
List <LeadData> lstLeads = new List <LeadData>();
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
lstLeads = uow.LeadRepository.Get().Where(x => x.SalesPersonID == userid).Select(usd => new LeadData
{
BusinessName = usd.BusinessName,
ContactName = usd.ContactName,
Date = usd.Date,
DOTNo = usd.DOTNo,
Email = usd.Email,
LeadID = usd.LeadID,
PhoneNoForContact = usd.PhoneNoForContact,
SalesPersonID = usd.SalesPersonID,
ServiceDiscussed = usd.ServiceDiscussed
}).ToList();
}
catch
{
}
}
return(lstLeads);
}
public bool RegisterTransaction(CoinTransaction trans)
{
bool isRegistered = false;
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
Transaction transactiondb = new Transaction();
transactiondb.NoOfCoins = trans.NoOfCoins;
transactiondb.TransactionCurrency = trans.TransactionCurrency;
transactiondb.TransactionTime = DateTime.Now.ToString();
transactiondb.UserID = trans.UserID;
transactiondb.Cryptoamount = trans.Cryptoamount;
uow.TransactionRepository.Insert(transactiondb);
uow.Save();
isRegistered = true;
}
catch
{
isRegistered = false;
}
}
return(isRegistered);
}
public bool DeleteUSDotSale(int USDOTSaleID)
{
bool isDriverProfileDeleted = false;
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
OrderForm orderFormdb = uow.OrderFormRepository.Get().Where(x => x.OrderFormID == USDOTSaleID).FirstOrDefault();
uow.OrderFormRepository.Delete(orderFormdb);
uow.Save();
ProfileCard profileCarddb = uow.ProfileCardRepository.Get().Where(x => x.OrderFormID == USDOTSaleID).FirstOrDefault();
uow.ProfileCardRepository.Delete(profileCarddb);
uow.Save();
List <DriverService> usDotServiceTemp = uow.DriverServiceRepository.Get().Where(x => x.DriverInterviewProfileID == orderFormdb.OrderFormID).ToList();
foreach (DriverService service in usDotServiceTemp)
{
uow.DriverServiceRepository.Delete(service);
uow.Save();
}
List <DriverInterviewProfile> usDotDriverInterviewProfileTemp = uow.DriverInterviewProfileRepository.Get().Where(x => x.OrderFormID == USDOTSaleID).ToList();
foreach (DriverInterviewProfile item in usDotDriverInterviewProfileTemp)
{
List <DriverVehicleCargo> usDotVehicleCargoTemp = uow.DriverVehicleCargoRepository.Get().Where(x => x.DriverVehicleID == item.DriverInterviewID).ToList();
foreach (DriverVehicleCargo vehicleCargo in usDotVehicleCargoTemp)
{
uow.DriverVehicleCargoRepository.Delete(vehicleCargo);
uow.Save();
}
List <DriverVehicle> usDotVehicleTemp = uow.DriverVehicleRepository.Get().Where(x => x.OrderFormID == item.DriverInterviewID).ToList();
foreach (DriverVehicle vehicleCargo in usDotVehicleTemp)
{
uow.DriverVehicleRepository.Delete(vehicleCargo);
uow.Save();
}
uow.DriverInterviewProfileRepository.Delete(item);
uow.Save();
}
isDriverProfileDeleted = true;
}
catch
{
isDriverProfileDeleted = false;
}
}
return(isDriverProfileDeleted);
}
public bool EditMCSales(MCSaleEntity mcSale)
{
bool isEdited = false;
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
MCSale mcSaledb = new MCSale();
mcSaledb = uow.MCSaleRepository.Get().Where(mcdata => mcdata.MCID == mcSale.MCID).FirstOrDefault();
mcSaledb.AddressOnCard = mcSale.AddressOnCard;
mcSaledb.DotNo = mcSale.DotNo;
mcSaledb.Email = mcSale.Email;
mcSaledb.MCID = mcSale.MCID;
mcSaledb.MCNo = mcSale.MCNo;
mcSaledb.CardNo = mcSale.CardNo;
mcSaledb.PhoneNo = mcSale.PhoneNo;
mcSaledb.NameOnCard = mcSale.NameOnCard;
mcSaledb.PhysicalAddress = mcSale.PhysicalAddress;
mcSaledb.CardType = mcSale.CardType;
mcSaledb.CVC = mcSale.CVC;
mcSaledb.MCSaleNo = mcSale.MCSaleNo;
mcSaledb.ExpirationDate = mcSale.ExpirationDate;
mcSaledb.LegalName = mcSale.LegalName;
mcSaledb.DBA = mcSale.DBA;
mcSaledb.DotPin = mcSale.DotPin;
uow.MCSaleRepository.Update(mcSaledb);
uow.Save();
List <MCServiceSale> mcTemp = uow.MCServiceSaleRepository.Get().Where(x => x.MCSaleID == mcSale.MCID).ToList();
foreach (MCServiceSale item in mcTemp)
{
uow.MCServiceSaleRepository.Delete(item);
uow.Save();
}
foreach (MCServiceSaleEntity item in mcSale.serviceSaleData)
{
MCServiceSale mcServiceSaledb = new MCServiceSale();
mcServiceSaledb.MCSaleID = mcSaledb.MCID;
mcServiceSaledb.ServiceID = item.ServiceID;
uow.MCServiceSaleRepository.Insert(mcServiceSaledb);
uow.Save();
}
isEdited = true;
}
catch
{
isEdited = false;
}
}
return(isEdited);
}
public int CheckDoc(LeadDocEntity leadDoc)
{
int isDocAvailable = 0;
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
isDocAvailable = uow.LeadDocRepository.Get().Where(x => x.UploadedFor == leadDoc.UploadedFor && x.UploadDate == leadDoc.UploadDate).Select(x => x.LeadDocID).FirstOrDefault();
}
catch
{
isDocAvailable = 0;
}
}
return(isDocAvailable);
}
public bool CheckSaleDate(string saleDate, int userID)
{
bool isDateExist = false;
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
isDateExist = uow.SaleRepository.Get().Any(x => x.EntryDate.Equals(saleDate) && x.SalesPersonID == userID);
//isDateExist = true;
}
catch
{
}
}
return(isDateExist);
}
public DriverInterviewProfileEntity GetDriverDataByInterviewProfileID(bool isSubmitted, int interviewprofileid)
{
DriverInterviewProfileEntity driverSale = new DriverInterviewProfileEntity();
using (uow = new UnitOfWork.UnitOfWork())
{
driverSale = uow.DriverInterviewProfileRepository.Get().Select(dv => new DriverInterviewProfileEntity
{
CDLNonCDL = dv.CDLNonCDL,
Class = dv.Class,
IsSubmitted = isSubmitted,
Date = dv.Date,
DOB = dv.DOB,
OrderFormID = dv.OrderFormID,
DriverInterviewID = dv.DriverInterviewID,
DriverName = dv.DriverName,
EIN = dv.EIN,
Email = dv.Email,
ExpirationDate = dv.ExpirationDate,
LegalName = dv.LegalName,
LicenseNo = dv.LicenseNo,
Notes = dv.Notes,
Phone = dv.Phone,
SSN = dv.SSN,
StatusIssued = dv.StatusIssued,
Supervisor = dv.Supervisor,
USDOT = dv.USDOT,
DriverCargos = uow.DriverVehicleCargoRepository.Get().Where(x => x.DriverVehicleID == interviewprofileid).Select(p => new DriverVehicleCargoEntity {
CargoCarriedName = p.CargoCarriedName, DriverVehicleID = p.DriverVehicleID, VehicleCargoID = p.VehicleCargoID
}).ToList(),
DriverServices = uow.DriverServiceRepository.Get().Join(uow.DocumentMasterRepository.Get(), msd => msd.ServiceID, dms => dms.DocumentID, (msd, dms) => new { msd, dms })
.Select(p => new DriverServiceEntity {
DriverServiceID = p.msd.DriverServiceID, ServiceID = (int)p.msd.ServiceID, DriverInterviewProfileID = p.msd.DriverInterviewProfileID, ServiceName = p.dms.DocumentName, ServicePrice = p.dms.Description
})
.Where(x => x.DriverInterviewProfileID == interviewprofileid).ToList(),
DriverVehicle = uow.DriverVehicleRepository.Get().Where(x => x.OrderFormID == interviewprofileid).Select(p => new DriverVehicleEntity {
DriverVehicleInfo = p.DriverVehicleInfo, GVW = p.GVW, Make = p.Make, Model = p.Model, OrderFormID = p.OrderFormID, Year = p.Year
}).FirstOrDefault(),
}).Where(x => x.DriverInterviewID == interviewprofileid && x.IsSubmitted == isSubmitted).FirstOrDefault();
}
return(driverSale);
}
public bool DeleteLead(int leadid)
{
bool isSalesDeleted = false;
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
uow.DailyLeadRepository.Delete(leadid);
uow.Save();
isSalesDeleted = true;
}
catch
{
isSalesDeleted = false;
}
}
return(isSalesDeleted);
}
public bool AddBulkLeads(List <DailyLeadEntity> leads)
{
bool isSalesAdded = false;
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
foreach (DailyLeadEntity leaddb in leads)
{
DailyLead lead = new DailyLead();
lead.AuthForHire = leaddb.AuthForHire;
lead.DailyLeadID = leaddb.DailyLeadID;
lead.DateFiled = leaddb.DateFiled;
lead.DOTNumber = leaddb.DOTNumber;
lead.Drivers = leaddb.Drivers;
lead.Interstate = leaddb.Interstate;
lead.LeadDocID = leaddb.LeadDocID;
lead.LegalName = leaddb.LegalName;
lead.MailingAddress = leaddb.MailingAddress;
lead.OperatingStatus = leaddb.OperatingStatus;
lead.PhoneNo = leaddb.PhoneNo;
lead.PhysicalAddress = leaddb.PhysicalAddress;
lead.PowerUnits = leaddb.PowerUnits;
lead.Status = leaddb.Status;
lead.TimeZone = leaddb.TimeZone;
lead.ZipCode = leaddb.ZipCode;
lead.SavedOn = DateTimeJavaScript.GetCurrentTime().ToString();
uow.DailyLeadRepository.Insert(lead);
}
uow.Save();
isSalesAdded = true;
}
catch
{
isSalesAdded = false;
}
}
return(isSalesAdded);
}
public List <MCSaleEntity> GetAllMCSales()
{
List <MCSaleEntity> lstMCSales = new List <MCSaleEntity>();
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
lstMCSales = uow.MCSaleRepository.Get().Select(sale => new MCSaleEntity
{
AddressOnCard = sale.AddressOnCard,
DotNo = sale.DotNo,
Email = sale.Email,
MCID = sale.MCID,
MCNo = sale.MCNo,
CardNo = sale.CardNo,
PhoneNo = sale.PhoneNo,
NameOnCard = sale.NameOnCard,
PhysicalAddress = sale.PhysicalAddress,
SoldAt = sale.SoldAt,
ExpirationDate = sale.ExpirationDate,
CardType = sale.CardType,
CVC = sale.CVC,
MCSaleNo = sale.MCSaleNo,
LegalName = sale.LegalName,
DBA = sale.DBA,
DotPin = sale.DotPin,
SalesPersonName = uow.ComplianceUserRepository.Get().Where(x => x.UserID == sale.SalesPersonID).FirstOrDefault().Name,
serviceSaleData = uow.MCServiceSaleRepository.Get().Join(uow.DocumentMasterRepository.Get(), msd => msd.ServiceID, dms => dms.DocumentID, (msd, dms) => new { msd, dms })
.Select(p => new MCServiceSaleEntity {
MCSaleID = p.msd.MCSaleID, MCServiceID = p.msd.MCServiceID, ServiceID = p.msd.ServiceID, ServiceName = p.dms.DocumentName, ServicePrice = p.dms.Description
})
.Where(x => x.MCSaleID == sale.MCID).ToList()
}).OrderByDescending(p => p.MCID).ToList();
}
catch
{
}
}
return(lstMCSales);
}
public bool EditLead(LeadData lead)
{
bool isSalesEdited = false;
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
Lead leaddb = uow.LeadRepository.Get().Where(x => x.LeadID == lead.LeadID).FirstOrDefault();
leaddb.BusinessName = lead.BusinessName;
leaddb.ComplianceAgent = lead.ComplianceAgent;
leaddb.ContactName = lead.ContactName;
leaddb.Date = DateTime.Now.Date.ToShortDateString();
leaddb.DOTNo = lead.DOTNo;
leaddb.Email = lead.Email;
leaddb.PhoneNoForContact = lead.PhoneNoForContact;
leaddb.ServiceDiscussed = lead.ServiceDiscussed;
leaddb.SalesPersonID = lead.SalesPersonID;
uow.LeadRepository.Update(leaddb);
uow.Save();
if (!String.IsNullOrEmpty(lead.Notes) && !String.IsNullOrEmpty(lead.TimeLine))
{
LeadNote leadNote = new LeadNote();
leadNote.LeadID = leaddb.LeadID;
leadNote.Note = lead.Notes;
leadNote.Timeline = lead.TimeLine;
leadNote.NoteLeftAt = DateTimeJavaScript.GetCurrentTime().ToString();
uow.LeadNoteRepository.Insert(leadNote);
uow.Save();
}
isSalesEdited = true;
}
catch
{
isSalesEdited = false;
}
}
return(isSalesEdited);
}
public MCSaleEntity GetMCSaleUSDotNo(string USDotNo)
{
MCSaleEntity MCSale = new MCSaleEntity();
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
MCSale = uow.MCSaleRepository.Get().Select(sale => new MCSaleEntity
{
AddressOnCard = sale.AddressOnCard,
DotNo = sale.DotNo,
Email = sale.Email,
MCID = sale.MCID,
MCNo = sale.MCNo,
CardNo = sale.CardNo,
PhoneNo = sale.PhoneNo,
NameOnCard = sale.NameOnCard,
PhysicalAddress = sale.PhysicalAddress,
ExpirationDate = sale.ExpirationDate,
CardType = sale.CardType,
CVC = sale.CVC,
MCSaleNo = sale.MCSaleNo,
DBA = sale.DBA,
LegalName = sale.LegalName,
SalesPersonID = sale.SalesPersonID,
DotPin = sale.DotPin,
serviceSaleData = uow.MCServiceSaleRepository.Get().Join(uow.DocumentMasterRepository.Get(), msd => msd.ServiceID, dms => dms.DocumentID, (msd, dms) => new { msd, dms })
.Select(p => new MCServiceSaleEntity {
MCSaleID = p.msd.MCSaleID, MCServiceID = p.msd.MCServiceID, ServiceID = p.msd.ServiceID, ServiceName = p.dms.DocumentName, ServicePrice = p.dms.Description
})
.Where(x => x.MCSaleID == sale.MCID).ToList()
}).Where(p => p.DotNo == USDotNo).FirstOrDefault();
}
catch
{
}
}
return(MCSale);
}
public bool UpdateLeadStatus(int leadid, string status)
{
bool isSalesUpdated = false;
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
DailyLead lead = uow.DailyLeadRepository.Get().Where(x => x.DailyLeadID == leadid).FirstOrDefault();
lead.Status = status;
uow.DailyLeadRepository.Update(lead);
uow.Save();
isSalesUpdated = true;
}
catch
{
isSalesUpdated = false;
}
}
return(isSalesUpdated);
}
public List <DailyLeadEntity> GetLeadRecordsByUserIDDesc(int userID)
{
List <DailyLeadEntity> dailyLeadRecords = new List <DailyLeadEntity>();
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
dailyLeadRecords = uow.DailyLeadRepository.Get().Join(uow.LeadDocRepository.Get(), dl => dl.LeadDocID, ld => ld.LeadDocID, (dl, ld) => new { dl, ld })
.Join(uow.ComplianceUserRepository.Get(), us => Convert.ToInt32(us.ld.UploadedFor), a => a.UserID, (us, a) => new { us, a }).Where(x => x.a.UserID == userID)
.Select(po => new DailyLeadEntity
{
AuthForHire = po.us.dl.AuthForHire,
DailyLeadID = po.us.dl.DailyLeadID,
DateFiled = po.us.dl.DateFiled,
DOTNumber = po.us.dl.DOTNumber,
Drivers = po.us.dl.Drivers,
Interstate = po.us.dl.Interstate,
LeadDocID = po.us.dl.LeadDocID,
LegalName = po.us.dl.LegalName,
MailingAddress = po.us.dl.MailingAddress,
OperatingStatus = po.us.dl.OperatingStatus,
PhoneNo = po.us.dl.PhoneNo,
PhysicalAddress = po.us.dl.PhysicalAddress,
PowerUnits = po.us.dl.PowerUnits,
Status = po.us.dl.Status,
TimeZone = po.us.dl.TimeZone,
ZipCode = po.us.dl.ZipCode,
SavedOn = po.us.dl.SavedOn
}).OrderByDescending(x => Convert.ToDateTime(x.SavedOn)).ToList();
//}).ToList();
}
catch
{
}
}
return(dailyLeadRecords);
}
public List <LeadNoteEntity> GetAllLeadNotes(int leadID)
{
List <LeadNoteEntity> lstLeadNotes = new List <LeadNoteEntity>();
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
lstLeadNotes = uow.LeadNoteRepository.Get().Where(p => p.LeadID == leadID).Select(usd => new LeadNoteEntity
{
NoteLeftAt = usd.NoteLeftAt,
Note = usd.Note,
LeadNoteID = usd.LeadNoteID,
LeadID = usd.LeadID,
Timeline = usd.Timeline
}).ToList();
}
catch
{
}
}
return(lstLeadNotes);
}
public bool AddLead(LeadData lead)
{
bool isSalesAdded = false;
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
Lead leaddb = new Lead();
leaddb.BusinessName = lead.BusinessName;
leaddb.ComplianceAgent = lead.ComplianceAgent;
leaddb.ContactName = lead.ContactName;
leaddb.Date = DateTime.Now.Date.ToShortDateString();
leaddb.DOTNo = lead.DOTNo;
leaddb.Email = lead.Email;
leaddb.PhoneNoForContact = lead.PhoneNoForContact;
leaddb.ServiceDiscussed = lead.ServiceDiscussed;
leaddb.SalesPersonID = lead.SalesPersonID;
uow.LeadRepository.Insert(leaddb);
uow.Save();
LeadNote leadNote = new LeadNote();
leadNote.LeadID = leaddb.LeadID;
leadNote.Note = lead.Notes;
leadNote.Timeline = lead.TimeLine;
leadNote.NoteLeftAt = DateTimeJavaScript.GetCurrentTime().ToString();
uow.LeadNoteRepository.Insert(leadNote);
uow.Save();
isSalesAdded = true;
}
catch
{
isSalesAdded = false;
}
}
return(isSalesAdded);
}
public List <DailyLeadEntity> GetAllLeads()
{
List <DailyLeadEntity> dailyLeadRecords = new List <DailyLeadEntity>();
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
dailyLeadRecords = uow.DailyLeadRepository.Get().Where(x => Convert.ToDateTime(x.SavedOn) >= DateTime.Now.AddDays(-1) && Convert.ToDateTime(x.SavedOn) < DateTime.Now)
.Select(po => new DailyLeadEntity
{
AuthForHire = po.AuthForHire,
DailyLeadID = po.DailyLeadID,
DateFiled = po.DateFiled,
DOTNumber = po.DOTNumber,
Drivers = po.Drivers,
Interstate = po.Interstate,
LeadDocID = po.LeadDocID,
LegalName = po.LegalName,
MailingAddress = po.MailingAddress,
OperatingStatus = po.OperatingStatus,
PhoneNo = po.PhoneNo,
PhysicalAddress = po.PhysicalAddress,
PowerUnits = po.PowerUnits,
Status = po.Status,
TimeZone = po.TimeZone,
ZipCode = po.ZipCode,
SavedOn = po.SavedOn
}).OrderByDescending(x => Convert.ToDateTime(x.SavedOn)).ToList();
//}).ToList();
}
catch
{
}
}
return(dailyLeadRecords);
}
public bool AddSales(DailySalesData dailySales)
{
bool isSalesAdded = false;
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
DailySalesRecord dailySalesdb = new DailySalesRecord();
dailySalesdb.DateTime = DateTime.Now.ToString();
dailySalesdb.DaySales = dailySales.DaySales;
dailySalesdb.MonthlySales = dailySales.MonthlySales;
dailySalesdb.NetSales = dailySales.NetSales;
dailySalesdb.Refunds = dailySales.Refunds;
dailySalesdb.Tier1 = dailySales.Tier1;
dailySalesdb.Tier2 = dailySales.Tier2;
dailySalesdb.Tier3 = dailySales.Tier3;
dailySalesdb.Tier4 = dailySales.Tier4;
dailySalesdb.UserID = dailySales.UserID;
dailySalesdb.MonthlyDrawsTaken = dailySales.MonthlyDrawsTaken;
dailySalesdb.QBTotalPay = dailySales.QBTotalPay;
dailySalesdb.Bonus = dailySales.Bonus;
dailySalesdb.ActualPayoutTotal = dailySales.ActualPayoutTotal;
dailySalesdb.CashBonus = dailySales.CashBonus;
dailySalesdb.MonthlyOfficeRent = dailySales.MonthlyOfficeRent;
uow.DailySalesRecordRepository.Insert(dailySalesdb);
uow.Save();
isSalesAdded = true;
}
catch
{
isSalesAdded = false;
}
}
return(isSalesAdded);
}
public List <LeadDocEntity> GetAllLeadDocsForUsers(int UserID)
{
List <LeadDocEntity> lstLeads = new List <LeadDocEntity>();
using (uow = new UnitOfWork.UnitOfWork())
{
try
{
lstLeads = uow.LeadDocRepository.Get().Where(x => x.UploadedFor == UserID).Select(usd => new LeadDocEntity
{
DocumentName = usd.DocumentName,
DocumentPath = usd.DocumentPath,
LeadDocID = usd.LeadDocID,
UploadDate = usd.UploadDate,
UploadedBy = usd.UploadedBy,
UploadedFor = usd.UploadedFor
}).OrderByDescending(x => Convert.ToDateTime(x.UploadDate)).ToList();
}
catch
{
}
}
return(lstLeads);
}
