/// <summary>
/// Accepts an invitation to commerce list.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>The response.</returns>
private static NullResponse AcceptInvitation(AcceptCommerceListInvitationRealtimeRequest request)
{
TransactionServiceClient transactionService = new TransactionServiceClient(request.RequestContext);
transactionService.AcceptCommerceListInvitation(request.InvitationToken, request.CustomerId);
return(new NullResponse());
}
/// <summary>
/// Parses XML into commerce list invitations.
/// </summary>
/// <param name="xml">The XML.</param>
/// <returns>The invitations.</returns>
private static IEnumerable <CommerceListInvitation> ParseCommerceListInvitations(string xml)
{
ThrowIf.NullOrWhiteSpace(xml, "xml");
XDocument doc = XDocument.Parse(xml);
var invitationElements = doc.Descendants("RetailWishListInvitation");
List <CommerceListInvitation> invitations = new List <CommerceListInvitation>();
foreach (var invitationElement in invitationElements)
{
CommerceListInvitation invitation = new CommerceListInvitation();
invitation.RecordId = Convert.ToInt64(invitationElement.Attribute("RecId").Value);
invitation.Invitee = invitationElement.Attribute("Invitee").Value;
invitation.IsSent = Convert.ToBoolean(invitationElement.Attribute("IsSent").Value);
invitation.LastRequestDateTime = TransactionServiceClient.ParseDateTimeOffset(invitationElement, "LastRequestDateTime");
invitation.LastSentDateTime = TransactionServiceClient.ParseDateTimeOffset(invitationElement, "LastSentDateTime");
invitation.StatusValue = Convert.ToInt32(invitationElement.Attribute("Status").Value);
invitation.Token = invitationElement.Attribute("Token").Value;
invitation.InvitationTypeValue = Convert.ToInt32(invitationElement.Attribute("Type").Value);
invitations.Add(invitation);
}
return(invitations);
}
public ActionResult CreateTransaction(Models.TransactionViewModel trans)
{
string serviceMessage;
bool isSuccessful = false;
Guid transId;
var service = new TransactionServiceClient();
var transaction = new TransactionModel();
transaction.AccountId = AccountId;
transaction.Amount = trans.Amount;
transaction.CategoryId = trans.CategoryId;
transaction.CategoryName = trans.CategoryName;
transaction.Description = trans.Description;
transaction.IsDeposit = trans.IsDeposit;
transaction.PaymentTypeId = trans.PaymentTypeId;
transaction.PaymentTypeName = trans.PaymentTypeName;
transaction.TransactionDate = trans.TransactionDate;
transaction.CreatedBy = trans.CreatedBy;
transaction.DateCreated = DateTime.Now.ToUniversalTime();
if (trans.IsDeposit)
{
serviceMessage = service.MakeDeposit(transaction);
}
else
{
serviceMessage = service.MakeWithdrawal(transaction);
}
if (Guid.TryParse(serviceMessage, out transId))
{
isSuccessful = true;
}
return(Json(new { success = isSuccessful, message = serviceMessage }, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Invokes the Real-time service to get commerce lists from AX.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Returns the response that contains the result.</returns>
private static GetCommerceListRealtimeResponse GetCommerceLists(GetCommerceListRealtimeRequest request)
{
TransactionServiceClient transactionService = new TransactionServiceClient(request.RequestContext);
var clists = transactionService.GetCommerceLists(request.Id, request.CustomerAccountNumber, request.FavoriteFilter, request.PublicFilter);
return(new GetCommerceListRealtimeResponse(clists));
}
/// <summary>
/// Picks and packs customer order.
/// </summary>
/// <param name="request">The request for picking/packing.</param>
/// <returns>The operation result.</returns>
private static Response PickAndPackOrder(PickAndPackOrderRealtimeRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
if (string.IsNullOrWhiteSpace(request.SalesId))
{
throw new ArgumentException("SalesId must be set in request", "request");
}
if (string.IsNullOrWhiteSpace(request.InventoryLocationId))
{
throw new ArgumentException("InventoyLocationId must be set in request", "request");
}
var client = new TransactionServiceClient(request.RequestContext);
if (request.CreatePickingList)
{
client.CreatePickingList(request.SalesId, request.InventoryLocationId);
}
if (request.CreatePackingSlip)
{
client.CreatePackingSlip(request.SalesId, request.InventoryLocationId);
}
return(new NullResponse());
}
/// <summary>
/// Recall a customer order by sales id.
/// </summary>
/// <param name="request">The request containing the sales id.</param>
/// <returns>The response containing the sales order.</returns>
private static RecallCustomerOrderRealtimeResponse RecallCustomerOrder(RecallCustomerOrderRealtimeRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
var client = new TransactionServiceClient(request.RequestContext);
ReadOnlyCollection <object> transactionResponse;
if (request.IsQuote)
{
transactionResponse = client.GetCustomerQuote(request.Id);
}
else
{
transactionResponse = client.GetCustomerOrder(request.Id, includeOnlineOrders: true);
}
var orderInfo = CustomerOrderInfo.FromXml(transactionResponse[0].ToString());
var order = SalesOrderHelper.GetSalesOrderFromInfo(orderInfo, request.RequestContext.GetChannelConfiguration(), request.RequestContext);
// Check that the channel currency code is the same as the recalled order
if (order != null && !string.IsNullOrWhiteSpace(order.CurrencyCode) && !request.RequestContext.GetChannelConfiguration().Currency.Equals(order.CurrencyCode, StringComparison.OrdinalIgnoreCase))
{
throw new DataValidationException(
DataValidationErrors.Microsoft_Dynamics_Commerce_Runtime_CurrencyChannelOrderMismatch,
string.Format("Channel currency = {0} doesn't match sales order currency = {1}", request.RequestContext.GetChannelConfiguration().Currency, order.CurrencyCode));
}
var response = new RecallCustomerOrderRealtimeResponse(order);
return(response);
}
private static SearchProductsRealtimeResponse RemoteSearchProducts(RemoteSearchProductsRealtimeRequest request)
{
var client = new TransactionServiceClient(request.RequestContext);
PagedResult <ProductSearchResult> searchResults = null;
long currentChannelId = request.RequestContext.GetPrincipal().ChannelId;
var retrieveAttributeSchemaEntriesDataRequest = new GetProductMediaAttributeSchemaEntriesDataRequest();
retrieveAttributeSchemaEntriesDataRequest.QueryResultSettings = new QueryResultSettings(new ColumnSet(new string[] { "ATTRIBUTE", "DATATYPE" }), PagingInfo.CreateWithExactCount(2, 0), new SortingInfo("DATATYPE"));
var attributeSchemaEntries = request.RequestContext.Execute <EntityDataServiceResponse <ProductAttributeSchemaEntry> >(retrieveAttributeSchemaEntriesDataRequest).PagedEntityCollection.Results;
var imageAttributeId = attributeSchemaEntries.Single(r => r.DataType == AttributeDataType.Image).RecordId;
var attributesValuesToRetrieve = Convert.ToString(imageAttributeId);
if (request.CategoryId.HasValue)
{
searchResults = new PagedResult <ProductSearchResult>(client.SearchProductsByCategoryId(currentChannelId, (long)request.CategoryId, request.RequestContext.LanguageId, request.ChannelId, request.CatalogId, attributesValuesToRetrieve, request.QueryResultSettings), request.QueryResultSettings.Paging);
}
else if (!string.IsNullOrWhiteSpace(request.SearchText))
{
searchResults = new PagedResult <ProductSearchResult>(client.SearchProductsByText(currentChannelId, request.SearchText, request.ChannelId, request.CatalogId, attributesValuesToRetrieve, request.QueryResultSettings), request.QueryResultSettings.Paging);
}
else
{
throw new ArgumentOutOfRangeException("request", "A valid category identfier or search text must be provided to search products.");
}
return(new SearchProductsRealtimeResponse(searchResults));
}
private void GetTransactionHistory()
{
decimal balance = 0.00M;
var transService = new TransactionServiceClient();
var history = transService.GetTransactions(_acctId);
dgvTransactionHistory.AutoGenerateColumns = false;
dgvTransactionHistory.DataSource = history;
for (int i = 0; i < history.Length; i++)
{
dgvTransactionHistory["TransactionDate", i].Value = history[i].TransactionDate.ToShortDateString();
dgvTransactionHistory["PaymentType", i].Value = history[i].PaymentTypeName;
dgvTransactionHistory["Category", i].Value = history[i].CategoryName;
dgvTransactionHistory["Description", i].Value = history[i].Description;
if (history[i].IsDeposit)
{
dgvTransactionHistory["Deposit", i].Value = history[i].Amount;
balance += history[i].Amount;
}
else
{
dgvTransactionHistory["Withdrawal", i].Value = history[i].Amount;
balance -= history[i].Amount;
}
dgvTransactionHistory["Balance", i].Value = balance;
}
}
/// <summary>
/// Retrieves the Stock Count Journals from AX.
/// </summary>
/// <param name="inventLocationId">Pass Invent Location Id.</param>
/// <returns>Returns the StockCountJournal list from AX.</returns>
public PagedResult <StockCountJournal> GetStockCountJournals(string inventLocationId)
{
ThrowIf.Null <string>(inventLocationId, "inventoryLocationId");
var data = this.InvokeMethod(GetInventJournalsMethodName, inventLocationId);
IEnumerable <StockCountJournal> journals = new List <StockCountJournal>();
if (!string.IsNullOrEmpty(data[0].ToString()))
{
XDocument doc = XDocument.Parse(data[0].ToString());
XElement root = doc.Elements("InventJournalTables").FirstOrDefault();
if (root != null)
{
journals = root.Elements("InventJournalTable").Select <XElement, StockCountJournal>(
(sc) =>
{
StockCountJournal scJournal = TransactionServiceClient.Parse(sc);
return(scJournal);
});
}
}
return(journals.AsPagedResult());
}
/// <summary>
/// Commits the Stock count journals and transactions to AX.
/// </summary>
/// <param name="stockCountJournal">Pass in stock count journal.</param>
/// <returns>Returns the stock count journal created.</returns>
public StockCountJournal CommitStockCounts(StockCountJournal stockCountJournal)
{
ThrowIf.Null <StockCountJournal>(stockCountJournal, "stockCountJournal");
// Filter stock count line that has status pending updates.
stockCountJournal.StockCountTransactionLines = stockCountJournal.StockCountTransactionLines
.Where(stockCountLine => stockCountLine.StatusEnum == StockCountStatus.PendingUpdate).ToList();
string importValue = TransactionServiceClient.ToXml(stockCountJournal);
var data = this.InvokeMethod(UpdateInventJournalsMethodName, importValue);
var journalTransactions = new List <StockCountJournalTransaction>();
if (!string.IsNullOrWhiteSpace(data[0].ToString()))
{
XDocument doc = XDocument.Parse(data[0].ToString());
XElement root = doc.Elements("InventJournalTable").FirstOrDefault();
if (root != null)
{
journalTransactions = root.Elements("InventJournalTrans").Select <XElement, StockCountJournalTransaction>(
(scLine) =>
{
var scJournalTransaction = TransactionServiceClient.ParseTransactions(scLine);
return(scJournalTransaction);
}).ToList <StockCountJournalTransaction>();
}
}
stockCountJournal.StockCountTransactionLines.Clear();
stockCountJournal.StockCountTransactionLines.AddRange(journalTransactions);
return(stockCountJournal);
}
/// <summary>
/// Parse xml StockCount journal transaction data into object.
/// </summary>
/// <param name="xmlJournalTransaction">Xml format of a stock count journal Transaction.</param>
/// <returns>Returns the StockCountJournalTransactions object.</returns>
private static StockCountJournalTransaction ParseTransactions(XElement xmlJournalTransaction)
{
var journalTransaction = new StockCountJournalTransaction();
string recId = TransactionServiceClient.GetAttributeValue(xmlJournalTransaction, "RecId");
// Set default values for those not existing in AX
journalTransaction.RecordId = string.IsNullOrEmpty(recId) ? 0 : long.Parse(recId);
journalTransaction.OperationType = 0;
journalTransaction.Quantity = 0;
journalTransaction.CountedDate = DateTime.UtcNow;
journalTransaction.StatusEnum = StockCountStatus.Unchanged;
journalTransaction.ItemId = TransactionServiceClient.GetAttributeValue(xmlJournalTransaction, "ItemId");
journalTransaction.ItemName = TransactionServiceClient.GetAttributeValue(xmlJournalTransaction, "EcoResProductName");
journalTransaction.InventDimId = TransactionServiceClient.GetAttributeValue(xmlJournalTransaction, "InventDimId");
journalTransaction.Counted = Convert.ToDecimal(TransactionServiceClient.GetAttributeValue(xmlJournalTransaction, "Counted"));
journalTransaction.InventBatchId = TransactionServiceClient.GetAttributeValue(xmlJournalTransaction, "InventBatchId");
journalTransaction.WarehouseLocationId = TransactionServiceClient.GetAttributeValue(xmlJournalTransaction, "WmsLocationId");
journalTransaction.WarehousePalletId = TransactionServiceClient.GetAttributeValue(xmlJournalTransaction, "WmsPalletId");
journalTransaction.InventSiteId = TransactionServiceClient.GetAttributeValue(xmlJournalTransaction, "InventSiteId");
journalTransaction.InventLocationId = TransactionServiceClient.GetAttributeValue(xmlJournalTransaction, "InventLocationId");
journalTransaction.ConfigId = TransactionServiceClient.GetAttributeValue(xmlJournalTransaction, "ConfigId");
journalTransaction.InventSizeId = TransactionServiceClient.GetAttributeValue(xmlJournalTransaction, "InventSizeId");
journalTransaction.InventColorId = TransactionServiceClient.GetAttributeValue(xmlJournalTransaction, "InventColorId");
journalTransaction.InventStyleId = TransactionServiceClient.GetAttributeValue(xmlJournalTransaction, "InventStyleId");
journalTransaction.InventSerialId = TransactionServiceClient.GetAttributeValue(xmlJournalTransaction, "InventSerialId");
journalTransaction.TrackingGuid = new Guid(TransactionServiceClient.GetAttributeValue(xmlJournalTransaction, "Guid"));
journalTransaction.UpdatedInAx = Convert.ToBoolean(TransactionServiceClient.GetAttributeValue(xmlJournalTransaction, "UpdatedInAx"));
journalTransaction.Message = TransactionServiceClient.GetAttributeValue(xmlJournalTransaction, "Message");
return(journalTransaction);
}
/// <summary>
/// Retrieves the commerce lists from AX.
/// </summary>
/// <param name="commerceListId">The commerce list id.</param>
/// <param name="customerId">The customer id.</param>
/// <param name="favoriteFilter">Indicates whether or not to filter by favorite.</param>
/// <param name="publicFilter">Indicates whether or not to filter by public.</param>
/// <returns>Returns the commerce lists from AX.</returns>
public PagedResult <CommerceList> GetCommerceLists(long commerceListId, string customerId, bool favoriteFilter, bool publicFilter)
{
var data = this.InvokeMethod(GetWishListsMethodName, commerceListId, customerId, favoriteFilter, publicFilter);
IEnumerable <CommerceList> wishLists = new List <CommerceList>();
var response = data[0].ToString();
if (!string.IsNullOrEmpty(response))
{
XDocument doc = XDocument.Parse(response);
XElement root = doc.Elements("WishLists").FirstOrDefault();
if (root != null)
{
wishLists = root.Elements("RetailWishListTable").Select <XElement, CommerceList>(
(wL) =>
{
CommerceList commerceList = TransactionServiceClient.ParseCommerceList(wL);
return(commerceList);
});
}
}
return(wishLists.AsPagedResult());
}
/// <summary>
/// Executes get stores by employee request.
/// </summary>
/// <param name="request">The service request.</param>
/// <returns>The response containing accessible stores of this employee.</returns>
private static EntityDataServiceResponse <OrgUnit> GetEmployeeStoresFromAddressBook(GetEmployeeStoresFromAddressBookRealtimeRequest request)
{
var transactionService = new TransactionServiceClient(request.RequestContext);
PagedResult <OrgUnit> orgUnits = transactionService.GetEmployeeStoresFromAddressBook(request.RequestContext.GetPrincipal().UserId, request.QueryResultSettings);
return(new EntityDataServiceResponse <OrgUnit>(orgUnits));
}
/// <summary>
/// Gets the customer purchase history data.
/// </summary>
/// <param name="request">The real time request to get customer purchase history.</param>
/// <returns>A collection of purchase history.</returns>
private static GetPurchaseHistoryRealtimeResponse GetPurchaseHistory(GetPurchaseHistoryRealtimeRequest request)
{
var client = new TransactionServiceClient(request.RequestContext);
PagedResult <PurchaseHistory> results = client.GetPurchaseHistory(request.CustomerAccountNumber, request.RequestContext.LanguageId, request.StartDateTime, request.QueryResultSettings);
return(new GetPurchaseHistoryRealtimeResponse(results));
}
/// <summary>
/// Retrieves Stock Count journal Transactions from AX.
/// </summary>
/// <param name="journalId">Pass JournalId.</param>
/// <param name="inventLocationId">Pass Invent Location Id.</param>
/// <returns>Returns the StockCount journal Transactions.</returns>
public PagedResult <StockCountJournalTransaction> GetStockCountJournalsTransaction(string journalId, string inventLocationId)
{
ThrowIf.Null <string>(journalId, "journalId");
ThrowIf.Null <string>(inventLocationId, "inventoryLocationId");
var data = this.InvokeMethod(GetInventJournalTransactionMethodName, journalId, inventLocationId);
IEnumerable <StockCountJournalTransaction> journalTransactions = new List <StockCountJournalTransaction>();
if (!string.IsNullOrWhiteSpace(data[0].ToString()))
{
XDocument doc = XDocument.Parse(data[0].ToString());
XElement root = doc.Elements("InventJournalTable").FirstOrDefault();
if (root != null)
{
journalTransactions = root.Elements("InventJournalTrans").Select <XElement, StockCountJournalTransaction>(
(scLine) =>
{
StockCountJournalTransaction scJournalTransaction = TransactionServiceClient.ParseTransactions(scLine);
return(scJournalTransaction);
}).ToList <StockCountJournalTransaction>();
}
}
return(journalTransactions.AsPagedResult());
}
/// <summary>
/// Generates a recording bundle.
/// </summary>
/// <param name="request">Request for generating the recording bundle.</param>
/// <returns>
/// The URL to download the recording bundle.
/// </returns>
private static SingleEntityDataServiceResponse <string> GenerateRecordingBundle(GenerateRecordingBundleRealtimeRequest request)
{
TransactionServiceClient transactionService = new TransactionServiceClient(request.RequestContext);
string recordingBundleUrl = transactionService.GenerateRecordingBundle(request.Recording);
return(new SingleEntityDataServiceResponse <string>(recordingBundleUrl));
}
/// <summary>
/// Generates a business process model package.
/// </summary>
/// <param name="request">Request for generating the business process model package.</param>
/// <returns>
/// The URL to download the business process model package.
/// </returns>
private static SingleEntityDataServiceResponse <string> GenerateBusinessProcessModelPackage(GenerateBusinessProcessModelPackageRealtimeRequest request)
{
TransactionServiceClient transactionService = new TransactionServiceClient(request.RequestContext);
string businessProcessModelPackageUrl = transactionService.GenerateBusinessProcessModelPackage(request.Recording);
return(new SingleEntityDataServiceResponse <string>(businessProcessModelPackageUrl));
}
/// <summary>
/// Generates a training document.
/// </summary>
/// <param name="request">Request for generating the training document.</param>
/// <returns>The URL to the training document.</returns>
private static SingleEntityDataServiceResponse <string> GenerateTrainingDocument(GenerateTrainingDocumentRealtimeRequest request)
{
TransactionServiceClient transactionService = new TransactionServiceClient(request.RequestContext);
string trainingDocumentUrl = transactionService.GenerateTrainingDocument(request.Recording);
return(new SingleEntityDataServiceResponse <string>(trainingDocumentUrl));
}
/// <summary>
/// Upload the recording to Lifecycle Services.
/// </summary>
/// <param name="request">Request for uploading the recording.</param>
/// <returns>The null response.</returns>
private static Response UploadRecording(UploadRecordingRealtimeRequest request)
{
TransactionServiceClient transactionService = new TransactionServiceClient(request.RequestContext);
transactionService.UploadRecording(request.Recording, request.BusinessProcessModelLineId);
return(new NullResponse());
}
/// <summary>
/// Gets a storage access token for upload.
/// </summary>
/// <param name="request">Request for getting the storage access token.</param>
/// <returns>The storage access token.</returns>
private static SingleEntityDataServiceResponse <StorageAccessToken> GetStorageAccessTokenForUpload(GetStorageAccessTokenForUploadRealtimeRequest request)
{
TransactionServiceClient transactionService = new TransactionServiceClient(request.RequestContext);
StorageAccessToken storageAccessToken = transactionService.GetStorageAccessTokenForUpload();
return(new SingleEntityDataServiceResponse <StorageAccessToken>(storageAccessToken));
}
/// <summary>
/// Sends an email to the requested customer using the email template defined in AX.
/// </summary>
/// <param name="request">Request containing the customer and email template identifier.</param>
/// <returns>SendCustomerEmailServiceResponse object.</returns>
private static NullResponse SendEmailToCustomer(SendEmailRealtimeRequest request)
{
TransactionServiceClient transactionService = new TransactionServiceClient(request.RequestContext);
transactionService.SendEmail(request.EmailAddress, request.Language, request.EmailId, request.Mappings, request.XmlData);
return(new NullResponse());
}
/// <summary>
/// Updates a customer in AX.
/// </summary>
/// <param name="request">The service request to update a customer.</param>
/// <returns>The service response.</returns>
private static SaveCustomerRealtimeResponse UpdateCustomer(SaveCustomerRealtimeRequest request)
{
var client = new TransactionServiceClient(request.RequestContext);
Customer customer = client.UpdateCustomer(request.CustomerToSave);
return(new SaveCustomerRealtimeResponse(customer));
}
/// <summary>
/// Gets a single business process model library framework.
/// </summary>
/// <param name="request">Request for getting the business process model library framework.</param>
/// <returns>
/// The response containing the business process model library framework.
/// </returns>
private static SingleEntityDataServiceResponse <Framework> GetBusinessProcessModelLibrary(GetBusinessProcessModelLibraryRealtimeRequest request)
{
TransactionServiceClient transactionService = new TransactionServiceClient(request.RequestContext);
var response = transactionService.GetBusinessProcessModelLibrary(request.BusinessProcessModelFrameworkId, request.HierarchyDepth);
return(new SingleEntityDataServiceResponse <Framework>(response));
}
/// <summary>
/// Downloads the recording from LCS.
/// </summary>
/// <param name="request">Request for downloading the recording.</param>
/// <returns>
/// The downloaded recording from LCS.
/// </returns>
private static SingleEntityDataServiceResponse <Recording> DownloadRecording(DownloadRecordingRealtimeRequest request)
{
TransactionServiceClient transactionService = new TransactionServiceClient(request.RequestContext);
Recording recording = transactionService.DownloadRecording(request.BusinessProcessModelLineId);
return(new SingleEntityDataServiceResponse <Recording>(recording));
}
/// <summary>
/// Gets the business process model libraries.
/// </summary>
/// <param name="request">Request for getting the business process model libraries.</param>
/// <returns>
/// The response containing the business process model libraries.
/// </returns>
private static GetBusinessProcessModelLibrariesRealtimeResponse GetBusinessProcessModelLibraries(GetBusinessProcessModelLibrariesRealtimeRequest request)
{
TransactionServiceClient transactionService = new TransactionServiceClient(request.RequestContext);
var response = transactionService.GetBusinessProcessModelLibraries(request.QueryResultSettings);
return(new GetBusinessProcessModelLibrariesRealtimeResponse(response));
}
/// <summary>
/// Loads and returns a recording from an XML file.
/// </summary>
/// <param name="request">Request for loading recording from file.</param>
/// <returns>
/// The recording from the XML file.
/// </returns>
private static SingleEntityDataServiceResponse <Recording> LoadRecordingFromFile(LoadRecordingFromFileRealtimeRequest request)
{
TransactionServiceClient transactionService = new TransactionServiceClient(request.RequestContext);
var response = transactionService.LoadRecordingFromFile(request.RecordingUrl);
return(new SingleEntityDataServiceResponse <Recording>(response));
}
/// <summary>
/// Searches for task guides by title.
/// </summary>
/// <param name="request">Request for searching task guides by title.</param>
/// <returns>
/// The response containing task guide search results.
/// </returns>
private static SingleEntityDataServiceResponse <TaskGuidesSearchResult> SearchTaskGuidesByTitle(SearchTaskGuidesByTitleRealtimeRequest request)
{
TransactionServiceClient transactionService = new TransactionServiceClient(request.RequestContext);
var response = transactionService.SearchTaskGuidesByTitle(request.BusinessProcessModelFrameworkId, request.TaskGuideSearchText, request.QueryTypeValue);
return(new SingleEntityDataServiceResponse <TaskGuidesSearchResult>(response));
}
/// <summary>
/// Deactivates an address in AX.
/// </summary>
/// <param name="request">The service request to deactivate an address.</param>
/// <returns>The service response.</returns>
private static NullResponse DeactivateAddress(DeactivateAddressRealtimeRequest request)
{
var client = new TransactionServiceClient(request.RequestContext);
client.DeactivateAddress(request.AddressId, request.CustomerId);
return(new NullResponse());
}
/// <summary>
/// Validates Customer Account Payment from AX.
/// </summary>
/// <param name="request">The service request to validate customer account payment.</param>
/// <returns>The service response.</returns>
private static NullResponse ValidateCustomerAccountPayment(ValidateCustomerAccountPaymentRealtimeRequest request)
{
var client = new TransactionServiceClient(request.RequestContext);
client.ValidateCustomerAccountPayment(request.AccountNumber, request.Amount, request.CurrencyCode);
return(new NullResponse());
}
/// <summary>
/// Default constructor
/// </summary>
public DAXVersionRealTimeServiceController()
{
// Need to set the ChannelId explicitly
this.CommerceIdentity = User.Identity as CommerceIdentity;
this.CommerceIdentity.ChannelId = 5637144662;
TransactionServiceClient = new TransactionServiceClient(CommerceRuntimeManager.Runtime.CreateRequestContext(new RealtimeRequest()));
}
protected void btnCreate_Click(object sender, EventArgs e) {
try {
using (TransactionScope ts = new TransactionScope()) {
var transClient = new TransactionServiceClient();
int id =
transClient.CreateEmployee(new Employee() {
EName = txtEmployeeName.Text,
ESalary = double.Parse(txtEmployeeSalary.Text)
});
//if (id != 0) {
transClient.CreateSalaryHistory(new SalaryHistory() {
// Eid = id,
ESalary = double.Parse(txtEmployeeSalary.Text),
StDate = DateTime.Now,
EndDate = null
});
//}
ts.Complete();
}
} catch (Exception Ex) {
}
}
public Program()
{
lock (_lock)
{
if (_transactionServiceClient == null)
_transactionServiceClient = new TransactionServiceClient();
if (_memberServiceClient == null)
_memberServiceClient = new MemberServiceClient();
}
}
static void Main(string[] args)
{
lock (_lock)
{
if (_transactionServiceClient == null)
_transactionServiceClient = new TransactionServiceClient();
if (_memberServiceClient == null)
_memberServiceClient = new MemberServiceClient();
}
var allTransaction = GetTransaction();
var filteredTransaction =ExcludeExistingTransaction(allTransaction);
ProcessSoftCash(filteredTransaction);
Log();
}
