Created
July 26, 2012 06:30
-
-
Save zzc000/3180591 to your computer and use it in GitHub Desktop.
CrmContext
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
using System; | |
using System.Collections.Generic; | |
using System.Data.Services; | |
using Microsoft.Xrm.Client; | |
using Microsoft.Xrm.Client.Configuration; | |
using Microsoft.Xrm.Client.Messages; | |
using Microsoft.Xrm.Sdk; | |
namespace CrmOrganizationServiceContextExtensions | |
{ | |
public class CrmContext : CrmOrganizationServiceContext, ICrmOrganizationServiceContext, IInitializable, IOrganizationService, IUpdatable, IExpandProvider, IOrganizationServiceContainer | |
{ | |
public CrmContext() : base() { } | |
public CrmContext(string contextName) : base(contextName) { } | |
public CrmContext(CrmConnection connection) : base(connection) { } | |
public CrmContext(IOrganizationService service) : base(service) { } | |
private Microsoft.Xrm.Sdk.Client.OrganizationServiceContext _context; | |
private Microsoft.Xrm.Sdk.Client.OrganizationServiceContext Context | |
{ | |
get | |
{ | |
if (_context == null) | |
{ | |
_context = this as Microsoft.Xrm.Sdk.Client.OrganizationServiceContext; | |
} | |
return _context; | |
} | |
} | |
#region Microsoft.Xrm.Client.Messages.OrganizationServiceContextExtensions | |
/* | |
* Microsoft.Xrm.Client.Messages.OrganizationServiceContextExtensions | |
*/ | |
public Guid AddItemCampaign(Guid campaignId, Guid entityId, string entityName) | |
{ | |
return Context.AddItemCampaign(campaignId, entityId, entityName); | |
} | |
public Guid AddItemCampaignActivity(Guid campaignActivityId, Guid itemId, string entityName) | |
{ | |
return Context.AddItemCampaignActivity(campaignActivityId, itemId, entityName); | |
} | |
public void AddListMembersList(Guid listId, Guid[] memberIds) | |
{ | |
Context.AddListMembersList(listId, memberIds); | |
} | |
public Guid AddMemberList(Guid listId, Guid entityId) | |
{ | |
return Context.AddMemberList(listId, entityId); | |
} | |
public void AddMembersTeam(Guid teamId, Guid[] memberIds) | |
{ | |
Context.AddMembersTeam(teamId, memberIds); | |
} | |
public void AddPrivilegesRole(Guid roleId, object privileges) | |
{ | |
Context.AddPrivilegesRole(roleId, privileges); | |
} | |
public void AddProductToKit(Guid kitId, Guid productId) | |
{ | |
Context.AddProductToKit(kitId, productId); | |
} | |
public Guid AddRecurrence(Microsoft.Xrm.Sdk.Entity target, Guid appointmentId) | |
{ | |
return Context.AddRecurrence(target, appointmentId); | |
} | |
public Guid AddSolutionComponent(Guid componentId, int componentType, string solutionUniqueName, bool addRequiredComponents) | |
{ | |
return Context.AddSolutionComponent(componentId, componentType, solutionUniqueName, addRequiredComponents); | |
} | |
public void AddSubstituteProduct(Guid productId, Guid substituteId) | |
{ | |
Context.AddSubstituteProduct(productId, substituteId); | |
} | |
public Guid AddToQueue(Microsoft.Xrm.Sdk.EntityReference target, Guid sourceQueueId, Guid destinationQueueId, Microsoft.Xrm.Sdk.Entity queueItemProperties) | |
{ | |
return Context.AddToQueue(target, sourceQueueId, destinationQueueId, queueItemProperties); | |
} | |
public void Assign(Microsoft.Xrm.Sdk.EntityReference target, Microsoft.Xrm.Sdk.EntityReference assignee) | |
{ | |
Context.Assign(target, assignee); | |
} | |
public void AssociateEntities(Microsoft.Xrm.Sdk.EntityReference moniker1, Microsoft.Xrm.Sdk.EntityReference moniker2, string relationshipName) | |
{ | |
Context.AssociateEntities(moniker1, moniker2, relationshipName); | |
} | |
public void AutoMapEntity(Guid entityMapId) | |
{ | |
Context.AutoMapEntity(entityMapId); | |
} | |
public TResponse BackgroundSendEmail<TResponse>(Microsoft.Xrm.Sdk.Query.QueryBase query) where TResponse : Microsoft.Xrm.Sdk.OrganizationResponse | |
{ | |
return Context.BackgroundSendEmail<TResponse>(query); | |
} | |
public TResult Book<TResult>(Microsoft.Xrm.Sdk.Entity target) | |
{ | |
return Context.Book<TResult>(target); | |
} | |
public Guid BulkDelete(Microsoft.Xrm.Sdk.Query.QueryExpression[] querySet, string jobName, bool sendEmailNotification, Guid[] toRecipients, Guid[] cCRecipients, string recurrencePattern, DateTime startDateTime, Guid? sourceImportId) | |
{ | |
return Context.BulkDelete(querySet, jobName, sendEmailNotification, toRecipients, cCRecipients, recurrencePattern, startDateTime, sourceImportId); | |
} | |
public Guid BulkDetectDuplicates(Microsoft.Xrm.Sdk.Query.QueryBase query, string jobName, bool sendEmailNotification, Guid templateId, Guid[] toRecipients, Guid[] cCRecipients, string recurrencePattern, DateTime recurrenceStartTime) | |
{ | |
return Context.BulkDetectDuplicates(query, jobName, sendEmailNotification, templateId, toRecipients, cCRecipients, recurrencePattern, recurrenceStartTime); | |
} | |
public void BulkOperationStatusClose(Guid bulkOperationId, int failureCount, int successCount, int statusReason, int errorCode) | |
{ | |
Context.BulkOperationStatusClose(bulkOperationId, failureCount, successCount, statusReason, errorCode); | |
} | |
public decimal CalculateActualValueOpportunity(Guid opportunityId) | |
{ | |
return Context.CalculateActualValueOpportunity(opportunityId); | |
} | |
public long CalculateTotalTimeIncident(Guid incidentId) | |
{ | |
return Context.CalculateTotalTimeIncident(incidentId); | |
} | |
public void CancelContract(Guid contractId, DateTime cancelDate, Microsoft.Xrm.Sdk.OptionSetValue status) | |
{ | |
Context.CancelContract(contractId, cancelDate, status); | |
} | |
public void CancelSalesOrder(Microsoft.Xrm.Sdk.Entity orderClose, Microsoft.Xrm.Sdk.OptionSetValue status) | |
{ | |
Context.CancelSalesOrder(orderClose, status); | |
} | |
public TResponse CheckIncomingEmail<TResponse>(string messageId, string subject, string from, string to, string cc, string bcc) where TResponse : Microsoft.Xrm.Sdk.OrganizationResponse | |
{ | |
return Context.CheckIncomingEmail<TResponse>(messageId, subject, from, to, cc, bcc); | |
} | |
public TResponse CheckPromoteEmail<TResponse>(string messageId, string subject) where TResponse : Microsoft.Xrm.Sdk.OrganizationResponse | |
{ | |
return Context.CheckPromoteEmail<TResponse>(messageId, subject); | |
} | |
public void CleanUpBulkOperation(Guid bulkOperationId, int bulkOperationSource) | |
{ | |
Context.CleanUpBulkOperation(bulkOperationId, bulkOperationSource); | |
} | |
public Microsoft.Xrm.Sdk.Entity CloneContract(Guid contractId, bool includeCanceledLines) | |
{ | |
return Context.CloneContract(contractId, includeCanceledLines); | |
} | |
public void CloseIncident(Microsoft.Xrm.Sdk.Entity incidentResolution, Microsoft.Xrm.Sdk.OptionSetValue status) | |
{ | |
Context.CloseIncident(incidentResolution, status); | |
} | |
public void CloseIncident(Microsoft.Xrm.Sdk.Entity incidentResolution, int status) | |
{ | |
Context.CloseIncident(incidentResolution, status); | |
} | |
public void CloseQuote(Microsoft.Xrm.Sdk.Entity quoteClose, Microsoft.Xrm.Sdk.OptionSetValue status) | |
{ | |
Context.CloseQuote(quoteClose, status); | |
} | |
public Guid CompoundCreate(Microsoft.Xrm.Sdk.Entity entity, Microsoft.Xrm.Sdk.EntityCollection childEntities) | |
{ | |
return Context.CompoundCreate(entity, childEntities); | |
} | |
public void CompoundUpdate(Microsoft.Xrm.Sdk.Entity entity, Microsoft.Xrm.Sdk.EntityCollection childEntities) | |
{ | |
Context.CompoundUpdate(entity, childEntities); | |
} | |
public void CompoundUpdateDuplicateDetectionRule(Microsoft.Xrm.Sdk.Entity entity, Microsoft.Xrm.Sdk.EntityCollection childEntities) | |
{ | |
Context.CompoundUpdateDuplicateDetectionRule(entity, childEntities); | |
} | |
public void ConvertKitToProduct(Guid kitId) | |
{ | |
Context.ConvertKitToProduct(kitId); | |
} | |
public void ConvertProductToKit(Guid productId) | |
{ | |
Context.ConvertProductToKit(productId); | |
} | |
public Microsoft.Xrm.Sdk.Entity ConvertQuoteToSalesOrder(Guid quoteId, Microsoft.Xrm.Sdk.Query.ColumnSet columnSet) | |
{ | |
return Context.ConvertQuoteToSalesOrder(quoteId, columnSet); | |
} | |
public Microsoft.Xrm.Sdk.Entity ConvertSalesOrderToInvoice(Guid salesOrderId, Microsoft.Xrm.Sdk.Query.ColumnSet columnSet) | |
{ | |
return Context.ConvertSalesOrderToInvoice(salesOrderId, columnSet); | |
} | |
public Guid CopyCampaign(Guid baseCampaign, bool saveAsTemplate) | |
{ | |
return Context.CopyCampaign(baseCampaign, saveAsTemplate); | |
} | |
public Guid CopyCampaignResponse(Microsoft.Xrm.Sdk.EntityReference campaignResponseId) | |
{ | |
return Context.CopyCampaignResponse(campaignResponseId); | |
} | |
public Guid CopyDynamicListToStatic(Guid listId) | |
{ | |
return Context.CopyDynamicListToStatic(listId); | |
} | |
public void CopyMembersList(Guid sourceListId, Guid targetListId) | |
{ | |
Context.CopyMembersList(sourceListId, targetListId); | |
} | |
public Guid CopySystemForm(Microsoft.Xrm.Sdk.Entity target, Guid sourceId) | |
{ | |
return Context.CopySystemForm(target, sourceId); | |
} | |
public Guid CreateActivitiesList(Guid listId, string friendlyName, Microsoft.Xrm.Sdk.Entity activity, Guid templateId, bool propagate, object ownershipOptions, Microsoft.Xrm.Sdk.EntityReference owner, bool sendEmail, bool postWorkflowEvent, Guid queueId) | |
{ | |
return Context.CreateActivitiesList(listId, friendlyName, activity, templateId, propagate, ownershipOptions, owner, sendEmail, postWorkflowEvent, queueId); | |
} | |
public Guid CreateException(Microsoft.Xrm.Sdk.Entity target, DateTime originalStartDate, bool isDeleted) | |
{ | |
return Context.CreateException(target, originalStartDate, isDeleted); | |
} | |
public bool CreateInstance(Microsoft.Xrm.Sdk.Entity target, int count) | |
{ | |
return Context.CreateInstance(target, count); | |
} | |
public Guid CreateWorkflowFromTemplate(string workflowName, Guid workflowTemplateId) | |
{ | |
return Context.CreateWorkflowFromTemplate(workflowName, workflowTemplateId); | |
} | |
public int DeleteAuditData(DateTime endDate) | |
{ | |
return Context.DeleteAuditData(endDate); | |
} | |
public void DeleteOpenInstances(Microsoft.Xrm.Sdk.Entity target, DateTime seriesEndDate, int stateOfPastInstances) | |
{ | |
Context.DeleteOpenInstances(target, seriesEndDate, stateOfPastInstances); | |
} | |
public Guid DeliverIncomingEmail(string messageId, string subject, string from, string to, string cc, string bcc, DateTime receivedOn, string submittedBy, string importance, string body, Microsoft.Xrm.Sdk.EntityCollection attachments) | |
{ | |
return Context.DeliverIncomingEmail(messageId, subject, from, to, cc, bcc, receivedOn, submittedBy, importance, body, attachments); | |
} | |
public Guid DeliverPromoteEmail(Guid emailId, string messageId, string subject, string from, string to, string cc, string bcc, DateTime receivedOn, string submittedBy, string importance, string body, Microsoft.Xrm.Sdk.EntityCollection attachments, Microsoft.Xrm.Sdk.Entity extraProperties) | |
{ | |
return Context.DeliverPromoteEmail(emailId, messageId, subject, from, to, cc, bcc, receivedOn, submittedBy, importance, body, attachments, extraProperties); | |
} | |
public void DeprovisionLanguage(int language) | |
{ | |
Context.DeprovisionLanguage(language); | |
} | |
public void DisassociateEntities(Microsoft.Xrm.Sdk.EntityReference moniker1, Microsoft.Xrm.Sdk.EntityReference moniker2, string relationshipName) | |
{ | |
Context.DisassociateEntities(moniker1, moniker2, relationshipName); | |
} | |
public Guid DistributeCampaignActivity(Guid campaignActivityId, bool propagate, Microsoft.Xrm.Sdk.Entity activity, Guid templateId, object ownershipOptions, Microsoft.Xrm.Sdk.EntityReference owner, bool sendEmail, Guid queueId) | |
{ | |
return Context.DistributeCampaignActivity(campaignActivityId, propagate, activity, templateId, ownershipOptions, owner, sendEmail, queueId); | |
} | |
public string DownloadReportDefinition(Guid reportId) | |
{ | |
return Context.DownloadReportDefinition(reportId); | |
} | |
public string ExecuteByIdSavedQuery(Guid entityId) | |
{ | |
return Context.ExecuteByIdSavedQuery(entityId); | |
} | |
public string ExecuteByIdUserQuery(Microsoft.Xrm.Sdk.EntityReference entityId) | |
{ | |
return Context.ExecuteByIdUserQuery(entityId); | |
} | |
public string ExecuteFetch(string fetchXml) | |
{ | |
return Context.ExecuteFetch(fetchXml); | |
} | |
public Guid ExecuteWorkflow(Guid entityId, Guid workflowId) | |
{ | |
return Context.ExecuteWorkflow(entityId, workflowId); | |
} | |
public TResult ExpandCalendar<TResult>(Guid calendarId, DateTime start, DateTime end) | |
{ | |
return Context.ExpandCalendar<TResult>(calendarId, start, end); | |
} | |
public byte[] ExportSolution(string solutionName, bool managed, bool exportAutoNumberingSettings, bool exportCalendarSettings, bool exportCustomizationSettings, bool exportEmailTrackingSettings, bool exportGeneralSettings, bool exportMarketingSettings, bool exportOutlookSynchronizationSettings, bool exportRelationshipRoles, bool exportIsvConfig) | |
{ | |
return Context.ExportSolution(solutionName, managed, exportAutoNumberingSettings, exportCalendarSettings, exportCustomizationSettings, exportEmailTrackingSettings, exportGeneralSettings, exportMarketingSettings, exportOutlookSynchronizationSettings, exportRelationshipRoles, exportIsvConfig); | |
} | |
public byte[] ExportTranslation(string solutionName) | |
{ | |
return Context.ExportTranslation(solutionName); | |
} | |
public Microsoft.Xrm.Sdk.Query.QueryExpression FetchXmlToQueryExpression(string fetchXml) | |
{ | |
return Context.FetchXmlToQueryExpression(fetchXml); | |
} | |
public bool FindParentResourceGroup(Guid parentId, Guid[] childrenIds) | |
{ | |
return Context.FindParentResourceGroup(parentId, childrenIds); | |
} | |
public void FulfillSalesOrder(Microsoft.Xrm.Sdk.Entity orderClose, Microsoft.Xrm.Sdk.OptionSetValue status) | |
{ | |
Context.FulfillSalesOrder(orderClose, status); | |
} | |
public Microsoft.Xrm.Sdk.Entity GenerateInvoiceFromOpportunity(Guid opportunityId, Microsoft.Xrm.Sdk.Query.ColumnSet columnSet) | |
{ | |
return Context.GenerateInvoiceFromOpportunity(opportunityId, columnSet); | |
} | |
public Microsoft.Xrm.Sdk.Entity GenerateQuoteFromOpportunity(Guid opportunityId, Microsoft.Xrm.Sdk.Query.ColumnSet columnSet) | |
{ | |
return Context.GenerateQuoteFromOpportunity(opportunityId, columnSet); | |
} | |
public Microsoft.Xrm.Sdk.Entity GenerateSalesOrderFromOpportunity(Guid opportunityId, Microsoft.Xrm.Sdk.Query.ColumnSet columnSet) | |
{ | |
return Context.GenerateSalesOrderFromOpportunity(opportunityId, columnSet); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection GetAllTimeZonesWithDisplayName(int localeId) | |
{ | |
return Context.GetAllTimeZonesWithDisplayName(localeId); | |
} | |
public string GetDecryptionKey() | |
{ | |
return Context.GetDecryptionKey(); | |
} | |
public string[] GetDistinctValuesImportFile(Guid importFileId, int columnNumber, int pageNumber, int recordsPerPage) | |
{ | |
return Context.GetDistinctValuesImportFile(importFileId, columnNumber, pageNumber, recordsPerPage); | |
} | |
public string[] GetHeaderColumnsImportFile(Guid importFileId) | |
{ | |
return Context.GetHeaderColumnsImportFile(importFileId); | |
} | |
public void GetInvoiceProductsFromOpportunity(Guid opportunityId, Guid invoiceId) | |
{ | |
Context.GetInvoiceProductsFromOpportunity(opportunityId, invoiceId); | |
} | |
public int GetQuantityDecimal(Microsoft.Xrm.Sdk.EntityReference target, Guid productId, Guid uoMId) | |
{ | |
return Context.GetQuantityDecimal(target, productId, uoMId); | |
} | |
public void GetQuoteProductsFromOpportunity(Guid opportunityId, Guid quoteId) | |
{ | |
Context.GetQuoteProductsFromOpportunity(opportunityId, quoteId); | |
} | |
public int GetReportHistoryLimit(Guid reportId) | |
{ | |
return Context.GetReportHistoryLimit(reportId); | |
} | |
public void GetSalesOrderProductsFromOpportunity(Guid opportunityId, Guid salesOrderId) | |
{ | |
Context.GetSalesOrderProductsFromOpportunity(opportunityId, salesOrderId); | |
} | |
public int GetTimeZoneCodeByLocalizedName(string localizedStandardName, int localeId) | |
{ | |
return Context.GetTimeZoneCodeByLocalizedName(localizedStandardName, localeId); | |
} | |
public string GetTrackingTokenEmail(string subject) | |
{ | |
return Context.GetTrackingTokenEmail(subject); | |
} | |
public void GrantAccess(Microsoft.Xrm.Sdk.EntityReference target, object principalAccess) | |
{ | |
Context.GrantAccess(target, principalAccess); | |
} | |
public Guid ImportRecordsImport(Guid importId) | |
{ | |
return Context.ImportRecordsImport(importId); | |
} | |
public void ImportSolution(bool overwriteUnmanagedCustomizations, bool publishWorkflows, byte[] customizationFile, Guid importJobId) | |
{ | |
Context.ImportSolution(overwriteUnmanagedCustomizations, publishWorkflows, customizationFile, importJobId); | |
} | |
public void ImportTranslation(byte[] translationFile, Guid importJobId) | |
{ | |
Context.ImportTranslation(translationFile, importJobId); | |
} | |
public Microsoft.Xrm.Sdk.Entity InitializeFrom(Microsoft.Xrm.Sdk.EntityReference entityMoniker, string targetEntityName, object targetFieldType) | |
{ | |
return Context.InitializeFrom(entityMoniker, targetEntityName, targetFieldType); | |
} | |
public void InstallSampleData() | |
{ | |
Context.InstallSampleData(); | |
} | |
public void InstantiateFilters(Microsoft.Xrm.Sdk.EntityReferenceCollection templateCollection, Guid userId) | |
{ | |
Context.InstantiateFilters(templateCollection, userId); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection InstantiateTemplate(Guid templateId, string objectType, Guid objectId) | |
{ | |
return Context.InstantiateTemplate(templateId, objectType, objectId); | |
} | |
public bool IsBackOfficeInstalled() | |
{ | |
return Context.IsBackOfficeInstalled(); | |
} | |
public bool IsComponentCustomizable(Guid componentId, int componentType) | |
{ | |
return Context.IsComponentCustomizable(componentId, componentType); | |
} | |
public bool IsValidStateTransition(Microsoft.Xrm.Sdk.EntityReference entity, string newState, int newStatus) | |
{ | |
return Context.IsValidStateTransition(entity, newState, newStatus); | |
} | |
public DateTime LocalTimeFromUtcTime(int timeZoneCode, DateTime utcTime) | |
{ | |
return Context.LocalTimeFromUtcTime(timeZoneCode, utcTime); | |
} | |
public void LockInvoicePricing(Guid invoiceId) | |
{ | |
Context.LockInvoicePricing(invoiceId); | |
} | |
public void LockSalesOrderPricing(Guid salesOrderId) | |
{ | |
Context.LockSalesOrderPricing(salesOrderId); | |
} | |
public void LogFailureBulkOperation(Guid bulkOperationId, Guid regardingObjectId, int regardingObjectTypeCode, int errorCode, string message, string additionalInfo) | |
{ | |
Context.LogFailureBulkOperation(bulkOperationId, regardingObjectId, regardingObjectTypeCode, errorCode, message, additionalInfo); | |
} | |
public void LogSuccessBulkOperation(Guid bulkOperationId, Guid regardingObjectId, int regardingObjectTypeCode, Guid createdObjectId, int createdObjectTypeCode, string additionalInfo) | |
{ | |
Context.LogSuccessBulkOperation(bulkOperationId, regardingObjectId, regardingObjectTypeCode, createdObjectId, createdObjectTypeCode, additionalInfo); | |
} | |
public void LoseOpportunity(Microsoft.Xrm.Sdk.Entity opportunityClose, Microsoft.Xrm.Sdk.OptionSetValue status) | |
{ | |
Context.LoseOpportunity(opportunityClose, status); | |
} | |
public void LoseOpportunity(Microsoft.Xrm.Sdk.Entity opportunityClose, int status) | |
{ | |
Context.LoseOpportunity(opportunityClose, status); | |
} | |
public void MakeAvailableToOrganizationReport(Guid reportId) | |
{ | |
Context.MakeAvailableToOrganizationReport(reportId); | |
} | |
public void MakeAvailableToOrganizationTemplate(Guid templateId) | |
{ | |
Context.MakeAvailableToOrganizationTemplate(templateId); | |
} | |
public void MakeUnavailableToOrganizationReport(Guid reportId) | |
{ | |
Context.MakeUnavailableToOrganizationReport(reportId); | |
} | |
public void MakeUnavailableToOrganizationTemplate(Guid templateId) | |
{ | |
Context.MakeUnavailableToOrganizationTemplate(templateId); | |
} | |
public void Merge(Microsoft.Xrm.Sdk.EntityReference target, Guid subordinateId, Microsoft.Xrm.Sdk.Entity updateContent, bool performParentingChecks) | |
{ | |
Context.Merge(target, subordinateId, updateContent, performParentingChecks); | |
} | |
public void ModifyAccess(Microsoft.Xrm.Sdk.EntityReference target, object principalAccess) | |
{ | |
Context.ModifyAccess(target, principalAccess); | |
} | |
public Guid ParseImport(Guid importId) | |
{ | |
return Context.ParseImport(importId); | |
} | |
public void ProcessInboundEmail(Guid inboundEmailActivity) | |
{ | |
Context.ProcessInboundEmail(inboundEmailActivity); | |
} | |
public int ProcessOneMemberBulkOperation(Guid bulkOperationId, Microsoft.Xrm.Sdk.Entity entity, int bulkOperationSource) | |
{ | |
return Context.ProcessOneMemberBulkOperation(bulkOperationId, entity, bulkOperationSource); | |
} | |
public Guid PropagateByExpression(Microsoft.Xrm.Sdk.Query.QueryBase queryExpression, string friendlyName, bool executeImmediately, Microsoft.Xrm.Sdk.Entity activity, Guid templateId, object ownershipOptions, bool postWorkflowEvent, Microsoft.Xrm.Sdk.EntityReference owner, bool sendEmail, Guid queueId) | |
{ | |
return Context.PropagateByExpression(queryExpression, friendlyName, executeImmediately, activity, templateId, ownershipOptions, postWorkflowEvent, owner, sendEmail, queueId); | |
} | |
public void ProvisionLanguage(int language) | |
{ | |
Context.ProvisionLanguage(language); | |
} | |
public void PublishAllXml() | |
{ | |
Context.PublishAllXml(); | |
} | |
public Guid PublishDuplicateRule(Guid duplicateRuleId) | |
{ | |
return Context.PublishDuplicateRule(duplicateRuleId); | |
} | |
public void PublishXml(string parameterXml) | |
{ | |
Context.PublishXml(parameterXml); | |
} | |
public Microsoft.Xrm.Sdk.EntityReferenceCollection QualifyLead(Microsoft.Xrm.Sdk.EntityReference leadId, bool createAccount, bool createContact, bool createOpportunity, Microsoft.Xrm.Sdk.EntityReference opportunityCurrencyId, Microsoft.Xrm.Sdk.EntityReference opportunityCustomerId, Microsoft.Xrm.Sdk.EntityReference sourceCampaignId, Microsoft.Xrm.Sdk.OptionSetValue status) | |
{ | |
return Context.QualifyLead(leadId, createAccount, createContact, createOpportunity, opportunityCurrencyId, opportunityCustomerId, sourceCampaignId, status); | |
} | |
public void QualifyMemberList(Guid listId, Guid[] membersId, bool overrideorRemove) | |
{ | |
Context.QualifyMemberList(listId, membersId, overrideorRemove); | |
} | |
public string QueryExpressionToFetchXml(Microsoft.Xrm.Sdk.Query.QueryBase query) | |
{ | |
return Context.QueryExpressionToFetchXml(query); | |
} | |
public TResult QueryMultipleSchedules<TResult>(Guid[] resourceIds, DateTime start, DateTime end, object timeCodes) | |
{ | |
return Context.QueryMultipleSchedules<TResult>(resourceIds, start, end, timeCodes); | |
} | |
public TResult QuerySchedule<TResult>(Guid resourceId, DateTime start, DateTime end, object timeCodes) | |
{ | |
return Context.QuerySchedule<TResult>(resourceId, start, end, timeCodes); | |
} | |
public void ReassignObjectsOwner(Microsoft.Xrm.Sdk.EntityReference fromPrincipal, Microsoft.Xrm.Sdk.EntityReference toPrincipal) | |
{ | |
Context.ReassignObjectsOwner(fromPrincipal, toPrincipal); | |
} | |
public void ReassignObjectsSystemUser(Guid userId, Microsoft.Xrm.Sdk.EntityReference reassignPrincipal) | |
{ | |
Context.ReassignObjectsSystemUser(userId, reassignPrincipal); | |
} | |
public void Recalculate(Microsoft.Xrm.Sdk.EntityReference target) | |
{ | |
Context.Recalculate(target); | |
} | |
public void RemoveItemCampaign(Guid campaignId, Guid entityId) | |
{ | |
Context.RemoveItemCampaign(campaignId, entityId); | |
} | |
public void RemoveItemCampaignActivity(Guid campaignActivityId, Guid itemId) | |
{ | |
Context.RemoveItemCampaignActivity(campaignActivityId, itemId); | |
} | |
public void RemoveMemberList(Guid listId, Guid entityId) | |
{ | |
Context.RemoveMemberList(listId, entityId); | |
} | |
public void RemoveMembersTeam(Guid teamId, Guid[] memberIds) | |
{ | |
Context.RemoveMembersTeam(teamId, memberIds); | |
} | |
public void RemoveParent(Microsoft.Xrm.Sdk.EntityReference target) | |
{ | |
Context.RemoveParent(target); | |
} | |
public void RemovePrivilegeRole(Guid roleId, Guid privilegeId) | |
{ | |
Context.RemovePrivilegeRole(roleId, privilegeId); | |
} | |
public void RemoveProductFromKit(Guid kitId, Guid productId) | |
{ | |
Context.RemoveProductFromKit(kitId, productId); | |
} | |
public void RemoveRelated(Microsoft.Xrm.Sdk.EntityReference[] target) | |
{ | |
Context.RemoveRelated(target); | |
} | |
public Guid RemoveSolutionComponent(Guid componentId, int componentType, string solutionUniqueName) | |
{ | |
return Context.RemoveSolutionComponent(componentId, componentType, solutionUniqueName); | |
} | |
public void RemoveSubstituteProduct(Guid productId, Guid substituteId) | |
{ | |
Context.RemoveSubstituteProduct(productId, substituteId); | |
} | |
public Microsoft.Xrm.Sdk.Entity RenewContract(Guid contractId, int status, bool includeCanceledLines) | |
{ | |
return Context.RenewContract(contractId, status, includeCanceledLines); | |
} | |
public void ReplacePrivilegesRole(Guid roleId, object privileges) | |
{ | |
Context.ReplacePrivilegesRole(roleId, privileges); | |
} | |
public TResult Reschedule<TResult>(Microsoft.Xrm.Sdk.Entity target) | |
{ | |
return Context.Reschedule<TResult>(target); | |
} | |
public void ResetUserFilters(int queryType) | |
{ | |
Context.ResetUserFilters(queryType); | |
} | |
public TResponse RetrieveAbsoluteAndSiteCollectionUrl<TResponse>(Microsoft.Xrm.Sdk.EntityReference target) where TResponse : Microsoft.Xrm.Sdk.OrganizationResponse | |
{ | |
return Context.RetrieveAbsoluteAndSiteCollectionUrl<TResponse>(target); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveAllChildUsersSystemUser(Guid entityId, Microsoft.Xrm.Sdk.Query.ColumnSet columnSet) | |
{ | |
return Context.RetrieveAllChildUsersSystemUser(entityId, columnSet); | |
} | |
public Microsoft.Xrm.Sdk.Metadata.EntityMetadata[] RetrieveAllEntities(Microsoft.Xrm.Sdk.Metadata.EntityFilters entityFilters = Microsoft.Xrm.Sdk.Metadata.EntityFilters.Default, bool retrieveAsIfPublished = false) | |
{ | |
return Context.RetrieveAllEntities(entityFilters, retrieveAsIfPublished); | |
} | |
public byte[] RetrieveApplicationRibbon() | |
{ | |
return Context.RetrieveApplicationRibbon(); | |
} | |
public Microsoft.Xrm.Sdk.Metadata.AttributeMetadata RetrieveAttribute(string entityLogicalName, string logicalName, bool retrieveAsIfPublished = false) | |
{ | |
return Context.RetrieveAttribute(entityLogicalName, logicalName, retrieveAsIfPublished); | |
} | |
public TResult RetrieveAttributeChangeHistory<TResult>(Microsoft.Xrm.Sdk.EntityReference target, string attributeLogicalName, Microsoft.Xrm.Sdk.Query.PagingInfo pagingInfo) | |
{ | |
return Context.RetrieveAttributeChangeHistory<TResult>(target, attributeLogicalName, pagingInfo); | |
} | |
public TResult RetrieveAuditDetails<TResult>(Guid auditId) | |
{ | |
return Context.RetrieveAuditDetails<TResult>(auditId); | |
} | |
public TResult RetrieveAuditPartitionList<TResult>() | |
{ | |
return Context.RetrieveAuditPartitionList<TResult>(); | |
} | |
public int[] RetrieveAvailableLanguages() | |
{ | |
return Context.RetrieveAvailableLanguages(); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveBusinessHierarchyBusinessUnit(Guid entityId, Microsoft.Xrm.Sdk.Query.ColumnSet columnSet) | |
{ | |
return Context.RetrieveBusinessHierarchyBusinessUnit(entityId, columnSet); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveByGroupResource(Guid resourceGroupId, Microsoft.Xrm.Sdk.Query.QueryBase query) | |
{ | |
return Context.RetrieveByGroupResource(resourceGroupId, query); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveByResourceResourceGroup(Guid resourceId, Microsoft.Xrm.Sdk.Query.QueryBase query) | |
{ | |
return Context.RetrieveByResourceResourceGroup(resourceId, query); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveByResourcesService(Guid[] resourceIds, Microsoft.Xrm.Sdk.Query.QueryBase query) | |
{ | |
return Context.RetrieveByResourcesService(resourceIds, query); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveByTopIncidentProductKbArticle(Guid productId) | |
{ | |
return Context.RetrieveByTopIncidentProductKbArticle(productId); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveByTopIncidentSubjectKbArticle(Guid subjectId) | |
{ | |
return Context.RetrieveByTopIncidentSubjectKbArticle(subjectId); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveDependenciesForDelete(Guid objectId, int componentType) | |
{ | |
return Context.RetrieveDependenciesForDelete(objectId, componentType); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveDependenciesForUninstall(string solutionUniqueName) | |
{ | |
return Context.RetrieveDependenciesForUninstall(solutionUniqueName); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveDependentComponents(Guid objectId, int componentType) | |
{ | |
return Context.RetrieveDependentComponents(objectId, componentType); | |
} | |
public string RetrieveDeploymentLicenseType() | |
{ | |
return Context.RetrieveDeploymentLicenseType(); | |
} | |
public int[] RetrieveDeprovisionedLanguages() | |
{ | |
return Context.RetrieveDeprovisionedLanguages(); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveDuplicates(Microsoft.Xrm.Sdk.Entity businessEntity, string matchingEntityName, Microsoft.Xrm.Sdk.Query.PagingInfo pagingInfo) | |
{ | |
return Context.RetrieveDuplicates(businessEntity, matchingEntityName, pagingInfo); | |
} | |
public Microsoft.Xrm.Sdk.Metadata.EntityMetadata RetrieveEntity(string logicalName, Microsoft.Xrm.Sdk.Metadata.EntityFilters entityFilters = Microsoft.Xrm.Sdk.Metadata.EntityFilters.Default, bool retrieveAsIfPublished = false) | |
{ | |
return Context.RetrieveEntity(logicalName, entityFilters, retrieveAsIfPublished); | |
} | |
public byte[] RetrieveEntityRibbon(string entityName, object ribbonLocationFilter) | |
{ | |
return Context.RetrieveEntityRibbon(entityName, ribbonLocationFilter); | |
} | |
public decimal RetrieveExchangeRate(Guid transactionCurrencyId) | |
{ | |
return Context.RetrieveExchangeRate(transactionCurrencyId); | |
} | |
public Microsoft.Xrm.Sdk.EntityReferenceCollection RetrieveFilteredForms(string entityLogicalName, Microsoft.Xrm.Sdk.OptionSetValue formType, Guid systemUserId) | |
{ | |
return Context.RetrieveFilteredForms(entityLogicalName, formType, systemUserId); | |
} | |
public string RetrieveFormattedImportJobResults(Guid importJobId) | |
{ | |
return Context.RetrieveFormattedImportJobResults(importJobId); | |
} | |
public TResponse RetrieveFormXml<TResponse>(string entityName) where TResponse : Microsoft.Xrm.Sdk.OrganizationResponse | |
{ | |
return Context.RetrieveFormXml<TResponse>(entityName); | |
} | |
public int[] RetrieveInstalledLanguagePacks() | |
{ | |
return Context.RetrieveInstalledLanguagePacks(); | |
} | |
public string RetrieveInstalledLanguagePackVersion(int language) | |
{ | |
return Context.RetrieveInstalledLanguagePackVersion(language); | |
} | |
public TResponse RetrieveLicenseInfo<TResponse>(int accessMode) where TResponse : Microsoft.Xrm.Sdk.OrganizationResponse | |
{ | |
return Context.RetrieveLicenseInfo<TResponse>(accessMode); | |
} | |
public Microsoft.Xrm.Sdk.Label RetrieveLocLabels(Microsoft.Xrm.Sdk.EntityReference entityMoniker, string attributeName, bool includeUnpublished) | |
{ | |
return Context.RetrieveLocLabels(entityMoniker, attributeName, includeUnpublished); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveMembersBulkOperation(Guid bulkOperationId, int bulkOperationSource, int entitySource, Microsoft.Xrm.Sdk.Query.QueryBase query) | |
{ | |
return Context.RetrieveMembersBulkOperation(bulkOperationId, bulkOperationSource, entitySource, query); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveMembersTeam(Guid entityId, Microsoft.Xrm.Sdk.Query.ColumnSet memberColumnSet) | |
{ | |
return Context.RetrieveMembersTeam(entityId, memberColumnSet); | |
} | |
public TResult RetrieveMissingComponents<TResult>(byte[] customizationFile) | |
{ | |
return Context.RetrieveMissingComponents<TResult>(customizationFile); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveMissingDependencies(string solutionUniqueName) | |
{ | |
return Context.RetrieveMissingDependencies(solutionUniqueName); | |
} | |
public Microsoft.Xrm.Sdk.Messages.RetrieveMultipleResponse RetrieveMultiple(Microsoft.Xrm.Sdk.Messages.RetrieveMultipleRequest request) | |
{ | |
return Context.RetrieveMultiple(request); | |
} | |
public TResult RetrieveOrganizationResources<TResult>() | |
{ | |
return Context.RetrieveOrganizationResources<TResult>(); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveParentGroupsResourceGroup(Guid resourceGroupId, Microsoft.Xrm.Sdk.Query.QueryBase query) | |
{ | |
return Context.RetrieveParentGroupsResourceGroup(resourceGroupId, query); | |
} | |
public string[][] RetrieveParsedDataImportFile(Guid importFileId, Microsoft.Xrm.Sdk.Query.PagingInfo pagingInfo) | |
{ | |
return Context.RetrieveParsedDataImportFile(importFileId, pagingInfo); | |
} | |
public TResult RetrievePrincipalAccess<TResult>(Microsoft.Xrm.Sdk.EntityReference target, Microsoft.Xrm.Sdk.EntityReference principal) | |
{ | |
return Context.RetrievePrincipalAccess<TResult>(target, principal); | |
} | |
public Microsoft.Xrm.Sdk.AttributePrivilegeCollection RetrievePrincipalAttributePrivileges(Microsoft.Xrm.Sdk.EntityReference principal) | |
{ | |
return Context.RetrievePrincipalAttributePrivileges(principal); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrievePrivilegeSet() | |
{ | |
return Context.RetrievePrivilegeSet(); | |
} | |
public string RetrieveProvisionedLanguagePackVersion(int language) | |
{ | |
return Context.RetrieveProvisionedLanguagePackVersion(language); | |
} | |
public int[] RetrieveProvisionedLanguages() | |
{ | |
return Context.RetrieveProvisionedLanguages(); | |
} | |
public TResult RetrieveRecordChangeHistory<TResult>(Microsoft.Xrm.Sdk.EntityReference target, Microsoft.Xrm.Sdk.Query.PagingInfo pagingInfo) | |
{ | |
return Context.RetrieveRecordChangeHistory<TResult>(target, pagingInfo); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveRequiredComponents(Guid objectId, int componentType) | |
{ | |
return Context.RetrieveRequiredComponents(objectId, componentType); | |
} | |
public TResult RetrieveRolePrivilegesRole<TResult>(Guid roleId) | |
{ | |
return Context.RetrieveRolePrivilegesRole<TResult>(roleId); | |
} | |
public TResult RetrieveSharedPrincipalsAndAccess<TResult>(Microsoft.Xrm.Sdk.EntityReference target) | |
{ | |
return Context.RetrieveSharedPrincipalsAndAccess<TResult>(target); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveSubGroupsResourceGroup(Guid resourceGroupId, Microsoft.Xrm.Sdk.Query.QueryBase query) | |
{ | |
return Context.RetrieveSubGroupsResourceGroup(resourceGroupId, query); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveSubsidiaryTeamsBusinessUnit(Guid entityId, Microsoft.Xrm.Sdk.Query.ColumnSet columnSet) | |
{ | |
return Context.RetrieveSubsidiaryTeamsBusinessUnit(entityId, columnSet); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveSubsidiaryUsersBusinessUnit(Guid entityId, Microsoft.Xrm.Sdk.Query.ColumnSet columnSet) | |
{ | |
return Context.RetrieveSubsidiaryUsersBusinessUnit(entityId, columnSet); | |
} | |
public TResult RetrieveTeamPrivileges<TResult>(Guid teamId) | |
{ | |
return Context.RetrieveTeamPrivileges<TResult>(teamId); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveTeamsSystemUser(Guid entityId, Microsoft.Xrm.Sdk.Query.ColumnSet columnSet) | |
{ | |
return Context.RetrieveTeamsSystemUser(entityId, columnSet); | |
} | |
public Microsoft.Xrm.Sdk.Entity RetrieveUnpublished(Microsoft.Xrm.Sdk.EntityReference target, Microsoft.Xrm.Sdk.Query.ColumnSet columnSet) | |
{ | |
return Context.RetrieveUnpublished(target, columnSet); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection RetrieveUnpublishedMultiple(Microsoft.Xrm.Sdk.Query.QueryBase query) | |
{ | |
return Context.RetrieveUnpublishedMultiple(query); | |
} | |
public TResult RetrieveUserPrivileges<TResult>(Guid userId) | |
{ | |
return Context.RetrieveUserPrivileges<TResult>(userId); | |
} | |
public Microsoft.Xrm.Sdk.Entity RetrieveUserSettingsSystemUser(Guid entityId, Microsoft.Xrm.Sdk.Query.ColumnSet columnSet) | |
{ | |
return Context.RetrieveUserSettingsSystemUser(entityId, columnSet); | |
} | |
public string RetrieveVersion() | |
{ | |
return Context.RetrieveVersion(); | |
} | |
public Microsoft.Xrm.Sdk.Entity ReviseQuote(Guid quoteId, Microsoft.Xrm.Sdk.Query.ColumnSet columnSet) | |
{ | |
return Context.ReviseQuote(quoteId, columnSet); | |
} | |
public void RevokeAccess(Microsoft.Xrm.Sdk.EntityReference target, Microsoft.Xrm.Sdk.EntityReference revokee) | |
{ | |
Context.RevokeAccess(target, revokee); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection Rollup(Microsoft.Xrm.Sdk.EntityReference target, Microsoft.Xrm.Sdk.Query.QueryBase query, object rollupType) | |
{ | |
return Context.Rollup(target, query, rollupType); | |
} | |
public TResult Search<TResult>(object appointmentRequest) | |
{ | |
return Context.Search<TResult>(appointmentRequest); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection SearchByBodyKbArticle(string searchText, Guid subjectId, bool useInflection, Microsoft.Xrm.Sdk.Query.QueryBase queryExpression) | |
{ | |
return Context.SearchByBodyKbArticle(searchText, subjectId, useInflection, queryExpression); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection SearchByKeywordsKbArticle(string searchText, Guid subjectId, bool useInflection, Microsoft.Xrm.Sdk.Query.QueryBase queryExpression) | |
{ | |
return Context.SearchByKeywordsKbArticle(searchText, subjectId, useInflection, queryExpression); | |
} | |
public Microsoft.Xrm.Sdk.EntityCollection SearchByTitleKbArticle(string searchText, Guid subjectId, bool useInflection, Microsoft.Xrm.Sdk.Query.QueryBase queryExpression) | |
{ | |
return Context.SearchByTitleKbArticle(searchText, subjectId, useInflection, queryExpression); | |
} | |
public void SendBulkMail(Microsoft.Xrm.Sdk.EntityReference sender, Guid templateId, string regardingType, Guid regardingId, Microsoft.Xrm.Sdk.Query.QueryBase query) | |
{ | |
Context.SendBulkMail(sender, templateId, regardingType, regardingId, query); | |
} | |
public string SendEmail(Guid emailId, bool issueSend, string trackingToken) | |
{ | |
return Context.SendEmail(emailId, issueSend, trackingToken); | |
} | |
public Guid SendEmailFromTemplate(Guid templateId, string regardingType, Guid regardingId, Microsoft.Xrm.Sdk.Entity target) | |
{ | |
return Context.SendEmailFromTemplate(templateId, regardingType, regardingId, target); | |
} | |
public void SendFax(Guid faxId, bool issueSend) | |
{ | |
Context.SendFax(faxId, issueSend); | |
} | |
public void SendTemplate(Guid templateId, Microsoft.Xrm.Sdk.EntityReference sender, string recipientType, Guid[] recipientIds, string regardingType, Guid regardingId) | |
{ | |
Context.SendTemplate(templateId, sender, recipientType, recipientIds, regardingType, regardingId); | |
} | |
public void SetBusinessEquipment(Guid equipmentId, Guid businessUnitId) | |
{ | |
Context.SetBusinessEquipment(equipmentId, businessUnitId); | |
} | |
public void SetBusinessSystemUser(Guid userId, Guid businessId, Microsoft.Xrm.Sdk.EntityReference reassignPrincipal) | |
{ | |
Context.SetBusinessSystemUser(userId, businessId, reassignPrincipal); | |
} | |
public void SetLocLabels(Microsoft.Xrm.Sdk.EntityReference entityMoniker, string attributeName, Microsoft.Xrm.Sdk.LocalizedLabel[] labels) | |
{ | |
Context.SetLocLabels(entityMoniker, attributeName, labels); | |
} | |
public void SetParentBusinessUnit(Guid businessUnitId, Guid parentId) | |
{ | |
Context.SetParentBusinessUnit(businessUnitId, parentId); | |
} | |
public void SetParentSystemUser(Guid userId, Guid parentId, bool keepChildUsers) | |
{ | |
Context.SetParentSystemUser(userId, parentId, keepChildUsers); | |
} | |
public void SetParentTeam(Guid teamId, Guid businessId) | |
{ | |
Context.SetParentTeam(teamId, businessId); | |
} | |
public void SetRelated(Microsoft.Xrm.Sdk.EntityReference[] target) | |
{ | |
Context.SetRelated(target); | |
} | |
public void SetReportRelated(Guid reportId, int[] entities, int[] categories, int[] visibility) | |
{ | |
Context.SetReportRelated(reportId, entities, categories, visibility); | |
} | |
public void SetState(Microsoft.Xrm.Sdk.EntityReference entityMoniker, Microsoft.Xrm.Sdk.OptionSetValue state, Microsoft.Xrm.Sdk.OptionSetValue status) | |
{ | |
Context.SetState(entityMoniker, state, status); | |
} | |
public void SetState(int state, int status, Microsoft.Xrm.Sdk.EntityReference entityMoniker) | |
{ | |
Context.SetState(state, status, entityMoniker); | |
} | |
public void SetState(int state, int status, Microsoft.Xrm.Sdk.Entity entity) | |
{ | |
Context.SetState(state, status, entity); | |
} | |
public void StatusUpdateBulkOperation(Guid bulkOperationId, int failureCount, int successCount) | |
{ | |
Context.StatusUpdateBulkOperation(bulkOperationId, failureCount, successCount); | |
} | |
public Guid TransformImport(Guid importId) | |
{ | |
return Context.TransformImport(importId); | |
} | |
public void TriggerServiceEndpointCheck(Microsoft.Xrm.Sdk.EntityReference entity) | |
{ | |
Context.TriggerServiceEndpointCheck(entity); | |
} | |
public void UninstallSampleData() | |
{ | |
Context.UninstallSampleData(); | |
} | |
public void UnlockInvoicePricing(Guid invoiceId) | |
{ | |
Context.UnlockInvoicePricing(invoiceId); | |
} | |
public void UnlockSalesOrderPricing(Guid salesOrderId) | |
{ | |
Context.UnlockSalesOrderPricing(salesOrderId); | |
} | |
public void UnpublishDuplicateRule(Guid duplicateRuleId) | |
{ | |
Context.UnpublishDuplicateRule(duplicateRuleId); | |
} | |
public void UpdateUserSettingsSystemUser(Guid userId, Microsoft.Xrm.Sdk.Entity settings) | |
{ | |
Context.UpdateUserSettingsSystemUser(userId, settings); | |
} | |
public DateTime UtcTimeFromLocalTime(int timeZoneCode, DateTime localTime) | |
{ | |
return Context.UtcTimeFromLocalTime(timeZoneCode, localTime); | |
} | |
public TResult Validate<TResult>(Microsoft.Xrm.Sdk.EntityCollection activities) | |
{ | |
return Context.Validate<TResult>(activities); | |
} | |
public string ValidateRecurrenceRule(Microsoft.Xrm.Sdk.Entity target) | |
{ | |
return Context.ValidateRecurrenceRule(target); | |
} | |
public void ValidateSavedQuery(string fetchXml, int queryType) | |
{ | |
Context.ValidateSavedQuery(fetchXml, queryType); | |
} | |
public bool VerifyProcessStateData(Microsoft.Xrm.Sdk.EntityReference target, string processState) | |
{ | |
return Context.VerifyProcessStateData(target, processState); | |
} | |
public TResponse WhoAmI<TResponse>() where TResponse : Microsoft.Xrm.Sdk.OrganizationResponse | |
{ | |
return Context.WhoAmI<TResponse>(); | |
} | |
public void WinOpportunity(Microsoft.Xrm.Sdk.Entity opportunityClose, Microsoft.Xrm.Sdk.OptionSetValue status) | |
{ | |
Context.WinOpportunity(opportunityClose, status); | |
} | |
public void WinOpportunity(Microsoft.Xrm.Sdk.Entity opportunityClose, int status) | |
{ | |
Context.WinOpportunity(opportunityClose, status); | |
} | |
public void WinQuote(Microsoft.Xrm.Sdk.Entity quoteClose, Microsoft.Xrm.Sdk.OptionSetValue status) | |
{ | |
Context.WinQuote(quoteClose, status); | |
} | |
#endregion | |
#region Microsoft.Xrm.Client.OrganizationServiceContextExtensions | |
/* | |
* Microsoft.Xrm.Client.OrganizationServiceContextExtensions | |
*/ | |
public void AddLink(Microsoft.Xrm.Sdk.Entity source, string relationshipSchemaName, Microsoft.Xrm.Sdk.Entity target, Microsoft.Xrm.Sdk.EntityRole? primaryEntityRole = null) | |
{ | |
Context.AddLink(source, relationshipSchemaName, target, primaryEntityRole); | |
} | |
public void AddLink<TSource, TTarget>(TSource source, System.Linq.Expressions.Expression<Func<TSource, TTarget>> propertySelector, TTarget target) | |
where TSource : Microsoft.Xrm.Sdk.Entity | |
where TTarget : Microsoft.Xrm.Sdk.Entity | |
{ | |
Context.AddLink<TSource, TTarget>(source, propertySelector, target); | |
} | |
public void AddRelatedObject(Microsoft.Xrm.Sdk.Entity source, string relationshipSchemaName, Microsoft.Xrm.Sdk.Entity target, Microsoft.Xrm.Sdk.EntityRole? primaryEntityRole = null) | |
{ | |
Context.AddRelatedObject(source, relationshipSchemaName, target, primaryEntityRole); | |
} | |
public void AddRelatedObject<TSource, TTarget>(TSource source, System.Linq.Expressions.Expression<Func<TSource, IEnumerable<TTarget>>> propertySelector, TTarget target) | |
where TSource : Microsoft.Xrm.Sdk.Entity | |
where TTarget : Microsoft.Xrm.Sdk.Entity | |
{ | |
Context.AddRelatedObject<TSource, TTarget>(source, propertySelector, target); | |
} | |
public void AddRelatedObject<TSource, TTarget>(TSource source, System.Linq.Expressions.Expression<Func<TSource, TTarget>> propertySelector, TTarget target) | |
where TSource : Microsoft.Xrm.Sdk.Entity | |
where TTarget : Microsoft.Xrm.Sdk.Entity | |
{ | |
Context.AddRelatedObject<TSource, TTarget>(source, propertySelector, target); | |
} | |
public T AttachClone<T>(T entity, bool includeRelatedEntities = false) where T : Microsoft.Xrm.Sdk.Entity | |
{ | |
return Context.AttachClone<T>(entity, includeRelatedEntities); | |
} | |
public void AttachLink(Microsoft.Xrm.Sdk.Entity source, string relationshipSchemaName, Microsoft.Xrm.Sdk.Entity target, Microsoft.Xrm.Sdk.EntityRole? primaryEntityRole = null) | |
{ | |
Context.AttachLink(source, relationshipSchemaName, target, primaryEntityRole); | |
} | |
public void AttachLink<TSource, TTarget>(TSource source, System.Linq.Expressions.Expression<Func<TSource, TTarget>> propertySelector, TTarget target) | |
where TSource : Microsoft.Xrm.Sdk.Entity | |
where TTarget : Microsoft.Xrm.Sdk.Entity | |
{ | |
Context.AttachLink<TSource, TTarget>(source, propertySelector, target); | |
} | |
public void DeleteLink(Microsoft.Xrm.Sdk.Entity source, string relationshipSchemaName, Microsoft.Xrm.Sdk.Entity target, Microsoft.Xrm.Sdk.EntityRole? primaryEntityRole = null) | |
{ | |
Context.DeleteLink(source, relationshipSchemaName, target, primaryEntityRole); | |
} | |
public void DeleteLink<TSource, TTarget>(TSource source, System.Linq.Expressions.Expression<Func<TSource, TTarget>> propertySelector, TTarget target) | |
where TSource : Microsoft.Xrm.Sdk.Entity | |
where TTarget : Microsoft.Xrm.Sdk.Entity | |
{ | |
Context.DeleteLink<TSource, TTarget>(source, propertySelector, target); | |
} | |
public bool Detach(IEnumerable<Microsoft.Xrm.Sdk.Entity> entities) | |
{ | |
return Context.Detach(entities); | |
} | |
public bool DetachLink(Microsoft.Xrm.Sdk.Entity source, string relationshipSchemaName, Microsoft.Xrm.Sdk.Entity target, Microsoft.Xrm.Sdk.EntityRole? primaryEntityRole = null) | |
{ | |
return Context.DetachLink(source, relationshipSchemaName, target, primaryEntityRole); | |
} | |
public bool DetachLink<TSource, TTarget>(TSource source, System.Linq.Expressions.Expression<Func<TSource, TTarget>> propertySelector, TTarget target) | |
where TSource : Microsoft.Xrm.Sdk.Entity | |
where TTarget : Microsoft.Xrm.Sdk.Entity | |
{ | |
return Context.DetachLink<TSource, TTarget>(source, propertySelector, target); | |
} | |
public TResponse Execute<TResponse>(Microsoft.Xrm.Sdk.OrganizationRequest request) where TResponse : Microsoft.Xrm.Sdk.OrganizationResponse | |
{ | |
return Context.Execute<TResponse>(request); | |
} | |
public void IsAttached(Microsoft.Xrm.Sdk.Entity source, string relationshipSchemaName, Microsoft.Xrm.Sdk.Entity target, Microsoft.Xrm.Sdk.EntityRole? primaryEntityRole = null) | |
{ | |
Context.IsAttached(source, relationshipSchemaName, target, primaryEntityRole); | |
} | |
public bool IsAttached<TSource, TTarget>(TSource source, System.Linq.Expressions.Expression<Func<TSource, IEnumerable<TTarget>>> propertySelector, TTarget target) | |
where TSource : Microsoft.Xrm.Sdk.Entity | |
where TTarget : Microsoft.Xrm.Sdk.Entity | |
{ | |
return Context.IsAttached<TSource, TTarget>(source, propertySelector, target); | |
} | |
public bool IsAttached<TSource, TTarget>(TSource source, System.Linq.Expressions.Expression<Func<TSource, TTarget>> propertySelector, TTarget target) | |
where TSource : Microsoft.Xrm.Sdk.Entity | |
where TTarget : Microsoft.Xrm.Sdk.Entity | |
{ | |
return Context.IsAttached<TSource, TTarget>(source, propertySelector, target); | |
} | |
public void IsDeleted(Microsoft.Xrm.Sdk.Entity source, string relationshipSchemaName, Microsoft.Xrm.Sdk.Entity target, Microsoft.Xrm.Sdk.EntityRole? primaryEntityRole = null) | |
{ | |
Context.IsDeleted(source, relationshipSchemaName, target, primaryEntityRole); | |
} | |
public bool IsDeleted<TSource, TTarget>(TSource source, System.Linq.Expressions.Expression<Func<TSource, TTarget>> propertySelector, TTarget target) | |
where TSource : Microsoft.Xrm.Sdk.Entity | |
where TTarget : Microsoft.Xrm.Sdk.Entity | |
{ | |
return Context.IsDeleted<TSource, TTarget>(source, propertySelector, target); | |
} | |
public void LoadProperty(Microsoft.Xrm.Sdk.Entity entity, string relationshipSchemaName, Microsoft.Xrm.Sdk.EntityRole? primaryEntityRole = null) | |
{ | |
Context.LoadProperty(entity, relationshipSchemaName, primaryEntityRole); | |
} | |
public void LoadProperty<TEntity>(TEntity entity, System.Linq.Expressions.Expression<Func<TEntity, object>> propertySelector) where TEntity : Microsoft.Xrm.Sdk.Entity | |
{ | |
Context.LoadProperty<TEntity>(entity, propertySelector); | |
} | |
public T MergeClone<T>(T entity, bool includeRelatedEntities = false) where T : Microsoft.Xrm.Sdk.Entity | |
{ | |
return Context.MergeClone<T>(entity, includeRelatedEntities); | |
} | |
public void ReAttach(Microsoft.Xrm.Sdk.Entity entity) | |
{ | |
Context.ReAttach(entity); | |
} | |
public bool TryAccessCache(Action<Microsoft.Xrm.Client.Services.IOrganizationServiceCache> action) | |
{ | |
return Context.TryAccessCache(action); | |
} | |
public bool TryRemoveFromCache(Microsoft.Xrm.Sdk.Entity entity) | |
{ | |
return Context.TryRemoveFromCache(entity); | |
} | |
public bool TryRemoveFromCache(Microsoft.Xrm.Sdk.EntityReference entity) | |
{ | |
return Context.TryRemoveFromCache(entity); | |
} | |
public bool TryRemoveFromCache(Microsoft.Xrm.Sdk.OrganizationRequest request) | |
{ | |
return Context.TryRemoveFromCache(request); | |
} | |
public bool TryRemoveFromCache(string cacheKey) | |
{ | |
return Context.TryRemoveFromCache(cacheKey); | |
} | |
public bool TryRemoveFromCache(string entityLogicalName, Guid? id) | |
{ | |
return Context.TryRemoveFromCache(entityLogicalName, id); | |
} | |
#endregion | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment