public int GetValidationsCount(int leadID)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
int count = dc.T_Validations.Where(l => l.LeadID == leadID).Count();
return count;
}
}
public void UpdateValidationResource(ValidationResource update)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
T_ValidationResource tvr = dc.T_ValidationResources.SingleOrDefault(vr => vr.vrName == update.Name);
if (tvr == null)
{
throw new ApplicationException("Invalid validation resource name");
}
tvr.vrDownloadDate = update.DownloadDate;
tvr.vrContent = update.Content;
dc.SubmitChanges();
}
}
public ValidationResource GetValidationResourceByName(string name)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
var tResource = dc.T_ValidationResources.SingleOrDefault(r => r.vrName == name);
if (tResource == null)
{
throw new ApplicationException("Invalid validation resource ID");
}
ValidationResource resource = new ValidationResource();
resource.Name = tResource.vrName;
resource.DownloadDate = (DateTime)tResource.vrDownloadDate;
resource.Content = tResource.vrContent;
return resource;
}
}
public void SaveTask(ScheduledTaskInfo taskInfo)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
T_ScheduledTask tTask;
tTask = dc.T_ScheduledTasks.SingleOrDefault(t => t.SheduledTaskID == taskInfo.ID);
if (tTask == null)
{
throw new ApplicationException("Invalid sheduled task ID");
}
tTask.stTitle = taskInfo.Title;
tTask.stInterval = taskInfo.Interval;
tTask.stLastRan = taskInfo.LastRan;
dc.SubmitChanges();
}
}
public ScheduledTaskInfo GetTaskByID(int id)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
var result = dc.T_ScheduledTasks.SingleOrDefault(t => t.SheduledTaskID == id);
if (result == null)
{
throw new ApplicationException("Invalid sheduled task ID");
}
ScheduledTaskInfo task = new ScheduledTaskInfo();
task.ID = result.SheduledTaskID;
task.Title = result.stTitle;
task.LastRan = result.stLastRan;
task.Interval = result.stInterval;
return task;
}
}
public IEnumerable<ScheduledTaskInfo> GetActiveTasks(DateTime dueTime)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
var result = dc.T_ScheduledTasks.Where(t => (t.stLastRan + new TimeSpan(t.stInterval)) < dueTime).ToArray();
List<ScheduledTaskInfo> tasks = new List<ScheduledTaskInfo>(result.Count());
foreach (var tTask in result)
{
ScheduledTaskInfo task = new ScheduledTaskInfo();
task.ID = tTask.SheduledTaskID;
task.Title = tTask.stTitle;
task.LastRan = tTask.stLastRan;
task.Interval = tTask.stInterval;
tasks.Add(task);
}
return tasks;
}
}
public List<ValidationLead> GetValidationsPage(int leadID, int rowIndex, int pageSize)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
int pageIndex = rowIndex / pageSize;
var list = new List<ValidationLead>();
var validPage = dc.T_Validations.Where(v => v.T_Lead.LeadID == leadID).OrderByDescending(o => o.vldDate).Skip(pageIndex * pageSize).Take(pageSize);
foreach (var item in validPage)
{
List<ValidationResult> results = new List<ValidationResult>();
var tResults = dc.T_ValidationResults
.Where(res => res.ValidationID == item.ValidationID)
.OrderBy(ob => ob.TypeID);
foreach (T_ValidationResult res in tResults)
{
//if (item.)
results.Add(GetValidationResultEntity(res));
}
ValidationLead validation = new ValidationLead();
DateTime dt = item.vldDate;
int year = dt.Year;
int month = dt.Month;
int day = dt.Day;
validation.Date = string.Format("{0}/{1}/{2}", month, day, year);
validation.Results = results;
CCTLeadProvider leadProvider = new CCTLeadProvider();
validation.ValidationID = item.ValidationID;
validation.Lead = leadProvider.GetLeadEntity(item.T_Lead);
validation.User = leadProvider.GetUserInformationEntity(item.T_UserInformation);
list.Add(validation);
}
return list;
}
}
public int SaveValidationAddress(ValidationAddress address)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
T_ValidationAddressError tError = new T_ValidationAddressError();
if (address.Error != null)
{
tError.erDesc = address.Error.Description;
tError.erLocation = address.Error.Location;
tError.erNumber = address.Error.Number;
dc.T_ValidationAddressErrors.InsertOnSubmit(tError);
dc.SubmitChanges();
}
T_ValidationAddress tAddress = new T_ValidationAddress();
if (!string.IsNullOrEmpty(address.Address))
{
tAddress.vadAddress = address.Address;
}
if (!string.IsNullOrEmpty(address.City))
{
tAddress.vadCity = address.City;
}
if (!string.IsNullOrEmpty(address.Country))
{
tAddress.vadCountry = address.Country;
}
if (!string.IsNullOrEmpty(address.State))
{
tAddress.vadState = address.State;
}
if (!string.IsNullOrEmpty(address.ZipCode))
{
tAddress.vadZipCode = address.ZipCode;
}
if (address.Error != null)
{
tAddress.ErrorID = tError.ErrorID;
}
dc.T_ValidationAddresses.InsertOnSubmit(tAddress);
dc.SubmitChanges();
return tAddress.AddressID;
}
}
public int SaveValidationAddressError(ValidationAddressError error)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
T_ValidationAddressError tError = new T_ValidationAddressError();
tError.erDesc = error.Description;
tError.erLocation = error.Location;
tError.erNumber = error.Number;
dc.T_ValidationAddressErrors.InsertOnSubmit(tError);
dc.SubmitChanges();
return tError.ErrorID;
}
}
//public Address GetLeadAddressByValidationID(int validationID)
//{
// using (var dc = new EngageCCTDataClassesDataContext())
// {
// T_Validation tValidation;
// T_Lead tLead;
// T_Address tAddress;
// Address address;
// tValidation = dc.T_Validations.Where(la => la.ValidationID == validationID).SingleOrDefault();
// tLead = dc.T_Leads.Where(l => l.LeadID == tValidation.LeadID).SingleOrDefault();
// tAddress = dc.T_Addresses.Where(a => a.AddressID == tLead.HomeAddressID).SingleOrDefault();
// address = GetAddressEntity(tAddress);
// return address;
// }
//}
public Address GetLeadAddressByLeadID(int leadID)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
T_Lead tLead;
T_Address tAddress;
Address address;
tLead = dc.T_Leads.Where(l => l.LeadID == leadID).SingleOrDefault();
tAddress = dc.T_Addresses.Where(a => a.AddressID == tLead.SubjectPropertyAddressID).SingleOrDefault();
address = GetAddressEntity(tAddress);
return address;
}
}
public void SaveExcludedCompanies(IEnumerable<Company> companies)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
foreach (var company in companies)
{
T_ExcListCompany tCompany = new T_ExcListCompany();
tCompany.elcAddressLine1 = company.AddressLine1;
tCompany.elcAddressLine2 = company.AddressLine2;
tCompany.elcAddressLine3 = company.AddressLine3;
tCompany.elcAkaDba = company.Aka;
tCompany.elcCity = company.City;
tCompany.elcComments = company.Comments;
tCompany.elcCompanyName = company.CompanyName;
tCompany.elcIssuingState = company.IssuingState;
tCompany.elcLicenseNumber = company.LicenseNumber;
tCompany.elcState = company.State;
tCompany.elcZip = company.Zip;
dc.T_ExcListCompanies.InsertOnSubmit(tCompany);
}
dc.SubmitChanges();
}
}
public int SaveAddrValidation(int validationID, Lead lead, string status)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
int addrValStatus = 0;
int addressID;
T_ValidationResult tResult = new T_ValidationResult();
T_ValidationAddress tAddress = new T_ValidationAddress();
T_ValidationAddressError tError = new T_ValidationAddressError();
tResult.ValidationID = validationID;
tResult.TypeID = (int)TypeValidation.AddressValidation;
if (status != ValidationConstants.StatusNoInformation)
{
var validAddress = LeadValidationManager.GetValidAddress(lead.SubjectPropertyAddress);
if (validAddress.Error != null)
{
int errorID;
ValidationAddressError error = new ValidationAddressError();
error.Description = validAddress.Error.Description;
error.Location = validAddress.Error.Location;
error.Number = validAddress.Error.Number;
errorID = SaveValidationAddressError(error);
addrValStatus = (int)StatusValidation.Failed;
tAddress.ErrorID = errorID;
}
else
{
// SaveValidationAddress(validAddress);
bool isCorrect = LeadValidationManager.CompareAddresses(lead.SubjectPropertyAddress, validAddress);
if (isCorrect)
{
addrValStatus = (int)StatusValidation.Passed;
}
else
{
addrValStatus = (int)StatusValidation.Error;
}
}
addressID = SaveValidationAddress(validAddress);
tResult.AddressID = addressID;
tResult.StatusID = addrValStatus;
}
else
{
addrValStatus = (int)StatusValidation.NoInformation;
tResult.StatusID = addrValStatus;
}
dc.T_ValidationResults.InsertOnSubmit(tResult);
dc.SubmitChanges();
return addrValStatus;
}
}
public ValidationResult GetLastValidation(int leadID, int validatoinTypeID)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
var tValidations = dc.T_Validations
.Where(v => v.LeadID == leadID)
.OrderBy(v => v.vldDate);
var tValidation = tValidations.FirstOrDefault();
if (tValidation == null)
{
return null;
}
var tValidationResult = dc.T_ValidationResults
.Where(r => r.ValidationID == tValidation.ValidationID && r.TypeID == validatoinTypeID).FirstOrDefault();
if (tValidationResult == null)
{
return null;
}
var validationResult = GetValidationResultEntity(tValidationResult);
return validationResult;
}
}
public AddressValidationRezult GetAddressValidationInformation(int validationID)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
CCTLeadProvider leadProvider = new CCTLeadProvider();
T_Lead tLead;
T_ValidationAddress tValAddress;
T_ValidationResult tRezult;
T_Validation tValidation;
T_ValidationStatus tStatus;
T_ValidationAddressError tError;
AddressValidationRezult avRezult = new AddressValidationRezult();
tValidation = dc.T_Validations.Where(v => v.ValidationID == validationID).SingleOrDefault();
tLead = dc.T_Leads.Where(l => l.LeadID == tValidation.LeadID).SingleOrDefault();
tRezult = dc.T_ValidationResults.Where(r => r.ValidationID == validationID).FirstOrDefault();
tValAddress = dc.T_ValidationAddresses.Where(va => va.AddressID == tRezult.AddressID).SingleOrDefault();
tStatus = dc.T_ValidationStatus.Where(s => s.StatusID == tRezult.StatusID).SingleOrDefault();
if (tValAddress != null)
{
if (tValAddress.ErrorID.HasValue)
{
tError = dc.T_ValidationAddressErrors.Where(e => e.ErrorID == tValAddress.ErrorID).FirstOrDefault();
ValidationAddressError vaError = new ValidationAddressError();
ValidationAddress vAddress = new ValidationAddress();
vaError = GetValidationAddressErrorEntity(tError);
vAddress.Error = vaError;
avRezult.CorrectAddress = vAddress;
}
else
{
avRezult.CorrectAddress = GetValidationAddressEntity(tValAddress);
}
}
if (tLead != null)
{
avRezult.Lead = leadProvider.GetLeadEntity(tLead);
}
if (tStatus != null)
{
avRezult.Status = GetValidationStatusEntity(tStatus);
}
return avRezult;
}
}
public int SaveOFAC(int validationID, Lead lead, string status)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
//int statusPassed = dc.T_ValidationStatus
// .Where(s => s.vsDescription == ValidationConstants.StatusPassed)
// .Select(st => st.StatusID)
// .First();
//int statusFailed = dc.T_ValidationStatus
// .Where(s => s.vsDescription == ValidationConstants.StatusFailed)
// .Select(st => st.StatusID)
// .First();
//int statusNoInfo = dc.T_ValidationStatus
// .Where(s => s.vsDescription == ValidationConstants.StatusNoInformation)
// .Select(st => st.StatusID)
// .First();
T_ValidationResult tResult = new T_ValidationResult();
LeadValidationManager tLeadVM = new LeadValidationManager();
T_ValidationFail tFail = new T_ValidationFail();
//T_Lead tLead = new T_Lead();
tResult.ValidationID = validationID;
tResult.TypeID = dc.T_ValidationTypes
.Where(t => t.vtDescription == ValidationConstants.OFAC).Select(tp => tp.TypeID).First();
int validStat = 0;
if (status != ValidationConstants.StatusNoInformation)
{
var resultSearchInPLC = LeadValidationManager.SearchInPLC(lead);
var resultSearchInSDN = LeadValidationManager.SearchInSDN(lead);
if (resultSearchInPLC == null && resultSearchInSDN == null)
{
validStat = (int)StatusValidation.Passed;
tResult.FailID = null;
}
else
{
if (resultSearchInPLC != null)
{
tFail.vfPLC = tLeadVM.GetXmlPLC(resultSearchInPLC);
}
if (resultSearchInSDN != null)
{
tFail.vfSDN = tLeadVM.GetXmlSDN(resultSearchInSDN);
}
dc.T_ValidationFails.InsertOnSubmit(tFail);
dc.SubmitChanges();
tResult.FailID = tFail.FailID;
validStat = (int)StatusValidation.Failed;
}
}
else
{
validStat = (int)StatusValidation.NoInformation;
tResult.FailID = null;
}
// if (resultSearchInPLC != null || resultSearchInSDN != null)
// {
// if (resultSearchInPLC != null)
// {
// tFail.vfPLC = tLeadVM.GetXmlPLC(resultSearchInPLC);
// }
// if (resultSearchInSDN != null)
// {
// tFail.vfSDN = tLeadVM.GetXmlSDN(resultSearchInSDN);
// }
// dc.T_ValidationFails.InsertOnSubmit(tFail);
// dc.SubmitChanges();
// tResult.FailID = tFail.FailID;
// }
// if (resultSearchInPLC == null && resultSearchInSDN == null)
// {
// validStat = (int)StatusValidation.Passed;
// tResult.FailID = null;
// //
// }
// else
// {
// validStat = (int)StatusValidation.Failed;
// }
//}
//else
//{
// validStat = (int)StatusValidation.NoInformation;
// tResult.FailID = null;
//}
tResult.StatusID = validStat;
dc.T_ValidationResults.InsertOnSubmit(tResult);
dc.SubmitChanges();
return validStat;
}
}
//------------------------------
public List<ExclusionaryListEntry> GetExcListValidationDetails(int validationID)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
var list = new List<ExclusionaryListEntry>();
LeadValidationManager manager = new LeadValidationManager();
var exList = manager.GetExcListEntryByXML(validationID);
if (exList == null)
return list;
foreach (var item in exList)
{
list.Add(item);
}
return list;
}
}
public List<ValidationResultSDNPLC> GetOFACValidationDetails(int validationID)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
var list = new List<ValidationResultSDNPLC>();
LeadValidationManager manager = new LeadValidationManager();
var plcBase = manager.GetPLCEntityByXML(validationID);
if (plcBase != null)
{
foreach (var entity in plcBase)
list.Add(new ValidationResultSDNPLC(entity));
}
var sdnBase = manager.GetSDNEntityByXML(validationID);
if (sdnBase != null)
{
foreach (var entity in sdnBase)
list.Add(new ValidationResultSDNPLC(entity));
}
return list;
}
}
public ValidationStatus GetValidationsStatus(int validationStatusID)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
var tValidationStatus = dc.T_ValidationStatus.Where(v => v.StatusID == validationStatusID).SingleOrDefault();
if (tValidationStatus == null)
{
return null;
}
return GetValidationStatusEntity(tValidationStatus);
}
}
public ExcListValidation GetExcListResultsByValidationID(int validationID)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
T_ValidationFail tExcList = new T_ValidationFail();
T_ValidationResult tResult = new T_ValidationResult();
//int excType = dc.T_ValidationTypes
// .Where(t => t.vtDescription == ValidationConstants.FreddieList)
// .Select(i => i.TypeID)
// .First();
int excType = (int)TypeValidation.ExclusionaryList;
var res = dc.T_ValidationResults
.Where(r => r.ValidationID == validationID && r.TypeID == excType)
.FirstOrDefault();
if (res == null)
return null;
tExcList = dc.T_ValidationFails.Where(l => l.FailID == res.FailID).FirstOrDefault();
if (tExcList == null)
return null;
var table = GetExcListValidationEntity(tExcList);
return table;
}
}
public ValidationFail GetValidationsResultsByValidationID(int validationID)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
T_ValidationFail tFail;
T_ValidationResult tResults;
T_Validation tValidation = new T_Validation();
ValidationFail result = new ValidationFail();
tResults = dc.T_ValidationResults
.Where(r => r.ValidationID == validationID && r.T_ValidationType.vtDescription == ValidationConstants.OFAC)
.FirstOrDefault();
if (tResults == null)
return null;
tFail = dc.T_ValidationFails.Where(f => f.FailID == tResults.FailID).FirstOrDefault();
if (tFail == null)
return null;
var table = GetValidationFailEntity(tFail);
return table;
//tResults = dc.T_ValidationResults.Where(r => r.ValidationID == validationID && r.FailID == r.T_ValidationFail.FailID).First();
//tFail = dc.T_ValidationFails.Where(f => f.FailID == tResults.FailID).First();
//var table = GetValidationFailEntity(tFail);
}
}
public int GetLeadIDByValidationID(int validationID)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
int id;
var validations = dc.T_Validations.AsQueryable();
var lead = validations.Single(e => e.ValidationID == validationID);
id = lead.LeadID;
return id;
}
}
public int SaveValidationLead(ValidationLead validation)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
T_Validation tValidation = new T_Validation();
tValidation.LeadID = (int)validation.Lead.LeadID;
tValidation.Login = validation.User.Login;
tValidation.vldDate = DateTime.Now;
dc.T_Validations.InsertOnSubmit(tValidation);
dc.SubmitChanges();
List<ValidationResult> results = validation.Results;
int ofac = 0;
int exList = 0;
int addVal = 0;
int noInfoStatus = dc.T_ValidationStatus
.Where(s => s.vsDescription == ValidationConstants.StatusNoInformation)
.Select(f => f.StatusID).First();
foreach (var result in results)
{
switch (result.Type.Type)
{
case ValidationConstants.OFAC:
ofac = SaveOFAC(tValidation.ValidationID, validation.Lead, result.Status.Status);
break;
case ValidationConstants.FreddieList:
exList = SaveExcList(tValidation.ValidationID, validation.Lead, result.Status.Status);
break;
case ValidationConstants.Address:
addVal = SaveAddrValidation(tValidation.ValidationID, validation.Lead, result.Status.Status);
break;
default: break;
}
}
var tLead = dc.T_Leads.Where(l => l.LeadID == (int)validation.Lead.LeadID).First();
tLead.ldOFAC = ofac;
tLead.ldAddrVal = addVal;
tLead.ldExlList = exList;
dc.SubmitChanges();
return tValidation.ValidationID;
}
}
public List<ValidationResult> CheckValidationsSource()
{
using (var dc = new EngageCCTDataClassesDataContext())
{
List<ValidationResult> list = new List<ValidationResult>();
int excCompanies = dc.T_ExcListCompanies.Count();
int excIndividuials = dc.T_ExcListIndividuals.Count();
var ofacXml = dc.T_ValidationResources.Select(v => v.vrContent).First();
var typeOFAC = new ValidationType();
var statusOFAC = new ValidationStatus();
typeOFAC.Type = ValidationConstants.OFAC;
if (ofacXml != null)
statusOFAC.Status = ValidationConstants.StatusPassed;
else
statusOFAC.Status = ValidationConstants.StatusError;
list.Add(new ValidationResult { Type = typeOFAC, Status = statusOFAC });
var typeFreddie = new ValidationType();
var statusFreddie = new ValidationStatus();
typeFreddie.Type = ValidationConstants.FreddieList;
if (excCompanies != 0 && excIndividuials != 0)
statusFreddie.Status = ValidationConstants.StatusPassed;
else
statusFreddie.Status = ValidationConstants.StatusError;
list.Add(new ValidationResult { Type = typeFreddie, Status = statusFreddie });
//var typeFreddie = new ValidationType();
//var statusFreddie = new ValidationStatus();
return list;
}
}
public List<ExclusionaryListEntry> GetExclusionaryList()
{
using (var dc = new EngageCCTDataClassesDataContext())
{
List<ExclusionaryListEntry> result = new List<ExclusionaryListEntry>();
foreach (T_ExcListIndividual tIndividual in dc.T_ExcListIndividuals.ToArray())
{
ExclusionaryListEntry individual = new ExclusionaryListEntry();
individual.IsIndividual = true;
individual.AddressLine1 = tIndividual.eliAddressLine1;
individual.AddressLine2 = tIndividual.eliAddressLine2;
individual.AddressLine3 = tIndividual.eliAddressLine3;
individual.Aka = tIndividual.eliAkaDba;
individual.City = tIndividual.eliCity;
individual.FirstName = tIndividual.eliFirstName;
individual.LastName = tIndividual.eliLastName;
individual.State = tIndividual.eliState;
individual.Zip = tIndividual.eliZip;
result.Add(individual);
}
foreach (T_ExcListCompany tCompany in dc.T_ExcListCompanies.ToArray())
{
ExclusionaryListEntry company = new ExclusionaryListEntry();
company.IsIndividual = false;
company.AddressLine1 = tCompany.elcAddressLine1;
company.AddressLine2 = tCompany.elcAddressLine2;
company.AddressLine3 = tCompany.elcAddressLine3;
company.Aka = tCompany.elcAkaDba;
company.City = tCompany.elcCity;
company.CompanyName = tCompany.elcCompanyName;
company.State = tCompany.elcState;
company.Zip = tCompany.elcZip;
result.Add(company);
}
return result;
}
}
public ValidationLead GetValidationInformation(int validationID)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
ValidationLead vlead = new ValidationLead();
var tValidation = dc.T_Validations.Where(v => v.ValidationID == validationID).FirstOrDefault();
if (tValidation != null)
{
List<ValidationResult> results = new List<ValidationResult>();
var tResults = dc.T_ValidationResults
.Where(res => res.ValidationID == tValidation.ValidationID);
foreach (T_ValidationResult res in tResults)
{
results.Add(GetValidationResultEntity(res));
}
vlead.Results = results;
DateTime dt = tValidation.vldDate;
int year = dt.Year;
int month = dt.Month;
int day = dt.Day;
vlead.Date = string.Format("{0}/{1}/{2}", month, day, year);
CCTLeadProvider leadProvider = new CCTLeadProvider();
vlead.ValidationID = tValidation.ValidationID;
vlead.Lead = leadProvider.GetLeadEntity(tValidation.T_Lead);
vlead.User = leadProvider.GetUserInformationEntity(tValidation.T_UserInformation);
}
return vlead;
}
}
public void SaveExcludedIndividuals(IEnumerable<Individual> individuals)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
foreach (var individual in individuals)
{
T_ExcListIndividual tIndividual = new T_ExcListIndividual();
tIndividual.eliAddressLine1 = individual.AddressLine1;
tIndividual.eliAddressLine2 = individual.AddressLine2;
tIndividual.eliAddressLine3 = individual.AddressLine3;
tIndividual.eliAkaDba = individual.Aka;
tIndividual.eliCity = individual.City;
tIndividual.eliComments = individual.Comments;
tIndividual.eliFirstName = individual.FirstName;
tIndividual.eliIssuingState = individual.IssuingState;
tIndividual.eliLastName = individual.LastName;
tIndividual.eliLicenseNumber = individual.LicenseNumber;
tIndividual.eliLicenseType = individual.LicenseType;
tIndividual.eliState = individual.State;
tIndividual.eliZip = individual.Zip;
dc.T_ExcListIndividuals.InsertOnSubmit(tIndividual);
}
dc.SubmitChanges();
}
}
public List<Individual> GetExcludedIndividuals(int? id)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
var query = dc.T_ExcListIndividuals.AsQueryable();
if (id.HasValue)
{
query = query.Where(i => i.ExcListIndividualID == id);
}
List<Individual> result = new List<Individual>();
foreach (var tIndividual in query.ToArray())
{
Individual individual = new Individual();
individual.ID = tIndividual.ExcListIndividualID;
individual.AddressLine1 = tIndividual.eliAddressLine1;
individual.AddressLine2 = tIndividual.eliAddressLine2;
individual.AddressLine3 = tIndividual.eliAddressLine3;
individual.Aka = tIndividual.eliAkaDba;
individual.City = tIndividual.eliCity;
individual.Comments = tIndividual.eliComments;
individual.FirstName = tIndividual.eliFirstName;
individual.IssuingState = tIndividual.eliIssuingState;
individual.LastName = tIndividual.eliLastName;
individual.LicenseNumber = tIndividual.eliLicenseNumber;
individual.LicenseType = tIndividual.eliLicenseType;
individual.State = tIndividual.eliState;
individual.Zip = tIndividual.eliZip;
result.Add(individual);
}
return result;
}
}
public int SaveExcList(int validationID, Lead lead, string status)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
//int statusPassed = dc.T_ValidationStatus
// .Where(s => s.vsDescription == ValidationConstants.StatusPassed)
// .Select(st => st.StatusID)
// .First();
//int statusFailed = dc.T_ValidationStatus
// .Where(s => s.vsDescription == ValidationConstants.StatusFailed)
// .Select(st => st.StatusID)
// .First();
//int statusNoInfo = dc.T_ValidationStatus
// .Where(s => s.vsDescription == ValidationConstants.StatusNoInformation)
// .Select(st => st.StatusID)
// .First();
int exRes = 0;
T_ValidationResult tResult = new T_ValidationResult();
T_ValidationFail tExcListValidation = new T_ValidationFail();
LeadValidationManager tLeadVM = new LeadValidationManager();
tResult.ValidationID = validationID;
tResult.TypeID = dc.T_ValidationTypes
.Where(t => t.vtDescription == ValidationConstants.FreddieList)
.Select(tp => tp.TypeID)
.First();
if (status != ValidationConstants.StatusNoInformation)
{
var validResult = LeadValidationManager.SearchInExclusionaryList(lead);
if (validResult != null)
{
exRes = (int)StatusValidation.Failed;
tExcListValidation.vfExcList = tLeadVM.GetXmlExcListEntry(validResult);
dc.T_ValidationFails.InsertOnSubmit(tExcListValidation);
dc.SubmitChanges();
tResult.StatusID = (int)StatusValidation.Failed;
tResult.FailID = tExcListValidation.FailID;
//---------------
}
else
{
exRes = (int)StatusValidation.Passed;
tResult.StatusID = (int)StatusValidation.Passed;
tResult.FailID = null;
}
}
else
{
exRes = (int)StatusValidation.NoInformation;
tResult.StatusID = (int)StatusValidation.NoInformation;
tResult.FailID = null;
}
dc.T_ValidationResults.InsertOnSubmit(tResult);
dc.SubmitChanges();
return exRes;
}
}
public List<Company> GetExcludedCompanies(int? id)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
var query = dc.T_ExcListCompanies.AsQueryable();
if (id.HasValue)
{
query = query.Where(c => c.ExcListCompanyID == id);
}
List<Company> result = new List<Company>();
foreach (T_ExcListCompany tCompany in query.ToArray())
{
Company company = new Company();
company.ID = tCompany.ExcListCompanyID;
company.AddressLine1 = tCompany.elcAddressLine1;
company.AddressLine2 = tCompany.elcAddressLine2;
company.AddressLine3 = tCompany.elcAddressLine3;
company.Aka = tCompany.elcAkaDba;
company.City = tCompany.elcCity;
company.Comments = tCompany.elcComments;
company.CompanyName = tCompany.elcCompanyName;
company.IssuingState = tCompany.elcIssuingState;
company.LicenseNumber = tCompany.elcLicenseNumber;
company.State = tCompany.elcState;
company.Zip = tCompany.elcZip;
result.Add(company);
}
return result;
}
}
public int GetValidationTypeID(string description)
{
using (var dc = new EngageCCTDataClassesDataContext())
{
var tValidationType = dc.T_ValidationTypes
.Where(v => v.vtDescription.Equals(description))
.FirstOrDefault();
if (tValidationType == null)
{
return -1;
}
else
{
return tValidationType.TypeID;
}
}
}
