/// <summary>
/// Get the person that the request is for.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="workflow">The Workflow initiating the request.</param>
/// <param name="personAttribute">The person attribute.</param>
/// <param name="person">Return the person.</param>
/// <param name="personAliasId">Return the person alias ID.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns>True/False value of whether the request was successfully sent or not.</returns>
private bool GetPerson(RockContext rockContext, Model.Workflow workflow, AttributeCache personAttribute, out Person person, out int?personAliasId, List <string> errorMessages)
{
person = null;
personAliasId = null;
if (personAttribute != null)
{
Guid?personAliasGuid = workflow.GetAttributeValue(personAttribute.Key).AsGuidOrNull();
if (personAliasGuid.HasValue)
{
person = new PersonAliasService(rockContext).Queryable()
.Where(p => p.Guid.Equals(personAliasGuid.Value))
.Select(p => p.Person)
.FirstOrDefault();
person.LoadAttributes(rockContext);
}
}
if (person == null)
{
errorMessages.Add("The 'Checkr' background check provider requires the workflow to have a 'Person' attribute that contains the person who the background check is for.");
return(false);
}
personAliasId = person.PrimaryAliasId;
if (!personAliasId.HasValue)
{
errorMessages.Add("The 'Checkr' background check provider requires the workflow to have a 'Person' attribute that contains the person who the background check is for.");
return(false);
}
return(true);
}
/// <summary>
/// Sends a background request to Protect My Ministry
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="workflow">The Workflow initiating the request.</param>
/// <param name="personAttribute">The person attribute.</param>
/// <param name="ssnAttribute">The SSN attribute.</param>
/// <param name="requestTypeAttribute">The request type attribute.</param>
/// <param name="billingCodeAttribute">The billing code attribute.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns>
/// True/False value of whether the request was successfully sent or not
/// </returns>
/// <exception cref="System.NotImplementedException"></exception>
/// <remarks>
/// Note: If the associated workflow type does not have attributes with the following keys, they
/// will automatically be added to the workflow type configuration in order to store the results
/// of the PMM background check request
/// RequestStatus: The request status returned by PMM request
/// RequestMessage: Any error messages returned by PMM request
/// ReportStatus: The report status returned by PMM
/// ReportLink: The location of the background report on PMM server
/// ReportRecommendation: PMM's recomendataion
/// Report (BinaryFile): The downloaded background report
/// </remarks>
public override bool SendRequest(RockContext rockContext, Model.Workflow workflow,
AttributeCache personAttribute, AttributeCache ssnAttribute, AttributeCache requestTypeAttribute,
AttributeCache billingCodeAttribute, out List <string> errorMessages)
{
errorMessages = new List <string>();
try
{
// Check to make sure workflow is not null
if (workflow == null)
{
errorMessages.Add("The 'Protect My Ministry' background check provider requires a valid workflow.");
return(false);
}
// Get the person that the request is for
Person person = null;
if (personAttribute != null)
{
Guid?personAliasGuid = workflow.GetAttributeValue(personAttribute.Key).AsGuidOrNull();
if (personAliasGuid.HasValue)
{
person = new PersonAliasService(rockContext).Queryable()
.Where(p => p.Guid.Equals(personAliasGuid.Value))
.Select(p => p.Person)
.FirstOrDefault();
person.LoadAttributes(rockContext);
}
}
if (person == null)
{
errorMessages.Add("The 'Protect My Ministry' background check provider requires the workflow to have a 'Person' attribute that contains the person who the background check is for.");
return(false);
}
string password = Encryption.DecryptString(GetAttributeValue("Password"));
XElement rootElement = new XElement("OrderXML",
new XElement("Method", "SEND ORDER"),
new XElement("Authentication",
new XElement("Username", GetAttributeValue("UserName")),
new XElement("Password", password)
)
);
if (GetAttributeValue("TestMode").AsBoolean())
{
rootElement.Add(new XElement("TestMode", "YES"));
}
rootElement.Add(new XElement("ReturnResultURL", GetAttributeValue("ReturnURL")));
XElement orderElement = new XElement("Order");
rootElement.Add(orderElement);
if (billingCodeAttribute != null)
{
string billingCode = workflow.GetAttributeValue(billingCodeAttribute.Key);
Guid? campusGuid = billingCode.AsGuidOrNull();
if (campusGuid.HasValue)
{
var campus = CampusCache.Read(campusGuid.Value);
if (campus != null)
{
billingCode = campus.Name;
}
}
orderElement.Add(new XElement("BillingReferenceCode", billingCode));
}
XElement subjectElement = new XElement("Subject",
new XElement("FirstName", person.FirstName),
new XElement("MiddleName", person.MiddleName),
new XElement("LastName", person.LastName)
);
orderElement.Add(subjectElement);
if (person.SuffixValue != null)
{
subjectElement.Add(new XElement("Generation", person.SuffixValue.Value));
}
if (person.BirthDate.HasValue)
{
subjectElement.Add(new XElement("DOB", person.BirthDate.Value.ToString("MM/dd/yyyy")));
}
if (ssnAttribute != null)
{
string ssn = Encryption.DecryptString(workflow.GetAttributeValue(ssnAttribute.Key)).AsNumeric();
if (!string.IsNullOrWhiteSpace(ssn) && ssn.Length == 9)
{
subjectElement.Add(new XElement("SSN", ssn.Insert(5, "-").Insert(3, "-")));
}
}
if (person.Gender == Gender.Male)
{
subjectElement.Add(new XElement("Gender", "Male"));
}
if (person.Gender == Gender.Female)
{
subjectElement.Add(new XElement("Gender", "Female"));
}
string dlNumber = person.GetAttributeValue("com.sparkdevnetwork.DLNumber");
if (!string.IsNullOrWhiteSpace(dlNumber))
{
subjectElement.Add(new XElement("DLNumber", dlNumber));
}
if (!string.IsNullOrWhiteSpace(person.Email))
{
subjectElement.Add(new XElement("EmailAddress", person.Email));
}
var homelocation = person.GetHomeLocation();
if (homelocation != null)
{
subjectElement.Add(new XElement("CurrentAddress",
new XElement("StreetAddress", homelocation.Street1),
new XElement("City", homelocation.City),
new XElement("State", homelocation.State),
new XElement("Zipcode", homelocation.PostalCode)
));
}
XElement aliasesElement = new XElement("Aliases");
if (person.NickName != person.FirstName)
{
aliasesElement.Add(new XElement("Alias", new XElement("FirstName", person.NickName)));
}
foreach (var previousName in person.GetPreviousNames())
{
aliasesElement.Add(new XElement("Alias", new XElement("LastName", previousName.LastName)));
}
if (aliasesElement.HasElements)
{
subjectElement.Add(aliasesElement);
}
DefinedValueCache pkgTypeDefinedValue = null;
string packageName = "BASIC";
string county = string.Empty;
string state = string.Empty;
string mvrJurisdiction = string.Empty;
string mvrState = string.Empty;
if (requestTypeAttribute != null)
{
pkgTypeDefinedValue = DefinedValueCache.Read(workflow.GetAttributeValue(requestTypeAttribute.Key).AsGuid());
if (pkgTypeDefinedValue != null)
{
if (pkgTypeDefinedValue.Attributes == null)
{
pkgTypeDefinedValue.LoadAttributes(rockContext);
}
packageName = pkgTypeDefinedValue.GetAttributeValue("PMMPackageName");
county = pkgTypeDefinedValue.GetAttributeValue("DefaultCounty");
state = pkgTypeDefinedValue.GetAttributeValue("DefaultState");
Guid?mvrJurisdictionGuid = pkgTypeDefinedValue.GetAttributeValue("MVRJurisdiction").AsGuidOrNull();
if (mvrJurisdictionGuid.HasValue)
{
var mvrJurisdictionDv = DefinedValueCache.Read(mvrJurisdictionGuid.Value);
if (mvrJurisdictionDv != null)
{
mvrJurisdiction = mvrJurisdictionDv.Value;
if (mvrJurisdiction.Length >= 2)
{
mvrState = mvrJurisdiction.Left(2);
}
}
}
if (homelocation != null)
{
if (!string.IsNullOrWhiteSpace(homelocation.County) &&
pkgTypeDefinedValue.GetAttributeValue("SendHomeCounty").AsBoolean())
{
county = homelocation.County;
}
if (!string.IsNullOrWhiteSpace(homelocation.State))
{
if (pkgTypeDefinedValue.GetAttributeValue("SendHomeState").AsBoolean())
{
state = homelocation.State;
}
if (pkgTypeDefinedValue.GetAttributeValue("SendHomeStateMVR").AsBoolean())
{
mvrState = homelocation.State;
}
}
}
}
}
if (!string.IsNullOrWhiteSpace(packageName))
{
orderElement.Add(new XElement("PackageServiceCode", packageName,
new XAttribute("OrderId", workflow.Id.ToString())));
if (packageName.Trim().Equals("BASIC", StringComparison.OrdinalIgnoreCase) ||
packageName.Trim().Equals("PLUS", StringComparison.OrdinalIgnoreCase))
{
orderElement.Add(new XElement("OrderDetail",
new XAttribute("OrderId", workflow.Id.ToString()),
new XAttribute("ServiceCode", "combo")));
}
}
if (!string.IsNullOrWhiteSpace(county) ||
!string.IsNullOrWhiteSpace(state))
{
orderElement.Add(new XElement("OrderDetail",
new XAttribute("OrderId", workflow.Id.ToString()),
new XAttribute("ServiceCode", string.IsNullOrWhiteSpace(county) ? "StateCriminal" : "CountyCrim"),
new XElement("County", county),
new XElement("State", state),
new XElement("YearsToSearch", 7),
new XElement("CourtDocsRequested", "NO"),
new XElement("RushRequested", "NO"),
new XElement("SpecialInstructions", ""))
);
}
if (!string.IsNullOrWhiteSpace(mvrJurisdiction) && !string.IsNullOrWhiteSpace(mvrState))
{
orderElement.Add(new XElement("OrderDetail",
new XAttribute("OrderId", workflow.Id.ToString()),
new XAttribute("ServiceCode", "MVR"),
new XElement("JurisdictionCode", mvrJurisdiction),
new XElement("State", mvrState))
);
}
XDocument xdoc = new XDocument(new XDeclaration("1.0", "UTF-8", "yes"), rootElement);
var requestDateTime = RockDateTime.Now;
XDocument xResult = PostToWebService(xdoc, GetAttributeValue("RequestURL"));
var responseDateTime = RockDateTime.Now;
int?personAliasId = person.PrimaryAliasId;
if (personAliasId.HasValue)
{
// Create a background check file
using (var newRockContext = new RockContext())
{
var backgroundCheckService = new BackgroundCheckService(newRockContext);
var backgroundCheck = backgroundCheckService.Queryable()
.Where(c =>
c.WorkflowId.HasValue &&
c.WorkflowId.Value == workflow.Id)
.FirstOrDefault();
if (backgroundCheck == null)
{
backgroundCheck = new Rock.Model.BackgroundCheck();
backgroundCheck.PersonAliasId = personAliasId.Value;
backgroundCheck.WorkflowId = workflow.Id;
backgroundCheckService.Add(backgroundCheck);
}
backgroundCheck.RequestDate = RockDateTime.Now;
// Clear any SSN nodes before saving XML to record
foreach (var xSSNElement in xdoc.Descendants("SSN"))
{
xSSNElement.Value = "XXX-XX-XXXX";
}
foreach (var xSSNElement in xResult.Descendants("SSN"))
{
xSSNElement.Value = "XXX-XX-XXXX";
}
backgroundCheck.ResponseXml = string.Format(@"
Request XML ({0}):
------------------------
{1}
Response XML ({2}):
------------------------
{3}
", requestDateTime, xdoc.ToString(), responseDateTime, xResult.ToString());
newRockContext.SaveChanges();
}
}
using (var newRockContext = new RockContext())
{
var handledErrorMessages = new List <string>();
bool createdNewAttribute = false;
if (_HTTPStatusCode == HttpStatusCode.OK)
{
var xOrderXML = xResult.Elements("OrderXML").FirstOrDefault();
if (xOrderXML != null)
{
var xStatus = xOrderXML.Elements("Status").FirstOrDefault();
if (xStatus != null)
{
if (SaveAttributeValue(workflow, "RequestStatus", xStatus.Value,
FieldTypeCache.Read(Rock.SystemGuid.FieldType.TEXT.AsGuid()), newRockContext, null))
{
createdNewAttribute = true;
}
}
handledErrorMessages.AddRange(xOrderXML.Elements("Message").Select(x => x.Value).ToList());
var xErrors = xOrderXML.Elements("Errors").FirstOrDefault();
if (xErrors != null)
{
handledErrorMessages.AddRange(xOrderXML.Elements("Message").Select(x => x.Value).ToList());
}
if (xResult.Root.Descendants().Count() > 0)
{
SaveResults(xResult, workflow, rockContext, false);
}
}
}
else
{
handledErrorMessages.Add("Invalid HttpStatusCode: " + _HTTPStatusCode.ToString());
}
if (handledErrorMessages.Any())
{
if (SaveAttributeValue(workflow, "RequestMessage", handledErrorMessages.AsDelimited(Environment.NewLine),
FieldTypeCache.Read(Rock.SystemGuid.FieldType.TEXT.AsGuid()), newRockContext, null))
{
createdNewAttribute = true;
}
}
newRockContext.SaveChanges();
if (createdNewAttribute)
{
AttributeCache.FlushEntityAttributes();
}
return(true);
}
}
catch (Exception ex)
{
ExceptionLogService.LogException(ex, null);
errorMessages.Add(ex.Message);
return(false);
}
}
/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
public override bool Execute(RockContext rockContext, WorkflowAction action, Object entity, out List <string> errorMessages)
{
errorMessages = new List <string>();
string updateValue = GetAttributeValue(action, "Value");
Guid? valueGuid = updateValue.AsGuidOrNull();
if (valueGuid.HasValue)
{
updateValue = action.GetWorkflowAttributeValue(valueGuid.Value);
// if the value is null no workflow attribute was found for that guid so use the actual guid as the value
if (updateValue == null)
{
updateValue = valueGuid.Value.ToString();
}
}
else
{
updateValue = updateValue.ResolveMergeFields(GetMergeFields(action));
}
string personAttribute = GetAttributeValue(action, "PersonAttribute");
Guid guid = personAttribute.AsGuid();
if (!guid.IsEmpty())
{
var attribute = AttributeCache.Get(guid, rockContext);
if (attribute != null)
{
string value = GetAttributeValue(action, "Person");
guid = value.AsGuid();
if (!guid.IsEmpty())
{
var attributePerson = AttributeCache.Get(guid, rockContext);
if (attributePerson != null)
{
string attributePersonValue = action.GetWorkflowAttributeValue(guid);
if (!string.IsNullOrWhiteSpace(attributePersonValue))
{
if (attributePerson.FieldType.Class == "Rock.Field.Types.PersonFieldType")
{
Guid personAliasGuid = attributePersonValue.AsGuid();
if (!personAliasGuid.IsEmpty())
{
var person = new PersonAliasService(rockContext).Queryable()
.Where(a => a.Guid.Equals(personAliasGuid))
.Select(a => a.Person)
.FirstOrDefault();
if (person != null)
{
// update person attribute
person.LoadAttributes();
string originalValue = person.GetAttributeValue(attribute.Key);
// Handle encrypted text fields as well.
if (attribute.FieldType.Field is Field.Types.EncryptedTextFieldType)
{
updateValue = Security.Encryption.EncryptString(updateValue);
}
Rock.Attribute.Helper.SaveAttributeValue(person, attribute, updateValue, rockContext);
action.AddLogEntry(string.Format("Set '{0}' attribute to '{1}'.", attribute.Name, updateValue));
return(true);
}
else
{
errorMessages.Add(string.Format("Person could not be found for selected value ('{0}')!", guid.ToString()));
}
}
}
else
{
errorMessages.Add("The attribute used to provide the person was not of type 'Person'.");
}
}
}
}
}
else
{
errorMessages.Add(string.Format("Person attribute could not be found for '{0}'!", guid.ToString()));
}
}
else
{
errorMessages.Add(string.Format("Selected person attribute ('{0}') was not a valid Guid!", personAttribute));
}
errorMessages.ForEach(m => action.AddLogEntry(m, true));
return(true);
}
public override bool SendRequest(RockContext rockContext, Workflow workflow, AttributeCache personAttribute, AttributeCache ssnAttribute, AttributeCache requestTypeAttribute, AttributeCache billingCodeAttribute, out List <string> errorMessages)
{
errorMessages = new List <string>();
rockContext.SaveChanges();
// Check to make sure workflow is not null
if (workflow == null || workflow.Id == 0)
{
errorMessages.Add("The 'Protect My Ministry' background check provider requires a valid persisted workflow.");
return(false);
}
workflow.LoadAttributes();
// Get the person that the request is for
Person person = null;
if (personAttribute != null)
{
Guid?personAliasGuid = workflow.GetAttributeValue(personAttribute.Key).AsGuidOrNull();
if (personAliasGuid.HasValue)
{
person = new PersonAliasService(rockContext).Queryable()
.Where(p => p.Guid.Equals(personAliasGuid.Value))
.Select(p => p.Person)
.FirstOrDefault();
person.LoadAttributes(rockContext);
}
}
if (person == null)
{
errorMessages.Add("The 'Protect My Ministry' background check provider requires the workflow to have a 'Person' attribute that contains the person who the background check is for.");
return(false);
}
string billingCode = workflow.GetAttributeValue(billingCodeAttribute.Key);
Guid? campusGuid = billingCode.AsGuidOrNull();
if (campusGuid.HasValue)
{
var campus = CampusCache.Read(campusGuid.Value);
if (campus != null)
{
billingCode = campus.Name;
}
}
string ssn = Encryption.DecryptString(workflow.GetAttributeValue(ssnAttribute.Key));
DefinedValueCache requestType = DefinedValueCache.Read(workflow.GetAttributeValue(requestTypeAttribute.Key).AsGuid());
if (requestType == null)
{
errorMessages.Add("Unknown request type.");
return(false);
}
int orderId = workflow.Id;
string requestTypePackageName = requestType.GetAttributeValue("PMMPackageName").Trim();
BackgroundCheck bgCheck = getBgCheck(rockContext, workflow, person.PrimaryAliasId.Value);
List <string[]> SSNTraceCounties = null;
if (requestTypePackageName.Equals("PLUS", StringComparison.OrdinalIgnoreCase) && !String.IsNullOrWhiteSpace(bgCheck.ResponseXml))
{
IEnumerable <XElement> transactions = XDocument.Parse(bgCheck.ResponseXml).Root.Elements("Transaction");
IEnumerable <XElement> OrderXMLs = transactions.SelectMany(x => x.Elements("OrderXML"));
IEnumerable <XElement> Orders = OrderXMLs.Select(x => x.Element("Order")).Where(x => x != null);
IEnumerable <XElement> OrderDetails = Orders.SelectMany(x => x.Elements("OrderDetail"));
IEnumerable <XElement> SSNTraces = OrderDetails.Where(x => x.Attribute("ServiceCode")?.Value == "SSNTrace" && x.Element("Status") != null);
IEnumerable <XElement> SSNTraceResults = SSNTraces.Select(x => x.Element("Result"));
IEnumerable <XElement> SSNTraceIndividuals = SSNTraceResults.SelectMany(x => x.Elements("Individual"));
IEnumerable <XElement> SSNTraceIndividualsToSearch = SSNTraceIndividuals.Where(x => x.Element("EndDate") == null || x.Element("EndDate").Element("Year") == null || (x.Element("EndDate").Element("Year").Value.AsInteger() > (DateTime.Now.Year - 8)));
SSNTraceCounties = SSNTraceIndividualsToSearch.Where(x => x.Element("County") != null && x.Element("State") != null).Select(x => new string[] { x.Element("County").Value, x.Element("State").Value }).ToList();
}
XElement xTransaction = makeBGRequest(bgCheck, ssn, requestType, billingCode, SSNTraceCounties);
saveTransaction(rockContext, bgCheck, xTransaction);
handleTransaction(rockContext, bgCheck, xTransaction);
return(true);
//catch (Exception ex)
//{
// ExceptionLogService.LogException(ex, null);
// errorMessages.Add(ex.Message);
// return false;
//}
}
/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
public override bool Execute(RockContext rockContext, WorkflowAction action, Object entity, out List <string> errorMessages)
{
errorMessages = new List <string>();
string updateValue = GetAttributeValue(action, "Value");
Guid? valueGuid = updateValue.AsGuidOrNull();
if (valueGuid.HasValue)
{
updateValue = action.GetWorklowAttributeValue(valueGuid.Value);
}
else
{
updateValue = updateValue.ResolveMergeFields(GetMergeFields(action));
}
string personAttribute = GetAttributeValue(action, "PersonAttribute");
Guid guid = personAttribute.AsGuid();
if (!guid.IsEmpty())
{
var attribute = AttributeCache.Read(guid, rockContext);
if (attribute != null)
{
string value = GetAttributeValue(action, "Person");
guid = value.AsGuid();
if (!guid.IsEmpty())
{
var attributePerson = AttributeCache.Read(guid, rockContext);
if (attributePerson != null)
{
string attributePersonValue = action.GetWorklowAttributeValue(guid);
if (!string.IsNullOrWhiteSpace(attributePersonValue))
{
if (attributePerson.FieldType.Class == "Rock.Field.Types.PersonFieldType")
{
Guid personAliasGuid = attributePersonValue.AsGuid();
if (!personAliasGuid.IsEmpty())
{
var person = new PersonAliasService(rockContext).Queryable()
.Where(a => a.Guid.Equals(personAliasGuid))
.Select(a => a.Person)
.FirstOrDefault();
if (person != null)
{
// update person attribute
person.LoadAttributes();
string originalValue = person.GetAttributeValue(attribute.Key);
// Handle encrypted text fields as well.
if (attribute.FieldType.Field is Field.Types.EncryptedTextFieldType)
{
updateValue = Security.Encryption.EncryptString(updateValue);
}
Rock.Attribute.Helper.SaveAttributeValue(person, attribute, updateValue, rockContext);
if ((originalValue ?? string.Empty).Trim() != (updateValue ?? string.Empty).Trim())
{
var changes = new List <string>();
string formattedOriginalValue = string.Empty;
if (!string.IsNullOrWhiteSpace(originalValue))
{
formattedOriginalValue = attribute.FieldType.Field.FormatValue(null, originalValue, attribute.QualifierValues, false);
}
string formattedNewValue = string.Empty;
if (!string.IsNullOrWhiteSpace(updateValue))
{
formattedNewValue = attribute.FieldType.Field.FormatValue(null, updateValue, attribute.QualifierValues, false);
}
History.EvaluateChange(changes, attribute.Name, formattedOriginalValue, formattedNewValue, attribute.FieldType.Field.IsSensitive());
if (changes.Any())
{
HistoryService.SaveChanges(rockContext, typeof(Person),
Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
person.Id, changes);
}
}
action.AddLogEntry(string.Format("Set '{0}' attribute to '{1}'.", attribute.Name, updateValue));
return(true);
}
else
{
errorMessages.Add(string.Format("Person could not be found for selected value ('{0}')!", guid.ToString()));
}
}
}
else
{
errorMessages.Add("The attribute used to provide the person was not of type 'Person'.");
}
}
}
}
}
else
{
errorMessages.Add(string.Format("Person attribute could not be found for '{0}'!", guid.ToString()));
}
}
else
{
errorMessages.Add(string.Format("Selected person attribute ('{0}') was not a valid Guid!", personAttribute));
}
errorMessages.ForEach(m => action.AddLogEntry(m, true));
return(true);
}
/// <summary>
/// Sends a background request to Trak-1
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="workflow">The Workflow initiating the request.</param>
/// <param name="personAttribute">The person attribute.</param>
/// <param name="ssnAttribute">The SSN attribute.</param>
/// <param name="requestTypeAttribute">The request type attribute.</param>
/// <param name="billingCodeAttribute">The billing code attribute.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns>
/// True/False value of whether the request was successfully sent or not
/// </returns>
/// <exception cref="System.NotImplementedException"></exception>
/// <remarks>
/// Note: If the associated workflow type does not have attributes with the following keys, they
/// will automatically be added to the workflow type configuration in order to store the results
/// of the background check request
/// RequestStatus: The request status returned by request
/// RequestMessage: Any error messages returned by request
/// ReportStatus: The report status returned
/// ReportLink: The location of the background report on server
/// ReportRecommendation: Recomendataion
/// Report (BinaryFile): The downloaded background report
/// </remarks>
public override bool SendRequest(RockContext rockContext, Rock.Model.Workflow workflow,
AttributeCache personAttribute, AttributeCache ssnAttribute, AttributeCache requestTypeAttribute,
AttributeCache billingCodeAttribute, out List <string> errorMessages)
{
errorMessages = new List <string>();
try
{
// Check to make sure workflow is not null
if (workflow == null)
{
errorMessages.Add("Trak-1 background check provider requires a valid workflow.");
return(false);
}
// Get the person that the request is for
Person person = null;
if (personAttribute != null)
{
Guid?personAliasGuid = workflow.GetAttributeValue(personAttribute.Key).AsGuidOrNull();
if (personAliasGuid.HasValue)
{
person = new PersonAliasService(rockContext).Queryable()
.Where(p => p.Guid.Equals(personAliasGuid.Value))
.Select(p => p.Person)
.FirstOrDefault();
person.LoadAttributes(rockContext);
}
}
if (person == null)
{
errorMessages.Add("Trak-1 background check provider requires the workflow to have a 'Person' attribute that contains the person who the background check is for.");
return(false);
}
//Get required fields from workflow
var packageList = GetPackageList();
var packageName = workflow.GetAttributeValue(requestTypeAttribute.Key);
// If this is a defined value, fetch the value
if (requestTypeAttribute.FieldType.Guid.ToString().ToUpper() == Rock.SystemGuid.FieldType.DEFINED_VALUE)
{
packageName = DefinedValueCache.Get(packageName).Value;
}
var package = packageList.Where(p => p.PackageName == packageName).FirstOrDefault();
if (package == null)
{
errorMessages.Add("Package name not valid");
return(false);
}
var requiredFields = package.Components.SelectMany(c => c.RequiredFields).ToList();
var requiredFieldsDict = new Dictionary <string, string>();
foreach (var field in requiredFields)
{
if (!workflow.Attributes.ContainsKey(field.Name))
{
errorMessages.Add("Workflow does not contain attribute for required field " + field.Name);
return(false);
}
requiredFieldsDict[field.Name] = workflow.GetAttributeValue(field.Name);
}
//Generate Request
var authentication = new Trak1Authentication
{
UserName = GetAttributeValue("UserName"),
SubscriberCode = Encryption.DecryptString(GetAttributeValue("SubscriberCode")),
CompanyCode = Encryption.DecryptString(GetAttributeValue("CompanyCode")),
BranchName = "Main"
};
var ssn = "";
if (ssnAttribute != null)
{
ssn = Rock.Field.Types.SSNFieldType.UnencryptAndClean(workflow.GetAttributeValue(ssnAttribute.Key));
if (!string.IsNullOrWhiteSpace(ssn) && ssn.Length == 9)
{
ssn = ssn.Insert(5, "-").Insert(3, "-");
}
}
Location homeLocation = null;
var homeAddressDv = DefinedValueCache.Get(Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_HOME);
foreach (var family in person.GetFamilies(rockContext))
{
var loc = family.GroupLocations
.Where(l =>
l.GroupLocationTypeValueId == homeAddressDv.Id)
.Select(l => l.Location)
.FirstOrDefault();
if (loc != null)
{
homeLocation = loc;
}
}
if (homeLocation == null)
{
errorMessages.Add("A valid home location to submit a Trak-1 background check.");
return(false);
}
var applicant = new Trak1Applicant
{
SSN = ssn,
FirstName = person.FirstName,
MiddleName = person.MiddleName,
LastName = person.LastName,
DateOfBirth = (person.BirthDate ?? new DateTime()).ToString("yyyy-MM-dd"),
Address1 = homeLocation.Street1,
Address2 = homeLocation.Street2,
City = homeLocation.City,
State = homeLocation.State,
Zip = homeLocation.PostalCode,
RequiredFields = requiredFieldsDict
};
var request = new Trak1Request
{
Authentication = authentication,
Applicant = applicant,
PackageName = packageName
};
var content = JsonConvert.SerializeObject(request);
Trak1Response response = null;
using (var client = new HttpClient(new HttpClientHandler()))
{
client.BaseAddress = new Uri(GetAttributeValue("RequestURL"));
var clientResponse = client.PostAsync("", new StringContent(content, Encoding.UTF8, "application/json")).Result.Content.ReadAsStringAsync().Result;
response = JsonConvert.DeserializeObject <Trak1Response>(clientResponse);
}
if (!string.IsNullOrWhiteSpace(response.Error?.Message))
{
errorMessages.Add(response.Error.Message);
return(false);
}
var transactionId = response.TransactionId;
int?personAliasId = person.PrimaryAliasId;
if (personAliasId.HasValue)
{
// Create a background check file
using (var newRockContext = new RockContext())
{
var backgroundCheckService = new BackgroundCheckService(newRockContext);
var backgroundCheck = backgroundCheckService.Queryable()
.Where(c =>
c.WorkflowId.HasValue &&
c.WorkflowId.Value == workflow.Id)
.FirstOrDefault();
if (backgroundCheck == null)
{
backgroundCheck = new Rock.Model.BackgroundCheck();
backgroundCheck.PersonAliasId = personAliasId.Value;
backgroundCheck.WorkflowId = workflow.Id;
backgroundCheckService.Add(backgroundCheck);
}
backgroundCheck.RequestDate = RockDateTime.Now;
backgroundCheck.RequestId = transactionId.ToString();
backgroundCheck.PackageName = request.PackageName;
newRockContext.SaveChanges();
}
}
return(true);
}
catch (Exception ex)
{
ExceptionLogService.LogException(ex, null);
errorMessages.Add(ex.Message);
return(false);
}
}