public async Task <IHttpActionResult> ServiceAppointmentEventListenerUpdate(PayloadParent payloadResponse)
{
string ActionName = "ServiceAppointmentEventListenerUpdate";
//Log the request
var logCommand = new LogCommand
{
User = User,
LoggingInstance = _loggingInstance,
LogMessage = $"{Controller}.{ActionName} Starting input parameter PayloadParent = {JsonConvert.SerializeObject(payloadResponse)}"
};
_logHandler.ReplayId = LoggingHelper.GetReplayId(JsonConvert.SerializeObject(payloadResponse));
_logHandler.HandleLog(logCommand);
//Await the response
var results = await _SchedulingService.SimpleServiceAppointmentHandler(payloadResponse, logCommand);
//Log the response
logCommand.LogMessage =
$"CustomerController.TaskEventListenerInsert completed. Output value End of controller";
_logHandler.HandleLog(logCommand);
//Return the results
return(ReturnFormattedResults(results));
}
public async Task <LkpLeadStatus> GetLkpLeadStatusFromGuid(Guid LkpLeadStatusGuid, LogCommand logCommand)
{
//Logging Helper for Method
const string methodName = "GetLkpLeadStatusFromGuid";
//Query Used by Dapper
var query =
" SELECT * from " + RepositoryTable +
" where LeadStatusGuid = @LkpLeadStatusGuid";
//Log the input
logCommand.LogMessage = $"{Repository}.{methodName} Starting input parameter LkpLeadStatusGuid={LkpLeadStatusGuid}" + Environment.NewLine +
$"Query: {query}";
_logHandler.HandleLog(logCommand);
using (var connection = _connectionFactory.GetConnection)
{
//Await the response
var _LkpLeadStatus = await connection.QueryFirstAsync <LkpLeadStatus>(query, new{ LkpLeadStatusGuid });
connection.Close();
//Log the output
logCommand.LogMessage = $"{Repository}.{methodName} completed";
_logHandler.HandleLog(logCommand);
return(_LkpLeadStatus);
}
}
public async Task <IEnumerable <Usage> > GetUsage(SearchUsage searchUsage, LogCommand logCommand)
{
//Logging Helper for Method
const string methodName = "GetUsage";
//Query Used by Dapper
var whereClause = searchUsage.getWhereClause();
var query =
" SELECT * from " + RepositoryTableUsage + " "
+ whereClause;
//Log the input
logCommand.LogMessage = $"{Repository}.{methodName} Starting input parameter _SearchUsage={JsonConvert.SerializeObject(searchUsage)}" + Environment.NewLine +
$"Query: {query}";
_logHandler.HandleLog(logCommand);
using (var connection = _connectionFactory.GetConnection)
{
//Await the response
var usage = await connection.QueryAsync <Usage>(query);
connection.Close();
//Log the output
logCommand.LogMessage = $"{Repository}.{methodName} completed";
_logHandler.HandleLog(logCommand);
return(usage);
}
}
public async Task <Account> GetAccountSingle(Guid AccountGuid, string SFAccountID, LogCommand logCommand)
{
//Logging Helper for Method
const string methodName = "GetAccountFromGuid";
//Query Used by Dapper
var query =
$" select * from {AccountTable} " +
" where AccountGuid = @AccountGuid || ( SFAccountID = @SFAccountID and SFAccountID is not null )";
//Log the input
logCommand.LogMessage = $"{Repository}.{methodName} Starting input parameters: AccountGuid={AccountGuid}, SFAccountID={SFAccountID}" + Environment.NewLine +
$"Query: {query}";
_logHandler.HandleLog(logCommand);
using (var connection = _connectionFactory.GetConnection)
{
//Await the response
var account = await connection.QueryFirstAsync <Account>(query, new { AccountGuid });
connection.Close();
//Log the output
logCommand.LogMessage = $"{Repository}.{methodName} completed";
_logHandler.HandleLog(logCommand);
return(account);
}
}
public async Task <int> InsertAuditRecord(CdcAuditEntity auditEntity, LogCommand logCommand)
{
//Logging Helper for Method
var method_name = "InsertAuditRecord";
var query = " insert into [CDCQueue].[AuditLog] " +
" ([AuditLogGuid] " +
", [ObjectType] " +
", [RecordID] " +
", [EventType] " +
", [CreatedDate] " +
", [CreatedById] " +
", [LastModifiedDate] " +
", [LastModifiedById]) " +
" Values " +
" (@AuditLogGuid, @ObjectType, @RecordID, @EventType, @CreatedDate, @CreatedById, @LastModifiedDate, @LastModifiedById); ";
//Log the input
logCommand.LogMessage = $"{Repository}.{method_name} Starting input parameters _Lead = {JsonConvert.SerializeObject(auditEntity)}" + Environment.NewLine +
$"Query: {query}";
_logHandler.HandleLog(logCommand);
using (var connection = _connectionFactory.GetConnection)
{
//Await the response
var returnValue = await connection.ExecuteAsync(query, auditEntity);
connection.Close();
//Log the output
logCommand.LogMessage = $"{Repository}.{method_name} completed";
_logHandler.HandleLog(logCommand);
return(returnValue);
}
}
public async Task <ERMSCustomer> GetERMSCustomer(Guid CustomerGuid, LogCommand logCommand)
{
try
{
//Logging Helper for Method
const string methodName = "GetAccountFromGuid";
//Query Used by Dapper
var query =
$" select * from {ERMSCustomerTable} " +
" where CustomerGuid = @CustomerGuid ";
//Log the input
logCommand.LogMessage = $"{Repository}.{methodName} Starting input parameters: CustomerGuid={CustomerGuid}" + Environment.NewLine +
$"Query: {query}";
_logHandler.HandleLog(logCommand);
using (var connection = _connectionFactory.GetConnection)
{
//Await the response
var ermsCustomer = await connection.QueryFirstOrDefaultAsync <ERMSCustomer>(query, new { CustomerGuid });
connection.Close();
//Log the output
logCommand.LogMessage = $"{Repository}.{methodName} completed";
_logHandler.HandleLog(logCommand);
return(ermsCustomer);
}
}
catch
{
return(new ERMSCustomer());
}
}
public async Task <GenericServiceResponse> SimpleServiceAppointmentHandler(PayloadParent responseObject, LogCommand logCommand)
{
const string method = "ServiceAppointmentUpdate";
var updateEventState = string.Empty;
try
{
logCommand.LogMessage = $"{Service}.{method} Starting input parameter ResponseObject = {responseObject}";
_logHandler.HandleLog(logCommand);
var serviceAppointmentPayload = new ServiceAppointmentPayload(responseObject);
logCommand.LogMessage = $"{Service}.{method} Starting input parameter serviceAppointmentPayload = {serviceAppointmentPayload}";
_logHandler.HandleLog(logCommand);
Guid programGuid;
//ProgramGuid
updateEventState = "Attempting To Get Program Guid" + Environment.NewLine;
if (!string.IsNullOrEmpty(serviceAppointmentPayload._PayloadHeader.SalesforceProgramIDC))
{
var program = await _programRepository.GetProgramFromSFID(serviceAppointmentPayload._PayloadHeader.SalesforceProgramIDC, logCommand);
programGuid = program.ProgramGuid;
}
else
{
//SubProgramGuid ProgramGuid
// programGuid = Guid.Parse("8CC20C6D-13C2-424B-9EB3-194F653CC778");
throw new Exception($"Error: {Service}.{method} -- Missing SalesforceProgramID ");
}
////SubprogramGuid
//updateEventState = "Attempting To Get SubProgram Guid" + Environment.NewLine;
//if (!string.IsNullOrEmpty(serviceAppointmentPayload._PayloadHeader.SalesforceSubProgramIDC))
//{
// var subprogram = await _programRepository.GetSubProgramSFID(serviceAppointmentPayload._PayloadHeader.SalesforceSubProgramIDC, logCommand);
// subprogramGuid = subprogram.SubProgramGuid;
//}
//else
//{
// subprogramGuid = Guid.Parse("FB02657F-3985-4F06-84C3-1669BE2F2991");
//}
updateEventState = "Attempting to Check Dates" + Environment.NewLine;
if (serviceAppointmentPayload._PayloadBody.ServiceAppointment.SchedStartTime == null)
{
throw new Exception($"Error: {Service}.{method} -- Missing SchedStartTime ");
}
var scheduleStartTime = (DateTime)serviceAppointmentPayload._PayloadBody.ServiceAppointment.SchedStartTime;
if (!DateTime.TryParse(serviceAppointmentPayload._PayloadBody.ServiceAppointment.LastModifiedDate,
out var lastModifiedDate))
{
lastModifiedDate = DateTime.Now;
}
updateEventState = "Attempting to Map dataObject" + Environment.NewLine;
var schedulingDataObject = new SimpleScheduling
{
SfRecordID = serviceAppointmentPayload._PayloadHeader.RecordIdC,
ProgramGuid = programGuid,
SalesforceUser = serviceAppointmentPayload._PayloadBody.ServiceAppointment.LastModifiedById,
Technician = serviceAppointmentPayload._PayloadBody.ServiceAppointment.TechnicianGuidC,
WorkOrderType = serviceAppointmentPayload._PayloadBody.WorkOrder.WorkTypeId,
ScheduleBit = true,
ScheduleDateTime = scheduleStartTime,
LastModifiedDateTime = lastModifiedDate
};
if (string.IsNullOrEmpty(schedulingDataObject.SfRecordID) ||
string.IsNullOrEmpty(schedulingDataObject.WorkOrderType) ||
string.IsNullOrEmpty(schedulingDataObject.SalesforceUser))
{
throw new Exception($"Error: {Service}.{method} -- Missing required fields");
}
updateEventState = "Attempting to Execute First" + Environment.NewLine;
var recordsChanged = await _schedulingRepository.CreateSimpleSchedulingRecordFirst(schedulingDataObject, logCommand);
if (recordsChanged > 0)
{
ServiceResponse = new GenericServiceResponse
{
Entity = $"Record Created in Simple Scheduling, rows affected = {recordsChanged}",
Success = true,
RestResponseStatus = GenericServiceResponse.RestStatus.Success
};
logCommand.LogMessage = string.Format($"{Service}.{method} completed");
_logHandler.HandleLog(logCommand);
return(ServiceResponse);
}
updateEventState = "Attempting to get List" + Environment.NewLine;
var simpleSchedulingList =
(await _schedulingRepository.GetSimpleScheduling(schedulingDataObject.SfRecordID, logCommand)).ToList();
updateEventState = "Attempting to start reschedule logic" + Environment.NewLine;
var simpleSchedulingList0 = simpleSchedulingList.Where(a => a.ScheduleBit == false).ToList();
if (simpleSchedulingList0.Any())
{
updateEventState = "Attempting to Rescheduled [1] " + Environment.NewLine;
var firstOrDefault = simpleSchedulingList0.OrderByDescending(a => a.SSID).FirstOrDefault();
if (
firstOrDefault != null && (schedulingDataObject.SalesforceUser != firstOrDefault.SalesforceUser &&
schedulingDataObject.LastModifiedDateTime > firstOrDefault.LastModifiedDateTime.AddMinutes(+5)
&&
(schedulingDataObject.WorkOrderType != firstOrDefault.WorkOrderType ||
schedulingDataObject.ScheduleDateTime != firstOrDefault.ScheduleDateTime ||
schedulingDataObject.Technician != firstOrDefault.Technician))
)
{
recordsChanged = await _schedulingRepository.CreateSimpleSchedulingRecordReschedule(schedulingDataObject,
logCommand);
}
}
else
{
updateEventState = "Attempting to Rescheduled [2] " + Environment.NewLine;
var firstOrDefault = simpleSchedulingList.OrderByDescending(a => a.SSID)
.FirstOrDefault(a => a.ScheduleBit);
if (firstOrDefault == null)
{
throw new Exception($"Error: {Service}.{method} -- Missing Created Date Record on Reschedule ");
}
if (schedulingDataObject.SalesforceUser != firstOrDefault.SalesforceUser &&
schedulingDataObject.LastModifiedDateTime > firstOrDefault.LastModifiedDateTime.AddMinutes(+30))
{
recordsChanged = await _schedulingRepository.CreateSimpleSchedulingRecordReschedule(schedulingDataObject,
logCommand);
}
}
updateEventState = "Executions Complete" + Environment.NewLine;
ServiceResponse = await InsertAuditRecordAsync(logCommand, responseObject,
schedulingDataObject.GetType().FullName,
serviceAppointmentPayload._PayloadBody.ServiceAppointment.LastModifiedById);
if (!ServiceResponse.Success)
{
return(ServiceResponse);
}
if (recordsChanged >= 1)
{
ServiceResponse = new GenericServiceResponse
{
Entity = $"Successful: Update Scheduling Related Table, rows added/updated = {recordsChanged}",
Success = true,
RestResponseStatus = GenericServiceResponse.RestStatus.Success
};
}
else
{
ServiceResponse = new GenericServiceResponse
{
Entity = $"Failure: Update Scheduling Related Table, rows added/updated = {recordsChanged}",
Success = true,
RestResponseStatus = GenericServiceResponse.RestStatus.Empty
};
}
logCommand.LogMessage = string.Format($"{Service}.{method} completed");
_logHandler.HandleLog(logCommand);
return(ServiceResponse);
}
catch (Exception ex)
{
ex.Data.Add("Point of Failure", updateEventState);
AppLogger.LogException(_loggingInstance, ex.Message, ex);
return(ServiceHelper.SetErrorGenericServiceResponse(ex));
}
}
public IHttpActionResult Intake_SurveyEventListenerInsert(JObject CDCPayload)
{
//UserGuid = GetUserGuidFromHttpContextBase(_httpContextBase);
//if (UserGuid == Guid.Empty) return new HttpActionResult(HttpStatusCode.Unauthorized, "User Validation Error");
//Log the request
var logCommand = new LogCommand
{
User = User,
LoggingInstance = _loggingInstance,
LogMessage = $"CustomerController.ContactEventListenerInsert Starting input parameter CDCPayload = {CDCPayload}"
};
_logHandler.HandleLog(logCommand);
//Await the response
var results = new GenericServiceResponse
{
Entity = "Temp Place Holder",
Success = true,
RestResponseStatus = GenericServiceResponse.RestStatus.Success
};
//Log the response
logCommand.LogMessage =
$"CustomerController.ContactEventListenerInsert completed. Output value End of controller";
_logHandler.HandleLog(logCommand);
//Return the results
return(ReturnFormattedResults(results));
}
public async Task <Program> GetProgramFromAccountGuid(Guid AccountGuid, LogCommand logCommand)
{
//Logging Helper for Method
const string methodName = "GetProgramFromAccountGuid";
//Query Used by Dapper
var query = " select * from " + ProgramTable + " where AccountGuid = @AccountGuid";
//Log the input
logCommand.LogMessage = $"{Repository}.{methodName} Starting input parameter AccountGuid={AccountGuid}" + Environment.NewLine +
$"Query: {query}";
_logHandler.HandleLog(logCommand);
using (var connection = _connectionFactory.GetConnection)
{
//Await the response
var Program = await connection.QueryFirstAsync <Program>(query, new { AccountGuid });
connection.Close();
//Log the output
logCommand.LogMessage = $"{Repository}.{methodName} completed";
_logHandler.HandleLog(logCommand);
return(Program);
}
}
public async Task <GenericServiceResponse> CdcEventAddressCreate(PayloadParent cdcPayload, LogCommand logCommand)
{
const string method = "CdcEventAddressCreate";
var UpdateEventState = string.Empty;
try
{
logCommand.LogMessage = $"{Service}.{method} Starting input parameter cdcPayload = {cdcPayload}";
_logHandler.HandleLog(logCommand);
var addressPayload = new AddressPayload(cdcPayload);
logCommand.LogMessage = $"{Service}.{method} Starting input parameter addressPayload = {addressPayload}";
_logHandler.HandleLog(logCommand);
var recordsAffected = 0;
var response = new GenericServiceResponse
{
Success = true,
RestResponseStatus = GenericServiceResponse.RestStatus.Empty
};
Guid programGuid;
Guid subprogramGuid;
Guid addressTypeGuid;
Guid countyGuid;
Guid ownershipGuid;
string ownershipTypeName = "Rented";
//Customer Guid Check
UpdateEventState = "Attempting to check CustomerGuid" + Environment.NewLine;
if (addressPayload._PayloadHeader.CmcCustomerGuidC == null ||
addressPayload._PayloadHeader.CmcCustomerGuidC == Guid.Empty)
{
throw new Exception($"Error: {Service}.{method} -- Missing Customer Guid ");
}
//Address Record ID
UpdateEventState = "Attempting To check Address Record ID Guid" + Environment.NewLine;
if (string.IsNullOrEmpty(addressPayload._PayloadHeader.RecordIdC))
{
throw new Exception($"Error: {Service}.{method} -- Missing Record ID, Required for Update ");
}
//ProgramGuid
UpdateEventState = "Attempting To Get Program Guid" + Environment.NewLine;
if (!string.IsNullOrEmpty(addressPayload._PayloadHeader.SalesforceProgramIDC))
{
var program = await _programRepository.GetProgramFromSFID(addressPayload._PayloadHeader.SalesforceProgramIDC, logCommand);
programGuid = program.ProgramGuid;
}
else
{
throw new Exception($"Error: {Service}.{method} -- Missing SalesforceProgramID ");
}
//SubprogramGuid
UpdateEventState = "Attempting To Get SubProgram Guid" + Environment.NewLine;
if (!string.IsNullOrEmpty(addressPayload._PayloadHeader.SalesforceSubProgramIDC))
{
var subprogram = await _programRepository.GetSubProgramSFID(addressPayload._PayloadHeader.SalesforceSubProgramIDC, logCommand);
subprogramGuid = subprogram.SubProgramGuid;
}
else
{
subprogramGuid = Guid.Parse("FB02657F-3985-4F06-84C3-1669BE2F2991");
}
//addressTypeGuid setting it to default for now.
UpdateEventState = "Attempting To Get addressTypeGuid" + Environment.NewLine;
if (!string.IsNullOrEmpty(addressPayload._PayloadBody.AddressTypeC))
{
var lkpAccountType = await _addressRepository.GetLKPAddressTypeFromAddressTypeName(addressPayload._PayloadBody.AddressTypeC, logCommand);
addressTypeGuid = lkpAccountType.AddressTypeGuid;
}
else
{
logCommand.LogMessage = string.Format($"Error: {Service}.{method} -- Missing addressTypeGuid ");
_logHandler.HandleLog(logCommand);
response.Entity = "Empty Address Type";
return(response);
}
//CountyGuid setting it to default for now.
UpdateEventState = "Attempting To Get CountyGuid" + Environment.NewLine;
if (addressPayload._PayloadBody.AddressTypeC.ToLower() == "service")
{
if (!string.IsNullOrEmpty(addressPayload._PayloadBody.CountyC))
{
var lkpCounties = await _addressRepository.GetLkpCountyFromCountyDescription(addressPayload._PayloadBody.CountyC, logCommand);
countyGuid = lkpCounties.CountyGuid;
}
else
{
logCommand.LogMessage = string.Format($"Error: {Service}.{method} -- Missing CountyGuid ");
_logHandler.HandleLog(logCommand);
response.Entity = "Empty County";
return(response);
}
}
else
{
countyGuid = Guid.Parse("24C3CDAC-2BB8-46A9-AF92-70E36D0B37F7");
}
//OwnershipGuid setting it to default for now.
UpdateEventState = "Attempting To Get OwnershipGuid" + Environment.NewLine;
if (ownershipTypeName == "Rented")
{
var lkpOwnership = await _addressRepository.GetLkpOwnershipFromOwnershipType("Rented", logCommand);
ownershipGuid = lkpOwnership.OwnershipGuid;
}
else
{
logCommand.LogMessage = string.Format($"Error: {Service}.{method} -- Missing OwnershipGuid ");
_logHandler.HandleLog(logCommand);
}
UpdateEventState = "Attempting To Build Object" + Environment.NewLine;
var address = new Address(addressPayload, addressTypeGuid, countyGuid, ownershipGuid);
//Update Phone
UpdateEventState = "Attempting To Insert/Update" + Environment.NewLine;
if (addressPayload._PayloadBody.Address_SourceC.ToLower() == "program")
{
recordsAffected += await _addressRepository.UpdateProgramServiceAddress(address, logCommand);
if (recordsAffected > 0)
{
response = new GenericServiceResponse
{
Entity = $"Update Address Complete. Rows updated = {recordsAffected}",
Success = true,
RestResponseStatus = GenericServiceResponse.RestStatus.Success
};
}
else
{
response = new GenericServiceResponse
{
Entity = $"Failure - Could not find Record for update, {recordsAffected}. " +
$"Records Affected with required fields: " +
$"-- Customer Guid: {addressPayload._PayloadBody.CmcCustomerGuidC} " +
$"-- Address Source: {addressPayload._PayloadBody.Address_SourceC} " +
$"-- Address Type: {addressPayload._PayloadBody.AddressTypeC} " +
$"-- AddressTypeGuid: {addressTypeGuid} ",
Success = false,
RestResponseStatus = GenericServiceResponse.RestStatus.Success
};
}
}
else
{
recordsAffected += await _addressRepository.InsertAddress(address, logCommand);
if (recordsAffected > 0)
{
response = new GenericServiceResponse
{
Entity = $"Insert Address Related Tables Successful, rows added/updated = {recordsAffected}",
Success = true,
RestResponseStatus = GenericServiceResponse.RestStatus.Error
};
}
else
{
response = new GenericServiceResponse
{
Entity = $"Failure - Could not insert into Address Table",
Success = false,
RestResponseStatus = GenericServiceResponse.RestStatus.Error
};
}
}
logCommand.LogMessage = string.Format($"{Service}.{method} completed");
_logHandler.HandleLog(logCommand);
return(response);
}
catch (Exception ex)
{
ex.Data.Add("Point of Failure", UpdateEventState);
AppLogger.LogException(_loggingInstance, ex.Message, ex);
return(ServiceHelper.SetErrorGenericServiceResponse(ex));
}
}
public async Task <Lead> GetLead(Guid leadGuid, LogCommand logCommand)
{
//Logging Helper for Method
const string methodName = "GetLeadAsync";
//Query Used by Dapper
var query =
" SELECT TOP (100) * from " + LeadTable +
" where LeadId = '" + leadGuid + "'";
//Log the input
logCommand.LogMessage = $"{Repository}.{methodName} Starting input parameter leadGuid={leadGuid}" + Environment.NewLine +
$"Query: {query}";
_logHandler.HandleLog(logCommand);
using (var connection = _connectionFactory.GetConnection)
{
//Await the response
var lead = await connection.QueryFirstAsync <Lead>(query);
connection.Close();
//Log the output
logCommand.LogMessage = $"{Repository}.{methodName} completed";
_logHandler.HandleLog(logCommand);
return(lead);
}
}
public async Task <IHttpActionResult> GetLeads(SearchLeadSimple leadSearcher)
{
//Log the request
var logCommand = new LogCommand
{
User = User,
LoggingInstance = _loggingInstance,
LogMessage = $"LeadController.GetLead Starting input parameter LeadSearcher = {JsonConvert.SerializeObject(leadSearcher)}"
};
_logHandler.HandleLog(logCommand);
//Await the response
var results = await _leadService.GetLead(leadSearcher, logCommand);
//Log the response
logCommand.LogMessage =
$"LeadController.GetLead completed. Output value = {JsonConvert.SerializeObject(results.Entity)}";
_logHandler.HandleLog(logCommand);
//Return the results
return(ReturnFormattedResults(results));
}
public async Task <GenericServiceResponse> GetLead(Guid leadGuid, LogCommand logCommand)
{
const string method = "GetLead";
try
{
logCommand.LogMessage = string.Format($"{Service}.{method} Starting input parameter leadGuid = {0}", leadGuid);
_logHandler.HandleLog(logCommand);
var lead = await _leadRepository.GetLead(leadGuid, logCommand);
var response = ServiceHelper.SetGenericServiceResponseForEntity(lead);
response.Success = true;
logCommand.LogMessage = string.Format($"{Service}.{method} completed");
_logHandler.HandleLog(logCommand);
return(response);
}
catch (Exception ex)
{
AppLogger.LogException(_loggingInstance, ex.Message, ex);
return(ServiceHelper.SetErrorGenericServiceResponse(ex));
}
}
public async Task <IEnumerable <SimpleScheduling> > GetSimpleScheduling(string SfRecordId, LogCommand logCommand)
{
//Logging Helper for Method
const string methodName = "GetSimpleScheduling";
//Query Used by Dapper
var query = " SELECT * from " + SimpleSchedulingTable + " where [SfRecordID] = @SfRecordID ";
//Log the input
logCommand.LogMessage = $"{Repository}.{methodName} Starting: No Input Parameter " + Environment.NewLine +
$"Query: {query}";
_logHandler.HandleLog(logCommand);
using (var connection = _connectionFactory.GetConnection)
{
//Await the response
var _returnModel = await connection.QueryAsync <SimpleScheduling>(query, new { SfRecordId });
connection.Close();
//Log the output
logCommand.LogMessage = $"{Repository}.{methodName} completed";
_logHandler.HandleLog(logCommand);
return(_returnModel);
}
}
