protected override Task <bool> ExecuteRequestAsync(IAuthenticatedTicket authenticatedTicket, InvoiceAddRqType request)
{
request.InvoiceAdd = new QbSync.QbXml.Objects.InvoiceAdd
{
// Mandatory
CustomerRef = new CustomerRef
{
// Find the ListID for a customer with a previous Query.
ListID = "80000001-1541542677"
},
InvoiceLineAdd = new List <InvoiceLineAdd>
{
new InvoiceLineAdd
{
Amount = 12,
ItemRef = new ItemRef
{
// Mandatory, you can query the list of of items prior to
// add an invoice. You may use the full name or ListID.
FullName = "test"
}
}
}
};
return(base.ExecuteRequestAsync(authenticatedTicket, request));
}
protected override Task <bool> ExecuteRequestAsync(IAuthenticatedTicket authenticatedTicket, CustomerQueryRqType request)
{
// By default, we return 100, let's do 5 here.
request.MaxReturned = "5";
return(base.ExecuteRequestAsync(authenticatedTicket, request));
}
protected override async Task <CustomerQueryRqType> CreateRequestAsync(IAuthenticatedTicket authenticatedTicket)
{
CustomerQueryRqType req = await base.CreateRequestAsync(authenticatedTicket);
req.MaxReturned = this.DefaultMaxReturned;
return(req);
}
/// <summary>
/// Returns the string that has to be sent to the Web Connector.
/// Return null if your step has nothing to do this time. The next step will be executed immediately.
/// </summary>
/// <param name="authenticatedTicket">The authenticated ticket.</param>
/// <returns>QbXml or null to execute the next step.</returns>
public virtual async Task <string?> SendXMLAsync(IAuthenticatedTicket authenticatedTicket)
{
var requestObject = await ExecuteRequestAsync(authenticatedTicket);
var requestObjectArray = requestObject?.ToArray();
if (requestObjectArray?.Any() == true)
{
var qbXmlRequest = new QbXmlRequest();
var list = new List <object>(requestObjectArray.Count());
foreach (var request in requestObjectArray)
{
list.Add(request);
}
qbXmlRequest.Add(new QBXMLMsgsRq
{
onError = await GetOnErrorAttributeAsync(authenticatedTicket),
Items = list.ToArray()
});
return(qbXmlRequest.GetRequest());
}
return(null);
}
public async Task SaveTicketAsync(IAuthenticatedTicket ticket)
{
// Save the ticket to the databse.
// It contains the information about the current step.
var qbTicket = await dbContext.QbTickets
.FirstOrDefaultAsync(m => m.Ticket == ticket.Ticket);
if (qbTicket == null)
{
var ticketAsQbTicket = ticket as QbTicket;
if (ticketAsQbTicket != null)
{
qbTicket = new QbTicket
{
Ticket = ticket.Ticket,
Authenticated = ticket.Authenticated,
User = ticketAsQbTicket.User,
UserId = ticketAsQbTicket.UserId
};
dbContext.QbTickets.Add(qbTicket);
}
}
qbTicket.CurrentStep = ticket.CurrentStep;
await dbContext.SaveChangesAsync();
}
/// <summary>
/// Handles the authentication.
/// </summary>
/// <param name="authenticatedTicket">The ticket.</param>
/// <returns>WebConnector Codes.</returns>
protected internal async Task <string[]> AuthenticateInternalAsync(IAuthenticatedTicket authenticatedTicket)
{
var ret = new string[4];
ret[0] = authenticatedTicket.Ticket;
ret[2] = string.Empty;
ret[3] = string.Empty; // Not used
if (authenticatedTicket.Authenticated == false)
{
ret[1] = "nvu"; // Invalid user
}
else
{
var waitTime = await GetWaitTimeAsync(authenticatedTicket);
if (waitTime == 0)
{
ret[1] = await GetCompanyFileAsync(authenticatedTicket);
}
else
{
ret[1] = "none"; // No work is necessary
ret[2] = waitTime.ToString();
}
}
return(ret);
}
protected override async Task <bool> ExecuteRequestAsync(IAuthenticatedTicket authenticatedTicket, CustomerQueryRqType request)
{
// Let's see if we had a previous saved time so we don't re-query the entire QuickBooks every time.
var previouslySavedFromModified = (await dbContext.QbSettings
.FirstOrDefaultAsync(m => m.Name == LAST_MODIFIED_CUSTOMER))?.Value;
request.FromModifiedDate = DATETIMETYPE.ParseOrDefault(previouslySavedFromModified, DATETIMETYPE.MinValue).GetQueryFromModifiedDate();
return(await base.ExecuteRequestAsync(authenticatedTicket, request));
}
public override Task <QbXmlResponseOptions> GetOptionsAsync(IAuthenticatedTicket authenticatedTicket)
{
// You should return a TimeZoneInfo based on the authenticated ticket.
// The timezone where the user is running their QuickBooks.
return(Task.FromResult(new QbXmlResponseOptions
{
TimeZoneBugFix = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time")
}));
}
protected override async Task <string> RetrieveMessageAsync(IAuthenticatedTicket ticket, string key)
{
var state = await dbContext.QbKvpStates
.Where(m => m.Ticket == ticket.Ticket)
.Where(m => m.CurrentStep == ticket.CurrentStep)
.Where(m => m.Key == key)
.FirstOrDefaultAsync();
return(state?.Value);
}
protected override Task <bool> ExecuteRequestAsync(IAuthenticatedTicket authenticatedTicket, CustomerAddRqType request)
{
request.CustomerAdd = new QbSync.QbXml.Objects.CustomerAdd
{
Name = "Unique Name" + Guid.NewGuid().ToString("D"),
FirstName = "User " + authenticatedTicket.GetUserId().ToString()
};
return(base.ExecuteRequestAsync(authenticatedTicket, request));
}
/// <summary>
/// Executes the response, useful to save the data coming from QuickBooks.
/// </summary>
/// <param name="authenticatedTicket">The ticket</param>
/// <param name="response">The QbResponse</param>
/// <returns>Task.</returns>
protected override async Task ExecuteResponseAsync(IAuthenticatedTicket authenticatedTicket, QbResponse response)
{
// We have more that can come our way.
if (response.iteratorRemainingCount.HasValue && response.iteratorRemainingCount.Value > 0)
{
gotoNextStep = false;
await SaveMessageAsync(authenticatedTicket, StepQueryRequestWithIterator.IteratorKey, response.iteratorID);
}
await base.ExecuteResponseAsync(authenticatedTicket, response);
}
protected override Task ExecuteResponseAsync(IAuthenticatedTicket authenticatedTicket, CustomerQueryRsType response)
{
if (response.CustomerRet != null)
{
foreach (var customer in response.CustomerRet)
{
// save these custoemr.
}
}
return(base.ExecuteResponseAsync(authenticatedTicket, response));
}
/// <summary>
/// Extension method to help fetching the extra properties off the IAuthenticatedTicket.
/// </summary>
/// <param name="authenticatedTicket">The ticket.</param>
/// <returns>The user id.</returns>
public static int GetUserId(this IAuthenticatedTicket authenticatedTicket)
{
if (authenticatedTicket != null)
{
var qbTicket = authenticatedTicket as QbTicket;
if (qbTicket != null && qbTicket.UserId.HasValue)
{
return(qbTicket.UserId.Value);
}
}
return(0);
}
/// <summary>
/// Called when the Web Connector returns some data.
/// </summary>
/// <param name="authenticatedTicket">The authenticated ticket.</param>
/// <param name="response">QbXml.</param>
/// <param name="hresult">HResult.</param>
/// <param name="message">Message.</param>
/// <returns>Message to be returned to the Web Connector.</returns>
public virtual async Task <int> ReceiveXMLAsync(IAuthenticatedTicket authenticatedTicket, string response, string hresult, string message)
{
var responseObject = new QbXmlResponse();
if (!string.IsNullOrEmpty(response))
{
var msgResponseObject = responseObject.GetSingleItemFromResponse(response, typeof(QbResponse)) as QbResponse;
await ExecuteResponseAsync(authenticatedTicket, msgResponseObject);
return(0);
}
return(-1);
}
/// <summary>
/// Called when the Web Connector returns some data.
/// </summary>
/// <param name="authenticatedTicket">The authenticated ticket.</param>
/// <param name="response">QbXml.</param>
/// <param name="hresult">HResult.</param>
/// <param name="message">Message.</param>
/// <returns>Message to be returned to the Web Connector.</returns>
public virtual async Task <int> ReceiveXMLAsync(IAuthenticatedTicket authenticatedTicket, string response, string hresult, string message)
{
var responseObject = new QbXmlResponse();
if (!string.IsNullOrEmpty(response))
{
var objects = responseObject.GetItemsFromResponse(response, typeof(IQbResponse));
var msgResponseObject = ((IEnumerable)objects).Cast <IQbResponse>();
await ExecuteResponseAsync(authenticatedTicket, msgResponseObject);
return(0);
}
return(-1);
}
protected override async Task ExecuteResponseAsync(IAuthenticatedTicket authenticatedTicket, CustomerQueryRsType response)
{
if (response.CustomerRet != null)
{
foreach (var customer in response.CustomerRet)
{
// save these customers.
}
var lastFromModifiedDate = response.CustomerRet.OrderBy(m => m.TimeModified).Select(m => m.TimeModified).LastOrDefault();
await dbContext.SaveIfNewerAsync(LAST_MODIFIED_CUSTOMER, lastFromModifiedDate);
}
await base.ExecuteResponseAsync(authenticatedTicket, response);
}
public override async Task CloseConnectionAsync(IAuthenticatedTicket authenticatedTicket)
{
// We do some clean up.
var savedStates = dbContext.QbKvpStates
.Where(m => m.Ticket == authenticatedTicket.Ticket)
.ToList();
dbContext.QbKvpStates.RemoveRange(savedStates);
var savedTickets = dbContext.QbTickets
.Where(m => m.Ticket == authenticatedTicket.Ticket)
.ToList();
dbContext.QbTickets.RemoveRange(savedTickets);
await dbContext.SaveChangesAsync();
}
/// <summary>
/// Returns the string that has to be sent to the Web Connector.
/// Return null if your step has nothing to do this time. The next step will be executed immediately.
/// </summary>
/// <param name="authenticatedTicket">The authenticated ticket.</param>
/// <returns>QbXml or null to execute the next step.</returns>
public virtual async Task <string?> SendXMLAsync(IAuthenticatedTicket authenticatedTicket)
{
var requestObject = await CreateRequestAsync(authenticatedTicket);
if (requestObject != null)
{
if (await ExecuteRequestAsync(authenticatedTicket, requestObject))
{
var qbXmlRequest = new QbXmlRequest();
qbXmlRequest.AddToSingle(requestObject);
return(qbXmlRequest.GetRequest());
}
}
return(null);
}
protected override Task ExecuteResponseAsync(IAuthenticatedTicket authenticatedTicket, IEnumerable <IQbResponse> responses)
{
foreach (var item in responses)
{
switch (item)
{
case CustomerQueryRsType customerQueryRsType:
// Do something with the CustomerQuery data
break;
case CustomerAddRsType customerAddRsType:
// Do something with the CustomerAdd data
break;
}
}
return(base.ExecuteResponseAsync(authenticatedTicket, responses));
}
protected override Task <IEnumerable <IQbRequest>?> ExecuteRequestAsync(IAuthenticatedTicket authenticatedTicket)
{
var list = new List <IQbRequest>
{
new CustomerAddRqType
{
CustomerAdd = new QbSync.QbXml.Objects.CustomerAdd
{
Name = "Unique Name" + Guid.NewGuid().ToString("D"),
FirstName = "User " + authenticatedTicket.GetUserId().ToString()
}
},
new CustomerQueryRqType
{
ActiveStatus = ActiveStatus.All
}
};
return(Task.FromResult <IEnumerable <IQbRequest>?>(list as IEnumerable <IQbRequest>));
}
protected override async Task SaveMessageAsync(IAuthenticatedTicket ticket, string key, string value)
{
var state = await dbContext.QbKvpStates
.Where(m => m.Ticket == ticket.Ticket)
.Where(m => m.CurrentStep == ticket.CurrentStep)
.Where(m => m.Key == key)
.FirstOrDefaultAsync();
if (state == null)
{
state = new QbKvpState
{
CurrentStep = ticket.CurrentStep,
Ticket = ticket.Ticket,
Key = key
};
dbContext.QbKvpStates.Add(state);
}
state.Value = value;
await dbContext.SaveChangesAsync();
}
/// <summary>
/// Called when the Web Connector detected an error.
/// You can return a message to be displayed to the user.
/// </summary>
/// <param name="authenticatedTicket">The authenticated ticket.</param>
/// <returns>Message to be displayed to the user.</returns>
public virtual Task <string> LastErrorAsync(IAuthenticatedTicket authenticatedTicket)
{
return(Task.FromResult(string.Empty));
}
/// <summary>
/// Executes the response with all the QbResponse found.
/// </summary>
/// <param name="authenticatedTicket">The authenticated ticket.</param>
/// <param name="responses">The responses.</param>
/// <returns>Task.</returns>
protected internal virtual Task ExecuteResponseAsync(IAuthenticatedTicket authenticatedTicket, IEnumerable <IQbResponse> responses)
{
return(Task.FromResult <object>(null));
}
protected override Task <bool> ExecuteRequestAsync(IAuthenticatedTicket authenticatedTicket, InvoiceQueryRqType request)
{
return(base.ExecuteRequestAsync(authenticatedTicket, request));
}
/// <summary>
/// Returns the path where the client company file is located.
/// Override this method if you wish to open a different file than the current one open on the client.
/// </summary>
/// <param name="authenticatedTicket">The ticket.</param>
/// <returns>Path where company file is located.</returns>
protected internal virtual Task <string> GetCompanyFileAsync(IAuthenticatedTicket authenticatedTicket)
{
return(webConnectorHandler.GetCompanyFileAsync(authenticatedTicket));
}
/// <summary>
/// Indicates if there is anything to be done with the current ticket.
/// Return 0 if you have work to do immediately. Otherwise return the number of seconds
/// when you want the Web Connector to come back.
/// </summary>
/// <returns>Number of seconds to wait before the Web Connector comes back, or 0 to do some work right now.</returns>
protected internal virtual Task <int> GetWaitTimeAsync(IAuthenticatedTicket authenticatedTicket)
{
return(webConnectorHandler.GetWaitTimeAsync(authenticatedTicket));
}
/// <summary>
/// Implement this function in order to save the states to your database.
/// </summary>
protected internal virtual Task SaveChangesAsync(IAuthenticatedTicket authenticatedTicket)
{
return(authenticator.SaveTicketAsync(authenticatedTicket));
}
/// <summary>
/// Processes the response sent for the first time by the WebConnector.
/// </summary>
/// <param name="authenticatedTicket">The ticket.</param>
/// <param name="response">First Message.</param>
protected virtual Task ProcessClientInformationAsync(IAuthenticatedTicket authenticatedTicket, string response)
{
return(webConnectorHandler.ProcessClientInformationAsync(authenticatedTicket, response));
}
protected override Task ExecuteResponseAsync(IAuthenticatedTicket authenticatedTicket, InvoiceQueryRsType response)
{
return(base.ExecuteResponseAsync(authenticatedTicket, response));
}
/// <summary>
/// Logs messages to a database.
/// </summary>
/// <param name="authenticatedTicket">The ticket which has the ticket string. The ticket could also be not authenticated if an error happened.</param>
/// <param name="messageType">Type of message.</param>
/// <param name="direction">Direction of the message (In the WebService, or Out the WebService).</param>
/// <param name="ticket">The ticket.</param>
/// <param name="arguments">Other arguments to save.</param>
protected internal virtual void LogMessage(IAuthenticatedTicket authenticatedTicket, LogMessageType messageType, LogDirection direction, string ticket, params string[] arguments)
{
logger.LogTrace("Ticket: {TICKET}; Type: {TYPE}; Direction: {DIRECTION}; Arguments: {Arguments}", ticket, messageType, direction, arguments);
}
