public override void Init(long nCustomerID, SafeReader oRow)
{
base.Init(nCustomerID, oRow);
UserStatus = oRow["UserStatus"];
RegDate = oRow["RegDate"];
WizardStep = oRow["WizardStep"];
SegmentType = oRow["SegmentType"];
IsWasLate = oRow["IsWasLate"];
MP_Statuses = oRow["MpStatus"];
} // Init
public override void Init(long nCustomerID, SafeReader oRow)
{
base.Init(nCustomerID, oRow);
MobilePhone = oRow["MobilePhone"];
DaytimePhone = oRow["DaytimePhone"];
AmountTaken = oRow["AmountTaken"];
OSBalance = oRow["OSBalance"];
CRMstatus = oRow["CRMstatus"];
CRMcomment = oRow["CRMcomment"];
} // Init
} // AddApprovalPhaseTotal
public void AddMarketplace(SafeReader sr)
{
string sMpName = sr["Marketplace"];
if (string.IsNullOrWhiteSpace(sMpName))
{
return;
}
ms_oAllMarketplaces.Add(sMpName);
m_oMarketplaces.Add(sMpName);
} // AddMarketplace
public ActionData(Guid oActionID, SafeReader sr)
{
m_bHasValue = false;
ID = oActionID;
StartTime = null;
EndTime = null;
IsSuccess = null;
LoadTime(sr);
} // constructor
public CaisGenerate(int underwriterId)
{
mailer = new StrategiesMailer();
SafeReader sr = DB.GetFirst("GetCaisFoldersPaths", CommandSpecies.StoredProcedure);
caisPath = sr["CaisPath"];
caisPath2 = sr["CaisPath2"];
this.underwriterId = underwriterId;
this.caisReportsHistoryRepository = ObjectFactory.GetInstance <CaisReportsHistoryRepository>();
service = new ExperianLib.Ebusiness.EBusinessService(DB);
}
public Job(EzServiceInstanceRuntimeData oRuntimeData, SafeReader sr, TypeRepository oTypeRepo)
{
WhyNotStarting = "never checked whether it is time to start";
m_oRuntimeData = oRuntimeData;
m_oArguments = new List <JobArgument>();
sr.Fill(this);
AddArgument(sr, oTypeRepo);
} // constructor
} // IsHomeOwner
private void ProcessRow(SafeReader sr)
{
Datum d = sr.Fill <Datum>();
sr.Fill(d.Manual);
sr.Fill(d.ManualCfg);
d.ManualCfg.Calculate(d.Manual);
d.LoadLoans(DB);
this.data.Add(d);
} // ProcessRow
} // Name
public override void Execute()
{
SafeReader sr = m_oSp.GetFirst();
int nCustomerMarketplaceID = sr.IsEmpty ? 0 : sr["CustomerMarketPlaceID"];
int nHistoryID = sr.IsEmpty ? 0 : sr["HistoryID"];
if (nCustomerMarketplaceID > 0)
{
new CalculateVatReturnSummary(nCustomerMarketplaceID).SetHistoryRecordID(nHistoryID).Execute();
}
} // Execute
public void ParseAndStore(long serviceLogId)
{
const string queryFormat =
"SELECT Id, ServiceType, CompanyRefNum, ResponseData FROM MP_ServiceLog WHERE Id = {0}";
string query = string.Format(queryFormat, serviceLogId);
SafeReader sr = this.db.GetFirst(query, CommandSpecies.Text);
if (sr.IsEmpty)
{
this.log.Debug("No MP_ServiceLog entry was found by id {0}.", serviceLogId);
return;
} // if
long id = sr["Id"];
if (id != serviceLogId)
{
this.log.Debug("MP_ServiceLog entry found by id {0} has id {1}.", serviceLogId, id);
return;
} // if
string serviceType = sr["ServiceType"];
if (serviceType != "E-SeriesNonLimitedData")
{
this.log.Debug(
"Unsupported service type '{0}' detected for MP_ServiceLog entry with id {1}.",
serviceType,
id
);
return;
} // if
string companyRefNum = sr["CompanyRefNum"];
if (string.IsNullOrWhiteSpace(companyRefNum))
{
this.log.Debug("Empty company reference number detected for MP_ServiceLog entry with id {0}.", id);
return;
} // if
string responseData = sr["ResponseData"];
if (string.IsNullOrWhiteSpace(responseData))
{
this.log.Debug("Empty response data detected for MP_ServiceLog entry with id {0}.", id);
return;
} // if
ParseAndStore(responseData, companyRefNum, id);
} // ParseAndStore
} //load From db
private ActionResult FillOneInvestor(SafeReader sr, bool arg2)
{
Result.Add(new OneInvestorModel {
InvestorID = sr["InvestorID"],
InvestorType = sr["InvestorType"],
InvestorTypeID = sr["InvestorTypeID"],
FundingLimitForNotification = sr["FundingLimitForNotification"],
CompanyName = sr["CompanyName"],
IsActive = sr["IsActive"]
});
return(ActionResult.Continue);
} //FillOneInvestor
} // GetDiscountPlan
private LoanSource GetLoanSource()
{
SafeReader lssr = Library.Instance.DB.GetFirst(
"GetLoanSource",
CommandSpecies.StoredProcedure,
// Get specific for re-approval or default otherwise
new QueryParameter("@LoanSourceID", IsAutoReApproval ? LoanSourceID : (int?)null),
new QueryParameter("@CustomerID", CustomerID)
);
return(lssr.Fill <LoanSource>());
} // GetLoanSource
private static ActionResult TestParsedValuesPrint(DbDataReader row, bool bRowsetStarts)
{
var sr = new SafeReader(row);
int nCustomerID = sr["Id"];
string sName = sr["Name"];
bool bIsOffline = sr["IsOffline"];
DateTime dt = sr["GreetingMailSentDate"];
ms_oLog.Info("{0}: {1} - {2} {3}", nCustomerID, sName, bIsOffline, dt);
return(ActionResult.Continue);
}
} // constructor
public void Add(SafeReader sr)
{
long cashRequestID = sr["CashRequestID"];
if (this.cashRequests.ContainsKey(cashRequestID))
{
this.cashRequests[cashRequestID].Add(sr);
}
else
{
this.cashRequests[cashRequestID] = new NotAutoApprovedCashRequest(sr);
}
} // Add
public NotAutoApprovedTrail(SafeReader sr)
{
this.traces = new SortedDictionary <int, NotAutoApprovedTrace>();
if (sr == null)
{
TrailID = 0;
return;
} // if
sr.Fill(this);
Add(sr);
} // constructor
} // constructor
public void Add(SafeReader sr)
{
long trailID = sr["TrailID"];
if (this.trails.ContainsKey(trailID))
{
this.trails[trailID].Add(sr);
}
else
{
this.trails[trailID] = new NotAutoApprovedTrail(sr);
}
} // Add
public override void Execute()
{
SafeReader sr = DB.GetFirst(
"GetPricingScenarioDetails",
CommandSpecies.StoredProcedure,
new QueryParameter("ScenarioID", this.scenarioID)
);
if (!sr.IsEmpty)
{
sr.Stuff(Model);
}
} // Execute
} // LoadCashRequests
private LoanStatsDataEntry CreateEntry(SafeReader sr)
{
var lse = new LoanStatsDataEntry(sr);
if (!Data.ContainsKey(lse.CustomerID))
{
Data[lse.CustomerID] = new List <LoanStatsDataEntry>();
}
Data[lse.CustomerID].Add(lse);
return(lse);
} // CreateEntry
} // constructor
public LoanSource GetDefault(int customerID)
{
SafeReader sr = Library.Instance.DB.GetFirst(
"GetLoanSource",
CommandSpecies.StoredProcedure,
new QueryParameter("@LoanSourceID"),
new QueryParameter("@CustomerID", customerID)
);
int loanSourceID = sr.IsEmpty ? 1 : sr["LoanSourceID"];
return(GetAll().Single(p => p.ID == loanSourceID));
} // GetDefault
} // Execute
private void UpdateMp(SafeReader sr)
{
int customerID = sr["CustomerId"];
int mpID = sr["MpID"];
try {
new UpdateMarketplace(customerID, mpID, false).Execute();
} catch (Exception e) {
Log.Warn(e, "Failed to update marketplace {0} of customer {1}.", mpID, customerID);
} // try
this.pc++;
} // UpdateMp
public void AddAction(SafeReader sr)
{
Guid oActionID = sr["ActionID"];
if (m_oData.ContainsKey(oActionID))
{
m_oData[oActionID].LoadTime(sr);
}
else
{
m_oData[oActionID] = new ActionData(oActionID, sr);
}
} // AddAction
public override void Init(long nCustomerID, SafeReader oRow)
{
base.Init(nCustomerID, oRow);
DateRejected = oRow["DateRejected"];
Reason = oRow["Reason"];
ApprovesNum = oRow["ApprovesNum"];
RejectsNum = oRow["RejectsNum"];
OSBalance = oRow["OSBalance"];
LastStatus = oRow["LastStatus"];
CRMcomment = oRow["CRMcomment"];
Broker = oRow["Broker"];
FirstSale = oRow["FirstSale"];
} // Init
public override void Init(long nRowID, SafeReader oRow)
{
oRow.Fill(this);
Id = nRowID;
ChooseInvestor = new List <PendingInvestorModel>();
foreach (var investor in allinvestors)
{
if (investor.InvestorFunds >= ApprovedAmount)
{
ChooseInvestor.Add(investor);
}
}
} // Init
} // Name
public override void Execute()
{
SafeReader sr = DB.GetFirst(
"BrokerLoadCurrentTerms",
CommandSpecies.StoredProcedure,
new QueryParameter("@OriginID", this.originID)
);
if (!sr.IsEmpty)
{
ID = sr["BrokerTermsID"];
Terms = sr["BrokerTerms"];
} // if
} // Execute
} // UpdateTotal
public void Update(SafeReader sr, AccountingLoanBalanceRawUpdate upd = null)
{
upd = upd ?? sr.Fill <AccountingLoanBalanceRawUpdate>();
if (upd.TransactionDate.HasValue && !Transactions.Contains(upd.TransactionID))
{
Transactions.Add(upd.TransactionID);
bool bNonCash = (upd.LoanTranMethod ?? string.Empty).ToLower().StartsWith("non-cash");
if (bNonCash)
{
NonCashPaid += upd.TotalRepaid;
}
else
{
CashPaid += upd.TotalRepaid;
}
EarnedFees += upd.RolloverRepaid;
RepaidPrincipal += upd.RepaidPrincipal;
RepaidInterest += upd.RepaidInterest;
FeesRepaid += upd.FeesRepaid;
if (upd.TransactionDate.Value < WriteOffDate)
{
if (bNonCash)
{
WriteOffNonCashPaid += upd.TotalRepaid;
}
else
{
WriteOffCashPaid += upd.TotalRepaid;
}
WriteOffEarnedFees += upd.RolloverRepaid;
} // if
} // if
if (upd.LoanChargeDate.HasValue && !LoanCharges.Contains(upd.FeesEarnedID))
{
LoanCharges.Add(upd.FeesEarnedID);
EarnedFees += upd.FeesEarned;
if (upd.LoanChargeDate < WriteOffDate)
{
WriteOffEarnedFees += upd.FeesEarned;
}
} // if
} // Update
private void NL_SendMailAndMarkDB(SafeReader sr)
{
int customerID = sr["CustomerId"];
long loanID = sr["LoanID"];
DateTime plannedDate = sr["PlannedDate"];
int Xdays = sr["Xdays"]; // 2|5 indicate which type of notification to send
long loanScheduleId = sr["LoanScheduleID"];
NL_AddLog(LogType.Info, "NL_SendMailAndMarkDB", new object[] { customerID, loanID, Xdays, loanScheduleId, plannedDate, nowTime }, null, null, null);
GetLoanState loanState = new GetLoanState(customerID, loanID, nowTime);
loanState.Execute();
var nlModel = loanState.Result;
NL_LoanSchedules theSchedule = null;
nlModel.Loan.Histories.ForEach(h => theSchedule = h.Schedule.FirstOrDefault(s => s.LoanScheduleID == loanScheduleId));
if (theSchedule == null)
{
Log.Debug("Schedule for loan {0}, old {1} not found", loanID, sr["OldLoanID"]);
NL_AddLog(LogType.Warn, "Schedule not found", new object[] { customerID, loanID, Xdays, loanScheduleId, plannedDate, nowTime }, null, null, null);
return;
}
var variables = new Dictionary <string, string> {
{ "FirstName", sr["FirstName"] },
{ "AmountDueScalar", theSchedule.AmountDue.ToString(CultureInfo.InvariantCulture) },
{ "Date", FormattingUtils.FormatDateToString(plannedDate) },
{ "DebitCard", sr["CreditCardNo"] }
};
var templateName = (Xdays == 2) ? "Mandrill - 2 days notice" : "Mandrill - 5 days notice";
XDaysDueMails xDaysDueMails = new XDaysDueMails(customerID, templateName, variables);
//DON"T DELETE - in the futere email will be sent from here.!!!
//xDaysDueMails.Execute();
var parameterName = (Xdays == 2) ? "TwoDaysDueMailSent" : "FiveDaysDueMailSent"; // new SP
var queryParameteres = new QueryParameter[] {
new QueryParameter("LoanScheduleID", loanScheduleId),
new QueryParameter(parameterName, true)
};
NL_AddLog(LogType.Info, "Processing", new object[] { customerID, loanID, Xdays, loanScheduleId, plannedDate, nowTime }, new object[] { theSchedule, parameterName, templateName }, null, null);
DB.ExecuteNonQuery("NL_LoanSchedulesUpdate", CommandSpecies.StoredProcedure, queryParameteres);
Log.Info("update loanID {2} scheduleID {1} x days due for customer {0}", customerID, loanScheduleId, loanID);
}
private static ArrayRule ParseRule(SafeReader reader, int min, int max)
{
var values = new bool[max + 1];
if (ParseListItem(reader, min, max, values))
{
for (; reader.MoveNextIf(',') && ParseListItem(reader, min, max, values);)
{
;
}
}
return(new ArrayRule(values));
}
public void LoadTime(SafeReader sr)
{
int nStatusID = sr["ActionStatusID"];
if (nStatusID == 1)
{
StartTime = sr["EntryTime"];
}
else
{
IsSuccess = nStatusID == 2;
EndTime = sr["EntryTime"];
} // if
} // LoadTime
} // ProcessEtl
private void ProcessModelOutput(SafeReader sr)
{
DBModelOutput dbModel = sr.Fill <DBModelOutput>();
if (!Enum.IsDefined(typeof(ModelNames), dbModel.ModelID))
{
throw OutOfRangeException(
"inference loader({1}): unsupported request type '{0}'.",
dbModel.ModelID,
this.argList
);
} // if
if (!this.resultSet.ContainsKey(dbModel.ResponseID))
{
throw OutOfRangeException(
"Inference loader({0}): model output '{1}' should belong to unknown response '{2}'.",
this.argList,
dbModel.ID,
dbModel.ResponseID
);
} // if
var pubModel = new PublicModelOutput {
Status = dbModel.Status,
Grade = new Grade {
DecodedResult = dbModel.InferenceResultDecoded,
EncodedResult = dbModel.InferenceResultEncoded,
Score = dbModel.Score,
},
Error = new ModelError {
ErrorCode = dbModel.ErrorCode,
Exception = dbModel.Exception,
Uuid = dbModel.Uuid,
},
};
ModelNames requestType = (ModelNames)dbModel.ModelID;
this.models[dbModel.ID] = pubModel;
this.resultSet[dbModel.ResponseID].ModelOutputs[requestType] = pubModel;
Log.Debug(
"Inference loader({0}): loaded model output (id: {1}, type: {2}).",
this.argList,
dbModel.ID,
requestType
);
} // ProcessModelOutput
} // CreateLoadInferenceProcedure
private void ProcessInferenceRow(SafeReader sr)
{
string rowTypeName = sr["RowType"];
RowTypes rowType;
if (!Enum.TryParse(rowTypeName, false, out rowType))
{
throw new KeeperAlert(Log, "Inference loader({1}): unknown row type '{0}'.", rowTypeName, this.argList);
}
switch (rowType)
{
case RowTypes.Request:
ProcessRequest(sr);
break;
case RowTypes.Response:
ProcessResponse(sr);
break;
case RowTypes.ModelOutput:
ProcessModelOutput(sr);
break;
case RowTypes.OutputRatio:
ProcessOutputRatio(sr);
break;
case RowTypes.Warning:
ProcessWarning(sr);
break;
case RowTypes.EncodingFailure:
ProcessEncodingFailure(sr);
break;
case RowTypes.MissingColumn:
ProcessMissingColumn(sr);
break;
case RowTypes.ETL:
ProcessEtl(sr);
break;
default:
throw OutOfRangeException("Inference loader({1}): unsupported row type '{0}'.", rowTypeName, this.argList);
} // switch
} // ProcessInferenceRow
} // CopyFrom
private int GetLoanType()
{
SafeReader ltsr = Library.Instance.DB.GetFirst(
"GetLoanTypeAndDefault",
CommandSpecies.StoredProcedure,
new QueryParameter("@LoanTypeID", this.loanTypeID)
);
int?dbLoanTypeID = ltsr["LoanTypeID"];
int defaultLoanTypeID = ltsr["DefaultLoanTypeID"];
return(DecidedToApprove
? (dbLoanTypeID ?? defaultLoanTypeID)
: defaultLoanTypeID);
} // GetLoanType
