public Changeset GetParentCommit(Changeset commit)
{
var command = new LogCommand().WithRevision(new RevSpec("{0}^".Fmt(commit.Hash))).WithIncludePathActions();
var changesets = _repository.Log(command);
var changeset = changesets.FirstOrDefault();
return changeset;
}
public void Log_WithUnknownArgument_ThrowsMercurialExecutionException()
{
Repo.Init();
var command = new LogCommand();
command.AdditionalArguments.Add("--dummyargument");
Assert.Throws<MercurialExecutionException>(() => Repo.Execute(command));
}
public IEnumerable<RevisionRange> GetFromTillHead(DateTime from, int pageSize)
{
var command = new LogCommand().WithAdditionalArgument("-d >{0:yyyy-MM-dd}".Fmt(from));
var pages = _repository.Log(command)
.Where(ch => ch.Timestamp >= from)
.OrderBy(ch => ch.Timestamp)
.ToArray()
.Split(pageSize);
var result = pages.Select(page => new RevisionRange(page.First().ToRevisionId(), page.Last().ToRevisionId()));
return result;
}
public IEnumerable<RevisionRange> GetAfterTillHead(RevisionId revisionId, int pageSize)
{
var revSpec = new RevSpec(revisionId.Value);
var command = new LogCommand().WithRevision(RevSpec.From(revSpec) && !new RevSpec(revisionId.Value));
var pages = _repository.Log(command)
.OrderBy(ch => ch.Timestamp)
.ToArray()
.Split(pageSize);
var result = pages.Select(page => new RevisionRange(page.First().ToRevisionId(), page.Last().ToRevisionId()));
return result;
}
public IEnumerable<RevisionRange> GetFromAndBefore(RevisionId fromRevision, RevisionId toRevision, int pageSize)
{
var command = new LogCommand();
var pages = _repository.Log(command)
.Where(ch => (ch.Timestamp >= fromRevision.Time.Value && ch.Timestamp <= toRevision.Time.Value))
.OrderBy(ch => ch.Timestamp)
.ToArray()
.Split(pageSize);
var result = pages.Select(page => new RevisionRange(page.First().ToRevisionId(), page.Last().ToRevisionId()));
return result;
}
public void AddEnvironmentVariables()
{
var localRoot = suiteRoot as LocalFileSystemDirectory;
if (localRoot != null)
{
var logCommand = new LogCommand().WithRevision(RevSpec.WorkingDirectoryParent);
Client.Execute(localRoot.AbsolutePath, logCommand);
var changeSet = logCommand.Result.First();
string revNo = changeSet.RevisionNumber.ToString(CultureInfo.InvariantCulture);
log.DebugFormat("Mercurial current revision number is {0}", revNo);
environmentVariableContext.Define("HG_REVNO", revNo);
}
}
public IEnumerable<RevisionRange> GetFromAndBefore(RevisionId fromRevision, RevisionId toRevision, int pageSize)
{
var from = new RevSpec(fromRevision.Value);
var to = new RevSpec(toRevision.Value);
var command = new LogCommand().WithRevision(RevSpec.Range(from, to));
var pages = _repository.Log(command)
.OrderBy(ch => ch.Timestamp)
.ToArray()
.Split(pageSize);
var result = pages.Select(page => new RevisionRange(page.First().ToRevisionId(), page.Last().ToRevisionId()));
return result;
}
/// <summary>
/// A thread safe logger
/// </summary>
/// <param name="m"></param>
public static void Log(LogCommand m)
{
if (!IsMainThread)
{
lock (syncRoot)
{
PendingLogs.Add(m);
}
}
else
{
Write(m);
}
}
public IEnumerable<RevisionRange> GetFromAndBefore(RevisionId fromRevision, RevisionId toRevision, int pageSize)
{
var command = new LogCommand();
if (string.IsNullOrEmpty(fromRevision.Value))
{
if (string.IsNullOrEmpty(toRevision.Value))
{
command = command.WithAdditionalArgument("-d {0:yyyy-MM-dd} to {1:yyyy-MM-dd}".Fmt(fromRevision.Time.Value, toRevision.Time.Value));
}
else
{
var to = new RevSpec(toRevision.Value);
command = command.WithRevision(RevSpec.To(to));
command = command.WithAdditionalArgument("-d >{0:yyyy-MM-dd}".Fmt(fromRevision.Time.Value));
}
}
else
{
var from = new RevSpec(fromRevision.Value);
if (string.IsNullOrEmpty(toRevision.Value))
{
command = command.WithAdditionalArgument("-d <{0:yyyy-MM-dd}".Fmt(toRevision.Time.Value));
command = command.WithRevision(RevSpec.From(from));
}
else
{
var to = new RevSpec(toRevision.Value);
command = command.WithRevision(RevSpec.Range(from, to));
}
}
var pages = _repository.Log(command)
.OrderBy(ch => ch.Timestamp)
.ToArray()
.Split(pageSize);
var result = pages.Select(page => new RevisionRange(page.First().ToRevisionId(), page.Last().ToRevisionId()));
return result;
}
public void Log_WithUnknownArgument_ThrowsMercurialExecutionExceptionThatMentionesArgument()
{
Repo.Init();
var command = new LogCommand();
command.AdditionalArguments.Add("--dummyargument");
try
{
Repo.Execute(command);
}
catch (MercurialExecutionException ex)
{
Assert.That(ex.Message, Is.StringContaining("hg log: option --dummyargument not recognized"));
return;
}
catch (Exception ex)
{
Assert.Fail(string.Format(CultureInfo.InvariantCulture, "Log with unknown argument should not have thrown {0}", ex.GetType().Name));
}
Assert.Fail("Log with unknown argument should have thrown MercurialExecutionException");
}
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 void Log_WithUnknownArgument_ThrowsMercurialExecutionExceptionThatMentionesArgument()
{
Repo.Init();
var command = new LogCommand();
command.AdditionalArguments.Add("--dummyargument");
try
{
Repo.Execute(command);
}
catch (MercurialExecutionException ex)
{
Assert.That(ex.Message, Contains.Substring("hg log: option --dummyargument not recognized"));
return;
}
catch (Exception ex)
{
Assert.Fail(string.Format(CultureInfo.InvariantCulture, "Log with unknown argument should not have thrown {0}", ex.GetType().Name));
}
Assert.Fail("Log with unknown argument should have thrown MercurialExecutionException");
}
public async Task <int> UpdateAccount(Account account, LogCommand logCommand)
{
//Logging Helper for Method
const string methodName = "UpdateAccount";
//Query Used by Dapper
var query =
$" update from {AccountTable} " +
" set [AccountStatusGuid] = @AccountStatusGuid " +
", JobId = @JobId " +
" where SFAccountID = @SFAccountID ";
if (account.AccountStatusGuid == Guid.Empty)
{
throw new Exception("Missing Fields");
}
//Log the input
logCommand.LogMessage = $"{Repository}.{methodName} Starting input parameter account={JsonConvert.SerializeObject(account)}" + Environment.NewLine +
$"Query: {query}";
_logHandler.HandleLog(logCommand);
using (var connection = _connectionFactory.GetConnection)
{
//Await the response
var Records = await connection.ExecuteAsync(query, account);
connection.Close();
//Log the output
logCommand.LogMessage = $"{Repository}.{methodName} completed";
_logHandler.HandleLog(logCommand);
return(Records);
}
}
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());
}
}
/// <summary>
/// Check user rights and execute command with logging
/// </summary>
/// <param name="commandType"></param>
/// <param name="user"></param>
/// <param name="CommandExecutor"></param>
/// <returns></returns>
public virtual LogCommand ExecuteNewCommand(CommandTypes commandType, FaceRecognitionUser user, Func <CommandTypes, CommandResults> CommandExecutor = null)
{
var command = new LogCommand(commandType);
command.StartCommandDate = DateTime.UtcNow;
LogCommandDAL.Add(command);
if (!IsExecutionAllowed(user))
{
command.CommandResult = CommandResults.Fail;
return(command);
}
if (CommandExecutor == null)
{
command.FinishCommandDate = DateTime.UtcNow;
command.CommandResult = CommandResults.Undefined;
LogCommandDAL.Update(command);
return(command);
}
if (command.CommandType == CommandTypes.DoNothingLogOnly)
{
command.FinishCommandDate = DateTime.UtcNow;
command.CommandResult = CommandResults.Success;
LogCommandDAL.Update(command);
return(command);
}
var result = CommandExecutor(commandType);
command.CommandResult = result;
command.FinishCommandDate = DateTime.UtcNow;
LogCommandDAL.Update(command);
return(command);
}
public async Task <IEnumerable <Lead> > GetLeadByCustomerGuidAsync(Guid customerGuid, LogCommand logCommand)
{
//Logging Helper for Method
const string methodName = "GetLeadByCustomerGuidAsync";
//Query Used by Dapper
var query = QueryResources.LeadQueries.ResourceManager.GetString("GetLeadByCustomerGuid");
//Log the input
logCommand.LogMessage = $"{Repository}.{methodName} Starting input parameter customerGuid={customerGuid}" + Environment.NewLine + $"Query: {query}";
_logHandler.HandleLog(logCommand);
using (var connection = _connectionFactory.GetConnection)
{
//Await the response
var lead = await connection.QueryAsync <Lead>(query, new { customerGuid });
connection.Close();
//Log the output
logCommand.LogMessage = $"{Repository}.{methodName} completed";
_logHandler.HandleLog(logCommand);
return(lead);
}
}
public void sendCommand(LogCommand logCommand)
{
string message = JsonConvert.SerializeObject(logCommand);
sendMessage(message);
}
private void LogModifications(DBLoggingAttribute LogAttribute, LogCommand Command)
{
Type objectType = typeof(T);
FieldInfo IDproperty = objectType.GetField("_IDproperty", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
PropertyInfo IDField = objectType.GetProperty(IDproperty.GetValue(null).ToString());
List <LogValue> _LogValues = new List <LogValue>();
if (Command == LogCommand.Save)
{
if (_initial == null)
{
Command = LogCommand.Insert;
}
else
if (Convert.ToInt64(IDField.GetValue(_initial, null)) == 0)
{
Command = LogCommand.Insert;
}
else
{
Command = LogCommand.Modify;
}
}
LogEntry.TableName = "LogEntry_" + Assembly.GetEntryAssembly().GetName().Name;
LogValue.TableName = "LogValue_" + Assembly.GetEntryAssembly().GetName().Name;
foreach (PropertyInfo p in objectType.GetProperties())
{
bool _LogProperty = false;
IList <BaseLogAttribute> CustomLogAttributes = p.GetCustomAttributes(typeof(BaseLogAttribute), true).Cast <BaseLogAttribute>().ToList();
string OldValue = string.Empty;
string NewValue = string.Empty;
if (Command == LogCommand.Modify || Command == LogCommand.Delete)
{
if (p.GetValue(_initial, null) != null)
{
switch (p.PropertyType.ToString())
{
case "System.DateTime":
if ((DateTime)p.GetValue(_initial, null) != DateTime.MinValue)
{
OldValue = ((DateTime)p.GetValue(_initial, null)).ToString("dd/MM/yyyy");
}
break;
case "System.TimeSpan":
OldValue = ((TimeSpan)p.GetValue(_initial, null)).Hours.ToString("00") + "h" + ((TimeSpan)p.GetValue(_initial, null)).Minutes.ToString("00");
break;
case "System.Decimal":
OldValue = ((decimal)p.GetValue(_initial, null)).ToString("0.00");
break;
case "System.Boolean":
if ((bool)p.GetValue(_initial, null))
{
OldValue = "X";
}
break;
default:
OldValue = p.GetValue(_initial, null).ToString();
break;
}
}
}
if (Command == LogCommand.Modify || Command == LogCommand.Insert)
{
if (p.GetValue(this, null) != null)
{
switch (p.PropertyType.ToString())
{
case "System.DateTime":
if ((DateTime)p.GetValue(this, null) != DateTime.MinValue)
{
NewValue = ((DateTime)p.GetValue(this, null)).ToString("dd/MM/yyyy");
}
break;
case "System.TimeSpan":
NewValue = ((TimeSpan)p.GetValue(this, null)).Hours.ToString("00") + "h" + ((TimeSpan)p.GetValue(this, null)).Minutes.ToString("00");
break;
case "System.Decimal":
NewValue = ((decimal)p.GetValue(this, null)).ToString("0.00");
break;
case "System.Boolean":
if ((bool)p.GetValue(this, null))
{
NewValue = "X";
}
break;
default:
NewValue = p.GetValue(this, null).ToString();
break;
}
}
}
if (CustomLogAttributes.Count != 0)
{
foreach (BaseLogAttribute CLA in CustomLogAttributes)
{
if (CLA is LogAttributes)
{
if (((LogAttributes)CLA).LogMe)
{
if (Command == LogCommand.Delete && ((LogAttributes)CLA).OnDelete)
{
_LogProperty = true;
}
if (Command == LogCommand.Insert && ((LogAttributes)CLA).OnNew)
{
_LogProperty = true;
}
if (Command == LogCommand.Modify && ((LogAttributes)CLA).OnEdit)
{
_LogProperty = true;
}
if (((LogAttributes)CLA).QueryValue != "")
{
if (OldValue != null && OldValue != "")
{
OldValue = (String)SynapseCore.Database.DBFunction.ExecuteScalarQuery(((LogAttributes)CLA).QueryValue + OldValue);
}
if (NewValue != null && NewValue != "")
{
NewValue = (String)SynapseCore.Database.DBFunction.ExecuteScalarQuery(((LogAttributes)CLA).QueryValue + NewValue);
}
if (OldValue == null)
{
OldValue = "";
}
if (NewValue == null)
{
NewValue = "";
}
}
}
}
if (CLA is LogEntryAttributeValue)
{
if (this.LogEntryValue == null)
{
if (Command == LogCommand.Delete)
{
this.LogEntryValue = OldValue;
}
else
{
this.LogEntryValue = NewValue;
}
}
//_LogProperty = true;
}
if (CLA is LogEntryAttributeKey)
{
if (this.LogEntryKey == null)
{
this.LogEntryKey = NewValue;
}
//_LogProperty = true;
}
}
}
else
{
if (p.Name != "LogEntryKey" && p.Name != "LogEntryValue" && p.Name != "IsDirty" && p.Name != "InitialValue")
{
_LogProperty = true;
}
}
if ((OldValue != NewValue && _LogProperty) || (Command == LogCommand.Delete && _LogProperty))
{
LogValue _LogValue = new LogValue();
_LogValue.FIELD = LogAttribute.EntityName + "." + p.Name;
_LogValue.OLD_VALUE = OldValue;
_LogValue.NEW_VALUE = NewValue;
_LogValues.Add(_LogValue);
}
}
if (_LogValues.Count > 0)
{
try
{
LogEntry _LogEntry = new LogEntry();
switch (Command)
{
case LogCommand.Delete:
_LogEntry.ACTION_CODE = "DELETE";
break;
case LogCommand.Insert:
_LogEntry.ACTION_CODE = "INSERT";
break;
case LogCommand.Modify:
_LogEntry.ACTION_CODE = "MODIFY";
break;
}
_LogEntry.USERID = SynapseForm.FormUser.UserID;
_LogEntry.TIMESTAMP = DateTime.Now;
_LogEntry.OBJECT_NAME = LogAttribute.EntityName;
_LogEntry.OBJECT_VALUE = this.LogEntryValue;
_LogEntry.LOGKEY = this.LogEntryKey;
_LogEntry.save();
try
{
foreach (LogValue lv in _LogValues)
{
lv.FK_LOGENTRY = _LogEntry.ID;
}
_LogValues.SaveCollection();
}
// TODO: Catch more specific exception
catch (Exception)
{
// TODO: Handle exception (e.g. log)
}
}
// TODO: Catch more specific exception
catch (Exception)
{
// TODO: Handle exception (e.g. log)
}
}
}
/// <summary>
/// Produce the report
/// Alternate interface for when we are given a server cooection
/// This is needed for the SharpCvsLib command line client
/// </summary>
public LogReport Run(ICommandConnection connection)
{
// read Root and Repository from local directory
if (null == this.cvsRoot)
{
Manager manager = new Manager(localDirectory);
Root root = (Root)manager.FetchSingle(localDirectory,
Factory.FileType.Root);
this.cvsRoot = new CvsRoot(root.FileContents);
}
if (null == workingDirectory)
{
Manager manager = new Manager(localDirectory);
Repository repository = (Repository)manager.FetchSingle(localDirectory,
Factory.FileType.Repository);
this.workingDirectory = new WorkingDirectory(cvsRoot,
localDirectory,
repository.FileContents);
}
ILogCommand command;
// Recursively add all cvs folders/files under the localDirectory
System.Console.WriteLine("GNE workingDirectory.WorkingPath = {0}", workingDirectory.WorkingPath);
System.Console.WriteLine("GNE localDirectory: {0}", localDirectory);
// if (Directory.Exists(workingDirectory.WorkingPath)) {
if (Directory.Exists(localDirectory) && File.Exists(Path.Combine(localDirectory, "Repository")))
{
workingDirectory.FoldersToUpdate = FetchFiles(localDirectory);
command =
new LogCommand(workingDirectory, this.workingDirectory.ModuleName, null);
}
else
{
command =
// GNE - this wont compile new LogCommand(workingDirectory, this.workingDirectory.ModuleName);
new RLogCommand(workingDirectory, this.workingDirectory.ModuleName);
}
// add any date restrictions
if (hasStartDate && hasEndDate)
{
command.AddInclusiveDateRange(startDate, endDate);
}
else if (hasStartDate)
{
command.AddInclusiveDateStart(startDate);
}
else if (hasEndDate)
{
command.AddInclusiveDateEnd(endDate);
}
// Initialse state machine
curLogReport = new LogReport(); // this is what we are going to return to the caller
curLogFile = new LogFile(this.cvsRoot);
curLogRevision = new LogRevision();
logState = LogState.WANT_FILE_HEADER_START;
if (connection.GetType() == typeof(CVSServerConnection))
{
CVSServerConnection cvsServerConnection = (CVSServerConnection)connection;
cvsServerConnection.MessageEvent.MessageEvent += new EncodedMessage.MessageHandler(OnMessage);
}
command.Execute(connection);
// return curLogReport but clear our reference to it
LogReport report = curLogReport;
curLogReport = null;
return(report);
}
static void Write(LogCommand m)
{
switch (m.Type)
{
case LogType.Warning:
Debug.LogWarning(m.Message);
break;
case LogType.Error:
case LogType.Exception:
Debug.LogError(m.Message);
break;
case LogType.Log:
case LogType.Assert:
Debug.Log(m.Message);
break;
}
}
public Task <int> UpdateLeadFromLeadPayload(LeadPayload cDcResponseObject, LogCommand logCommand)
{
throw new NotImplementedException();
}
public string[] RetrieveAuthors(DateRange dateRange)
{
var command = new LogCommand();
var authors = _repository.Log(command)
.Where(ch => ch.Timestamp >= dateRange.StartDate && ch.Timestamp <= dateRange.EndDate)
.Select(ch => ch.AuthorName)
.Distinct()
.ToArray();
return authors;
}
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 async Task <GenericServiceResponse> ServiceAppointmentUpdate(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);
var recordsAffected = 0;
Guid programGuid;
Guid subprogramGuid;
Guid WorkOrderScoreWeightingGuid;
Guid StatusTypeGuid;
Guid UsernameMappingGuid;
//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");
}
// Mapping SFUserid To AD Username
updateEventState = "Attempting To Get Map Status GUid" + Environment.NewLine;
if (!string.IsNullOrEmpty(serviceAppointmentPayload._PayloadBody.ServiceAppointment.Status))
{
var lkpSchedulingType = await _schedulingRepository.GetLkpSchedulingTypeEnum(logCommand);
var statusTypeMapping = lkpSchedulingType.FirstOrDefault(a => string.Equals(a.SchedulingTypeName, serviceAppointmentPayload._PayloadBody.ServiceAppointment.Status, StringComparison.CurrentCultureIgnoreCase));
if (statusTypeMapping != null)
{
StatusTypeGuid = statusTypeMapping.LkpSchedulingTypeGuid;
}
else
{
throw new Exception($"Error: {Service}.{method} -- Cannot Status GUid ");
}
}
else
{
throw new Exception($"Error: {Service}.{method} -- Cannot Status GUid ");
}
// LKPWorkOrderScoreMapping Workorder WorkTypeId
updateEventState = "Attempting To Get Map Work Order Type Guid" + Environment.NewLine;
if (!string.IsNullOrEmpty(serviceAppointmentPayload._PayloadBody.WorkOrder.WorkTypeId))
{
var lkpAuditType = await _schedulingRepository.GetWorkOrderScoreWeightingEnum(logCommand);
var workOrderScoreMapping = lkpAuditType.FirstOrDefault(a => a.SalesforceRecordID == serviceAppointmentPayload._PayloadBody.WorkOrder.WorkTypeId);
if (workOrderScoreMapping != null)
{
WorkOrderScoreWeightingGuid = workOrderScoreMapping.WorkOrderScoreWeightingGuid;
}
else
{
throw new Exception($"Error: {Service}.{method} -- Cannot Map Work order Type ");
}
}
else
{
throw new Exception($"Error: {Service}.{method} -- Cannot Map Work order Type ");
}
// LKPWorkOrderScoreMapping Workorder WorkTypeId
updateEventState = "Attempting To Get Username Guid" + Environment.NewLine;
if (!string.IsNullOrEmpty(serviceAppointmentPayload._PayloadBody.ServiceAppointment.LastModifiedById))
{
var usernameMappingList = await _schedulingRepository.GetUsernameMappingSFtoADEnum(logCommand);
var usernameMapping = usernameMappingList.FirstOrDefault(a => a.SalesForceUserRecordID == serviceAppointmentPayload._PayloadBody.ServiceAppointment.LastModifiedById);
if (usernameMapping != null)
{
UsernameMappingGuid = usernameMapping.UsernameMappingSFtoADGuid;
}
else
{
throw new Exception($"Error: {Service}.{method} -- Cannot Map Username ");
}
}
else
{
throw new Exception($"Error: {Service}.{method} -- Cannot Map Username");
}
updateEventState = "Attempting Execute" + Environment.NewLine;
var schedulingDataObject = new Scheduling()
{
SubprogramGuid = subprogramGuid,
ProgramGuid = programGuid,
WorkOrderScoreWeightingGuid = WorkOrderScoreWeightingGuid,
UsernameMappingSFtoADGuid = UsernameMappingGuid,
CreatedDateTime = DateTime.Now,
LkpSchedulingTypeGuid = StatusTypeGuid,
SalesforceRecordID = serviceAppointmentPayload._PayloadHeader.RecordIdC
};
recordsAffected = await _schedulingRepository.CreateNewSchedulingRecord(schedulingDataObject, logCommand);
ServiceResponse = await InsertAuditRecordAsync(logCommand, ResponseObject,
schedulingDataObject.GetType().FullName,
serviceAppointmentPayload._PayloadBody.ServiceAppointment.LastModifiedById);
if (!ServiceResponse.Success)
{
return(ServiceResponse);
}
updateEventState = "Executions Complete" + Environment.NewLine;
ServiceResponse = new GenericServiceResponse
{
Entity = $"Update Scheduling Related Tables Successful, rows added/updated = {recordsAffected}",
Success = true,
RestResponseStatus = GenericServiceResponse.RestStatus.Success
};
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 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 Task <GenericServiceResponse> CdcEventContactUpdate(JObject cdcPayload, LogCommand logCommand)
{
const string method = "CDCEventContactUpdate";
try
{
logCommand.LogMessage = $"{Service}.{method} Starting input parameter CDCPayload = {cdcPayload}";
_logHandler.HandleLog(logCommand);
var response = new GenericServiceResponse
{
Entity = $"Ignoring Contact ",
Success = true,
RestResponseStatus = GenericServiceResponse.RestStatus.Success
};
logCommand.LogMessage = string.Format($"{Service}.{method} completed");
_logHandler.HandleLog(logCommand);
return(Task.Run(() => response));
}
catch (Exception ex)
{
AppLogger.LogException(_loggingInstance, ex.Message, ex);
return(Task.Run(() => ServiceHelper.SetErrorGenericServiceResponse(ex)));
}
}
public async Task <GenericServiceResponse> CdcEventAddressUpdate(PayloadParent PayloadResponse, LogCommand logCommand)
{
const string method = "UpdateLeadFromUpdateEvent";
var UpdateEventState = string.Empty;
try
{
logCommand.LogMessage = $"{Service}.{method} Starting input parameter PayloadResponse = {PayloadResponse}";
_logHandler.HandleLog(logCommand);
var addressPayload = new AddressPayload(PayloadResponse);
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);
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);
return(response);
}
}
else
{
countyGuid = Guid.Parse("24C3CDAC-2BB8-46A9-AF92-70E36D0B37F7");
}
//CountyGuid 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);
}
var address = new Address(addressPayload, addressTypeGuid, countyGuid, ownershipGuid);
//Even though this is an address update PE message, it may be the initial insert of a landlord mailing address
if (addressTypeGuid == Guid.Parse("431407C6-C889-48BF-9DFC-7CD879F85847")) //Landlord Mailing
{
var existingLlAddress = await _addressRepository.GetAddressBySfIdAndAddressType(address, logCommand);
if (!existingLlAddress.Any())
{
recordsAffected += await _addressRepository.InsertAddress(address, logCommand);
}
else
{
//Update Address
recordsAffected += await _addressRepository.UpdateAddress(address, logCommand);
}
if (recordsAffected > 0)
{
response = new GenericServiceResponse
{
Entity = $"Update Address Related Tables Successful, rows added/updated = {recordsAffected}",
Success = true,
RestResponseStatus = GenericServiceResponse.RestStatus.Success
};
}
else
{
response = new GenericServiceResponse
{
Entity = $"Address Does not Exist. Records Changed: {recordsAffected}. Could not update. ",
Success = false,
RestResponseStatus = GenericServiceResponse.RestStatus.Success
};
}
}
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 Changeset GetParentCommit(Changeset commit)
{
var command = new LogCommand().WithIncludePathActions();
var changeset = _repository.Log(command)
.FirstOrDefault(ch => ch.RevisionNumber == (commit.RevisionNumber > 0 ? commit.RevisionNumber - 1 : commit.RevisionNumber));
return changeset;
}
public async Task <int> UpdateLeadFromLeadPayload_GUID(LeadPayload leadPayload, LogCommand logCommand)
{
//Logging Helper for Method
var method_name = "UpdateLeadFromLeadPayload_GUID";
var UpdateQuery = " update _LeadTable " +
" set " +
" _LeadTable.[SFLeadID] = @ID " +
" ,_LeadTable.[LeadStatusGuid] = _LeadStatus.LeadStatusGuid " +
" ,_LeadTable.LeadSource = @LeadSource " +
" ,_LeadTable.QualifiedAuditTypeGuid = _AuditType.AuditTypeGuid " +
" From [CMC-SFDC_DEV].[Customer].[Lead] as _LeadTable " +
" join customer.LkpAuditType as _AuditType " +
" on _AuditType.AuditTypeName = @AuditTypeC " +
" join Customer.LkpLeadStatus as _LeadStatus " +
" on _LeadStatus.LeadStatusName = @Status " +
" where _LeadTable.CustomerGuid = @CmcCustomerGuidC ";
//Log the input
logCommand.LogMessage = $"{Repository}.{method_name} Starting input parameters CDCResponseObject = {JsonConvert.SerializeObject(leadPayload)}" + Environment.NewLine +
$"Query: {UpdateQuery}";
_logHandler.HandleLog(logCommand);
using (var connection = _connectionFactory.GetConnection)
{
//Await the response
var returnValue = await connection.ExecuteAsync(UpdateQuery, leadPayload);
connection.Close();
//Log the output
logCommand.LogMessage = $"{Repository}.{method_name} completed";
_logHandler.HandleLog(logCommand);
return(returnValue);
}
}
public Changeset GetCommit(RevisionId id)
{
var command = new LogCommand().WithRevision(RevSpec.ById(id.Value)).WithIncludePathActions();
var changeset = _repository.Log(command).FirstOrDefault(ch => ch.Hash == id.Value);
return changeset;
}
public async Task <int> LeadCreatedSetRecordId(Guid customerGuid, string sFLeadId, LogCommand logCommand)
{
//Logging Helper for Method
const string methodName = "UpdateLeadFromLeadPayload_SFID";
var updateQuery = $"update {LeadTable} " +
" set SFLeadID = @SFLeadID " +
" where CustomerGuid = @CustomerGuid ";
//Log the input
logCommand.LogMessage = $"{Repository}.{methodName} Starting input parameters CustomerGuid = {customerGuid} || SFLeadID = {sFLeadId}" + Environment.NewLine +
$"Query: {updateQuery}";
_logHandler.HandleLog(logCommand);
using (var connection = _connectionFactory.GetConnection)
{
//Await the response
var returnValue = await connection.ExecuteAsync(updateQuery, new { CustomerGuid = customerGuid, SFLeadID = sFLeadId });
connection.Close();
//Log the output
logCommand.LogMessage = $"{Repository}.{methodName} completed";
_logHandler.HandleLog(logCommand);
return(returnValue);
}
}
public RevisionInfo[] GetRevisions(RevisionId fromChangeset, RevisionId toChangeset)
{
var from = new RevSpec(fromChangeset.Value);
var to = new RevSpec(toChangeset.Value);
var command = new LogCommand().WithRevision(RevSpec.Range(from, to)).WithIncludePathActions();
var revisionInfos = _repository.Log(command)
.Where(ch => ch.Timestamp >= fromChangeset.Time.Value && ch.Timestamp <= toChangeset.Time.Value)
.Select(ch => ch.ToRevisionInfo())
.ToArray();
return revisionInfos;
}
public async Task <IEnumerable <Program> > FindProgram(SearchProgram _SearchProgram, LogCommand logCommand)
{
//Logging Helper for Method
var method_name = "GetClientAsync";
//Query Used by Dapper
var query =
" SELECT * from " + ProgramTable +
_SearchProgram.getWhereClause();
//Log the input
logCommand.LogMessage = $"{Repository}.{method_name} Starting input parameter _SearchProgram={JsonConvert.SerializeObject(_SearchProgram)}" + Environment.NewLine +
$"Query: {query}";
_logHandler.HandleLog(logCommand);
using (var connection = _connectionFactory.GetConnection)
{
//Await the response
var _Program = await connection.QueryAsync <Program>(query);
connection.Close();
//Log the output
logCommand.LogMessage = $"{Repository}.{method_name} completed";
_logHandler.HandleLog(logCommand);
return(_Program);
}
}
public async Task <LkpAuditType> GetLkpLeadAuditTypeFromName(string auditTypeName, LogCommand logCommand)
{
//Logging Helper for Method
const string methodName = "GetLkpLeadAuditTypeFromName";
if (string.IsNullOrEmpty(auditTypeName) ||
auditTypeName.ToLower() != "not qualified" ||
auditTypeName.ToLower() != "heating" ||
auditTypeName.ToLower() != "baseload" ||
auditTypeName.ToLower() != "apartment heating")
{
if (string.IsNullOrEmpty(auditTypeName))
{
auditTypeName = "Not Qualified";
}
else if (auditTypeName.ToLower() == "wta")
{
auditTypeName = "Baseload";
}
else if (auditTypeName.ToLower() == "bda")
{
auditTypeName = "Heating";
}
else if (auditTypeName.ToLower() == "apt")
{
auditTypeName = "Apartment Heating";
}
else if (auditTypeName.ToLower() == "not qualify")
{
auditTypeName = "Not Qualified";
}
}
//Query Used by Dapper
var query =
" SELECT * from " + LeadAuditTypeTable +
" where [AuditTypeName] = @AuditTypeName";
//Log the input
logCommand.LogMessage = $"{Repository}.{methodName} Starting input parameter AuditTypeName={auditTypeName}" + Environment.NewLine +
$"Query: {query}";
_logHandler.HandleLog(logCommand);
using (var connection = _connectionFactory.GetConnection)
{
//Await the response
var lkpAuditType = await connection.QueryFirstAsync <LkpAuditType>(query, new { AuditTypeName = auditTypeName });
connection.Close();
//Log the output
logCommand.LogMessage = $"{Repository}.{methodName} completed";
_logHandler.HandleLog(logCommand);
return(lkpAuditType);
}
}
public async Task <IEnumerable <Subprogram> > GetProgramAndSubprogramBySfSubProgramId(string sfSubProgramId, LogCommand logCommand)
{
//Logging Helper for Method
var method_name = "GetProgramAndSubprogramBySfSubProgramId";
//Query Used by Dapper
var query =
" SELECT ProgramGuid, SubProgramGuid, SubProgramName from Program.SubProgram " +
$" WHERE SfSubProgramId = '{sfSubProgramId}'";
//Log the input
logCommand.LogMessage = $"{Repository}.{method_name} Starting input parameter: {sfSubProgramId} + Query: {query}";
_logHandler.HandleLog(logCommand);
using (var connection = _connectionFactory.GetConnection)
{
//Await the response
var program = await connection.QueryAsync <Subprogram>(query);
connection.Close();
//Log the output
logCommand.LogMessage = $"{Repository}.{method_name} completed";
_logHandler.HandleLog(logCommand);
return(program);
}
}
public async Task <int> UpsertEmail(string Email, string FieldName, Guid ContactGuid, LogCommand logCommand)
{
//Logging Helper for Method
var method_name = "UpsertEmail";
var query = "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE; " +
"BEGIN TRANSACTION; " +
$" UPDATE [Customer].Email SET " +
$" [EmailAddress] = '{Email}' " +
$" where [ContactGuid] = '{ContactGuid}' and [SFFieldName] = '{FieldName}'; " +
"IF @@ROWCOUNT = 0 " +
"BEGIN " +
" Insert into [CMC-SFDC_DEV].[Contact].[Email] " +
$" values (newID(), '{ContactGuid}', '{FieldName}', '{Email}' )" +
"END " +
"COMMIT TRANSACTION; ";
//Log the input
logCommand.LogMessage = $"{Repository}.{method_name} Starting input parameter " +
$"Email={Email}" + Environment.NewLine +
$"Email={Email}" + Environment.NewLine +
$"Email={Email}" + Environment.NewLine +
$"______________" + Environment.NewLine +
$"Query: {query}";
_logHandler.HandleLog(logCommand);
using (var connection = _connectionFactory.GetConnection)
{
//Await the response
var _Email = await connection.ExecuteAsync(query);
connection.Close();
//Log the output
logCommand.LogMessage = $"{Repository}.{method_name} completed";
_logHandler.HandleLog(logCommand);
return(_Email);
}
}
/// <summary>
/// Function that connect the server to clients.
/// </summary>
public void ConnectServer()
{
Thread.Sleep(100);
IPEndPoint ep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8888);
TcpListener listener = new TcpListener(ep);
//first of all start the listener for searching connections.
listener.Start();
Console.Write("Waiting for connection...");
HandleLogs handleLogs = new HandleLogs();
//thread for alwayes search for cnnections.
Task ta = new Task(() =>
{
while (true)
{
try
{
TcpClient client = listener.AcceptTcpClient();
//this.client = client;
Console.WriteLine("Connection accepted.");
m_logging.Log("Connection to server accepted", MessageTypeEnum.INFO);
mutex3.WaitOne();
NetworkStream ns = client.GetStream();
byte[] bytes = new byte[1024];
//this.ns = client.GetStream();
int bytesRead = ns.Read(bytes, 0, bytes.Length);
string r = Encoding.ASCII.GetString(bytes, 0, bytesRead);
mutex3.ReleaseMutex();
Task task2 = new Task(() =>
{
if (client.Connected)
{
if (r == "GetConfigCommand")
{
ICommand command = new GetConfigCommand(this, client, m_controller);
bool success;
command.Execute(null, out success);
//HandleSettings h = new HandleSettings(this, client, m_controller);
}
else if (r == "LogCommand")
{
ICommand command = new LogCommand(handleLogs, this, m_logging, client);
bool success;
command.Execute(null, out success);
//handleLogs.SetAllProt(this, m_logging , client);
}
}
}); task2.Start();
/*
* need to take care the close
* when the client close the screen we should out this while !
*
* */
}
catch (Exception e)
{
break;
}
}
});
ta.Start();
tcpListener = listener;
}
//Change Minor
//TODO: HW This is temporary code Needs to be removed ASAP Hack to update Lead so that it will be excluded from GetPrioritizedLeads query if touched by user.
public Task <GenericServiceResponse> TaskEventInsertUpdate(PayloadParent payloadResponse, LogCommand logCommand)
{
const string method = "TaskEventInsertUpdate";
try
{
logCommand.LogMessage = $"{Service}.{method} Starting input parameter cdcPayload = {JsonConvert.SerializeObject(payloadResponse)}";
_logHandler.HandleLog(logCommand);
var response = AuditInsert.InsertAuditRecordAsync(logCommand, payloadResponse, "Shared.Entities.DTO.Customer.Lead", payloadResponse.CreatedById, _cdcRepository);
logCommand.LogMessage = string.Format($"{Service}.{method} completed");
_logHandler.HandleLog(logCommand);
return(response);
}
catch (Exception ex)
{
AppLogger.LogException(_loggingInstance, ex.Message, ex);
return(Task.Run(() => ServiceHelper.SetErrorGenericServiceResponse(ex)));
}
}
/// <summary>
/// Updates ReserveDateProperty of a Lead to 15 minutes from now
/// </summary>
/// <param name="customerGuid"></param>
/// <param name="reservedDateTime"></param>
/// <param name="logCommand"></param>
/// <param name="trans"></param>
/// <returns></returns>
public async Task <int> UpdateReservedDateAsync(Guid customerGuid, DateTime reservedDateTime, LogCommand logCommand, IDbTransaction trans)
{
//Logging Helper for Method
const string methodName = "UpdateReservedDateAsync";
var query = $"Update Customer.Lead set ReservedDate = '{reservedDateTime}' where CustomerGuid = @CustomerGuid";
//Log the input
logCommand.LogMessage = $"{Repository}.{methodName} Starting input parameter: {customerGuid} " + Environment.NewLine + $"Query: {query}";
_logHandler.HandleLog(logCommand);
//NOTE: NO USING STATEMENT CALLING ROUTINE IN THE SERVICE LAYER NEEDS TO MANAGE THE CONNECTION !!!
//Await the response
var results = await trans.Connection.ExecuteAsync(query, new { @CustomerGuid = customerGuid }, trans, null, CommandType.Text);
// connection.Close();
//Log the output
logCommand.LogMessage = $"{Repository}.{methodName} completed";
_logHandler.HandleLog(logCommand);
return(results);
}
public async Task <IEnumerable <LkpLeadStatus> > GetLkpLeadStatus(SearchLkpLeadStatus _SearchLkpLeadStatus, LogCommand logCommand)
{
//Logging Helper for Method
const string methodName = "GetLkpLeadStatus";
//Query Used by Dapper
var whereClause = _SearchLkpLeadStatus.getWhereClause();
var query =
" SELECT * from " + RepositoryTable + " "
+ whereClause;
//Log the input
logCommand.LogMessage = $"{Repository}.{methodName} Starting input parameter _SearchLkpLeadStatus={JsonConvert.SerializeObject(_SearchLkpLeadStatus)}" + Environment.NewLine +
$"Query: {query}";
_logHandler.HandleLog(logCommand);
using (var connection = _connectionFactory.GetConnection)
{
//Await the response
var _LkpLeadStatus = await connection.QueryAsync <LkpLeadStatus>(query);
connection.Close();
//Log the output
logCommand.LogMessage = $"{Repository}.{methodName} completed";
_logHandler.HandleLog(logCommand);
return(_LkpLeadStatus);
}
}
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 Task <GenericServiceResponse> GetSchedulingList(LogCommand logCommand)
{
throw new NotImplementedException();
}
public async Task <Subprogram> GetSubProgramNameFromSubProgramGuid(Guid?SubProgramGuid, LogCommand logCommand)
{
//Logging Helper for Method
const string methodName = "GetSubProgramNameFromSubProgramGuid";
//Query Used by Dapper
var query =
$" select * from {SubProgramTable} " +
" where SubProgramId = @SubProgramGuid ";
//Log the input
logCommand.LogMessage = $"{Repository}.{methodName} Starting input parameter SubProgramGuid={SubProgramGuid}" + Environment.NewLine +
$"Query: {query}";
_logHandler.HandleLog(logCommand);
using (var connection = _connectionFactory.GetConnection)
{
//Await the response
var _SubProgram = await connection.QueryFirstAsync <Subprogram>(query, new { SubProgramGuid });
connection.Close();
//Log the output
logCommand.LogMessage = $"{Repository}.{methodName} completed";
_logHandler.HandleLog(logCommand);
return(_SubProgram);
}
}
/// <summary>
/// SendLog(). It is used to request for FreeSwitch log.
/// </summary>
/// <param name="level">The log level to specify</param>
/// <returns></returns>
public async Task SetLogLevel(EslLogLevels level)
{
var command = new LogCommand(level);
await SendAsync(command);
}
public Task <Program> GetProgramFromCustomerGuid(Guid CustomerGuid, LogCommand logCommand)
{
throw new NotImplementedException();
}
